RCS对接优化

chen.lin

12 小时以前 c81fc5e2a4f4153be2bb8602ed14a0743e6ecd29

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

@@ -1,9 +1,6 @@
package com.vincent.rsf.server.manager.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
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.manager.controller.params.PakinItem;
@@ -11,12 +8,16 @@
import com.vincent.rsf.server.manager.entity.*;
import com.vincent.rsf.server.manager.enums.PakinIOStatus;
import com.vincent.rsf.server.manager.mapper.WaitPakinMapper;
import com.vincent.rsf.server.manager.mapper.MatnrMapper;
import com.vincent.rsf.server.manager.service.*;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.vincent.rsf.server.common.utils.QuantityUtils;
import com.vincent.rsf.server.system.constant.GlobalConfigCode;
import com.vincent.rsf.server.system.constant.SerialRuleCode;
import com.vincent.rsf.server.system.entity.Config;
import com.vincent.rsf.server.system.service.ConfigService;
import com.vincent.rsf.server.system.utils.SerialRuleUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@@ -44,6 +45,10 @@
    private TaskService taskService;
    @Autowired
    private TaskItemService taskItemService;
    @Autowired
    private MatnrMapper matnrMapper;
    @Autowired
    private ConfigService configService;


    /**
@@ -61,121 +66,293 @@
            throw new CoolException("参数错误：物料跟踪码为空！");
        }
        if (StringUtils.isBlank(waitPakin.getBarcode())) {
            throw new CoolException("参数错误：托盘码为空！！");
            throw new CoolException("参数错误：料箱码为空！！");
        }
        List<Short> asList = Arrays.asList(Short.valueOf(PakinIOStatus.PAKIN_IO_STATUS_DONE.val), Short.valueOf(PakinIOStatus.PAKIN_IO_STATUS_DONE.val));
        WaitPakin pakin = waitPakinService.getOne(new LambdaQueryWrapper<WaitPakin>()
                .notIn(WaitPakin::getIoStatus, asList)
                .eq(WaitPakin::getBarcode, waitPakin.getBarcode()));
        if (!Objects.isNull(pakin)) {
            throw new CoolException("托盘码：" + waitPakin.getBarcode() + "已被组托单：" + pakin.getCode() + "使用！！");

        // 半箱时允许同一料箱码继续组托追加；非半箱时料箱码已组托则不可再用
        if (!Objects.isNull(pakin) && !Boolean.TRUE.equals(waitPakin.getIsHalf())) {
            throw new CoolException("已组托，请更换料箱码");
        }

        List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, waitPakin.getBarcode()));
        if (!tasks.isEmpty()) {
            throw new CoolException("当前料箱已有任务档在执行，不能再次组托！！");
        }
        
        // 检查料箱码是否在库存中存在（通过库位表查询）
        List<Loc> locs = locService.list(new LambdaQueryWrapper<Loc>().eq(Loc::getBarcode, waitPakin.getBarcode()));
        if (!locs.isEmpty()) {
            List<String> locCodes = locs.stream().map(Loc::getCode).collect(Collectors.toList());
            String join = StringUtils.join(locCodes, ",");
            throw new CoolException("托盘码：" + waitPakin.getBarcode() + "已被库位：" + join + "使用！！");
            throw new CoolException("在库，请更换料箱码");
        }
        double sum = waitPakin.getItems().stream().mapToDouble(PakinItem::getReceiptQty).sum();

        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(Short.parseShort(PakinIOStatus.PAKIN_IO_STATUS_DONE.val))
                .setAnfme(sum)
                .setUpdateBy(userId)
                .setCreateBy(userId)
                .setBarcode(waitPakin.getBarcode());
        if (!this.save(waitPakin1)) {
            throw new CoolException("主单保存失败！！");
        }
//        /**物料跟踪码*/
//        List<WaitPakinItem> pakinItems = waitPakinItemService.list(new LambdaQueryWrapper<WaitPakinItem>()
//                .eq(WaitPakinItem::getPakinId, waitPakin1.getId()))
//                ;
//        if (!pakinItems.isEmpty()) {
//            if (!waitPakinItemService.remove(new LambdaQueryWrapper<WaitPakinItem>()
//                    .eq(WaitPakinItem::getPakinId, waitPakin1.getId())
//                    )) {
//                throw new CoolException("原单据清除失败！！");
//            }
//        }
        List<WaitPakinItem> items = new ArrayList<>();
        for (PakinItem pakinItem1 : waitPakin.getItems()) {
            //不良标签组托
            WarehouseAreasItem warehouseAreasItems = warehouseAreasItemService.getById(pakinItem1.getId());
            if (null == warehouseAreasItems) {
                throw new CoolException("物料未送至收货区！！");
        Double sum = QuantityUtils.roundToScale(waitPakin.getItems().stream().mapToDouble(PakinItem::getReceiptQty).sum());

        Config directPakinConfig = configService.getOne(new LambdaQueryWrapper<Config>().eq(Config::getFlag, GlobalConfigCode.DIRECT_WAIT_PAKIN));
        boolean directWaitPakin = directPakinConfig != null && Boolean.parseBoolean(directPakinConfig.getVal());

        WaitPakin waitPakin1;
        if (Objects.isNull(pakin)) {
            waitPakin1 = new WaitPakin();
            String ruleCode = SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_WAIT_PAKIN_CODE, null);
            if (StringUtils.isBlank(ruleCode)) {
                throw new CoolException("编码规则错误： 编码规则「SYS_WAIT_PAKIN_CODE」规则是不存在");
            }
            WaitPakinItem pakinItem = new WaitPakinItem();
            pakinItem.setAnfme(warehouseAreasItems.getAnfme())
                    .setPakinId(waitPakin1.getId())
                    .setSource(warehouseAreasItems.getId())
                    .setAsnId(warehouseAreasItems.getAsnId())
                    .setAsnCode(warehouseAreasItems.getAsnCode())
                    .setAsnItemId(warehouseAreasItems.getAsnItemId())
                    .setIsptResult(warehouseAreasItems.getIsptResult())
                    .setBatch(warehouseAreasItems.getSplrBatch())
                    .setUnit(warehouseAreasItems.getStockUnit())
                    .setFieldsIndex(warehouseAreasItems.getFieldsIndex())
                    .setMatnrId(warehouseAreasItems.getMatnrId())
                    .setMaktx(warehouseAreasItems.getMaktx())
            waitPakin1.setCode(ruleCode)
                    .setIoStatus(PakinIOStatus.PAKIN_IO_STATUS_DONE.val)
                    .setAnfme(sum)
                    .setUpdateBy(userId)
                    .setCreateBy(userId)
                    .setMatnrCode(warehouseAreasItems.getMatnrCode());
            AsnOrder order = asnOrderService.getById(warehouseAreasItems.getAsnId());
            if (!Objects.isNull(order)) {
                pakinItem.setType(null == order.getType() ? null : order.getType())
                        .setWkType(null == order.getWkType() ? null : Short.parseShort(order.getWkType()));
                    .setBarcode(waitPakin.getBarcode());
            if (!this.save(waitPakin1)) {
                throw new CoolException("主单保存失败！！");
            }

            for (PakinItem waitPakinItem : waitPakin.getItems()) {
                if (waitPakinItem.getId().equals(warehouseAreasItems.getId())) {
                    if (waitPakinItem.getReceiptQty() > warehouseAreasItems.getAnfme() || waitPakinItem.getReceiptQty().compareTo(0.0) <= 0) {
                        throw new CoolException("组托数量不能大于收货数量且不能小于零！！");
                    }
                    pakinItem.setAnfme(waitPakinItem.getReceiptQty())
                            .setTrackCode(waitPakinItem.getTrackCode());
                }
            }
            items.add(pakinItem);

        } else {
            // 半箱追加：沿用已有组托单，只追加明细
            waitPakin1 = pakin;
        }

        double sum1 = items.stream().mapToDouble(WaitPakinItem::getAnfme).sum();
        List<WaitPakinItem> items = new ArrayList<>();
        if (directWaitPakin) {
            // DirectWaitPakin 启用：组托可来自收货区（有 id）或无订单组托（id 为 null，仅物料+数量）
            for (PakinItem pakinItem1 : waitPakin.getItems()) {
                if (pakinItem1.getId() == null) {
                    // 无订单组托：无收货区来源，按 matnrId + receiptQty 建组托明细
                    if (pakinItem1.getMatnrId() == null) {
                        throw new CoolException("无订单组托时物料ID不能为空！！");
                    }
                    Matnr matnr = matnrMapper.selectById(pakinItem1.getMatnrId());
                    if (matnr == null) {
                        throw new CoolException("物料信息不存在，物料ID：" + pakinItem1.getMatnrId());
                    }
                    if (pakinItem1.getReceiptQty() == null || pakinItem1.getReceiptQty().compareTo(0.0) <= 0) {
                        throw new CoolException("组托数量不能小于等于零！！");
                    }
                    WaitPakinItem pakinItem = new WaitPakinItem();
                    pakinItem.setPakinId(waitPakin1.getId())
                            .setSource(null)
                            .setAsnId(null)
                            .setAsnCode(null)
                            .setAsnItemId(null)
                            .setIsptResult(null)
                            .setPlatItemId(null)
                            .setPlatOrderCode(null)
                            .setPlatWorkCode(null)
                            .setProjectCode(null)
                            .setBatch(null)
                            .setUnit(matnr.getStockUnit() != null ? matnr.getStockUnit() : "个")
                            .setFieldsIndex(matnr.getFieldsIndex())
                            .setMatnrId(matnr.getId())
                            .setMaktx(matnr.getName())
                            .setUpdateBy(userId)
                            .setCreateBy(userId)
                            .setMatnrCode(matnr.getCode())
                            .setAnfme(QuantityUtils.roundToScale(pakinItem1.getReceiptQty()))
                            .setTrackCode(pakinItem1.getTrackCode());
                    items.add(pakinItem);
                    continue;
                }
                WarehouseAreasItem areaItem = warehouseAreasItemService.getById(pakinItem1.getId());
                if (areaItem == null) {
                    throw new CoolException("物料未送至收货区！！");
                }
                WaitPakinItem pakinItem = new WaitPakinItem();
                pakinItem.setPakinId(waitPakin1.getId())
                        .setSource(areaItem.getId())
                        .setAsnId(areaItem.getAsnId())
                        .setAsnCode(areaItem.getAsnCode())
                        .setAsnItemId(areaItem.getAsnItemId())
                        .setIsptResult(areaItem.getIsptResult())
                        .setPlatItemId(areaItem.getPlatItemId())
                        .setPlatOrderCode(areaItem.getPlatOrderCode())
                        .setPlatWorkCode(areaItem.getPlatWorkCode())
                        .setProjectCode(areaItem.getProjectCode())
                        .setBatch(areaItem.getSplrBatch())
                        .setUnit(areaItem.getStockUnit())
                        .setFieldsIndex(areaItem.getFieldsIndex())
                        .setMatnrId(areaItem.getMatnrId())
                        .setMaktx(areaItem.getMaktx())
                        .setUpdateBy(userId)
                        .setCreateBy(userId)
                        .setMatnrCode(areaItem.getMatnrCode());
                WkOrder order = asnOrderService.getById(areaItem.getAsnId());
                if (order != null) {
                    pakinItem.setType(order.getType()).setWkType(StringUtils.isNotBlank(order.getWkType()) ? Short.parseShort(order.getWkType()) : null);
                }
                if (pakinItem1.getReceiptQty() == null || pakinItem1.getReceiptQty().compareTo(0.0) <= 0) {
                    throw new CoolException("组托数量不能小于等于零！！");
                }
                if (QuantityUtils.compare(pakinItem1.getReceiptQty(), areaItem.getAnfme()) > 0) {
                    throw new CoolException("组托数量不能大于收货数量！！");
                }
                pakinItem.setAnfme(QuantityUtils.roundToScale(pakinItem1.getReceiptQty())).setTrackCode(pakinItem1.getTrackCode());
                items.add(pakinItem);
            }
            if (!waitPakinItemService.saveBatch(items)) {
                throw new CoolException("组托明细保存失败！！");
            }
            for (WaitPakinItem pakinItem : items) {
                if (pakinItem.getSource() == null) {
                    continue; // 无订单组托无收货区来源，不更新收货区
                }
                WarehouseAreasItem one = warehouseAreasItemService.getOne(new LambdaQueryWrapper<WarehouseAreasItem>().eq(WarehouseAreasItem::getId, pakinItem.getSource()));
                if (one == null) {
                    throw new CoolException("收货区数据错误！！");
                }
                Double workQty = QuantityUtils.roundToScale(QuantityUtils.add(one.getWorkQty() != null ? one.getWorkQty() : 0.0, pakinItem.getAnfme()));
                Double qty = QuantityUtils.roundToScale(QuantityUtils.add(workQty, one.getQty() != null ? one.getQty() : 0.0));
                one.setWorkQty(workQty);
                if (QuantityUtils.compare(qty, one.getAnfme() != null ? one.getAnfme() : 0.0) > 0) {
                    throw new CoolException("组托数量不能大于收货数量！！");
                }
                if (!warehouseAreasItemService.saveOrUpdate(one)) {
                    throw new CoolException("收货区执行数量修改失败！！");
                }
            }
            // 半箱追加时需按该组托单下全部明细重算总数量
            List<WaitPakinItem> allItems = waitPakinItemService.list(new LambdaQueryWrapper<WaitPakinItem>().eq(WaitPakinItem::getPakinId, waitPakin1.getId()));
            waitPakin1.setAnfme(QuantityUtils.roundToScale(allItems.stream().mapToDouble(w -> w.getAnfme() != null ? w.getAnfme() : 0.0).sum()));
            if (!this.updateById(waitPakin1)) {
                throw new CoolException("组托数量修改失败！！");
            }
            return waitPakin1;
        }

        // 有ASN时：按订单明细汇总已组托数量，校验 已组托+本次组盘 ≤ 计划数量
        Map<Long, Double> alreadyPalletizedByItemId = new java.util.HashMap<>();
        for (PakinItem p : waitPakin.getItems()) {
            if (StringUtils.isNotBlank(p.getAsnCode()) && p.getId() != null) {
                alreadyPalletizedByItemId.putIfAbsent(p.getId(), null);
            }
        }
        if (!alreadyPalletizedByItemId.isEmpty()) {
            for (Long asnItemId : alreadyPalletizedByItemId.keySet()) {
                double alreadySum = waitPakinItemService.list(new LambdaQueryWrapper<WaitPakinItem>().eq(WaitPakinItem::getAsnItemId, asnItemId).eq(WaitPakinItem::getDeleted, 0))
                        .stream().mapToDouble(w -> w.getAnfme() != null ? w.getAnfme() : 0.0).sum();
                alreadyPalletizedByItemId.put(asnItemId, QuantityUtils.roundToScale(alreadySum));
            }
        }

        for (PakinItem pakinItem1 : waitPakin.getItems()) {
            WaitPakinItem pakinItem = new WaitPakinItem();
            if (StringUtils.isBlank(pakinItem1.getAsnCode())) {
                if (Objects.isNull(pakinItem1.getMatnrId())) {
                    throw new CoolException("物料ID不能为空！！");
                }
                
                // 从物料信息表获取物料信息
                Matnr matnr = matnrMapper.selectById(pakinItem1.getMatnrId());
                if (Objects.isNull(matnr)) {
                    throw new CoolException("物料信息不存在，物料ID：" + pakinItem1.getMatnrId());
                }
                
                // 设置组托明细信息（不设置source，因为不在收货区）
                pakinItem.setPakinId(waitPakin1.getId())
                        .setSource(null) // 不在收货区，source设为null
                        .setAsnId(null)
                        .setAsnCode(null)
                        .setAsnItemId(null)
                        .setIsptResult(null)
                        .setPlatItemId(null)
                        .setPlatOrderCode(null)
                        .setPlatWorkCode(null)
                        .setProjectCode(null)
                        .setBatch(null)
                        .setUnit(matnr.getStockUnit())
                        .setFieldsIndex(matnr.getFieldsIndex())
                        .setMatnrId(matnr.getId())
                        .setMaktx(matnr.getName())
                        .setUpdateBy(userId)
                        .setCreateBy(userId)
                        .setMatnrCode(matnr.getCode());
                
                // 设置组托数量
                if (pakinItem1.getReceiptQty() == null || pakinItem1.getReceiptQty().compareTo(0.0) <= 0) {
                    throw new CoolException("组托数量不能小于等于零！！");
                }
                pakinItem.setAnfme(QuantityUtils.roundToScale(pakinItem1.getReceiptQty()))
                        .setTrackCode(pakinItem1.getTrackCode());
            } else {
                // 收货区已停用：有ASN单号时从订单明细获取物料信息
                WkOrderItem orderItem = asnOrderItemService.getById(pakinItem1.getId());
                if (null == orderItem) {
                    throw new CoolException("订单明细不存在！！");
                }
                WkOrder order = asnOrderService.getById(orderItem.getOrderId());
                if (null == order) {
                    throw new CoolException("订单不存在！！");
                }
                pakinItem.setAnfme(QuantityUtils.roundToScale(orderItem.getAnfme()))
                        .setPakinId(waitPakin1.getId())
                        .setSource(null) // 收货区已停用，不关联收货区
                        .setAsnId(order.getId())
                        .setAsnCode(order.getCode())
                        .setAsnItemId(orderItem.getId())
                        .setIsptResult(orderItem.getIsptResult())
                        .setPlatItemId(orderItem.getPlatItemId())
                        .setPlatOrderCode(orderItem.getPlatOrderCode())
                        .setPlatWorkCode(orderItem.getPlatWorkCode())
                        .setProjectCode(orderItem.getProjectCode())
                        .setBatch(orderItem.getSplrBatch())
                        .setUnit(orderItem.getStockUnit())
                        .setFieldsIndex(orderItem.getFieldsIndex())
                        .setMatnrId(orderItem.getMatnrId())
                        .setMaktx(orderItem.getMaktx())
                        .setUpdateBy(userId)
                        .setCreateBy(userId)
                        .setMatnrCode(orderItem.getMatnrCode());
                pakinItem.setType(null == order.getType() ? null : order.getType())
                        .setWkType(StringUtils.isNotBlank(order.getWkType()) ? Short.parseShort(order.getWkType()) : null);

                for (PakinItem waitPakinItem : waitPakin.getItems()) {
                    if (waitPakinItem.getId().equals(orderItem.getId())) {
                        if (waitPakinItem.getReceiptQty() == null || waitPakinItem.getReceiptQty().compareTo(0.0) <= 0) {
                            throw new CoolException("组托数量不能小于等于零！！");
                        }
                        Double anfme = orderItem.getAnfme() != null ? orderItem.getAnfme() : 0.0;
                        Double already = alreadyPalletizedByItemId.getOrDefault(orderItem.getId(), 0.0);
                        if (QuantityUtils.compare(QuantityUtils.add(already, waitPakinItem.getReceiptQty()), anfme) > 0) {
                            throw new CoolException("组托数量不能超过可组盘数量（计划" + anfme + "，已组托" + already + "，本次最多" + QuantityUtils.subtract(anfme, already) + "）！！");
                        }
                        pakinItem.setAnfme(QuantityUtils.roundToScale(waitPakinItem.getReceiptQty()))
                                .setTrackCode(waitPakinItem.getTrackCode());
                    }
                }
            }
            
            items.add(pakinItem);
        }

        if (!waitPakinItemService.saveBatch(items)) {
            throw new CoolException("组托明细保存失败！！");
        }

        for (WaitPakinItem pakinItem : items) {
            WarehouseAreasItem one = warehouseAreasItemService.getOne(new LambdaQueryWrapper<WarehouseAreasItem>()
                    .eq(WarehouseAreasItem::getId, pakinItem.getSource()));
            if (Objects.isNull(one)) {
                throw new CoolException("收货区数据错误！！");
            }
//            one.setAnfme(one.getAnfme() - pakinItem.getAnfme())
            one.setWorkQty(one.getWorkQty() + pakinItem.getAnfme() + one.getQty());
            if (one.getWorkQty() > one.getAnfme()) {
                throw new CoolException("组托数量不能大于收货数量！！");
            }
            if (!warehouseAreasItemService.saveOrUpdate(one)) {
                throw new CoolException("收货区执行数量修改失败！！");
            }
        List<WaitPakinItem> pakinItems = waitPakinItemService.list(new LambdaQueryWrapper<WaitPakinItem>().eq(WaitPakinItem::getPakinId, waitPakin1.getId()));
        Double waitSum = 0.0;
        if (!pakinItems.isEmpty()) {
            waitSum = QuantityUtils.roundToScale(pakinItems.stream().mapToDouble(WaitPakinItem::getAnfme).sum());
        }
//        Double total = Math.round((sum + waitSum) * 100) / 100.0;

        waitPakin1.setAnfme(sum1);
        // 收货区已停用，不再更新收货区
        // for (WaitPakinItem pakinItem : items) {
        //     if (Objects.isNull(pakinItem.getSource())) continue;
        //     WarehouseAreasItem one = warehouseAreasItemService.getOne(new LambdaQueryWrapper<WarehouseAreasItem>()
        //             .eq(WarehouseAreasItem::getId, pakinItem.getSource()));
        //     if (Objects.isNull(one)) throw new CoolException("收货区数据错误！！");
        //     Double workQty = Math.round((one.getWorkQty() + pakinItem.getAnfme()) * 1000000) / 1000000.0;
        //     Double qty = Math.round((workQty + one.getQty()) * 1000000) / 1000000.0;
        //     one.setWorkQty(workQty);
        //     if (qty.compareTo(one.getAnfme()) > 0) throw new CoolException("组托数量不能大于收货数量！！");
        //     if (!warehouseAreasItemService.saveOrUpdate(one)) throw new CoolException("收货区执行数量修改失败！！");
        // }

        waitPakin1.setAnfme(waitSum);
        if (!this.updateById(waitPakin1)) {
            throw new CoolException("组托数量修改失败！！");
        }

        //TODO 组托完成后，扣减收货区库存

        return pakin;
        return waitPakin1;
    }

    /**
@@ -195,41 +372,71 @@
                throw new CoolException("组托不存在！！");
            }
            List<PakinItem> paramItems = param.getItems();

            if (Objects.isNull(paramItems) || paramItems.isEmpty()) {
                throw new CoolException("解绑物料不能为空！！");
            }
            List<Long> list = paramItems.stream().map(PakinItem::getId).collect(Collectors.toList());
            List<WaitPakinItem> pakinItems = waitPakinItemService.list(new LambdaQueryWrapper<WaitPakinItem>()
                    .eq(WaitPakinItem::getPakinId, waitPakins.getId())
                    .in(WaitPakinItem::getSource, list));
                    .in(WaitPakinItem::getId, list)
                    );
            if (pakinItems.isEmpty()) {
                throw new CoolException("数据错误：组托明细不存在！！");
            }
            List<Long> ids = pakinItems.stream().map(WaitPakinItem::getId).collect(Collectors.toList());
            if (!waitPakinItemService.removeByIds(ids)) {
                throw new CoolException("组托明细解绑失败！！");
            }

            List<WarehouseAreasItem> warehouseAreasItems = warehouseAreasItemService.listByIds(list);
//            List<Long> ids = pakinItems.stream().map(WaitPakinItem::getId).collect(Collectors.toList());
//            if (!waitPakinItemService.removeByIds(ids)) {
//                throw new CoolException("组托明细解绑失败！！");
//            }
            // 收货区已停用：仅保留非空 source 用于兼容旧数据，不再更新收货区
            List<Long> list2 = pakinItems.stream().map(WaitPakinItem::getSource).filter(Objects::nonNull).collect(Collectors.toList());
            List<WarehouseAreasItem> warehouseAreasItems = list2.isEmpty() ? Collections.emptyList() : warehouseAreasItemService.listByIds(list2);
            for (int i1 = 0; i1 < pakinItems.size(); i1++) {
                for (int i = 0; i < warehouseAreasItems.size(); i++) {
                    if (warehouseAreasItems.get(i).getId().equals(pakinItems.get(i1).getId())) {
                        double v = warehouseAreasItems.get(i).getWorkQty() - pakinItems.get(i1).getAnfme();
                        warehouseAreasItems.get(i).setWorkQty(v);
                        if (!warehouseAreasItemService.updateById(warehouseAreasItems.get(i))) {
                            throw new CoolException("收货区数量修改失败！！");
                for (PakinItem item : paramItems) {
                    if (item.getId().equals(pakinItems.get(i1).getId())) {
                        if (QuantityUtils.compare(pakinItems.get(i1).getAnfme(), item.getReceiptQty()) > 0) {
                            if (QuantityUtils.compare(item.getReceiptQty(), 0.00) == 0) {
                                throw new CoolException("解绑数量不能为零！！");
                            }
                            Double reslt = QuantityUtils.subtract(QuantityUtils.subtract(pakinItems.get(i1).getAnfme(), pakinItems.get(i1).getWorkQty()), pakinItems.get(i1).getQty());
                            if (QuantityUtils.compare(item.getReceiptQty(), reslt) > 0) {
                                throw new CoolException("解绑数量不能大于剩余可执行数！！");
                            }

                            Double anfme = QuantityUtils.subtract(pakinItems.get(i1).getAnfme(), item.getReceiptQty());
                           pakinItems.get(i1).setAnfme(anfme);
                           if (!waitPakinItemService.updateById(pakinItems.get(i1))) {
                               throw new CoolException("组托明细数量修改失败！！");
                           }
                        } else {
                            if (!waitPakinItemService.removeById(pakinItems.get(i1).getId())) {
                                throw new CoolException("组托明细删除失败！！");
                            }
                        }
                        // DirectWaitPakin 启用时组托来自收货区，解绑需回写收货区 workQty
                        if (Objects.nonNull(pakinItems.get(i1).getSource())) {
                            for (WarehouseAreasItem areaItem : warehouseAreasItems) {
                                if (areaItem.getId().equals(pakinItems.get(i1).getSource())) {
                                    Double v = QuantityUtils.roundToScale(QuantityUtils.subtract(areaItem.getWorkQty() != null ? areaItem.getWorkQty() : 0.0, item.getReceiptQty()));
                                    areaItem.setWorkQty(v);
                                    if (!warehouseAreasItemService.updateById(areaItem)) {
                                        throw new CoolException("收货区数量修改失败！！");
                                    }
                                    break;
                                }
                            }
                        }
                    }
                }
            }
            double anfmes = warehouseAreasItems.stream().mapToDouble(WarehouseAreasItem::getAnfme).sum();

            if (waitPakins.getAnfme().compareTo(anfmes) <= 0) {
            Double anfmes = QuantityUtils.roundToScale(paramItems.stream().mapToDouble(PakinItem::getReceiptQty).sum());
//            double anfmes = warehouseAreasItems.stream().mapToDouble(WarehouseAreasItem::getAnfme).sum();
            if (QuantityUtils.compare(waitPakins.getAnfme(), anfmes) <= 0) {
                if (!waitPakinService.removeById(waitPakins.getId())) {
                    throw new CoolException("组托删除失败！！");
                }
            } else {
                waitPakins.setAnfme(waitPakins.getAnfme() - anfmes);
                waitPakins.setAnfme(QuantityUtils.subtract(waitPakins.getAnfme(), anfmes));
                if (!waitPakinService.updateById(waitPakins)) {
                    throw new CoolException("组托数据修改失败！！");
                }
@@ -256,27 +463,31 @@
            if (!taskItems.isEmpty()) {
                return R.error("组拖档有明细任务");
            }
        }

        Set<Long> sourceIds = pakinItems.stream().map(WaitPakinItem::getSource).collect(Collectors.toSet());
            Set<Long> sourceIds = pakinItems.stream().map(WaitPakinItem::getSource).filter(Objects::nonNull).collect(Collectors.toSet());

        List<WarehouseAreasItem> areasItems = warehouseAreasItemService.listByIds(sourceIds);
            List<WarehouseAreasItem> areasItems = sourceIds.isEmpty() ? Collections.emptyList() : warehouseAreasItemService.list(new LambdaQueryWrapper<WarehouseAreasItem>().in(WarehouseAreasItem::getId, sourceIds));

        if (areasItems.isEmpty()) {
            return R.error("收货区数据不存在！！");
        }

        Map<Long, List<WaitPakinItem>> listMap = pakinItems.stream().collect(Collectors.groupingBy(WaitPakinItem::getSource));
        for (WarehouseAreasItem item : areasItems) {
            List<WaitPakinItem> pakin = listMap.get(item.getId());
            if (Objects.isNull(pakin)) {
                continue;
            // 收货区已停用，仅兼容旧数据时回滚收货区数量
            if (!areasItems.isEmpty()) {
                Map<Long, List<WaitPakinItem>> listMap = pakinItems.stream().collect(Collectors.groupingBy(WaitPakinItem::getSource));
                for (WarehouseAreasItem item : areasItems) {
                    List<WaitPakinItem> pakin = listMap.get(item.getId());
                    if (Objects.isNull(pakin)) {
                        continue;
                    }
                    Double sum = QuantityUtils.roundToScale(pakin.stream().mapToDouble(WaitPakinItem::getAnfme).sum());
                    item.setWorkQty(QuantityUtils.subtract(item.getWorkQty(), sum));
                    if (!warehouseAreasItemService.updateById(item)) {
                        throw new CoolException("收货区数据回滚失败！！");
                    }
                }
            }
            double sum = pakin.stream().mapToDouble(WaitPakinItem::getAnfme).sum();
            item.setWorkQty(item.getWorkQty() - sum)
                    .setAnfme(item.getAnfme() + sum);
            if (!warehouseAreasItemService.updateById(item)) {
                throw new CoolException("收货区数据回滚失败！！");

            Set<Long> pakinItemIds = pakinItems.stream().map(WaitPakinItem::getId).collect(Collectors.toSet());

            if (!waitPakinItemService.removeByIds(pakinItemIds)) {
                throw new CoolException("明细删除失败！！");
            }
        }

@@ -284,13 +495,6 @@
            return R.error("Delete Fail");
        }

        Set<Long> pakinItemIds = pakinItems.stream().map(WaitPakinItem::getId).collect(Collectors.toSet());

        if (!waitPakinItemService.removeByIds(pakinItemIds)) {
            throw new CoolException("明细删除失败！！");
        }
        return R.ok("Delete Success").add(pakinIds);


    }
}