拣货过程中的出库库存匹配+空板

chen.lin

昨天 79ce234f181a8fa5e3e02938520395243c82a5da

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

@@ -8,12 +8,16 @@
import com.vincent.rsf.framework.exception.CoolException;
import com.vincent.rsf.server.api.utils.LocUtils;
import com.vincent.rsf.server.common.constant.Constants;
import com.vincent.rsf.server.common.domain.BaseParam;
import com.vincent.rsf.server.common.domain.PageParam;
import com.vincent.rsf.server.manager.controller.dto.ExistDto;
import com.vincent.rsf.server.manager.controller.dto.OrderOutItemDto;
import com.vincent.rsf.server.manager.controller.params.*;
import com.vincent.rsf.server.manager.enums.*;
import com.vincent.rsf.server.manager.entity.Matnr;
import com.vincent.rsf.server.manager.entity.*;
import com.vincent.rsf.server.manager.mapper.AsnOrderMapper;
import com.vincent.rsf.server.manager.mapper.LocItemMapper;
import com.vincent.rsf.server.manager.service.*;
import com.vincent.rsf.server.manager.utils.LocManageUtil;
import com.vincent.rsf.server.manager.utils.OptimalAlgorithmUtil;
@@ -50,6 +54,16 @@

    /** 出库剩余量容差：小于等于此值视为已分配完，避免浮点误差产生多余“库存不足”行 */
    private static final BigDecimal ISSUED_TOLERANCE = new BigDecimal("0.000001");
    /** 数量精度（小数位数），统一用 BigDecimal 计算后按此精度舍入再写回 Double 字段 */
    private static final int QTY_SCALE = 6;

    /** 将 Map/实体中的数量转为 BigDecimal，避免 double 精度问题 */
    private static BigDecimal toBigDecimal(Object o) {
        if (o == null) return BigDecimal.ZERO;
        if (o instanceof BigDecimal) return (BigDecimal) o;
        if (o instanceof Number) return new BigDecimal(o.toString());
        try { return new BigDecimal(o.toString()); } catch (NumberFormatException e) { return BigDecimal.ZERO; }
    }

    @Autowired
    private AsnOrderItemService asnOrderItemService;
@@ -81,7 +95,128 @@
    private LocService locService;
    @Autowired
    private WaveOrderRelaServiceImpl waveOrderRelaService;
    @Autowired
    private TaskItemService taskItemService;
    @Autowired
    private TaskService taskService;
    @Autowired
    private LocItemMapper locItemMapper;

    @Override
    public PageParam<Matnr, BaseParam> pageMatnrForOutStock(PageParam<Matnr, BaseParam> pageParam, Map<String, Object> params) {
        // 在 getMatnrPage 之前取出 locUseStatus：getMatnrPage 会从 where.map 中 remove 掉该键（与 params 同引用），导致后续取不到
        String locUseStatus = params.get("locUseStatus") != null ? params.get("locUseStatus").toString().trim() : null;
        if (locUseStatus != null && locUseStatus.isEmpty()) locUseStatus = null;

        PageParam<Matnr, BaseParam> page = matnrService.getMatnrPage(pageParam, params);
        List<Matnr> records = page.getRecords();
        if (records == null || records.isEmpty()) {
            return page;
        }
        List<Long> matnrIds = records.stream().map(Matnr::getId).collect(Collectors.toList());
        List<Map<String, Object>> stockByLocList = locItemMapper.listStockByMatnrIdsGroupByStatusAndLoc(matnrIds, locUseStatus);
        Map<Long, List<Map<String, Object>>> rowsByMatnr = buildRowsByMatnrFromPerLoc(stockByLocList);
        List<Matnr> expanded = new ArrayList<>();
        for (Matnr record : records) {
            List<Map<String, Object>> statusRows = rowsByMatnr.get(record.getId());
            if (statusRows == null || statusRows.isEmpty()) {
                record.setStockQty(0d);
                record.setLocUseStatus$(null);
                record.setLocCodes$(null);
                expanded.add(record);
                continue;
            }
            for (Map<String, Object> row : statusRows) {
                BigDecimal stockQtyVal = toBigDecimal(row.get("stockQty"));
                String useStatus = getStr(row, "useStatus", "usestatus");
                String statusDesc = useStatus != null ? LocStsType.getDescByType(useStatus) : null;
                String locCodesWithQty = getStr(row, "locCodes$", "loccodes$");
                Matnr copy = cloneMatnrForRow(record);
                copy.setStockQty(stockQtyVal.setScale(QTY_SCALE, RoundingMode.HALF_UP).doubleValue());
                copy.setLocUseStatus$(statusDesc);
                copy.setLocCodes$(locCodesWithQty);
                expanded.add(copy);
            }
        }
        page.setRecords(expanded);
        return page;
    }

    /** 复制物料用于按状态展开行（仅复制展示用字段，id 保持原样供前端选行用） */
    private static Matnr cloneMatnrForRow(Matnr source) {
        Matnr copy = new Matnr();
        BeanUtils.copyProperties(source, copy, "stockQty", "locUseStatus$", "locCodes$");
        return copy;
    }

    /**
     * 仅用「按库位明细」查询结果在内存中分组汇总：按 (matnrId, useStatus) 聚合，
     * 得到 stockQty、locCodes$（库位(数量),...），减轻数据库压力。
     */
    private static Map<Long, List<Map<String, Object>>> buildRowsByMatnrFromPerLoc(List<Map<String, Object>> stockByLocList) {
        Map<String, List<Map<String, Object>>> perLocByMatnrAndStatus = new HashMap<>();
        for (Map<String, Object> locRow : stockByLocList) {
            Long mid = getLong(locRow, "matnrId", "matnrid");
            String us = getStr(locRow, "useStatus", "usestatus");
            if (mid == null || us == null) continue;
            String key = mid + ":" + us;
            perLocByMatnrAndStatus.computeIfAbsent(key, k -> new ArrayList<>()).add(locRow);
        }
        Map<Long, List<Map<String, Object>>> rowsByMatnr = new HashMap<>();
        for (Map.Entry<String, List<Map<String, Object>>> e : perLocByMatnrAndStatus.entrySet()) {
            String[] parts = e.getKey().split(":", 2);
            if (parts.length != 2) continue;
            Long matnrId;
            try { matnrId = Long.parseLong(parts[0]); } catch (NumberFormatException ex) { continue; }
            String useStatus = parts[1];
            List<Map<String, Object>> locs = e.getValue();
            BigDecimal stockQty = BigDecimal.ZERO;
            StringBuilder sb = new StringBuilder();
            for (Map<String, Object> locRow : locs) {
                Object q = getAny(locRow, "locQty", "locqty");
                BigDecimal qty = toBigDecimal(q);
                stockQty = stockQty.add(qty);
                String code = getStr(locRow, "locCode", "loccode");
                if (sb.length() > 0) sb.append(",");
                sb.append(code != null ? code : "").append("(").append(formatQtyForLoc(qty)).append(")");
            }
            Map<String, Object> statusRow = new HashMap<>();
            statusRow.put("matnrId", matnrId);
            statusRow.put("useStatus", useStatus);
            statusRow.put("stockQty", stockQty);
            statusRow.put("locCodes$", sb.toString());
            rowsByMatnr.computeIfAbsent(matnrId, k -> new ArrayList<>()).add(statusRow);
        }
        return rowsByMatnr;
    }

    private static String formatQtyForLoc(BigDecimal qty) {
        if (qty == null) return "0";
        BigDecimal scaled = qty.setScale(QTY_SCALE, RoundingMode.HALF_UP).stripTrailingZeros();
        if (scaled.scale() <= 0) return scaled.toPlainString();
        return scaled.toPlainString();
    }

    private static Long getLong(Map<String, Object> map, String... keys) {
        Object v = getAny(map, keys);
        if (v == null) return null;
        if (v instanceof Long) return (Long) v;
        if (v instanceof Number) return ((Number) v).longValue();
        try { return Long.parseLong(v.toString()); } catch (NumberFormatException e) { return null; }
    }

    private static String getStr(Map<String, Object> map, String... keys) {
        Object v = getAny(map, keys);
        return v != null ? v.toString() : null;
    }

    private static Object getAny(Map<String, Object> map, String... keys) {
        for (String key : keys) {
            Object v = map.get(key);
            if (v != null) return v;
        }
        return null;
    }

    /**
     * @param
@@ -105,8 +240,10 @@
        });
        List<WkOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>()
                .eq(WkOrderItem::getOrderId, params.getOrders().getId()));
        Double sum = orderItems.stream().mapToDouble(WkOrderItem::getAnfme).sum();
        orders.setAnfme(sum);
        BigDecimal sum = orderItems.stream()
                .map(o -> toBigDecimal(o.getAnfme()))
                .reduce(BigDecimal.ZERO, BigDecimal::add);
        orders.setAnfme(sum.setScale(QTY_SCALE, RoundingMode.HALF_UP).doubleValue());
        if (!this.updateById(orders)) {
            throw new CoolException("计划收货数量修改失败！！");
        }
@@ -137,18 +274,18 @@
        List<WkOrderItem> orderItems = outStockItemService.list(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getOrderId, id));
        if (!orderItems.isEmpty()) {
            for (WkOrderItem orderItem : orderItems) {
                if (!Objects.isNull(orderItem.getPoDetlId())) {
                    if (!Objects.isNull(orderItem.getPoDetlId())) {
                    DeliveryItem deliveryItem = deliveryItemService.getById(orderItem.getPoDetlId());
                    Double workQty = Math.round((deliveryItem.getWorkQty() - orderItem.getAnfme()) * 1000000) / 1000000.0;
                    deliveryItem.setWorkQty(workQty.compareTo(0.0) >= 0 ? workQty : 0);
                    BigDecimal workQty = toBigDecimal(deliveryItem.getWorkQty()).subtract(toBigDecimal(orderItem.getAnfme())).setScale(QTY_SCALE, RoundingMode.HALF_UP);
                    deliveryItem.setWorkQty(workQty.compareTo(BigDecimal.ZERO) >= 0 ? workQty.doubleValue() : 0);
                    if (!deliveryItemService.updateById(deliveryItem)) {
                        throw new CoolException("DO单明细更新失败！！");
                    }

                    Delivery delivery = deliveryService.getOne(new LambdaQueryWrapper<Delivery>().eq(Delivery::getCode, orderItem.getPoCode()));
                    if (!Objects.isNull(delivery)) {
                        Double wkQty = Math.round((delivery.getWorkQty() - delivery.getAnfme()) * 1000000) / 1000000.0;
                        delivery.setWorkQty(wkQty.compareTo(0.0) >= 0 ? wkQty : 0).setExceStatus(POExceStatus.PO_EXCE_STATUS_UN_EXCE.val);
                        BigDecimal wkQty = toBigDecimal(delivery.getWorkQty()).subtract(toBigDecimal(delivery.getAnfme())).setScale(QTY_SCALE, RoundingMode.HALF_UP);
                        delivery.setWorkQty(wkQty.compareTo(BigDecimal.ZERO) >= 0 ? wkQty.doubleValue() : 0).setExceStatus(POExceStatus.PO_EXCE_STATUS_UN_EXCE.val);
                        if (!deliveryService.updateById(delivery)) {
                            throw new CoolException("DO单据修改失败！！");
                        }
@@ -211,8 +348,8 @@
                if (item.getAnfme().compareTo(0.0) <= 0) {
                    throw new CoolException("出库数量不能小于或等于零！！");
                }
                Double anfme = Math.round((deliveryItem.getAnfme() - item.getAnfme()) * 1000000) / 1000000.0;
                if (anfme.compareTo(0.0) < 0) {
                BigDecimal anfme = toBigDecimal(deliveryItem.getAnfme()).subtract(toBigDecimal(item.getAnfme())).setScale(QTY_SCALE, RoundingMode.HALF_UP);
                if (anfme.compareTo(BigDecimal.ZERO) < 0) {
                    throw new CoolException("出库数量不足！！");
                }

@@ -244,9 +381,9 @@
                }
            });

            Double sum = orderItems.stream().mapToDouble(WkOrderItem::getAnfme).sum();
            BigDecimal sum = orderItems.stream().map(o -> toBigDecimal(o.getAnfme())).reduce(BigDecimal.ZERO, BigDecimal::add);
            //修改计划数量
            order.setAnfme(sum).setWorkQty(0.0);
            order.setAnfme(sum.setScale(QTY_SCALE, RoundingMode.HALF_UP).doubleValue()).setWorkQty(0.0);
            if (!this.saveOrUpdate(order)) {
                throw new CoolException("主单数量修改失败！！");
            }
@@ -259,10 +396,10 @@
                exceStatus = AsnExceStatus.ASN_EXCE_STATUS_TASK_DONE.val;
            }

            Double wkQty = Math.round((delivery.getWorkQty() + sum) * 1000000) / 1000000.0;
            BigDecimal wkQty = toBigDecimal(delivery.getWorkQty()).add(sum).setScale(QTY_SCALE, RoundingMode.HALF_UP);
            if (!deliveryService.update(new LambdaUpdateWrapper<Delivery>()
                    .set(Delivery::getExceStatus, exceStatus)
                    .set(Delivery::getWorkQty, wkQty)
                    .set(Delivery::getWorkQty, wkQty.doubleValue())
                    .eq(Delivery::getId, key))) {
                throw new CoolException("主单修改失败！！");
            }
@@ -289,9 +426,9 @@
        if (orders.isEmpty()) {
            throw new CoolException("当前单据状态不能执行波次生成操作！！");
        }
        Double sum = orders.stream().mapToDouble(WkOrder::getAnfme).sum();
        Double workQty = orders.stream().mapToDouble(WkOrder::getWorkQty).sum();
        Double anfme = Math.round((sum - workQty) * 1000000) / 1000000.0;
        BigDecimal sum = orders.stream().map(o -> toBigDecimal(o.getAnfme())).reduce(BigDecimal.ZERO, BigDecimal::add);
        BigDecimal workQty = orders.stream().map(o -> toBigDecimal(o.getWorkQty())).reduce(BigDecimal.ZERO, BigDecimal::add);
        BigDecimal anfme = sum.subtract(workQty).setScale(QTY_SCALE, RoundingMode.HALF_UP);
        Wave wave = new Wave();
        String ruleCode = SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_WAVE_TYPE, null);
        if (StringUtils.isBlank(ruleCode)) {
@@ -301,7 +438,7 @@
                .setType(Short.parseShort("1"))
                .setCode(ruleCode)
                .setExceStatus(WaveExceStatus.WAVE_EXCE_STATUS_INIT.val)
                .setAnfme(anfme);
                .setAnfme(anfme.doubleValue());
        if (!waveService.save(wave)) {
            throw new CoolException("波次保存失败！！");
        }
@@ -320,8 +457,8 @@
        if (!waveItemService.saveBatch(waveItems)) {
            throw new CoolException("波次明细保存失败！！");
        }
        double sum1 = waveItems.stream().mapToDouble(WaveItem::getAnfme).sum();
        wave.setAnfme(sum1).setGroupQty(waveItems.size());
        BigDecimal sum1 = waveItems.stream().map(o -> toBigDecimal(o.getAnfme())).reduce(BigDecimal.ZERO, BigDecimal::add);
        wave.setAnfme(sum1.setScale(QTY_SCALE, RoundingMode.HALF_UP).doubleValue()).setGroupQty(waveItems.size());
        if (!waveService.saveOrUpdate(wave)) {
            throw new CoolException("主单修改失败！！");
        }
@@ -356,10 +493,10 @@
            throw new CoolException("出库单执行数量修改失败！！");
        }
        for (WkOrder order : orders) {
            Double wkQty = Math.round((order.getWorkQty() + order.getAnfme()) * 1000000) / 1000000.0;
            BigDecimal wkQty = toBigDecimal(order.getWorkQty()).add(toBigDecimal(order.getAnfme())).setScale(QTY_SCALE, RoundingMode.HALF_UP);
            if (!this.update(new LambdaUpdateWrapper<WkOrder>()
                    .set(WkOrder::getWaveId, wave.getId())
                    .set(WkOrder::getWorkQty, wkQty)
                    .set(WkOrder::getWorkQty, wkQty.doubleValue())
                    .set(WkOrder::getExceStatus, AsnExceStatus.OUT_STOCK_STATUS_TASK_WAVE.val)
                    .eq(WkOrder::getId, order.getId()))) {
                throw new CoolException("执行状态修改修改失败！！");
@@ -419,6 +556,7 @@
     * @time 2025/4/29 13:47
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R updateOrderItem(AsnOrderAndItemsParams params, Long loginUserId) {
        WkOrder orders = params.getOrders();
        if (Objects.isNull(orders)) {
@@ -433,12 +571,102 @@
        if (Objects.isNull(params.getItems()) || params.getItems().isEmpty()) {
            throw new CoolException("明细参数不能为空！！");
        }
        // 删除/修改明细前收集当前单据下的明细 id，用于校验与同步库位状态
        List<Long> existingIds = asnOrderItemService.list(
                new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getOrderId, orders.getId()))
                .stream().map(WkOrderItem::getId).collect(Collectors.toList());
        Set<Long> requestedIds = params.getItems().stream()
                .map(item -> item.get("id"))
                .filter(Objects::nonNull)
                .map(id -> Long.valueOf(id.toString()))
                .collect(Collectors.toSet());
        // 已生成工作档的明细不允许删除
        for (Long existingId : existingIds) {
            if (!requestedIds.contains(existingId) && hasGeneratedTask(orders.getId(), existingId)) {
                throw new CoolException("该明细已生成工作档，不能删除");
            }
        }
        // 已生成工作档的明细不允许修改
        for (Map<String, Object> item : params.getItems()) {
            Object idObj = item.get("id");
            if (idObj != null && hasGeneratedTask(orders.getId(), Long.valueOf(idObj.toString()))) {
                throw new CoolException("该明细已生成工作档，不能修改");
            }
        }
        try {
            svaeOrUpdateOrderItem(params, loginUserId);
        } catch (Exception e) {
            throw new CoolException(e.getMessage());
        }
        // 对本次被删除的明细（仅初始化状态）：先同步库位状态，再删除明细记录
        for (Long existingId : existingIds) {
            if (!requestedIds.contains(existingId)) {
                syncLocStatusOnOrderItemRemoved(orders.getId(), existingId, loginUserId);
                outStockItemService.removeById(existingId);
            }
        }
        // 重新汇总主单数量（删除明细后）
        List<WkOrderItem> afterItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>()
                .eq(WkOrderItem::getOrderId, orders.getId()));
        BigDecimal sum = afterItems.stream().map(o -> toBigDecimal(o.getAnfme())).reduce(BigDecimal.ZERO, BigDecimal::add);
        orders.setAnfme(sum.setScale(QTY_SCALE, RoundingMode.HALF_UP).doubleValue());
        this.updateById(orders);
        return R.ok();
    }

    /**
     * 判断出库单明细是否已生成工作档（存在关联的任务明细）
     */
    private boolean hasGeneratedTask(Long orderId, Long orderItemId) {
        return taskItemService.count(new LambdaQueryWrapper<TaskItem>()
                .eq(TaskItem::getSourceId, orderId)
                .eq(TaskItem::getOrderItemId, orderItemId)) > 0;
    }

    /**
     * 出库单明细被删除时同步库位状态：释放该明细关联的库位预约、回滚 LocItem.workQty、恢复库位为在库(F)
     */
    private void syncLocStatusOnOrderItemRemoved(Long orderId, Long orderItemId, Long loginUserId) {
        List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>()
                .eq(TaskItem::getSourceId, orderId)
                .eq(TaskItem::getOrderItemId, orderItemId));
        if (taskItems.isEmpty()) {
            return;
        }
        Set<Long> affectedLocIds = new HashSet<>();
        Date now = new Date();
        for (TaskItem taskItem : taskItems) {
            if (taskItem.getSource() == null) {
                continue;
            }
            LocItem locItem = locItemService.getById(taskItem.getSource());
            if (locItem == null) {
                continue;
            }
            BigDecimal anfme = toBigDecimal(taskItem.getAnfme());
            BigDecimal newWorkQty = toBigDecimal(locItem.getWorkQty()).subtract(anfme).setScale(QTY_SCALE, RoundingMode.HALF_UP);
            locItem.setWorkQty(newWorkQty.compareTo(BigDecimal.ZERO) >= 0 ? newWorkQty.doubleValue() : 0)
                    .setOrderId(null)
                    .setOrderItemId(null)
                    .setUpdateBy(loginUserId)
                    .setUpdateTime(now);
            locItemService.updateById(locItem);
            affectedLocIds.add(locItem.getLocId());
        }
        for (Long locId : affectedLocIds) {
            long stillReserved = locItemService.count(new LambdaQueryWrapper<LocItem>()
                    .eq(LocItem::getLocId, locId)
                    .isNotNull(LocItem::getOrderId));
            if (stillReserved == 0) {
                Loc loc = locService.getById(locId);
                if (loc != null && LocStsType.LOC_STS_TYPE_R.type.equals(loc.getUseStatus())) {
                    loc.setUseStatus(LocStsType.LOC_STS_TYPE_F.type)
                            .setUpdateBy(loginUserId)
                            .setUpdateTime(now);
                    locService.updateById(loc);
                }
            }
        }
    }

    @Override
@@ -520,71 +748,93 @@
                if (StringUtils.isNotBlank(locItem.getFieldsIndex())) {
                    orderItemWrapper.eq(WkOrderItem::getFieldsIndex, locItem.getFieldsIndex());
                }
                WkOrderItem orderItem = outStockItemService.getOne(orderItemWrapper);
                // 同一出库单下同一物料可能有多条明细（如多行合并），用 list 取仍有剩余数量的第一条
                List<WkOrderItem> orderItemCandidates = outStockItemService.list(orderItemWrapper);
                WkOrderItem orderItem = orderItemCandidates.stream()
                        .filter(o -> o.getAnfme() != null && o.getWorkQty() != null && o.getAnfme().compareTo(o.getWorkQty()) > 0)
                        .findFirst()
                        .orElse(null);

                // 如果找不到单据明细，且LocItem来自库存调整，则自动创建WkOrderItem
                // 严格匹配未找到时：再按「同单号+同物料」宽松匹配，避免原明细 fields_index 为空而分配带票号导致重复创建一条
                if (Objects.isNull(orderItem)) {
                    // 检查是否是库存调整产生的库存
                    if (locItem.getWkType() != null && 
                        locItem.getWkType().equals(Short.parseShort(OrderWorkType.ORDER_WORK_TYPE_STOCK_REVISE.type))) {
                        // 获取出库单信息
                        WkOrder outOrder = outStockService.getById(outId);
                        if (Objects.isNull(outOrder)) {
                            throw new CoolException("出库单据不存在！！");
                        }
                        
                        log.info("库存调整产生的库存，自动创建WkOrderItem - 出库单ID：{}，物料ID：{}，批次：{}", 
                                outId, locItem.getMatnrId(), locItem.getBatch());
                        
                        // 创建WkOrderItem
                        orderItem = new WkOrderItem();
                        orderItem.setOrderId(outId)
                                .setOrderCode(outOrder.getCode())
                                .setMatnrId(locItem.getMatnrId())
                                .setMatnrCode(locItem.getMatnrCode())
                                .setMaktx(locItem.getMaktx())
                                .setBatch(StringUtils.isNotBlank(param.getBatch()) ? param.getBatch() : locItem.getBatch())
                                .setSplrBatch(StringUtils.isNotBlank(locItem.getSplrBatch()) ? locItem.getSplrBatch() : 
                                             (StringUtils.isNotBlank(locItem.getBatch()) ? locItem.getBatch() : null))
                                .setFieldsIndex(locItem.getFieldsIndex())
                                .setAnfme(param.getOutQty())
                                .setWorkQty(0.0)
                                .setStockUnit(locItem.getUnit())
                                .setPurUnit(locItem.getUnit())
                                .setSpec(locItem.getSpec())
                                .setModel(locItem.getModel())
                                .setCreateBy(loginUserId)
                                .setUpdateBy(loginUserId)
                                .setCreateTime(new Date())
                                .setUpdateTime(new Date());
                        
                        if (!outStockItemService.save(orderItem)) {
                            throw new CoolException("库存调整单据明细创建失败！！");
                        }
                        
                        log.info("WkOrderItem创建成功 - ID：{}，出库单ID：{}，物料ID：{}", 
                                orderItem.getId(), outId, locItem.getMatnrId());
                    } else {
                        throw new CoolException("单据明细不存在！！出库单ID：" + outId + "，物料ID：" + locItem.getMatnrId() + 
                                (StringUtils.isNotBlank(locItem.getSplrBatch()) ? "，供应商批次：" + locItem.getSplrBatch() : 
                                 StringUtils.isNotBlank(locItem.getBatch()) ? "，库存批次：" + locItem.getBatch() : "") +
                                (StringUtils.isNotBlank(locItem.getFieldsIndex()) ? "，字段索引：" + locItem.getFieldsIndex() : ""));
                    LambdaQueryWrapper<WkOrderItem> relaxedWrapper = new LambdaQueryWrapper<WkOrderItem>()
                            .eq(WkOrderItem::getOrderId, outId)
                            .eq(WkOrderItem::getMatnrId, locItem.getMatnrId());
                    if (StringUtils.isNotBlank(locItem.getSplrBatch())) {
                        relaxedWrapper.eq(WkOrderItem::getSplrBatch, locItem.getSplrBatch());
                    } else if (StringUtils.isNotBlank(locItem.getBatch())) {
                        relaxedWrapper.and(w -> w.eq(WkOrderItem::getBatch, locItem.getBatch()).or().eq(WkOrderItem::getSplrBatch, locItem.getBatch()));
                    }
                    orderItem = outStockItemService.list(relaxedWrapper).stream()
                            .filter(o -> o.getAnfme() != null && o.getWorkQty() != null && o.getAnfme().compareTo(o.getWorkQty()) > 0)
                            .findFirst()
                            .orElse(null);
                    if (orderItem != null && StringUtils.isNotBlank(locItem.getFieldsIndex()) && !locItem.getFieldsIndex().equals(orderItem.getFieldsIndex())) {
                        orderItem.setFieldsIndex(locItem.getFieldsIndex());
                        outStockItemService.updateById(orderItem);
                    }
                }

                // 找不到单据明细时：出库单存在则自动创建WkOrderItem（库存调整或分配时出库单暂无该物料行）
                if (Objects.isNull(orderItem)) {
                    WkOrder outOrder = outStockService.getById(outId);
                    if (Objects.isNull(outOrder)) {
                        throw new CoolException("出库单据不存在！！");
                    }
                    boolean isStockRevise = locItem.getWkType() != null
                            && locItem.getWkType().equals(Short.parseShort(OrderWorkType.ORDER_WORK_TYPE_STOCK_REVISE.type));
                    if (isStockRevise) {
                        log.info("库存调整产生的库存，自动创建WkOrderItem - 出库单ID：{}，物料ID：{}，批次：{}",
                                outId, locItem.getMatnrId(), locItem.getBatch());
                    } else {
                        log.info("出库单下无匹配明细，自动创建WkOrderItem - 出库单ID：{}，物料ID：{}，批次：{}",
                                outId, locItem.getMatnrId(), locItem.getBatch());
                    }
                    orderItem = new WkOrderItem();
                    orderItem.setOrderId(outId)
                            .setOrderCode(outOrder.getCode())
                            .setMatnrId(locItem.getMatnrId())
                            .setMatnrCode(locItem.getMatnrCode())
                            .setMaktx(locItem.getMaktx())
                            .setBatch(StringUtils.isNotBlank(param.getBatch()) ? param.getBatch() : locItem.getBatch())
                            .setSplrBatch(StringUtils.isNotBlank(locItem.getSplrBatch()) ? locItem.getSplrBatch() :
                                    (StringUtils.isNotBlank(locItem.getBatch()) ? locItem.getBatch() : null))
                            .setFieldsIndex(locItem.getFieldsIndex())
                            .setAnfme(param.getOutQty())
                            .setWorkQty(0.0)
                            .setStockUnit(locItem.getUnit())
                            .setPurUnit(locItem.getUnit())
                            .setSpec(locItem.getSpec())
                            .setModel(locItem.getModel())
                            .setCreateBy(loginUserId)
                            .setUpdateBy(loginUserId)
                            .setCreateTime(new Date())
                            .setUpdateTime(new Date());

                    if (!outStockItemService.save(orderItem)) {
                        throw new CoolException("出库单明细创建失败！！");
                    }
                    log.info("WkOrderItem创建成功 - ID：{}，出库单ID：{}，物料ID：{}",
                            orderItem.getId(), outId, locItem.getMatnrId());
                }

                locItem.setOutQty(param.getOutQty())
                        .setBatch(param.getBatch())
                        .setOrderId(outId)
                        .setOrderItemId(orderItem.getId())
                        .setSourceId(outId)
                        .setSourceCode(orderItem.getOrderCode())
                        .setSource(orderItem.getId());
                locItems.add(locItem);

                LocToTaskParams taskParams = new LocToTaskParams();
                // 出库单下发任务时，出库口未传则默认 1001
                String siteNo = StringUtils.isNotBlank(param.getSiteNo()) ? param.getSiteNo() : "1001";
                taskParams.setType(Constants.TASK_TYPE_ORDER_OUT_STOCK)
                        .setOrgLoc(loc.getCode())
                        .setItems(locItems)
                        .setSourceId(outId)
                        .setSiteNo(param.getSiteNo());
                        .setSiteNo(siteNo);
                try {
                    //生成出库任务
                    locItemService.generateTask(TaskResouceType.TASK_RESOUCE_ORDER_TYPE.val, taskParams, loginUserId);
@@ -593,9 +843,9 @@
                    throw new CoolException(e.getMessage());
                }

                Double workQty = Math.round((orderItem.getWorkQty() + locItem.getOutQty()) * 1000000) / 1000000.0;
                BigDecimal workQty = toBigDecimal(orderItem.getWorkQty()).add(toBigDecimal(locItem.getOutQty())).setScale(QTY_SCALE, RoundingMode.HALF_UP);

                orderItem.setUpdateBy(loginUserId).setUpdateTime(new Date()).setWorkQty(workQty);
                orderItem.setUpdateBy(loginUserId).setUpdateTime(new Date()).setWorkQty(workQty.doubleValue());

                if (!outStockItemService.updateById(orderItem)) {
                    throw new CoolException("单据明细修改失败！！");
@@ -603,15 +853,15 @@
            }
        }

        Double sum = Items.stream().mapToDouble(OutStockToTaskParams::getOutQty).sum();
        BigDecimal sum = Items.stream().map(OutStockToTaskParams::getOutQty).map(OutStockServiceImpl::toBigDecimal).reduce(BigDecimal.ZERO, BigDecimal::add);
        //更新出库单明细及主单
        WkOrder outOrder = outStockService.getById(outId);
        if (Objects.isNull(outOrder)) {
            throw new CoolException("出库单据不存在！！");
        }
        Double workQty = Math.round((outOrder.getWorkQty() + sum) * 1000000) / 1000000.0;
        BigDecimal workQty = toBigDecimal(outOrder.getWorkQty()).add(sum).setScale(QTY_SCALE, RoundingMode.HALF_UP);

        outOrder.setWorkQty(workQty).setExceStatus(AsnExceStatus.OUT_STOCK_STATUS_TASK_CREATE.val);
        outOrder.setWorkQty(workQty.doubleValue()).setExceStatus(AsnExceStatus.OUT_STOCK_STATUS_TASK_CREATE.val);

        if (!outStockService.updateById(outOrder)) {
            throw new CoolException("出库单状态修改失败！！");
@@ -631,7 +881,12 @@
                TaskType.TASK_TYPE_OUT.type,
                TaskType.TASK_TYPE_MERGE_OUT.type,
                TaskType.TASK_TYPE_PICK_AGAIN_OUT.type);
        List<DeviceSite> sites = deviceSiteService.list(new LambdaQueryWrapper<DeviceSite>().in(DeviceSite::getType, list).groupBy(DeviceSite::getSite));
        // 先查全部再按 site 去重，避免 GROUP BY 与 only_full_group_by 冲突
        List<DeviceSite> all = deviceSiteService.list(new LambdaQueryWrapper<DeviceSite>().in(DeviceSite::getType, list));
        List<DeviceSite> sites = all.stream()
                .collect(Collectors.toMap(DeviceSite::getSite, d -> d, (a, b) -> a))
                .values().stream()
                .collect(Collectors.toList());
        return R.ok(sites);
    }

@@ -648,16 +903,16 @@
            if (!items.isEmpty()) {
                for (WkOrderItem orderItem : items) {
                    DeliveryItem deliveryItem = deliveryItemService.getById(orderItem.getPoDetlId());
                    Double workQty = Math.round((deliveryItem.getWorkQty() - orderItem.getAnfme()) * 1000000) / 1000000.0;
                    deliveryItem.setWorkQty(workQty.compareTo(0.0) >= 0 ? workQty : 0);
                    BigDecimal workQty = toBigDecimal(deliveryItem.getWorkQty()).subtract(toBigDecimal(orderItem.getAnfme())).setScale(QTY_SCALE, RoundingMode.HALF_UP);
                    deliveryItem.setWorkQty(workQty.compareTo(BigDecimal.ZERO) >= 0 ? workQty.doubleValue() : 0);
                    if (!deliveryItemService.updateById(deliveryItem)) {
                        throw new CoolException("DO单明细更新失败！！");
                    }

                    Delivery delivery = deliveryService.getOne(new LambdaQueryWrapper<Delivery>().eq(Delivery::getCode, orderItem.getPoCode()));
                    if (!Objects.isNull(delivery)) {
                        Double wkQty = Math.round((delivery.getWorkQty() - delivery.getAnfme()) * 1000000) / 1000000.0;
                        delivery.setWorkQty(wkQty.compareTo(0.0) >= 0 ? wkQty : 0).setExceStatus(POExceStatus.PO_EXCE_STATUS_UN_EXCE.val);
                        BigDecimal wkQty = toBigDecimal(delivery.getWorkQty()).subtract(toBigDecimal(delivery.getAnfme())).setScale(QTY_SCALE, RoundingMode.HALF_UP);
                        delivery.setWorkQty(wkQty.compareTo(BigDecimal.ZERO) >= 0 ? wkQty.doubleValue() : 0).setExceStatus(POExceStatus.PO_EXCE_STATUS_UN_EXCE.val);
                        if (!deliveryService.updateById(delivery)) {
                            throw new CoolException("DO单据修改失败！！");
                        }
@@ -702,20 +957,53 @@
                if (issued.compareTo(ISSUED_TOLERANCE) <= 0) {
                    break;
                }
                // 该库位可分配数量：取本行待分配与库位库存的较小值
                double allocatable = Math.min(issued.doubleValue(), locItem.getAnfme() != null ? locItem.getAnfme() : 0);
                // 预约出库中且未生成拣料入库单的库位：扣减「拣料中占用」得到剩余可用，并标记「正在拣料中，剩余 X 可用」
                BigDecimal pickingAllocated = getPickingAllocatedOnLoc(loc.getCode(), locItem.getMatnrId(), locItem.getBatch(), locItem.getFieldsIndex());
                BigDecimal rawAnfme = toBigDecimal(locItem.getAnfme());
                BigDecimal available = rawAnfme.subtract(pickingAllocated).setScale(QTY_SCALE, RoundingMode.HALF_UP);
                if (available.compareTo(BigDecimal.ZERO) < 0) available = BigDecimal.ZERO;
                locItem.setAnfme(available.doubleValue());
                String pickingStatus = null;
                if (pickingAllocated.compareTo(ISSUED_TOLERANCE) > 0) {
                    pickingStatus = "正在拣料中，剩余 " + available.setScale(2, RoundingMode.HALF_UP).stripTrailingZeros().toPlainString() + " 可用";
                }
                // 该库位可分配数量：取本行待分配与库位剩余可用的较小值
                BigDecimal allocatable = issued.min(available);
                // 当分配量等于库位库存时，使用库位库存精度作为出库数量，避免截断导致界面显示/库存校验不一致（如库存15.123457被截成15.123）
                BigDecimal outQtyToSet = (allocatable.subtract(available).abs().compareTo(ISSUED_TOLERANCE) <= 0) ? available : allocatable;
                ExistDto existDto = new ExistDto().setBatch(locItem.getBatch()).setMatnr(locItem.getMatnrCode()).setLocNo(locItem.getLocCode());
                if (existDtos.add(existDto)) {
                    // 首次使用该库位：加入列表并扣减 issued
                    locItem.setOutQty(allocatable);
                    locItem.setBarcode(loc.getBarcode());
                    locItem.setOutQty(outQtyToSet.doubleValue());
                    String barcode = StringUtils.isNotBlank(loc.getBarcode()) ? loc.getBarcode() : null;
                    if (barcode == null && LocStsType.LOC_STS_TYPE_R.type.equals(loc.getUseStatus())) {
                        List<Task> tasksOnLoc = taskService.list(new LambdaQueryWrapper<Task>()
                                .eq(Task::getOrgLoc, loc.getCode())
                                .in(Task::getTaskStatus, Arrays.asList(TaskStsType.GENERATE_OUT.id, TaskStsType.WAVE_SEED.id))
                                .last("LIMIT 1"));
                        if (!tasksOnLoc.isEmpty() && StringUtils.isNotBlank(tasksOnLoc.get(0).getBarcode())) {
                            barcode = tasksOnLoc.get(0).getBarcode();
                        }
                    }
                    locItem.setBarcode(barcode != null ? barcode : loc.getBarcode());
                    OrderOutItemDto orderOutItemDto = new OrderOutItemDto();
                    orderOutItemDto.setLocItem(locItem);
                    if (pickingStatus != null) {
                        orderOutItemDto.setPickingStatus(pickingStatus);
                    }

                    List<DeviceSite> deviceSites = deviceSiteService.list(new LambdaQueryWrapper<DeviceSite>()
                            .eq(DeviceSite::getChannel, loc.getChannel())
                            .eq(DeviceSite::getType, issued.doubleValue() >= locItem.getAnfme() && itemList.size() == 1 ? TaskType.TASK_TYPE_OUT.type : TaskType.TASK_TYPE_PICK_AGAIN_OUT.type)
                            .eq(DeviceSite::getType, issued.compareTo(toBigDecimal(locItem.getAnfme())) >= 0 && itemList.size() == 1 ? TaskType.TASK_TYPE_OUT.type : TaskType.TASK_TYPE_PICK_AGAIN_OUT.type)
                    );
                    // 出库口列表排序：1001 排第一，作为默认
                    deviceSites.sort((a, b) -> {
                        boolean a1001 = "1001".equals(a.getSite());
                        boolean b1001 = "1001".equals(b.getSite());
                        if (a1001 && !b1001) return -1;
                        if (!a1001 && b1001) return 1;
                        return 0;
                    });

                    if (!deviceSites.isEmpty()) {
                        List<OrderOutItemDto.staListDto> maps = new ArrayList<>();
@@ -728,25 +1016,25 @@
                        orderOutItemDto.setStaNos(maps);
                        //默认获取第一站点
                        DeviceSite deviceSite = deviceSites.stream().findFirst().get();
                        orderOutItemDto.setSiteNo(deviceSite.getSite());
                        orderOutItemDto.setSitesNo(deviceSite.getSite());
                    }

                    list.add(orderOutItemDto);
                    issued = issued.subtract(new BigDecimal(locItem.getAnfme().toString()));
                    issued = issued.subtract(outQtyToSet);
                } else {
                    // 该库位已被前序订单行占用：只扣减 issued，不重复加入列表，避免产生“库存不足”脏数据
                    issued = issued.subtract(new BigDecimal(String.valueOf(allocatable)));
                    issued = issued.subtract(allocatable);
                }
            }
            if (issued.compareTo(ISSUED_TOLERANCE) > 0) {
                double remaining = issued.setScale(6, RoundingMode.HALF_UP).doubleValue();
                BigDecimal remaining = issued.setScale(QTY_SCALE, RoundingMode.HALF_UP);
                LocItem locItem = new LocItem()
                        .setId(new Random().nextLong())
                        .setMatnrCode(wkOrderItem.getMatnrCode())
                        .setMaktx(wkOrderItem.getMaktx())
                        .setAnfme(0.00)
                        .setWorkQty(remaining)
                        .setOutQty(remaining)
                        .setWorkQty(remaining.doubleValue())
                        .setOutQty(remaining.doubleValue())
                        .setUnit(wkOrderItem.getStockUnit())
                        .setBatch(wkOrderItem.getSplrBatch());
                OrderOutItemDto orderOutItemDto = new OrderOutItemDto();
@@ -760,6 +1048,25 @@
    }

    /**
     * 该库位下「拣料出库」且未生成拣料入库单的任务占用的数量（同一物料+批次+票号）
     */
    private BigDecimal getPickingAllocatedOnLoc(String locCode, Long matnrId, String batch, String fieldsIndex) {
        List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>()
                .eq(Task::getOrgLoc, locCode)
                .eq(Task::getTaskType, TaskType.TASK_TYPE_PICK_AGAIN_OUT.type)
                .in(Task::getTaskStatus, Arrays.asList(TaskStsType.GENERATE_OUT.id, TaskStsType.WAVE_SEED.id)));
        if (tasks.isEmpty()) return BigDecimal.ZERO;
        Set<Long> taskIds = tasks.stream().map(Task::getId).collect(Collectors.toSet());
        LambdaQueryWrapper<TaskItem> q = new LambdaQueryWrapper<TaskItem>()
                .in(TaskItem::getTaskId, taskIds)
                .eq(TaskItem::getMatnrId, matnrId);
        if (StringUtils.isNotBlank(batch)) q.eq(TaskItem::getBatch, batch);
        if (StringUtils.isNotBlank(fieldsIndex)) q.eq(TaskItem::getFieldsIndex, fieldsIndex);
        List<TaskItem> items = taskItemService.list(q);
        return items.stream().map(ti -> toBigDecimal(ti.getAnfme())).reduce(BigDecimal.ZERO, BigDecimal::add);
    }

    /**
     * @param
     * @param wave
     * @return
@@ -770,11 +1077,11 @@
    private List<WaveItem> mergeWave(List<WkOrderItem> orderItems, Wave wave) {
        List<WaveItem> items = new ArrayList<>();
        orderItems.forEach(order -> {
            Double anfme = Math.round((order.getAnfme() - order.getWorkQty()) * 1000000) / 1000000.0;
            BigDecimal anfme = toBigDecimal(order.getAnfme()).subtract(toBigDecimal(order.getWorkQty())).setScale(QTY_SCALE, RoundingMode.HALF_UP);
            WaveItem item = new WaveItem();
            BeanUtils.copyProperties(order, item);
                item.setId(null)
                    .setAnfme(anfme)
                    .setAnfme(anfme.doubleValue())
                    .setMatnrId(order.getMatnrId())
                    .setMaktx(order.getMaktx())
                    .setWaveId(wave.getId())
@@ -796,7 +1103,7 @@
                        p1.getUnit(),
                        p1.getTrackCode(),
                        p1.getFieldsIndex(),
                        Math.round((p1.getAnfme() + p2.getAnfme())* 1000000) / 1000000.0,
                        toBigDecimal(p1.getAnfme()).add(toBigDecimal(p2.getAnfme())).setScale(QTY_SCALE, RoundingMode.HALF_UP).doubleValue(),
                        p1.getWorkQty(),
                        p1.getTenantId(),
                        p1.getStatus(),
@@ -828,6 +1135,9 @@
            return R.error("出库单不存在！！");
        }
        order.setExceStatus(AsnExceStatus.OUT_STOCK_STATUS_TASK_DONE.val);
        if (order.getQty() == null || order.getQty().compareTo(0.0) == 0) {
            order.setQty(order.getWorkQty() != null ? order.getWorkQty() : 0.0);
        }
        if (!this.updateById(order)) {
            throw new CoolException("完成出库单失败！！");
        }