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.entity.params.WavePickItemsParams;
|
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.service.*;
|
import com.vincent.rsf.server.system.entity.Fields;
|
import com.vincent.rsf.server.system.entity.FieldsItem;
|
import com.vincent.rsf.server.system.service.FieldsItemService;
|
import com.vincent.rsf.server.system.service.FieldsService;
|
import com.vincent.rsf.server.system.service.impl.FieldsItemServiceImpl;
|
import com.vincent.rsf.server.system.service.impl.FieldsServiceImpl;
|
import com.vincent.rsf.server.system.utils.SystemAuthUtils;
|
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 org.springframework.web.bind.annotation.RequestBody;
|
|
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 FieldsItemService fieldsItemService;
|
@Autowired
|
private FieldsService fieldsService;
|
|
@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 saveOutTaskSts(String barcode) {
|
LambdaQueryWrapper<Task> lambdaQueryWrapper = new LambdaQueryWrapper<>();
|
lambdaQueryWrapper.eq(Task::getBarcode, barcode);
|
Task task = taskService.getOne(lambdaQueryWrapper);
|
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
|
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.AWAIT.id)) {
|
return R.error("任务状态不是等待确认");
|
}
|
List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
|
Set<Long> longSet = taskItems.stream().map(TaskItem::getSourceId).collect(Collectors.toSet());
|
List<WaveOrderRela> waveOrderRelas = waveOrderRelaService.list(new LambdaQueryWrapper<WaveOrderRela>()
|
.in(WaveOrderRela::getWaveId, longSet));
|
if (Cools.isEmpty(waveOrderRelas)) {
|
throw new CoolException("波次对应关联单未找到");
|
}
|
Set<Long> orderIds = waveOrderRelas.stream().map(WaveOrderRela::getOrderId).collect(Collectors.toSet());
|
List<WkOrder> wkOrders = asnOrderService.listByIds(orderIds);
|
if (wkOrders.isEmpty()) {
|
throw new CoolException("单据不存在！！");
|
}
|
Set<String> codes = taskItems.stream().map(TaskItem::getMatnrCode).collect(Collectors.toSet());
|
List<WkOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>()
|
.in(WkOrderItem::getMatnrCode, codes)
|
.in(WkOrderItem::getOrderId, orderIds));
|
|
return R.ok("查询成功").add(orderItems);
|
|
// 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("查询成功").add(wkOrders);
|
}
|
|
/**
|
* @author Ryan
|
* @date 2025/11/13
|
* @description: 获取波次拣货明细
|
* @version 1.0
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public R getWaveOrderItems(Map<String, Object> param) {
|
if (Objects.isNull(param)) {
|
return R.error("参数不能为空！！");
|
}
|
if (Objects.isNull(param.get("fieldsIndex"))) {
|
return R.error("票号不能为空！！");
|
}
|
if (Objects.isNull(param.get("barcode"))) {
|
return R.error("容器号不能为空！！");
|
}
|
if (Objects.isNull(param.get("orderId"))) {
|
return R.error("订单ID不能为空！！");
|
}
|
Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, param.get("barcode").toString()));
|
if (Objects.isNull(task)) {
|
throw new CoolException("数据错误，任务档已不存在！！");
|
}
|
FieldsItem fieldsItem = fieldsItemService.getOne(new LambdaQueryWrapper<FieldsItem>()
|
.eq(FieldsItem::getValue, param.get("fieldsIndex").toString())
|
.last("limit 1"));
|
if (Objects.isNull(fieldsItem)) {
|
return R.error("数据错误，票号不存在！！");
|
}
|
TaskItem taskItem = taskItemService.getOne(new LambdaQueryWrapper<TaskItem>()
|
.eq(TaskItem::getFieldsIndex, fieldsItem.getUuid())
|
.eq(TaskItem::getTaskId, task.getId()));
|
if (Objects.isNull(taskItem)) {
|
return R.error("数据错误，任务档明细不存在！！");
|
}
|
// Long orderId = Long.valueOf(param.get("orderId").toString());
|
// List<WkOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getOrderId, orderId));
|
// if (orderItems.isEmpty()) {
|
// return R.error("数据错误，订单数据不存在！！");
|
// }
|
//根据索引获取动态字段Value值
|
Map<String, String> fields = new HashMap<>();
|
Fields fields1 = fieldsService.getById(fieldsItem.getFieldsId());
|
fields.put(fields1.getFields(), fieldsItem.getValue());
|
taskItem.setExtendFields(fields);
|
|
return R.ok().add(taskItem);
|
}
|
|
/**
|
* @author Ryan
|
* @date 2025/11/13
|
* @description: 波次明细拣货
|
* @version 1.0
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public R wavePickItems(WavePickItemsParams params) {
|
if (Objects.isNull(params.getBarcode())) {
|
return R.error("托盘码不能为空！！");
|
}
|
if (Objects.isNull(params.getOrderId())) {
|
return R.error("订单ID不能为空！！");
|
}
|
if (Objects.isNull(params.getTaskItems()) || params.getTaskItems().isEmpty()) {
|
return R.error("拣货明细不能为空！");
|
}
|
Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, params.getBarcode()));
|
if (null == task) {
|
return R.error("未找到托盘对应的任务");
|
}
|
if (!task.getTaskStatus().equals(TaskStsType.AWAIT.id)) {
|
return R.error("任务状态不是等待确认");
|
}
|
WkOrder order = asnOrderService.getById(params.getOrderId());
|
if (Objects.isNull(order)) {
|
return R.error("单据信息不存在！！");
|
}
|
List<TaskItem> taskItems = params.getTaskItems();
|
Map<String, List<TaskItem>> listMap = taskItems.stream().collect(Collectors.groupingBy(TaskItem::getMatnrCode));
|
listMap.keySet().forEach(code -> {
|
List<TaskItem> items = listMap.get(code);
|
//一张出库单，相同的品种不会出现两次
|
WkOrderItem orderItem = asnOrderItemService.getOne(new LambdaQueryWrapper<WkOrderItem>()
|
.eq(WkOrderItem::getMatnrCode, code)
|
.eq(WkOrderItem::getOrderId, order.getId()));
|
if (Objects.isNull(orderItem)) {
|
throw new CoolException("数据错误，拣料不在单据需求中！！");
|
}
|
Double summed = items.stream().mapToDouble(TaskItem::getAnfme).sum();
|
//加上历史拣料数量
|
Double pickQty = Math.round((orderItem.getQty() + summed) * 10000) / 10000.0;
|
if (pickQty.compareTo(orderItem.getAnfme()) > 0.0) {
|
throw new CoolException("播种数量不能超出订单需求数量");
|
}
|
orderItem.setQty(pickQty);
|
|
if (!asnOrderItemService.updateById(orderItem)) {
|
throw new CoolException("出库单明细更新失败！！");
|
}
|
|
items.forEach(taskItem -> {
|
taskItem.setQty(taskItem.getAnfme());
|
if (!taskItemService.updateById(taskItem)) {
|
throw new CoolException("状态完成失败！！");
|
}
|
});
|
});
|
|
List<WkOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getOrderId, params.getOrderId()));
|
double total = orderItems.stream().mapToDouble(WkOrderItem::getQty).sum();
|
double wkQty = orderItems.stream().mapToDouble(WkOrderItem::getWorkQty).sum();
|
order.setQty(total).setWorkQty(order.getWorkQty() - wkQty);
|
if (!asnOrderService.updateById(order)) {
|
throw new CoolException("订单数量更新失败！！");
|
}
|
//检查单据是否完成
|
if (order.getAnfme().compareTo(order.getQty()) == 0) {
|
order.setExceStatus(AsnExceStatus.OUT_STOCK_STATUS_TASK_DONE.val);
|
if (!asnOrderService.updateById(order)) {
|
throw new CoolException("出库单更新状态失败");
|
}
|
}
|
|
return R.ok();
|
}
|
|
/**
|
* @author Ryan
|
* @date 2025/11/5
|
* @description: 波次拣货
|
* @version 1.0
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
@Synchronized
|
public R saveWavePick(ContainerWaveParam containerWaveParam, Long loginUserId) {
|
if (null == containerWaveParam ) {
|
return R.error("参数错误");
|
}
|
List<WkOrderItem> orderItems = containerWaveParam.getContainerWaveDtos();
|
if (Objects.isNull(orderItems) || orderItems.isEmpty()) {
|
return R.error("数据错误！！");
|
}
|
|
Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, containerWaveParam.getContainer()));
|
if (null == task) {
|
return R.error("未找到托盘对应的任务");
|
}
|
if (!task.getTaskStatus().equals(TaskStsType.AWAIT.id)) {
|
return R.error("任务状态不是等待确认");
|
}
|
|
List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
|
taskItems.forEach(taskItem -> {
|
if (!(taskItem.getQty().compareTo(taskItem.getAnfme()) == 0)) {
|
throw new CoolException("有单据物料未拣，请拣完后再确认！！");
|
}
|
});
|
|
orderItems.forEach(orderItem -> {
|
try {
|
taskService.saveOutStockItem(taskItems, orderItem, null, null, SystemAuthUtils.getLoginUserId());
|
} catch (Exception e) {
|
throw new RuntimeException(e);
|
}
|
});
|
|
// containerWaveParam.getOrderItems().forEach(orderItem -> {
|
//
|
// });
|
// 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("出库单更新状态失败");
|
// }
|
//
|
// if (Objects.isNull(oldOrderItem.getFieldsIndex())) {
|
// throw new CoolException("票号不能为空！！");
|
// }
|
// //Fix 这里只针对希日项目的票号功能，票号和uuid为一对一的情况，不会出现重复的情况
|
// FieldsItem fieldsItem = fieldsItemService.getOne(new LambdaQueryWrapper<FieldsItem>().eq(FieldsItem::getValue, oldOrderItem.getFieldsIndex()).last("limit 1"));
|
// if (!Objects.isNull(fieldsItem)) {
|
// orderItem.setFieldsIndex(fieldsItem.getUuid());
|
// }
|
// 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();
|
}
|
|
|
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())));
|
}
|
}
|
