盘点功能优化

skyouc

2 天以前 ae2b0889d677be95535349c389bfb041b18a27ef

 rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/TaskServiceImpl.java

@@ -33,6 +33,7 @@

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

@Service("taskService")
public class TaskServiceImpl extends ServiceImpl<TaskMapper, Task> implements TaskService {
@@ -683,13 +684,13 @@
        if (taskItems.isEmpty()) {
            throw new CoolException("任务明细不存在！！");
        }

        List<LocItem> items = new ArrayList<>();
        for (TaskItem taskItem : taskItems) {
            LocItem locItem = new LocItem();
            LocItemWorking locWorking = locItemWorkingService.getOne(new LambdaQueryWrapper<LocItemWorking>()
                    .eq(LocItemWorking::getTaskId, taskItem.getTaskId())
                    .eq(StringUtils.isNotBlank(taskItem.getBatch()), LocItemWorking::getBatch, taskItem.getBatch())
//                    .eq(StringUtils.isNotBlank(taskItem.getFieldsIndex()), LocItemWorking::getFieldsIndex, taskItem.getFieldsIndex())
                    .eq(LocItemWorking::getMatnrId, taskItem.getMatnrId()));
            if (Objects.isNull(locWorking)) {
                throw new CoolException("数据错误，作业中库存数据丢失！！");
@@ -775,29 +776,9 @@
                List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().in(TaskItem::getTaskId, Arrays.asList(ids)));
                if (!taskItems.isEmpty()) {
                    taskItems.forEach(taskItem -> {
                        if (!checkOrderItemService.update(new LambdaUpdateWrapper<WkOrderItem>()
                                .eq(WkOrderItem::getId, taskItem.getOrderItemId())
                                .setSql("work_qty = work_qty - " + taskItem.getAnfme()))) {
                            throw new CoolException("明细数量修改失败！！");
                        }
                        checkDiffItemService.remove(new LambdaQueryWrapper<CheckDiffItem>().eq(CheckDiffItem::getTaskItemId, taskItem.getId()));

                        if (!checkOrderService.update(new LambdaUpdateWrapper<WkOrder>()
                                .eq(WkOrder::getId, taskItem.getOrderId())
                                .setSql("work_qty = work_qty - " + taskItem.getAnfme()))) {
                            throw new CoolException("盘点单执行数量修改失败！！");
                        }

                        List<CheckDiffItem> diffItems = checkDiffItemService
                                .list(new LambdaQueryWrapper<CheckDiffItem>()
                                .eq(CheckDiffItem::getTaskItemId, taskItem.getTaskId()));
                        if (!diffItems.isEmpty()) {
                            CheckDiffItem item = diffItems.stream().findFirst().get();
                            List<CheckDiffItem> items = checkDiffItemService.list(new LambdaQueryWrapper<CheckDiffItem>()
                                    .eq(CheckDiffItem::getId, item.getCheckId()));
                            if (items.isEmpty()) {
                                checkDiffService.removeById(item.getCheckId());
                            }
                        }
                        checkDiffService.removeById(taskItem.getSourceId());
                    });
                }

@@ -991,46 +972,84 @@
        if (!this.updateById(task)) {
            throw new CoolException("任务状态更新失败！！");
        }

        //获取因当前任务出库的所有物料信息
        List<LocItemWorking> tempLocs = locItemWorkingService.list(new LambdaQueryWrapper<LocItemWorking>().eq(LocItemWorking::getTaskId, task.getId()));
        if (tempLocs.isEmpty()) {
            throw new CoolException("数据错误，作业中库存数据丢失！！");
        }
        List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
        for (int i = 0; i < taskItems.size(); i++) {
            TaskItem taskItem = taskItems.get(i);
            LocItemWorking locWorking = locItemWorkingService.getOne(new LambdaQueryWrapper<LocItemWorking>()
                    .eq(LocItemWorking::getTaskId, taskItem.getTaskId())
                    .eq(StringUtils.isNotBlank(taskItem.getBatch()), LocItemWorking::getBatch, taskItem.getBatch())
//                    .eq(StringUtils.isNotBlank(taskItem.getFieldsIndex()), LocItemWorking::getFieldsIndex, taskItem.getFieldsIndex())
                    .eq(LocItemWorking::getMatnrId, taskItem.getMatnrId()));
            if (Objects.isNull(locWorking)) {
                throw new CoolException("数据错误，作业中库存数据丢失！！");
            }
            if (task.getTaskType().equals(TaskType.TASK_TYPE_CHECK_IN.type)) {
                locWorking.setWorkQty(0.0);
                locWorking.setAnfme(taskItem.getAnfme());
            } else {
                if (locWorking.getAnfme().compareTo(taskItem.getAnfme()) >= 0) {
                    locWorking.setWorkQty(0.0);
                    locWorking.setAnfme(Math.round((locWorking.getAnfme() - taskItem.getAnfme()) * 10000) / 10000.0);
                } else {
                    continue;
        if (taskItems.isEmpty()) {
            throw new CoolException("数据错误：任务明细为空！！");
        }

        tempLocs.forEach(working -> {
            taskItems.forEach(taskItem -> {
                if (taskItem.getMatnrId().equals(working.getMatnrId())) {
                    Double minQty = taskItem.getAnfme();
                    if (!task.getTaskType().equals(TaskType.TASK_TYPE_CHECK_IN.type)) {
                        minQty = Math.round((working.getAnfme() - taskItem.getAnfme()) * 10000) / 10000.0;
                    }
                    if (minQty.compareTo(0.0) > 0) {
                        taskItem.setAnfme(minQty);
                        if (!taskItemService.updateById(taskItem)) {
                            throw new CoolException("任务明细修改失败！！");
                        }
                    } else {
                        if (!taskItemService.removeById(taskItem)) {
                            throw new CoolException("任务明细修改失败！！");
                        }
                    }
                }
            }
            if (!locItemWorkingService.updateById(locWorking)) {
                throw new CoolException("临时库存更新失败！！");
            }
            taskItems.get(i).setAnfme(locWorking.getAnfme());
        }

        if (!taskItemService.updateBatchById(taskItems)) {
            throw new CoolException("任务明细更新失败！！");
        }

        Loc one = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getCode, task.getTargLoc()));
        if (Objects.isNull(one)) {
            });
        });
        List<Long> matnrIds = taskItems.stream().map(TaskItem::getMatnrId).collect(Collectors.toList());
        //删除与任务明细重复的库存信息，以任务明细为准
        List<LocItemWorking> itemWorkings = tempLocs.stream()
                .filter(working -> !matnrIds.contains(working.getMatnrId()))
                .collect(Collectors.toList());
        itemWorkings.forEach(working -> {
            TaskItem taskItem = taskItems.stream().findFirst().get();
            taskItem.setMatnrId(working.getMatnrId())
                    .setMaktx(working.getMaktx())
                    .setMatnrId(working.getMatnrId())
                    .setMatnrCode(working.getMatnrCode())
                    .setSpec(working.getSpec())
                    .setAnfme(working.getAnfme())
                    .setBatch(working.getBatch())
                    .setFieldsIndex(working.getFieldsIndex())
                    .setUnit(working.getUnit())
                    .setId(null)
                    .setModel(working.getModel());

            if (!taskItemService.saveOrUpdate(taskItem)) {
                throw new CoolException("临时库存转任务明细失败！！");
            }
        });

        locItemWorkingService.remove(new LambdaQueryWrapper<LocItemWorking>().eq(LocItemWorking::getTaskId, task.getId()));
        Loc loc1 = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getCode, task.getTargLoc()));
        if (Objects.isNull(loc1)) {
            throw new CoolException("目标库位不存在！！");
        }
        one.setUseStatus(LocStsType.LOC_STS_TYPE_S.type);

        if (!locService.updateById(one)) {
        List<LocItemWorking> workings = new ArrayList<>();
        List<TaskItem> items = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
        items.forEach(taskItem -> {
            LocItemWorking itemWorking = new LocItemWorking();
            BeanUtils.copyProperties(taskItem, itemWorking);
            itemWorking.setTaskId(task.getId()).setLocId(loc1.getId()).setLocCode(loc1.getCode());
            workings.add(itemWorking);
        });

        if (!locItemWorkingService.saveBatch(workings)) {
            throw new CoolException("临时库存更新失败！！");
        }

        loc1.setUseStatus(LocStsType.LOC_STS_TYPE_S.type);

        if (!locService.updateById(loc1)) {
            throw new CoolException("库位预约入库失败！！");
        }
        return task;
@@ -1098,35 +1117,41 @@
         * */
        List<TaskItem> list = listMap.get(Short.parseShort(OrderWorkType.ORDER_WORK_TYPE_STOCK_OUT.type));
        if (Objects.isNull(list) || list.isEmpty()) {
                Map<Long, List<TaskItem>> maps = taskItems.stream().collect(Collectors.groupingBy(TaskItem::getSource));
                maps.keySet().forEach(key -> {
                    if (task.getResource().equals(TaskResouceType.TASK_RESOUCE_WAVE_TYPE.val)) {
                        WaveItem waveItem = waveItemService.getById(key);
                        if (Objects.isNull(waveItem)) {
                            throw new CoolException("波次明细不存在！！");
                        }
                        try {
                            saveOutStockItem(maps.get(key), null, waveItem, loginUserId);
                        } catch (Exception e) {
                            throw new CoolException(e.getMessage());
                        }
                    } else if (task.getResource().equals(TaskResouceType.TASK_RESOUCE_ORDER_TYPE.val) || task.getResource().equals(TaskResouceType.TASK_RESOUCE_CHECK_TYPE.val)) {
                        WkOrderItem orderItem = asnOrderItemService.getById(key);
                        if (Objects.isNull(orderItem)) {
                            throw new CoolException("单据明细不存在！！");
                        }
                        try {
                            saveOutStockItem(maps.get(key), orderItem, null, loginUserId);
                        } catch (Exception e) {
                            throw new CoolException(e.getMessage());
                        }
            Map<Long, List<TaskItem>> maps = taskItems.stream().collect(Collectors.groupingBy(TaskItem::getSource));
            maps.keySet().forEach(key -> {
                if (task.getResource().equals(TaskResouceType.TASK_RESOUCE_WAVE_TYPE.val)) {
                    WaveItem waveItem = waveItemService.getById(key);
                    if (Objects.isNull(waveItem)) {
                        throw new CoolException("波次明细不存在！！");
                    }
                    try {
                        saveOutStockItem(maps.get(key), null, waveItem, null, loginUserId);
                    } catch (Exception e) {
                        throw new CoolException(e.getMessage());
                    }
                } else if (task.getResource().equals(TaskResouceType.TASK_RESOUCE_ORDER_TYPE.val) || task.getResource().equals(TaskResouceType.TASK_RESOUCE_CHECK_TYPE.val)) {
                    WkOrderItem orderItem = new WkOrderItem();
                    if (task.getResource().equals(TaskResouceType.TASK_RESOUCE_CHECK_TYPE.val)) {
                        CheckDiffItem diffItem = checkDiffItemService.getById(key);
                    } else {
                        orderItem = asnOrderItemService.getById(key);

                    }
                });
                    if (Objects.isNull(orderItem)) {
                        throw new CoolException("单据明细不存在！！");
                    }
                    try {
                        saveOutStockItem(maps.get(key), orderItem, null, null, loginUserId);
                    } catch (Exception e) {
                        throw new CoolException(e.getMessage());
                    }
                } else {

                }
            });
        } else {
            try {
                saveOutStockItem(taskItems, null, null, loginUserId);
                saveOutStockItem(taskItems, null, null, null, loginUserId);
            } catch (Exception e) {
                throw new CoolException(e.getMessage());
            }
@@ -1173,7 +1198,22 @@
     * @version 1.0
     */
    @Transactional(rollbackFor = Exception.class)
    public void saveOutStockItem(List<TaskItem> taskItems, WkOrderItem orderItem, WaveItem waveItem, Long loginUserId) throws Exception {
    public void saveOutStockItem(List<TaskItem> taskItems, CheckDiffItem diffItem, Long loginUserId) {
        try {
            saveOutStockItem(taskItems, null, null, diffItem, loginUserId);
        } catch (Exception e) {
            throw new CoolException(e);
        }
    }

    /**
     * @author Ryan
     * @date 2025/5/20
     * @description: 出库信息保存至库存明细表
     * @version 1.0
     */
    @Transactional(rollbackFor = Exception.class)
    public void saveOutStockItem(List<TaskItem> taskItems, WkOrderItem orderItem, WaveItem waveItem, CheckDiffItem diffItem, Long loginUserId) throws Exception {
        Stock stock = new Stock();
        String ruleCode = SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_STOCK_CODE, null);
        if (StringUtils.isBlank(ruleCode)) {
@@ -1192,6 +1232,9 @@
            WkOrder wkOrder = asnOrderService.getById(orderItem.getOrderId());
            stock.setWkType(Short.parseShort(wkOrder.getWkType()))
                    .setType(OrderType.ORDER_OUT.type);
        } else if (!Objects.isNull(diffItem)) {
            stock.setWkType(Short.parseShort(OrderWorkType.ORDER_WORK_TYPE_STOCK_CHECK.type))
                    .setType(OrderType.ORDER_CHECK.type);
        } else {
            //TODO 生成波次时需要将波次号写入单据，通过物料，批次，动态字段等唯一值反查单据信息
            stock.setSourceId(waveItem.getId()).setType(OrderType.ORDER_OUT.type);