新增库存调整单

skyouc

2025-08-02 f69206f035ee67537779497598fa9611baa65775

 rsf-server/src/main/java/com/vincent/rsf/server/api/service/impl/MobileServiceImpl.java

@@ -2,36 +2,33 @@

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
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.controller.params.*;
import com.vincent.rsf.server.api.entity.dto.*;
import com.vincent.rsf.server.api.entity.enums.OrderType;
import com.vincent.rsf.server.api.entity.enums.OrderWorkType;
import com.vincent.rsf.server.manager.enums.*;
import com.vincent.rsf.server.api.service.MobileService;
import com.vincent.rsf.server.common.config.ConfigProperties;
import com.vincent.rsf.server.common.enums.WarehouseAreaType;
import com.vincent.rsf.server.common.security.JwtSubject;
import com.vincent.rsf.server.common.utils.CommonUtil;
import com.vincent.rsf.server.common.utils.FieldsUtils;
import com.vincent.rsf.server.common.utils.JwtUtil;
import com.vincent.rsf.server.manager.controller.params.GenerateTaskParams;
import com.vincent.rsf.server.manager.controller.params.IsptItemsParams;
import com.vincent.rsf.server.manager.controller.params.WaitPakinParam;
import com.vincent.rsf.server.manager.entity.*;
import com.vincent.rsf.server.manager.enums.AsnExceStatus;
import com.vincent.rsf.server.manager.enums.PakinIOStatus;
import com.vincent.rsf.server.manager.enums.QlyIsptStatus;
import com.vincent.rsf.server.manager.mapper.*;
import com.vincent.rsf.server.manager.service.*;
import com.vincent.rsf.server.system.constant.CodeRes;
import com.vincent.rsf.server.system.constant.GlobalConfigCode;
import com.vincent.rsf.server.system.constant.SerialRuleCode;
import com.vincent.rsf.server.system.controller.param.LoginParam;
import com.vincent.rsf.server.system.controller.result.LoginResult;
import com.vincent.rsf.server.system.entity.*;
import com.vincent.rsf.server.system.mapper.FieldsMapper;
import com.vincent.rsf.server.system.mapper.TenantMapper;
import com.vincent.rsf.server.system.service.ConfigService;
import com.vincent.rsf.server.system.service.FieldsItemService;
import com.vincent.rsf.server.system.service.UserLoginService;
import com.vincent.rsf.server.system.service.UserService;
@@ -45,6 +42,8 @@

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

@@ -92,13 +91,10 @@
    private FieldsMapper fieldsMapper;
    @Autowired
    private IsptHistoriesMapper isptHistoriesMapper;

    @Autowired
    private AsnOrderLogService asnOrderLogService;

    @Autowired
    private WaitPakinService waitPakinService;

    @Autowired
    private WaitPakinItemService waitPakinItemService;
    @Autowired
@@ -123,12 +119,20 @@
    private LocAreaRelaMapper locAreaRelaMapper;
    @Autowired
    private LocAreaMapper locAreaMapper;
    @Autowired
    private DeviceSiteMapper deviceSiteMapper;
    @Autowired
    private ConfigService configService;
    @Autowired
    private CompanysService companysService;
    @Autowired
    private OutStockService outStockService;

    /**
     * @return
     * @author Ryan
     * @description 手持PDA登录接口
     * @params LoginParam param， HttpServletRequest request
     * @return
     * @time 2025/3/10 15:36
     */
    @Override
@@ -160,10 +164,10 @@
    }

    /**
     * @author Ryan
     * @description 扫码获取收货明细
     * @param barcode
     * @return
     * @author Ryan
     * @description 扫码获取收货明细
     * @time 2025/3/10 15:37
     */
    @Override
@@ -171,24 +175,34 @@
        if (StringUtils.isBlank(barcode)) {
            return R.error("标签码不能为空！！");
        }
        List<AsnOrderItem> asnOrderItem = asnOrderItemMapper.selectList(new LambdaQueryWrapper<AsnOrderItem>().eq(AsnOrderItem::getTrackCode, barcode));
        if (Objects.isNull(asnOrderItem)) {
        List<WkOrderItem> wkOrderItem = asnOrderItemMapper.selectList(new LambdaQueryWrapper<WkOrderItem>()
                .eq(WkOrderItem::getTrackCode, barcode));

        if (Objects.isNull(wkOrderItem)) {
            throw new CoolException("单据明细不存在！！");
        }

        return getAsnOrderItem(asnOrderItem);
        List<WkOrderItem> items = new ArrayList<>();
        for (WkOrderItem record : wkOrderItem) {
            if (!Objects.isNull(record.getFieldsIndex())) {
                Map<String, String> fields = FieldsUtils.getFields(record.getFieldsIndex());
                record.setExtendFields(fields);
            }
            items.add(record);
        }
        return getAsnOrderItem(items);
    }

    /**
     * @param params
     * @param loginUserId
     * @return
     * @author Ryan
     * @description 收货至收货区
     * @param  params
     * @return
     * @time 2025/3/10 15:41
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R receiptToWarehouse(Map<String, Object> params) {
    public synchronized R receiptToWarehouse(Map<String, Object> params, Long loginUserId) {
        if (Objects.isNull(params)) {
            throw new CoolException("参数不能为空！！");
        }
@@ -207,7 +221,6 @@
        }

        List<ReceiptDetlsDto> receipts = receiptParam.getReceipts();
        List<WarehouseAreasItem> allOrders = new ArrayList<>();

        Double receiptQty = receipts.stream().mapToDouble(ReceiptDetlsDto::getReceiptQty).sum();

@@ -217,21 +230,39 @@

        String asnCode = receipts.stream().findFirst().get().getAsnCode();

        AsnOrder asnOrder = asnOrderMapper.getOne(new LambdaQueryWrapper<AsnOrder>()
                .eq(AsnOrder::getCode, asnCode));
        if (Objects.isNull(asnOrder)) {
        WkOrder wkOrder = asnOrderMapper.getOne(new LambdaQueryWrapper<WkOrder>()
                .eq(WkOrder::getCode, asnCode));

        //判断调拔单出库是否完成
        if (wkOrder.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_OTHER_TERANSFER.type)) {
            WkOrder one = outStockService.getOne(new LambdaQueryWrapper<WkOrder>()
                    .eq(WkOrder::getPoId, wkOrder.getPoId())
                    .eq(WkOrder::getWkType, OrderWorkType.ORDER_WORK_TYPE_STOCK_TERANSFER.type)
                    .eq(WkOrder::getType, OrderType.ORDER_OUT.type));
            if (Objects.isNull(one)) {
                throw new CoolException("数据错误！！");
            }
            if (!one.getExceStatus().equals(AsnExceStatus.OUT_STOCK_STATUS_TASK_DONE.val)) {
                throw new CoolException("调拔出库单未完成，不可执行收货操作！！");
            }
        }

        if (Objects.isNull(wkOrder)) {
            throw new CoolException("数据错误：主单不存在！！");
        }
        //TODO /**收货数量累加，1. 会出超收情况 2. 会有收货不足情况*/
        Double rcptedQty = asnOrder.getQty() + receiptQty;
        asnOrder.setQty(rcptedQty).setExceStatus(Short.parseShort(AsnExceStatus.ASN_EXCE_STATUS_EXCE_ING.val));

        if (!asnOrderMapper.updateById(asnOrder)) {
        Double rcptedQty = Math.round((wkOrder.getQty() + receiptQty) * 10000) / 10000.0;
        wkOrder.setQty(rcptedQty).setExceStatus(AsnExceStatus.ASN_EXCE_STATUS_EXCE_ING.val);
        if (!asnOrderMapper.updateById(wkOrder)) {
            throw new CoolException("已收货数量修改失败！！");
        }
        Config config = configService.getOne(new LambdaQueryWrapper<Config>().eq(Config::getFlag, GlobalConfigCode.ALLOW_OVER_CHANGE));

        List<Map<String, Object>> receipts1 = (List<Map<String, Object>>) params.get("receipts");
        for (Map<String, Object> rcpt : receipts1) {
            if (Objects.isNull(rcpt)) {continue;}
            if (null == rcpt || Objects.isNull(rcpt)) {
                continue;
            }
            ReceiptDetlsDto dto = JSONObject.parseObject(JSONObject.toJSONString(rcpt), ReceiptDetlsDto.class);
            Matnr matnr = matnrMapper.selectById(dto.getMatnrId());
            if (Objects.isNull(matnr)) {
@@ -243,162 +274,280 @@
//            if (dto.getReceiptQty().compareTo(dto.getAnfme()) > 0) {
//                throw new CoolException("收货数量不能大于采购数量！！");
//            }
            AsnOrderItem orderItem = asnOrderItemMapper.selectOne(new LambdaQueryWrapper<AsnOrderItem>()
                    .eq(AsnOrderItem::getAsnCode, asnCode)
                    .eq(AsnOrderItem::getMatnrId, dto.getMatnrId()));
//            AsnOrderItem orderItem = asnOrderItemMapper.selectOne(new LambdaQueryWrapper<AsnOrderItem>()
//                    .eq(AsnOrderItem::getAsnCode, asnCode)
//                    .eq(AsnOrderItem::getId, dto.getId())
//                    .eq(AsnOrderItem::getTrackCode, dto.getBarcode())
//                    .eq(AsnOrderItem::getSplrBatch, dto.getSplrBatch()));

            WkOrderItem orderItem = asnOrderItemMapper.selectOne(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getId, dto.getId()));
            //asnOrderItemMapper.resultById(new LambdaQueryWrapper<AsnOrderItem>().eq(AsnOrderItem::getId, dto.getId()));

            if (Objects.isNull(orderItem)) {
                throw new CoolException("通知单明细不存在！！");
            }
            if (Objects.isNull(dto.getReceiptQty()) || Double.compare(dto.getReceiptQty(), 0.0) == 0) {
                throw new CoolException("物料:" + dto.getMaktx() +  "收货数量不能为零！！");
                throw new CoolException("物料:" + dto.getMaktx() + "收货数量不能为零！！");
            }
            Double itemRcptQty = dto.getReceiptQty() + orderItem.getQty();

            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            try {
                if (!Objects.isNull(dto.getProdTime())) {
                    sdf.parse(dto.getProdTime());
                }
            } catch (ParseException e) {
                throw new CoolException("请输入正确的时间格式！！");
            }

            Double itemRcptQty = Math.round((dto.getReceiptQty() + orderItem.getQty()) * 10000) / 10000.0;
            Boolean allowOver = false;
            if (!Objects.isNull(config)) {
                if (Boolean.parseBoolean(config.getVal())) {
                    allowOver = true;
                }
            }
            if (itemRcptQty.compareTo(orderItem.getAnfme()) > 0 && !allowOver) {
                throw new CoolException("收货数量不能大于计划数量！！");
            }

            orderItem.setQty(itemRcptQty)
                    .setSplrBatch(dto.getSplrBatch())
//                    .setSplrBatch(dto.getSplrBatch())
                    .setUpdateBy(loginUserId)
                    .setStockUnit(dto.getStockUnit())
                    .setProdTime(dto.getProdTime());

            if (!Objects.isNull(rcpt)) {
                try {
                    if (Objects.isNull(rcpt.get("fieldsindex")) || StringUtils.isBlank(rcpt.get("fieldsindex").toString())) {
                        //获取16位uuid
                        String uuid16 = CommonUtil.randomUUID16();
                        rcpt.put("index", uuid16);
                        orderItem.setFieldsIndex(uuid16);
                    }
                    //保存或更新扩展字段
                    FieldsUtils.updateFieldsValue(rcpt);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
//            if (!Objects.isNull(rcpt)) {
//                try {
//                    if (Objects.isNull(rcpt.get("fieldsindex")) || StringUtils.isBlank(rcpt.get("fieldsindex").toString())) {
//                        StringBuffer sb = new StringBuffer();
//                        if (!dto.getExtendFields().isEmpty()) {
//                            dto.getExtendFields().forEach(field -> {
//                                field.keySet().forEach(key -> {
//                                    sb.append(field.get(key));
//                                });
//                            });
//                        }
//                        sb.append(dto.getAsnCode() + dto.getMatnr() + dto.getSplrBatch() + orderItem.getIsptResult$());
//                        //获取16位uuid
//                        String uuid16 = Cools.md5Chinese(sb.toString());
//                        rcpt.put("index", uuid16);
//                        orderItem.setFieldsIndex(uuid16);
//                    }
//                    //保存或更新扩展字段
//                    FieldsUtils.updateFieldsValue(rcpt);
//                } catch (Exception e) {
//                    throw new RuntimeException(e);
//                }
//            }

            if (asnOrderItemMapper.updateById(orderItem) < 1) {
                throw new CoolException("通知单明细数量修改失败！！");
            }
            /**保存明细至收货区**/
            extracted(loginUserId, dto, areasItem, orderItem, wkOrder, matnr);

            WarehouseAreasItem item = new WarehouseAreasItem();
//            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//            String format = null;
//            if (Objects.isNull(dto.getProdTime())) {
//                 format = dateFormat.format(dto.getProdTime());
//            }
            item.setTrackCode(dto.getBarcode())
                    .setAreaName(areasItem.getName())
                    .setAreaId(areasItem.getId())
                    .setAsnItemId(orderItem.getId())
                    .setAsnCode(asnOrder.getCode())
                    .setAsnId(asnOrder.getId())
                    .setProdTime(dto.getProdTime())
                    .setWeight(dto.getWeigth())
                    .setStockUnit(dto.getStockUnit())
                    .setBatch(SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_RECEIPT_BATCH, dto))
                    .setAnfme(dto.getReceiptQty())
                    .setSplrBatch(dto.getSplrBatch())
                    .setMatnrCode(matnr.getCode())
                    .setMatnrId(matnr.getId())
                    .setMaktx(matnr.getName())
                    //库存单位为最小单位
                    .setUnit(dto.getStockUnit())
                    .setStockUnit(dto.getStockUnit())
                    .setWeight(matnr.getWeight())
                    .setFieldsIndex(orderItem.getFieldsIndex())
                    .setShipperId(matnr.getShipperId());
            //TODO 供应商标识未设置，标识由PO单供应商编码转换

            allOrders.add(item);
        }

        if (!warehouseAreasItemService.saveBatch(allOrders)) {
        WkOrder order = asnOrderMapper.getOne(new LambdaQueryWrapper<WkOrder>().eq(WkOrder::getCode, asnCode));
        if (order.getQty().compareTo(order.getAnfme()) >= 0.00) {
            order.setExceStatus(AsnExceStatus.ASN_EXCE_STATUS_RECEIPT_DONE.val).setRleStatus(Short.valueOf("1"));
            if (!asnOrderMapper.updateById(order)) {
                throw new CoolException("订单状态修改失败！！");
            }
        }

        return R.ok("收货成功！！");
    }

    private void extracted(Long loginUserId, ReceiptDetlsDto dto, WarehouseAreas areasItem, WkOrderItem orderItem, WkOrder wkOrder, Matnr matnr) {

        Companys companys = new Companys();
        if (StringUtils.isNoneBlank(orderItem.getSplrCode())) {
            companys = companysService.getOne(new LambdaQueryWrapper<Companys>().eq(Companys::getCode, orderItem.getSplrCode()));
        }

        WarehouseAreasItem item = new WarehouseAreasItem();
        item.setTrackCode(dto.getBarcode())
                .setAreaName(areasItem.getName())
                .setAreaId(areasItem.getId())
                .setAsnItemId(orderItem.getId())
                .setAsnCode(wkOrder.getCode())
                .setAsnId(wkOrder.getId())
                .setProdTime(dto.getProdTime())
                .setSplrId(companys.getId())
                .setWeight(dto.getWeigth())
                .setPlatOrderCode(orderItem.getPlatOrderCode())
                .setPlatWorkCode(orderItem.getPlatWorkCode())
                .setProjectCode(orderItem.getProjectCode())
                //库存单位为最小单位
                .setUnit(orderItem.getStockUnit())
                .setStockUnit(orderItem.getStockUnit())
                .setBatch(StringUtils.isBlank(orderItem.getBatch()) ? SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_RECEIPT_BATCH, dto) : orderItem.getBatch())
                .setAnfme(dto.getReceiptQty())
                .setSplrBatch(dto.getSplrBatch())
                .setMatnrCode(matnr.getCode())
                .setUpdateBy(loginUserId)
                .setCreateBy(loginUserId)
                .setMatnrId(matnr.getId())
                .setIsptResult(orderItem.getIsptResult())
                .setMaktx(matnr.getName())
                .setWeight(matnr.getWeight())
                .setFieldsIndex(orderItem.getFieldsIndex())
                .setShipperId(matnr.getShipperId());
        //TODO 供应商标识未设置，标识由PO单供应商编码转换

        LambdaQueryWrapper<WarehouseAreasItem> queryWrapper = new LambdaQueryWrapper<WarehouseAreasItem>()
//                .eq(WarehouseAreasItem::getAsnItemId, item.getAsnItemId())
                .eq(WarehouseAreasItem::getMatnrCode, item.getMatnrCode())
                .eq(!Cools.isEmpty(item.getFieldsIndex()), WarehouseAreasItem::getFieldsIndex, item.getFieldsIndex())
                .eq(WarehouseAreasItem::getAsnCode, item.getAsnCode())
                .eq(StringUtils.isNotBlank(item.getSplrBatch()), WarehouseAreasItem::getSplrBatch, item.getSplrBatch());
        if (Objects.isNull(orderItem.getIsptResult())) {
            queryWrapper.isNull(WarehouseAreasItem::getIsptResult);
        } else {
            queryWrapper.eq(WarehouseAreasItem::getIsptResult, orderItem.getIsptResult());
        }

        WarehouseAreasItem serviceOne = warehouseAreasItemService.getOne(queryWrapper);

        if (!Objects.isNull(serviceOne)) {
            item.setId(serviceOne.getId());
            Double anfme = Math.round((item.getAnfme() + serviceOne.getAnfme()) * 10000) / 10000.0;
            item.setAnfme(anfme);
        }

        //未质检
        if (!warehouseAreasItemService.saveOrUpdate(item)) {
            throw new CoolException("收货失败！！");
        }
//        //获取采购数量
//        double purQty = receipts.stream().mapToDouble(ReceiptDetlsDto::getPurQty).sum();

//        if (null != orderItem.getSafeQty() || null != orderItem.getDisQty() ) {
//
//        BigDecimal subtract = BigDecimal.valueOf(receiptQty).subtract(BigDecimal.valueOf(purQty));
//        //判断已收货数量是否小于等于采购数量
//        if (subtract.compareTo(new BigDecimal("0.0")) <= 0) {
//            asnOrder.setRleStatus(Short.valueOf("1"));
//            //日志表操作
//            operateOrderLogs(asnOrder);
//        }
        return R.ok(asnOrder);
//        else {
//            //不合格数量
//            if (orderItem.getDisQty().compareTo(0.00) > 0) {
//                item.setIsptQty(orderItem.getDisQty()).setFlagNorm(QlyIsptResult.QLY_ISPT_RESULT_DEFECT.val);
//                if (!warehouseAreasItemService.saveOrUpdate(item)) {
//                    throw new CoolException("收货失败！！");
//                }
//            }
//
//            item.setIsptQty(orderItem.getSafeQty()).setFlagNorm(QlyIsptResult.QLY_ISPT_RESULT_EXCELLENT.val);
//            if (!warehouseAreasItemService.saveOrUpdate(item)) {
//                throw new CoolException("收货失败！！");
//            }
//        }


    }

    /**
     * @author Ryan
     * @description 其它收货
     * @param params
     * @return
     * @author Ryan
     * @description 其它收货
     */
    @Override
    public R otherReceipt(OtherReceiptParams params) {
        if (Objects.isNull(params.getAsnCode())) {
            throw new CoolException("通知单不能为空！！");
        }
        List<AsnOrderItem> asnOrderItem = asnOrderItemMapper.selectList(new LambdaQueryWrapper<AsnOrderItem>()
                .eq(AsnOrderItem::getAsnCode, params.getAsnCode())
                .eq(!Objects.isNull(params.getTrackCode()) ,AsnOrderItem::getTrackCode, params.getTrackCode()));

        if (Objects.isNull(asnOrderItem)) {
        List<Short> shorts = Arrays.asList(AsnExceStatus.ASN_EXCE_STATUS_TASK_CANCEL.val, AsnExceStatus.ASN_EXCE_STATUS_TASK_CLOSE
                .val, AsnExceStatus.ASN_EXCE_STATUS_TASK_DONE.val);
        WkOrder order = asnOrderMapper.getOne(new LambdaQueryWrapper<WkOrder>()
                .notIn(WkOrder::getExceStatus, shorts)
                .eq(WkOrder::getCode, params.getAsnCode()));
        if (Objects.isNull(order)) {
            throw new CoolException("请检查订单状态是否已完成或已取消！！");
        }

        List<WkOrderItem> wkOrderItem = asnOrderItemMapper.selectList(new LambdaQueryWrapper<WkOrderItem>()
                .eq(WkOrderItem::getOrderCode, params.getAsnCode())
                .eq(!Objects.isNull(params.getTrackCode()), WkOrderItem::getTrackCode, params.getTrackCode())
                .eq(!Cools.isEmpty(params.getMatnrCode()), WkOrderItem::getMatnrCode, params.getMatnrCode())
        );

        if (Objects.isNull(wkOrderItem)) {
            throw new CoolException("单据明细不存在！！");
        }

       return getAsnOrderItem(asnOrderItem);
        List<WkOrderItem> items = new ArrayList<>();
        for (WkOrderItem record : wkOrderItem) {
            if (!Objects.isNull(record.getFieldsIndex())) {
                Map<String, String> fields = FieldsUtils.getFields(record.getFieldsIndex());
                record.setExtendFields(fields);
            }
            items.add(record);
        }

        return getAsnOrderItem(items);

    }

    /**
     * @return
     * @author Ryan
     * @description 获取所有通知单
     * @return
     */
    @Override
    public List<AsnOrder> getAllAsnOrders() {
        List<AsnOrder> asnOrders = asnOrderMapper.list(new LambdaQueryWrapper<AsnOrder>().eq(AsnOrder::getWkType, OrderWorkType.ORDER_PURCHASE_IN.type));
        return asnOrders;
    public List<WkOrder> getAllAsnOrders() {
        List<WkOrder> wkOrders = asnOrderMapper.list(new LambdaQueryWrapper<WkOrder>().eq(WkOrder::getWkType, OrderWorkType.ORDER_WORK_TYPE_PURCHASE.type));
        return wkOrders;
    }

    /**
     * @author Ryan
     * @description 获取收货区
     * @param
     * @return
     * @author Ryan
     * @description 获取收货区
     * @time 2025/3/11 10:12
     */
    @Override
    public R getReceiptAreas() {
        List<WarehouseAreas> areas = warehouseAreasService.list(new LambdaQueryWrapper<WarehouseAreas>().eq(WarehouseAreas::getType, WarehouseAreaType.WAREHOUSE_AREA_RECEIPT.type));
        List<WarehouseAreas> areas = warehouseAreasService.list(new LambdaQueryWrapper<WarehouseAreas>()
                .eq(WarehouseAreas::getType, WarehouseAreaType.WAREHOUSE_AREA_RECEIPT.type));
        return R.ok(areas);
    }

    /**
     * @author Ryan
     * @description 获取所有启用动态字段
     * @param
     * @return
     * @author Ryan
     * @description 获取所有启用动态字段
     * @time 2025/3/12 09:23
     */
    @Override
    public List<Fields> getDynamicFields() {
        return fieldsMapper.selectList(new LambdaQueryWrapper<Fields>().eq(Fields::getFlagEnable, 1).eq(Fields::getStatus, 1));
        return fieldsMapper.selectList(new LambdaQueryWrapper<Fields>()
                .eq(Fields::getFlagEnable, 1)
                .eq(Fields::getStatus, 1).orderByAsc(Fields::getId));
    }

    /**
     * @author Ryan
     * @description 获取组盘明细
     * @param
     * @return
     * @author Ryan
     * @description 获取组盘明细
     * @time 2025/4/7 16:58
     */
    @Override
    public R getDeltByCode(String code) {
    public R getDeltByCode(Map<String, Object> params) {
        Object code = params.get("code");
        Object matnrCode = params.get("matnrCode");
        Object asnCode = params.get("asnCode");
        Object batch = params.get("batch");

        //TODO 后续需根据策略配置，获取组拖数据。如：混装，按批次混装等
        LambdaQueryWrapper<WarehouseAreasItem> queryWrapper = new QueryWrapper<WarehouseAreasItem>()
                .select("SUM(anfme) as anfme, track_code, asn_code, id, splr_batch, ispt_result, plat_item_id, batch, qty, work_qty, matnr_code, matnr_id, maktx").lambda()
                .eq(WarehouseAreasItem::getTrackCode, code)
                .groupBy(WarehouseAreasItem::getSplrBatch, WarehouseAreasItem::getAsnId, WarehouseAreasItem::getAreaId, WarehouseAreasItem::getMatnrId);
        return R.ok(warehouseAreasItemService.getOne(queryWrapper));
        LambdaQueryWrapper<WarehouseAreasItem> queryWrapper = new LambdaQueryWrapper<WarehouseAreasItem>()
                .or().eq(!Cools.isEmpty(code), WarehouseAreasItem::getTrackCode, code)
                .or().eq(!Cools.isEmpty(batch), WarehouseAreasItem::getSplrBatch, batch)
                .or().eq(!Cools.isEmpty(matnrCode), WarehouseAreasItem::getMatnrCode, matnrCode)
                .or().eq(!Cools.isEmpty(asnCode), WarehouseAreasItem::getAsnCode, asnCode);
        List<WarehouseAreasItem> list = warehouseAreasItemService.list(queryWrapper);
        list.removeIf(e -> e.getAnfme() <= e.getWorkQty());
        return R.ok(list);
    }

    /**
@@ -415,10 +564,10 @@
    }

    /**
     * @author Ryan
     * @description 解绑
     * @param param
     * @return
     * @author Ryan
     * @description 解绑
     */
    @Override
    public WaitPakin unBind(WaitPakinParam param) {
@@ -427,19 +576,20 @@

    /**
     * 报检功能
     *
     * @param code
     * @param loginUserId
     * @return
     */
    @Override
    public R inspect(String code, Long loginUserId) {
        AsnOrder asnOrders = asnOrderMapper.getOne(new LambdaQueryWrapper<AsnOrder>().eq(AsnOrder::getCode, code));
        if (Objects.isNull(asnOrders)) {
        WkOrder wkOrders = asnOrderMapper.getOne(new LambdaQueryWrapper<WkOrder>().eq(WkOrder::getCode, code));
        if (Objects.isNull(wkOrders)) {
            throw new CoolException("单据不存在！！");
        }
        InspectDetlDto detlDto = new InspectDetlDto();
        detlDto.setCode(asnOrders.getCode()).setId(asnOrders.getId()).setPoCode(asnOrders.getPoCode());
        List<AsnOrderItem> orderItems = asnOrderItemMapper.selectList(new LambdaQueryWrapper<AsnOrderItem>().eq(AsnOrderItem::getAsnCode, code));
        detlDto.setCode(wkOrders.getCode()).setId(wkOrders.getId()).setPoCode(wkOrders.getPoCode());
        List<WkOrderItem> orderItems = asnOrderItemMapper.selectList(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getOrderCode, code));
        if (orderItems.isEmpty()) {
            detlDto.setItems(new ArrayList<>());
        } else {
@@ -461,16 +611,16 @@
            detlDto.setItems(itemDtos);
        }

        List<IsptHistories> histories = isptHistoriesMapper.selectList(new LambdaQueryWrapper<IsptHistories>().eq(IsptHistories::getAsnId, asnOrders.getId()));
        List<IsptHistories> histories = isptHistoriesMapper.selectList(new LambdaQueryWrapper<IsptHistories>().eq(IsptHistories::getAsnId, wkOrders.getId()));
        detlDto.setHistories(histories);
        return R.ok(detlDto);
    }

    /**
     * @author Ryan
     * @description 提交报检
     * @param
     * @return
     * @author Ryan
     * @description 提交报检
     * @time 2025/4/1 16:47
     */
    @Override
@@ -478,21 +628,22 @@
        if (org.apache.commons.lang3.StringUtils.isBlank(id)) {
            throw new CoolException("参数不能为空！！");
        }
        AsnOrder asnOrder = asnOrderMapper.getById(id);
        if (Objects.isNull(asnOrder)) {
        WkOrder wkOrder = asnOrderMapper.getById(id);
        if (Objects.isNull(wkOrder)) {
            throw new CoolException("单据不存在！！");
        }
        List<AsnOrder> orders = new ArrayList<>();
        orders.add(asnOrder);
        List<WkOrder> orders = new ArrayList<>();
        orders.add(wkOrder);
        if (asnOrderMapper.notifyInspect(orders)) {
           return R.ok("上报成功！！");
        }else {
            return R.ok("上报成功！！");
        } else {
            return R.error("上报失败！！");
        }
    }

    /**
     * 通过物料，质检单获取需要质检单据
     *
     * @param params
     * @return
     */
@@ -503,7 +654,7 @@
        }
        List<Short> asList = Arrays.asList(QlyIsptStatus.QLY_ISPT_STAS_DONE.val, QlyIsptStatus.QLY_ISPT_STAS_CLOSE.val);
        QlyInspect inspect = qlyInspectMapper.selectOne(new LambdaQueryWrapper<QlyInspect>()
                        .notIn(QlyInspect::getIsptStatus, asList)
                .notIn(QlyInspect::getIsptStatus, asList)
                .eq(QlyInspect::getCode, params.getIsptCode()));
        if (Objects.isNull(inspect)) {
            throw new CoolException("质检单据不存在！!");
@@ -522,15 +673,15 @@
                    .setId(isptItem.getId())
                    .setMatnrCode(isptItem.getMatnrCode())
                    .setMaktx(isptItem.getMaktx())
                    .setDisQty(isptItem.getDisQty())
//                    .setDisQty(isptItem.getDisQty())
                    .setDlyQty(isptItem.getDlyQty())
                    .setRcptQty(isptItem.getRcptQty())
                    .setIsptResult(isptItem.getIsptResult())
                    .setSplrBatch(isptItem.getSplrBatch())
                    .setSplrName(isptItem.getSplrName())
                    .setPicPath(isptItem.getPicPath())
                    .setMemo(isptItem.getMemo())
                    .setSafeQty(isptItem.getSafeQty());
                    .setMemo(isptItem.getMemo());
//                    .setSafeQty(isptItem.getSafeQty());
            dtos.add(objDto);
        });
        return R.ok(dtos);
@@ -538,17 +689,19 @@

    /**
     * 快速质检
     *
     * @param params
     * @param loginUserId
     * @return
     */
    @Override
    public R checkUpdate(List<QlyIsptItem> params) {
    public R checkUpdate(List<QlyIsptItem> params, Long loginUserId) {
        if (Objects.isNull(params) || params.isEmpty()) {
            throw new CoolException("参数不能为空！！");
        }
        IsptItemsParams itemsParams = new IsptItemsParams();
        itemsParams.setIsptItem(params).setType("0");
        if (qlyIsptItemService.batchUpdate(itemsParams)) {
        if (qlyIsptItemService.batchUpdate(itemsParams, loginUserId)) {
            return R.ok();
        } else {
            return R.error("保存失败！！");
@@ -556,44 +709,31 @@
    }

    /**
    * @author Ryan
    * @description 人工上架
    * @param
    * @return
    * @time 2025/4/2 16:33
    */
     * @param
     * @return
     * @author Ryan
     * @description 人工上架
     * @time 2025/4/2 16:33
     */
    @Override
    public R operateToStock(OpStockParams params) {
        if (org.apache.commons.lang3.StringUtils.isBlank(params.getBarcode())) {
            throw new CoolException("拖盘码不能为空！！");
            throw new CoolException("托盘码不能为空！！");
        }
        if (StringUtils.isBlank(params.getAsnCode())) {
            throw new CoolException("单据不能为空！！");
        WaitPakin waitPakin = waitPakinService.getOne(new LambdaQueryWrapper<WaitPakin>()
                .eq(WaitPakin::getBarcode, params.getBarcode())
                .eq(WaitPakin::getIoStatus, PakinIOStatus.PAKIN_IO_STATUS_DONE.val)
        );
        if (Cools.isEmpty(waitPakin)) {
            throw new CoolException("未找到组托数据,请检查状态");
        }
        if (StringUtils.isBlank(params.getMatnrCode())) {
            throw new CoolException("物料编码不能为空！！");
        List<WaitPakinItem> waitPakinItems = waitPakinItemService.list(new LambdaQueryWrapper<WaitPakinItem>().eq(WaitPakinItem::getPakinId, waitPakin.getId()));
        if (Cools.isEmpty(waitPakinItems)) {
            throw new CoolException("数据错误，未找到组托明细");
        }
        AsnOrder asnOrders = asnOrderMapper.getOne(new LambdaQueryWrapper<AsnOrder>().eq(AsnOrder::getCode, params.getAsnCode()));
        if (Objects.isNull(asnOrders)) {
            throw new CoolException("单据不存在！！");
        }
        List<Loc> locs = locService.list(new LambdaQueryWrapper<Loc>().eq(Loc::getBarcode, params.getBarcode()));
        if (!locs.isEmpty()) {
            throw new CoolException("拖盘已使用");
        }
        List<WaitPakin> waitPakins = waitPakinService.list(new LambdaQueryWrapper<WaitPakin>().eq(WaitPakin::getBarcode, params.getBarcode()));
        if (!waitPakins.isEmpty()) {
            throw new CoolException("拖盘已使用!!");
        }
        AsnOrderItem orderItems = asnOrderItemMapper.selectOne(new LambdaQueryWrapper<AsnOrderItem>()
                .eq(AsnOrderItem::getAsnId, asnOrders.getId())
                .eq(AsnOrderItem::getMatnrCode, params.getMatnrCode()));
        if (Objects.isNull(orderItems)) {
            return R.ok(null);
        }
        orderItems.setBarcode(params.getBarcode());

        return R.ok(orderItems);

        return R.ok(waitPakinItems);
    }

    /**
@@ -605,20 +745,21 @@
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R publicToStock(PublicToStockParams params, Long loginUserId) {
    public synchronized R publicToStock(PublicToStockParams params, Long loginUserId) {
        if (Objects.isNull(params.getLocCode()) || StringUtils.isBlank(params.getLocCode())) {
            throw new CoolException("库位不能为空！！");
        }
        if (Objects.isNull(params.getItemList()) || params.getItemList().isEmpty()) {
            throw new CoolException("单据明细不能为空！！");
        }
        Long OrderId = params.getItemList().stream().findFirst().get().getAsnId();
        Long OrderId = params.getItemList().stream().findFirst().get().getOrderId();
        /**获取平库订单*/
        AsnOrder order = asnOrderMapper.getOne(new LambdaQueryWrapper<AsnOrder>()
                .eq(AsnOrder::getId, OrderId)
                .eq(AsnOrder::getType, OrderType.ORDER_PLAT_IN.type));
        WkOrder order = asnOrderMapper.getOne(new LambdaQueryWrapper<WkOrder>()
                .eq(WkOrder::getId, OrderId)
                .eq(WkOrder::getWkType, OrderWorkType.ORDER_WORK_TYPE_OTHER_IN.type)
                .eq(WkOrder::getType, OrderType.ORDER_IN.type));
        if (Objects.isNull(order)) {
            throw new CoolException("单据不存在！！");
            throw new CoolException("非平库单据不可执行人工上架！！");
        }
        Stock stock = new Stock();
//        if (!Objects.isNull(order.getPoCode()) && StringUtils.isNotBlank(order.getPoCode())) {
@@ -631,11 +772,13 @@
        if (StringUtils.isBlank(ruleCode)) {
            throw new CoolException("当前业务：" + SerialRuleCode.SYS_STOCK_CODE + "，编码规则不存在！！");
        }
        List<AsnOrderItem> itemList = params.getItemList();
        double sum = itemList.stream().mapToDouble(AsnOrderItem::getAnfme).sum();
        List<WkOrderItem> itemList = params.getItemList();
        double sum = itemList.stream().mapToDouble(WkOrderItem::getAnfme).sum();
        stock.setAnfme(sum)
                .setSourceId(order.getId())
                .setType(order.getType())
                .setUpdateBy(loginUserId)
                .setCreateBy(loginUserId)
                .setWkType(Short.parseShort(order.getWkType()));
        if (!stockService.save(stock)) {
            throw new CoolException("库存保存失败！！");
@@ -650,8 +793,12 @@
        itemList.forEach(asnOrderItem -> {
            LocItem item = new LocItem();
            BeanUtils.copyProperties(asnOrderItem, item);
            item.setId(loc.getId())
            item.setLocId(loc.getId())
                    .setId(null)
                    .setLocCode(loc.getCode())
                    .setOrderId(order.getId())
                    .setUpdateBy(loginUserId)
                    .setUpdateBy(loginUserId)
                    .setOrderItemId(asnOrderItem.getId())
                    .setWkType(Short.parseShort(order.getWkType()))
                    .setType(order.getType());
@@ -683,6 +830,7 @@

    /**
     * 获取任务信息
     *
     * @param code
     * @return
     */
@@ -727,14 +875,14 @@
    }

    /**
     * @Author Ryan
     * @param code
     * @desc  任务上架
     * @return
     * @Author Ryan
     * @desc 任务上架
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R taskGetLocs(String code) throws Exception {
    public synchronized R taskGetLocs(String code) throws Exception {
        if (StringUtils.isBlank(code)) {
            throw new CoolException("拖盘码不能为空！！");
        }
@@ -756,88 +904,184 @@

    @Override
    public R completeOrder(Long id, Long loginUserId) {
      return  asnOrderMapper.completeOrder(id, loginUserId);
        return asnOrderMapper.completeOrder(id, loginUserId);
    }

    /**
     * @author Ryan
     * @description 通过容器获取组拖物料
     * @param
     * @return
     * @author Ryan
     * @description 通过容器获取组拖物料
     * @time 2025/4/9 16:57
     */
    @Override
    public R getItemByContainer(Map<String, Object> params) {
//        if (Objects.isNull(params.get("code"))) {
//            throw new CoolException("参数不能为空！！");
//        }
        //获取组拖未生成任务的组拖档
        List<Short> asList = Arrays.asList(Short.valueOf(PakinIOStatus.PAKIN_IO_STATUS_DONE.val), Short.valueOf(PakinIOStatus.PAKIN_IO_STATUS_DONE.val));
        List<Short> asList = Arrays.asList(Short.valueOf(PakinIOStatus.PAKIN_IO_STATUS_DONE.val));
        Short flagDefect = 0;
        if (!Objects.isNull(params.get("type")) && params.get("type").equals("defective")) {
            flagDefect = 1;
        }
        WaitPakin waitPakin = waitPakinService.getOne(new LambdaQueryWrapper<WaitPakin>()
        List<WaitPakin> waitPakin = waitPakinService.list(new LambdaQueryWrapper<WaitPakin>()
                .eq(WaitPakin::getBarcode, params.get("barcode").toString())
                        .eq(WaitPakin::getFlagDefect, flagDefect)
//                .eq(WaitPakin::getFlagDefect, flagDefect)
                .in(WaitPakin::getIoStatus, asList));
        if (Objects.isNull(waitPakin)) {
            return R.ok(new ArrayList<>());
        if (!Cools.isEmpty(waitPakin)) {
            throw new CoolException("托盘不可用,在组托中已存在");
        }
        List<WaitPakinItem> pakinItems = waitPakinItemService.list(new LambdaQueryWrapper<WaitPakinItem>()
                .eq(WaitPakinItem::getPakinId, waitPakin.getId()));
        if (pakinItems.isEmpty()) {
            return R.ok(new ArrayList<>());
        List<Loc> locs = locService.list(new LambdaQueryWrapper<Loc>().eq(Loc::getBarcode, params.get("barcode").toString()));
        if (!Cools.isEmpty(locs)) {
            throw new CoolException("托盘不可用，在库位中已存在");
        }
        if (!Objects.isNull(params.get("type")) && params.get("type").equals("defective")) {
            return R.ok(pakinItems);
        } else {
            List<String> list = pakinItems.stream().map(WaitPakinItem::getTrackCode).collect(Collectors.toList());
            LambdaQueryWrapper<WarehouseAreasItem> queryWrapper = new QueryWrapper<WarehouseAreasItem>()
                    .select("SUM(anfme) as anfme, track_code, asn_code, id, splr_batch, ispt_result, plat_item_id, batch, qty, work_qty, matnr_code, matnr_id, maktx")
                    .lambda()
                    .in(WarehouseAreasItem::getTrackCode, list)
                    .groupBy(WarehouseAreasItem::getSplrBatch,
                            WarehouseAreasItem::getTrackCode);
            List<WarehouseAreasItem> warehouseAreasItems = warehouseAreasItemService.list(queryWrapper);
            for (int i = 0; i < warehouseAreasItems.size(); i++) {
                for (WaitPakinItem pakinItem : pakinItems) {
                    if (warehouseAreasItems.get(i).getTrackCode().equals(pakinItem.getTrackCode())) {
                        warehouseAreasItems.get(i).setAnfme(pakinItem.getAnfme());
                    }
                }
            }
            return R.ok(warehouseAreasItems);
        }
        return R.ok("托盘可用");
    }

    /**
     * @author Ryan
     * @description 不良标签
     * @param
     * @return
     * @author Ryan
     * @description 通过容器获取组拖物料
     * @time 2025/4/9 16:57
     */
    @Override
    public R getUnItemByContainer(Map<String, Object> params) {
        if (Cools.isEmpty(params.get("barcode")) && Cools.isEmpty(params.get("code"))) {
            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 waitPakin = waitPakinService.getOne(new LambdaQueryWrapper<WaitPakin>()
                .eq(!Cools.isEmpty(params.get("barcode")), WaitPakin::getBarcode, params.get("barcode"))
                .eq(!Cools.isEmpty(params.get("code")), WaitPakin::getCode, params.get("code"))
                .eq(WaitPakin::getIoStatus, PakinIOStatus.PAKIN_IO_STATUS_DONE.val));
        if (Objects.isNull(waitPakin)) {
            return R.error("未找到该容器码的组托明细，请检查组托状态");
        }
        List<WaitPakinItem> pakinItems = waitPakinItemService.list(new LambdaQueryWrapper<WaitPakinItem>()
                .eq(WaitPakinItem::getPakinId, waitPakin.getId()));
//        if (pakinItems.isEmpty()) {
//            return R.ok(new ArrayList<>());
//        }
//        List<Long> list = pakinItems.stream().map(WaitPakinItem::getSource).collect(Collectors.toList());
//        LambdaQueryWrapper<WarehouseAreasItem> queryWrapper = new LambdaQueryWrapper<WarehouseAreasItem>().in(WarehouseAreasItem::getId, list);
//        List<WarehouseAreasItem> warehouseAreasItems = warehouseAreasItemService.list(queryWrapper);
//        for (int i = 0; i < warehouseAreasItems.size(); i++) {
//            for (WaitPakinItem pakinItem : pakinItems) {
//                if (warehouseAreasItems.get(i).getId().equals(pakinItem.getSource())) {
//                    warehouseAreasItems.get(i).setAnfme(pakinItem.getAnfme());
//                }
//            }
//        }
        return R.ok(pakinItems);
    }


    /**
     * @param
     * @return
     * @author Ryan
     * @description 不良标签
     * @time 2025/4/12 08:12
     */
    @Override
    public R defectProducts(String trackCode) {
        AsnOrderItem orderItem = asnOrderItemMapper.selectOne(new LambdaQueryWrapper<AsnOrderItem>().eq(AsnOrderItem::getTrackCode, trackCode));
        WkOrderItem orderItem = asnOrderItemMapper.selectOne(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getTrackCode, trackCode));
        return R.ok(orderItem);
    }

    /**
     * @param barcode
     * @return
     * @author Ryan
     * @description 获取入库组拖信息
     */
    @Override
    public R getPakinInStock(String barcode) {
        WaitPakin waitPakin = waitPakinService.getOne(new LambdaQueryWrapper<WaitPakin>().eq(WaitPakin::getBarcode, barcode));
        if (Objects.isNull(waitPakin)) {
            throw new CoolException("组拖单据不存在！！");
        }
        List<WaitPakinItem> pakinItems = waitPakinItemService.list(new LambdaQueryWrapper<WaitPakinItem>().eq(WaitPakinItem::getPakinId, waitPakin.getId()));
        if (pakinItems.isEmpty()) {
            return R.ok(new ArrayList<>());
        }
        return R.ok(pakinItems);
    }

    /**
     * @return
     * @author Ryan
     * @description 获取库口站点信息
     */
    @Override
    public R getDeviceSites() {
        List<DeviceSite> sites = deviceSiteMapper.selectList(new LambdaQueryWrapper<DeviceSite>()
                .select(DeviceSite::getId, DeviceSite::getSite, DeviceSite::getName)
                .eq(DeviceSite::getStatus, 1)
                .groupBy(DeviceSite::getSite, DeviceSite::getId, DeviceSite::getName));
        return R.ok(sites);
    }

    /**
     * @return
     * @author Ryan
     * @description 获取推荐库位
     */
    @Override
    public R getRecommondLocs() {
        return R.ok(locService.list(new LambdaQueryWrapper<Loc>().last("limit 10")));
    }

    /**
     * @param map
     * @param loginUserId
     * @return
     * @author Ryan
     * @description 生成任务列表
     */
    @Override
    public synchronized R generateTask(Map<String, Object> map, Long loginUserId) {
        String barcode = map.get("barcode").toString();
        List<WaitPakin> waitPakins = waitPakinService.list(new LambdaQueryWrapper<WaitPakin>().eq(WaitPakin::getBarcode, barcode));
        if (waitPakins.isEmpty()) {
            throw new CoolException("单据不存在 ！！");
        }
        GenerateTaskParams taskParams = new GenerateTaskParams();
        taskParams.setWaitPakins(waitPakins)
                .setSiteId(Long.parseLong(map.get("site").toString()))
                .setLocCode(map.get("locCode").toString());
        return R.ok(taskService.generateTasks(taskParams, loginUserId));

    }

    /**
     * 获取ReceiptDetlsDtos
     */
    private R getAsnOrderItem(List<AsnOrderItem> items) {
    private R getAsnOrderItem(List<WkOrderItem> items) {
        List<ReceiptDetlsDto> detlsDtos = new ArrayList<>();
        items.forEach(asnOrderItem -> {
            ReceiptDetlsDto detlsDto = new ReceiptDetlsDto();

            detlsDto.setAsnCode(asnOrderItem.getAsnCode())
            detlsDto.setAsnCode(asnOrderItem.getOrderCode())
                    .setId(asnOrderItem.getId())
                    .setMaktx(asnOrderItem.getMaktx())
                    .setFieldsIndex(asnOrderItem.getFieldsIndex())
                    .setBarcode(asnOrderItem.getTrackCode())
                    .setQty(asnOrderItem.getQty())
                    .setStockUnit(asnOrderItem.getStockUnit())
                    .setPurUnit(asnOrderItem.getPurUnit())
                    .setPoCode(asnOrderItem.getPoCode())
                    .setAnfme(asnOrderItem.getAnfme())
                    .setPurQty(asnOrderItem.getPurQty())
                    .setSplrBatch(asnOrderItem.getSplrBatch());
                    .setSplrBatch(asnOrderItem.getSplrBatch())
                    .setExtendFields(asnOrderItem.getExtendFields())
                    .setMatnr(asnOrderItem.getMatnrCode())
                    .setInspect(asnOrderItem.getIsptResult$()) //质检结果
                    .setPlatItemId(asnOrderItem.getPlatItemId());

            Matnr matnr = matnrMapper.selectById(asnOrderItem.getMatnrId());
            if (Objects.isNull(matnr)) {
@@ -845,24 +1089,25 @@
            }
            //SET 物料最大存放数量
            detlsDto.setMaxQty(matnr.getMaxQty())
                    .setMatnrId(matnr.getId())
                    .setStockUnit(matnr.getStockUnit());
            QlyInspect inspect = qlyInspectMapper.selectOne(new LambdaQueryWrapper<QlyInspect>()
                    .eq(QlyInspect::getAsnId, asnOrderItem.getAsnId()));
            if (!Objects.isNull(inspect)) {
                //set 质检结果
                detlsDto.setInspect(inspect.getStatus$());
            }
                    .setMatnrId(matnr.getId());
//            QlyInspect inspect = qlyInspectMapper.selectOne(new LambdaQueryWrapper<QlyInspect>()
//                    .eq(QlyInspect::getAsnId, asnOrderItem.getAsnId()));
//            if (!Objects.isNull(inspect)) {
//                //set 质检结果
//                detlsDto.setInspect(inspect.getStatus$());
//            }
            //获取当前库存信息
            LocItem stockItem = locItemService.getOne(new LambdaQueryWrapper<LocItem>()
                    .eq(LocItem::getOrderItemId, asnOrderItem.getId())
                    .eq(LocItem::getBatch, asnOrderItem.getBatch())
//                    .eq(LocItem::getOrderItemId, asnOrderItem.getId())
                    .eq(LocItem::getFieldsIndex, asnOrderItem.getFieldsIndex())
                    .eq(LocItem::getBatch, asnOrderItem.getSplrBatch())
                    .eq(LocItem::getMatnrId, asnOrderItem.getMatnrId()));
            //SET 当前库存数量
            if (Objects.isNull(stockItem)) {
                detlsDto.setStockQty(0.0);
            } else {
                detlsDto.setStockQty(stockItem.getAnfme() + stockItem.getWorkQty());
                Double anfme = Math.round((stockItem.getAnfme() + stockItem.getWorkQty()) * 10000) / 10000.0;
                detlsDto.setStockQty(anfme);
            }

            if (!Objects.isNull(asnOrderItem.getPoDetlId())) {