package com.vincent.rsf.server.api.service.impl;
|
|
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.ContainerWaveParam;
|
import com.vincent.rsf.server.api.service.PdaOutStockService;
|
import com.vincent.rsf.server.manager.entity.*;
|
import com.vincent.rsf.server.manager.enums.AsnExceStatus;
|
import com.vincent.rsf.server.manager.enums.TaskStsType;
|
import com.vincent.rsf.server.manager.enums.WaveExceStatus;
|
import com.vincent.rsf.server.manager.service.*;
|
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.ArrayList;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
|
@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;
|
|
@Override
|
public R getOutStockTaskItem(String barcode) {
|
LambdaQueryWrapper<Task> lambdaQueryWrapper = new LambdaQueryWrapper<>();
|
lambdaQueryWrapper.eq(Task::getBarcode, barcode);
|
Task task = taskService.getOne(lambdaQueryWrapper);
|
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 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));
|
if (null == task){
|
throw new CoolException("未找到容器号对应任务");
|
}
|
if (task.getTaskStatus().equals(TaskStsType.COMPLETE_OUT.id)){
|
throw new CoolException("当前状态为不可拣货状态");
|
}
|
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("未找到容器号对应波次");
|
}
|
ArrayList<AsnOrderItem> list = new ArrayList<>();
|
List<AsnOrder> asnOrderList = asnOrderService.list(new LambdaQueryWrapper<AsnOrder>().eq(AsnOrder::getWaveId, wave.getId()));
|
for (AsnOrder asnOrder : asnOrderList) {
|
AsnOrderItem orderItem = asnOrderItemService.getOne(new LambdaQueryWrapper<AsnOrderItem>()
|
.eq(AsnOrderItem::getAsnId, asnOrder.getId())
|
.eq(AsnOrderItem::getMatnrCode, taskItem.getMatnrCode())
|
.eq(AsnOrderItem::getSplrBatch, taskItem.getBatch())
|
);
|
if (null != orderItem){
|
list.add(orderItem);
|
}
|
|
|
}
|
containerWaveDto.setAsnOrderItems(list);
|
containerWaveDtos.add(containerWaveDto);
|
}
|
|
return R.ok(containerWaveDtos);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
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()));
|
if (null == task){
|
return R.error("未找到托盘对应的任务");
|
}
|
|
for (ContainerWaveDto containerWaveDto : containerWaveParam.getContainerWaveDtos()) {
|
//做一次校验，判断前端所有出库数量是否超过本托出库数量
|
double sum = containerWaveDto.getAsnOrderItems().stream().mapToDouble(AsnOrderItem::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 (AsnOrderItem orderItem : containerWaveDto.getAsnOrderItems()) {
|
if (Double.compare(orderItem.getDemandQty(), 0.0) == 0) {
|
continue;
|
}
|
BigDecimal num = new BigDecimal(orderItem.getWorkQty().toString()).subtract(new BigDecimal(orderItem.getQty().toString()));
|
BigDecimal orderDemandQty = new BigDecimal(orderItem.getDemandQty().toString());
|
if (num.compareTo(orderDemandQty) < 0){
|
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){
|
AsnOrder asnOrder = asnOrderService.getById(orderItem.getAsnId());
|
if (Cools.isEmpty(asnOrder)){
|
throw new CoolException("出库单主单未找到");
|
}
|
asnOrder.setExceStatus(AsnExceStatus.OUT_STOCK_STATUS_TASK_DONE.val);
|
if (!asnOrderService.updateById(asnOrder)){
|
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_DONE.val);
|
if (!waveService.updateById(wave)){
|
throw new CoolException("波次单更新状态失败");
|
}
|
}
|
|
}
|
|
task.setTaskStatus(TaskStsType.COMPLETE_OUT.id);
|
if (!taskService.updateById(task)){
|
throw new CoolException("任务状态更新失败");
|
}
|
|
|
return R.ok();
|
}
|
|
private Boolean checkWaveComplete(TaskItem taskItem) {
|
Wave wave = waveService.getById(taskItem.getSourceId());
|
List<AsnOrder> asnOrderList = asnOrderService.list(new LambdaQueryWrapper<AsnOrder>().eq(AsnOrder::getWaveId, wave.getId()));
|
return asnOrderList.stream().allMatch(item -> new BigDecimal(item.getAnfme().toString()).equals(new BigDecimal(item.getQty().toString())));
|
}
|
|
private Boolean checkOrderComplete(AsnOrderItem orderItem) {
|
List<AsnOrderItem> asnOrderItems = asnOrderItemService.list(new LambdaQueryWrapper<AsnOrderItem>().eq(AsnOrderItem::getAsnCode, orderItem.getAsnCode()));
|
return asnOrderItems.stream().allMatch(item -> new BigDecimal(item.getAnfme().toString()).equals(new BigDecimal(item.getQty().toString())));
|
}
|
}
|
