package com.vincent.rsf.server.api.service.impl;
|
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.vincent.rsf.framework.common.Cools;
|
import com.vincent.rsf.framework.common.R;
|
import com.vincent.rsf.framework.exception.CoolException;
|
import com.vincent.rsf.server.api.entity.dto.ContainerWaveDto;
|
import com.vincent.rsf.server.api.entity.params.CallForEmptyContainersParam;
|
import com.vincent.rsf.server.api.entity.params.ContainerWaveParam;
|
import com.vincent.rsf.server.api.entity.params.PdaGeneralParam;
|
import com.vincent.rsf.server.api.service.PdaOutStockService;
|
import com.vincent.rsf.server.common.constant.Constants;
|
import com.vincent.rsf.server.manager.controller.params.LocToTaskParams;
|
import com.vincent.rsf.server.manager.entity.*;
|
import com.vincent.rsf.server.manager.enums.*;
|
import com.vincent.rsf.server.manager.service.*;
|
import com.vincent.rsf.server.manager.service.impl.BasContainerServiceImpl;
|
import com.vincent.rsf.server.system.constant.SerialRuleCode;
|
import com.vincent.rsf.server.system.utils.SerialRuleUtils;
|
import lombok.Synchronized;
|
import org.apache.commons.lang3.StringUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import javax.annotation.Resource;
|
import java.math.BigDecimal;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
@Service
|
public class PdaOutStockServiceImpl implements PdaOutStockService {
|
|
@Resource
|
private TaskService taskService;
|
@Resource
|
private TaskItemService taskItemService;
|
@Autowired
|
private WaveService waveService;
|
@Autowired
|
private AsnOrderService asnOrderService;
|
@Autowired
|
private AsnOrderItemService asnOrderItemService;
|
@Autowired
|
private WaveOrderRelaService waveOrderRelaService;
|
@Autowired
|
private BasStationService basStationService;
|
@Autowired
|
private LocService locService;
|
@Autowired
|
private BasContainerServiceImpl basContainerService;
|
@Autowired
|
private LocItemService locItemService;
|
@Autowired
|
private WaitPakinService waitPakinService;
|
@Autowired
|
private WaitPakinItemService waitPakinItemService;
|
|
@Override
|
public R getOutStockTaskItem(String barcode) {
|
LambdaQueryWrapper<Task> lambdaQueryWrapper = new LambdaQueryWrapper<>();
|
lambdaQueryWrapper.eq(Task::getBarcode, barcode);
|
Task task = taskService.getOne(lambdaQueryWrapper.last("limit 1"));
|
if (null == task) {
|
return R.error("未查询到相关任务");
|
}
|
List<TaskItem> taskItems = taskItemService
|
.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
|
if (null == taskItems || taskItems.size() <= 0) {
|
return R.error("任务出错，未查询到相关任务明细");
|
}
|
|
return R.ok(taskItems);
|
}
|
|
@Override
|
public R saveOutTaskSts(String barcode) {
|
LambdaQueryWrapper<Task> lambdaQueryWrapper = new LambdaQueryWrapper<>();
|
lambdaQueryWrapper.eq(Task::getBarcode, barcode);
|
Task task = taskService.getOne(lambdaQueryWrapper.last("limit 1"));
|
if (null == task) {
|
throw new CoolException("未找到容器号对应任务");
|
}
|
if (!task.getTaskStatus().equals(TaskStsType.AWAIT.id)) {
|
return R.error("任务状态不是等待确认");
|
}
|
List<TaskItem> taskItems = taskItemService
|
.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
|
Map<Long, List<TaskItem>> maps = taskItems.stream().collect(Collectors.groupingBy(TaskItem::getSource));
|
maps.keySet().forEach(key -> {
|
WkOrderItem orderItem = asnOrderItemService.getById(key);
|
if (Objects.isNull(orderItem)) {
|
throw new CoolException("单据明细不存在！！");
|
}
|
});
|
task.setTaskStatus(TaskStsType.COMPLETE_OUT.id);
|
if (!taskService.updateById(task)) {
|
return R.error("更新任务状态失败");
|
}
|
|
return R.ok("确认成功");
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public R containerRebinding(PdaGeneralParam param, Long userId) {
|
if (Cools.isEmpty(param.getContainerNo())) {
|
throw new CoolException("无容器号");
|
}
|
Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, param.getContainerNo()));
|
if (null == task) {
|
throw new CoolException("未找到任务");
|
}
|
if (!task.getResource().equals(TaskResouceType.TASK_RESOUCE_STOCK_UP.val)) {
|
throw new CoolException("当前托盘不是备货出库任务");
|
}
|
|
WaitPakin waitPakin = waitPakinService
|
.getOne(new LambdaQueryWrapper<WaitPakin>().eq(WaitPakin::getBarcode, param.getNewContainerNo()));
|
if (Cools.isEmpty(waitPakin)) {
|
WaitPakin waitPakin1 = new WaitPakin();
|
String ruleCode = SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_WAIT_PAKIN_CODE, null);
|
if (StringUtils.isBlank(ruleCode)) {
|
throw new CoolException("编码规则错误： 编码规则「SYS_WAIT_PAKIN_CODE」规则是不存在");
|
}
|
waitPakin1.setCode(ruleCode)
|
.setIoStatus(PakinIOStatus.PAKIN_IO_STATUS_HOLD.val)
|
.setAnfme(param.getTaskItemList().stream()
|
.map(TaskItem::getInputQty)
|
.filter(Objects::nonNull)
|
.reduce(BigDecimal.ZERO, BigDecimal::add)
|
.doubleValue())
|
.setUpdateBy(userId)
|
.setCreateBy(userId)
|
.setBarcode(param.getNewContainerNo());
|
if (!waitPakinService.save(waitPakin1)) {
|
throw new CoolException("组托主单保存失败！！");
|
}
|
List<WaitPakinItem> items = new ArrayList<>();
|
for (TaskItem taskItem : param.getTaskItemList()) {
|
WaitPakinItem pakinItem = new WaitPakinItem();
|
pakinItem.setAnfme(taskItem.getInputQty().doubleValue())
|
.setPakinId(waitPakin1.getId())
|
.setSource(taskItem.getId())
|
.setAsnId(taskItem.getSourceId())
|
.setAsnCode(taskItem.getSourceCode())
|
.setAsnItemId(taskItem.getSource())
|
.setIsptResult(taskItem.getIsptResult())
|
.setPlatItemId(taskItem.getPlatItemId())
|
.setPlatOrderCode(taskItem.getPlatOrderCode())
|
.setPlatWorkCode(taskItem.getPlatWorkCode())
|
.setProjectCode(taskItem.getProjectCode())
|
.setBatch(taskItem.getSplrBatch())
|
.setUnit(taskItem.getUnit())
|
.setFieldsIndex(taskItem.getFieldsIndex())
|
.setMatnrId(taskItem.getMatnrId())
|
.setMaktx(taskItem.getMaktx())
|
.setUpdateBy(userId)
|
.setCreateBy(userId)
|
.setMatnrCode(taskItem.getMatnrCode());
|
WkOrder order = asnOrderService.getById(taskItem.getSourceId());
|
if (!Objects.isNull(order)) {
|
pakinItem.setType(null == order.getType() ? null : order.getType())
|
.setWkType(null == order.getWkType() ? null : Short.parseShort(order.getWkType()));
|
}
|
items.add(pakinItem);
|
}
|
if (!waitPakinItemService.saveBatch(items)) {
|
throw new CoolException("组托明细保存失败！！");
|
}
|
} else {
|
double sum = param.getTaskItemList().stream()
|
.map(TaskItem::getInputQty)
|
.filter(Objects::nonNull)
|
.reduce(BigDecimal.ZERO, BigDecimal::add)
|
.doubleValue();
|
waitPakin
|
.setAnfme(waitPakin.getAnfme() + sum)
|
.setUpdateBy(userId)
|
.setCreateBy(userId);
|
if (!waitPakinService.updateById(waitPakin)) {
|
throw new CoolException("组托主单保存失败！！");
|
}
|
List<WaitPakinItem> existPakinItems = waitPakinItemService
|
.list(new LambdaQueryWrapper<WaitPakinItem>().eq(WaitPakinItem::getPakinId, waitPakin.getId()));
|
List<WaitPakinItem> items = new ArrayList<>();
|
for (TaskItem taskItem : param.getTaskItemList()) {
|
Optional<WaitPakinItem> optionalItem = existPakinItems.stream()
|
.filter(e -> Objects.equals(e.getMatnrCode(), taskItem.getMatnrCode())
|
&& Objects.equals(e.getBatch(), taskItem.getSplrBatch())
|
&& Objects.equals(e.getPlatWorkCode(), taskItem.getPlatWorkCode())
|
&& Objects.equals(e.getPlatItemId(), taskItem.getPlatItemId())
|
)
|
.findFirst();
|
|
if (optionalItem.isPresent()) {
|
WaitPakinItem existItem = optionalItem.get();
|
existItem.setAnfme(existItem.getAnfme() + taskItem.getInputQty().doubleValue())
|
.setUpdateBy(userId);
|
if (!items.contains(existItem)) {
|
items.add(existItem);
|
}
|
} else {
|
WaitPakinItem pakinItem = new WaitPakinItem();
|
pakinItem.setAnfme(taskItem.getInputQty().doubleValue())
|
.setPakinId(waitPakin.getId())
|
.setSource(taskItem.getId())
|
.setAsnId(taskItem.getSourceId())
|
.setAsnCode(taskItem.getSourceCode())
|
.setAsnItemId(taskItem.getSource())
|
.setIsptResult(taskItem.getIsptResult())
|
.setPlatItemId(taskItem.getPlatItemId())
|
.setPlatOrderCode(taskItem.getPlatOrderCode())
|
.setPlatWorkCode(taskItem.getPlatWorkCode())
|
.setProjectCode(taskItem.getProjectCode())
|
.setBatch(taskItem.getSplrBatch())
|
.setUnit(taskItem.getUnit())
|
.setFieldsIndex(taskItem.getFieldsIndex())
|
.setMatnrId(taskItem.getMatnrId())
|
.setMaktx(taskItem.getMaktx())
|
.setUpdateBy(userId)
|
.setCreateBy(userId)
|
.setMatnrCode(taskItem.getMatnrCode());
|
WkOrder order = asnOrderService.getById(taskItem.getSourceId());
|
if (!Objects.isNull(order)) {
|
pakinItem.setType(null == order.getType() ? null : order.getType())
|
.setWkType(null == order.getWkType() ? null : Short.parseShort(order.getWkType()));
|
}
|
items.add(pakinItem);
|
existPakinItems.add(pakinItem);
|
}
|
}
|
if (!waitPakinItemService.saveOrUpdateBatch(items)) {
|
throw new CoolException("组托明细保存失败！！");
|
}
|
}
|
|
return R.ok();
|
}
|
|
@Override
|
public R taskItemList(PdaGeneralParam param, Long loginUserId) {
|
if (Cools.isEmpty(param.getContainerNo())) {
|
throw new CoolException("无容器号");
|
}
|
Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, param.getContainerNo()));
|
if (null == task) {
|
throw new CoolException("未找到任务");
|
}
|
if (!task.getResource().equals(TaskResouceType.TASK_RESOUCE_STOCK_UP.val)) {
|
throw new CoolException("当前托盘不是备货出库任务");
|
}
|
List<TaskItem> taskItems = taskItemService
|
.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
|
|
return R.ok(taskItems);
|
}
|
|
@Override
|
public R getWaveListItem(String barcode) {
|
LambdaQueryWrapper<Wave> lambdaQueryWrapper = new LambdaQueryWrapper<>();
|
lambdaQueryWrapper.eq(!Cools.isEmpty(barcode), Wave::getCode, barcode);
|
List<Wave> waveList = waveService.list(lambdaQueryWrapper);
|
return R.ok(waveList);
|
}
|
|
@Override
|
public R getContainerWaveList(Map<String, String> map) {
|
String barcode = map.get("barcode");
|
|
if (Cools.isEmpty(barcode)) {
|
throw new CoolException("参数有误");
|
}
|
Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, barcode).last("limit 1"));
|
if (null == task) {
|
throw new CoolException("未找到容器号对应任务");
|
}
|
if (!task.getTaskStatus().equals(TaskStsType.AWAIT.id)) {
|
return R.error("任务状态不是等待确认");
|
}
|
ArrayList<ContainerWaveDto> containerWaveDtos = new ArrayList<>();
|
List<TaskItem> taskItems = taskItemService
|
.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
|
for (TaskItem taskItem : taskItems) {
|
ContainerWaveDto containerWaveDto = new ContainerWaveDto();
|
containerWaveDto.setTaskItem(taskItem);
|
Wave wave = waveService.getById(taskItem.getSourceId());
|
if (null == wave) {
|
throw new CoolException("未找到容器号对应波次");
|
}
|
List<WaveOrderRela> waveOrderRelas = waveOrderRelaService
|
.list(new LambdaQueryWrapper<WaveOrderRela>().eq(WaveOrderRela::getWaveId, wave.getId()));
|
if (Cools.isEmpty(waveOrderRelas)) {
|
throw new CoolException("波次对应关联单未找到");
|
}
|
Set<Long> ids = waveOrderRelas.stream().map(WaveOrderRela::getOrderId).collect(Collectors.toSet());
|
ArrayList<WkOrderItem> list = new ArrayList<>();
|
List<WkOrder> wkOrderList = asnOrderService.list(new LambdaQueryWrapper<WkOrder>().in(WkOrder::getId, ids));
|
for (WkOrder wkOrder : wkOrderList) {
|
List<WkOrderItem> orderItem = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>()
|
.eq(WkOrderItem::getOrderId, wkOrder.getId())
|
.eq(StringUtils.isNotEmpty(taskItem.getMatnrCode()), WkOrderItem::getMatnrCode,
|
taskItem.getMatnrCode())
|
// .eq(StringUtils.isNotEmpty(taskItem.getBatch()), WkOrderItem::getSplrBatch,
|
// taskItem.getBatch())
|
);
|
if (null != orderItem) {
|
list.addAll(orderItem);
|
}
|
}
|
containerWaveDto.setWkOrderItems(list);
|
containerWaveDtos.add(containerWaveDto);
|
}
|
|
return R.ok(containerWaveDtos);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
@Synchronized
|
public R saveWavePick(ContainerWaveParam containerWaveParam, Long loginUserId) {
|
if (null == containerWaveParam || containerWaveParam.getContainerWaveDtos().size() <= 0) {
|
return R.error("参数错误");
|
}
|
Task task = taskService.getOne(
|
new LambdaQueryWrapper<Task>().eq(Task::getBarcode, containerWaveParam.getContainer()).last("limit 1"));
|
if (null == task) {
|
return R.error("未找到托盘对应的任务");
|
}
|
if (!task.getTaskStatus().equals(TaskStsType.AWAIT.id)) {
|
return R.error("任务状态不是等待确认");
|
}
|
|
for (ContainerWaveDto containerWaveDto : containerWaveParam.getContainerWaveDtos()) {
|
// 做一次校验，判断前端所有出库数量是否超过本托出库数量
|
double sum = containerWaveDto.getWkOrderItems().stream().mapToDouble(WkOrderItem::getDemandQty).sum();
|
BigDecimal total = new BigDecimal(String.valueOf(sum));
|
BigDecimal anfme = new BigDecimal(containerWaveDto.getTaskItem().getAnfme().toString());
|
if (!anfme.equals(total)) {
|
throw new CoolException("播种数量不等于容器出库数量，请检查");
|
}
|
for (WkOrderItem oldOrderItem : containerWaveDto.getWkOrderItems()) {
|
if (Double.compare(oldOrderItem.getDemandQty(), 0.0) == 0) {
|
continue;
|
}
|
WkOrderItem orderItem = asnOrderItemService.getById(oldOrderItem.getId());
|
BigDecimal num = new BigDecimal(orderItem.getWorkQty().toString())
|
.subtract(new BigDecimal(orderItem.getQty().toString()));
|
BigDecimal orderDemandQty = new BigDecimal(oldOrderItem.getDemandQty().toString());
|
if (num.compareTo(orderDemandQty) < 0) {
|
throw new CoolException("播种数量大于单据出库数量，请检查");
|
}
|
WkOrder wkOrder = asnOrderService.getById(orderItem.getOrderId());
|
if (Cools.isEmpty(wkOrder)) {
|
throw new CoolException("出库单主单未找到");
|
}
|
wkOrder.setQty(new BigDecimal(wkOrder.getQty().toString()).add(orderDemandQty).doubleValue());
|
if (!asnOrderService.updateById(wkOrder)) {
|
throw new CoolException("出库单更新状态失败");
|
}
|
orderItem.setQty(new BigDecimal(orderItem.getQty().toString()).add(orderDemandQty).doubleValue());
|
if (!asnOrderItemService.updateById(orderItem)) {
|
throw new CoolException("单据明细更新失败");
|
}
|
// 检查单据是否完成
|
Boolean orderChecked = checkOrderComplete(orderItem);
|
if (orderChecked) {
|
wkOrder.setExceStatus(AsnExceStatus.OUT_STOCK_STATUS_TASK_DONE.val);
|
if (!asnOrderService.updateById(wkOrder)) {
|
throw new CoolException("出库单更新状态失败");
|
}
|
}
|
}
|
// 检查波次是否完成
|
// Boolean waveChecked = checkWaveComplete(containerWaveDto.getTaskItem());
|
// if (waveChecked){
|
// Wave wave =
|
// waveService.getById(containerWaveDto.getTaskItem().getSourceId());
|
// if (null == wave){
|
// throw new CoolException("未找到容器号对应波次");
|
// }
|
// wave.setExceStatus(WaveExceStatus.WAVE_EXCE_STATUS_TASK.val);
|
// if (!waveService.updateById(wave)){
|
// throw new CoolException("波次单更新状态失败");
|
// }
|
// }
|
|
}
|
|
task.setTaskStatus(TaskStsType.COMPLETE_OUT.id);
|
if (!taskService.updateById(task)) {
|
throw new CoolException("任务状态更新失败");
|
}
|
|
return R.ok();
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
@Synchronized
|
public R callForEmptyContainers(CallForEmptyContainersParam containerWaveParam, Long loginUserId) {
|
// 参数校验
|
if (Objects.isNull(containerWaveParam) || StringUtils.isEmpty(containerWaveParam.getStaNo())) {
|
throw new CoolException("参数错误，站点号不能为空");
|
}
|
// 1. 站点信息判断 - 终点
|
BasStation basStation = basStationService.getOne(new LambdaQueryWrapper<BasStation>()
|
.eq(BasStation::getStationName, containerWaveParam.getStaNo())
|
.orderByDesc(BasStation::getId)
|
.last("LIMIT 1"));
|
|
if (Objects.isNull(basStation)) {
|
throw new CoolException(containerWaveParam.getStaNo() + "站点不存在！！");
|
}
|
if (!basStation.getUseStatus().equals("O")) {
|
throw new CoolException("站点状态不为空闲");
|
}
|
|
List<Long> areaList = basStation.getCrossZoneArea();
|
if (Cools.isEmpty(areaList)) {
|
throw new CoolException("当前站点库区未配置");
|
}
|
|
BasContainer basContainer = basContainerService.getOne(new LambdaQueryWrapper<BasContainer>()
|
.in(BasContainer::getContainerType, containerWaveParam.getType(), false).last("limit 1"));
|
if (Cools.isEmpty(basContainer)) {
|
throw new CoolException("未查询到相关容器规则");
|
}
|
String barcodeType = "barcode REGEXP '" + basContainer.getCodeType() + "'";
|
// 容器类型查询 起点
|
Loc loc = locService.getOne(new LambdaQueryWrapper<Loc>()
|
.apply(barcodeType)
|
.eq(Loc::getDeleted, 0)
|
.eq(Loc::getStatus, 1)
|
.eq(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_D.type)
|
.in(Loc::getAreaId, areaList)
|
.orderByDesc(Loc::getId)
|
.last("LIMIT 1"),
|
false);
|
|
if (Cools.isEmpty(loc)) {
|
throw new CoolException("未查询到符合条件的托盘");
|
}
|
// 生成任务参数
|
LocToTaskParams locToTaskParams = new LocToTaskParams();
|
locToTaskParams.setType(Constants.TASK_TYPE_OUT_STOCK_EMPTY)
|
.setSiteNo(basStation.getStationName())
|
.setOrgLoc(loc.getId().toString());
|
try {
|
locItemService.generateTaskEmpty(TaskResouceType.TASK_RESOUCE_STOCK_TYPE.val, locToTaskParams, loginUserId,
|
containerWaveParam.getTaskNo());
|
} catch (Exception e) {
|
throw new CoolException(e.getMessage());
|
}
|
return R.ok();
|
}
|
|
private Boolean checkWaveComplete(TaskItem taskItem) {
|
Wave wave = waveService.getById(taskItem.getSourceId());
|
List<WkOrder> wkOrderList = asnOrderService
|
.list(new LambdaQueryWrapper<WkOrder>().eq(WkOrder::getWaveId, wave.getId()));
|
return wkOrderList.stream().allMatch(
|
item -> new BigDecimal(item.getAnfme().toString()).equals(new BigDecimal(item.getQty().toString())));
|
}
|
|
private Boolean checkOrderComplete(WkOrderItem orderItem) {
|
List<WkOrderItem> wkOrderItems = asnOrderItemService
|
.list(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getOrderCode, orderItem.getOrderCode()));
|
return wkOrderItems.stream().allMatch(
|
item -> new BigDecimal(item.getAnfme().toString()).equals(new BigDecimal(item.getQty().toString())));
|
}
|
}
|
