fix: 领料功能修改，移除订单领料，添加工序领料功能，支持按工序查询物料与已领料记录

yuan

2026-08-13 3066a8f5c1f475997bfe23857ba4bae9395900c4

 src/main/java/com/ruoyi/production/service/impl/ProductionOrderPickServiceImpl.java

@@ -3,23 +3,37 @@
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.enums.ReviewStatusEnum;
import com.ruoyi.common.enums.StockInQualifiedRecordTypeEnum;
import com.ruoyi.common.enums.StockOutQualifiedRecordTypeEnum;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.production.bean.dto.ProductionOrderPickDto;
import com.ruoyi.production.bean.vo.ProductionOrderPickVo;
import com.ruoyi.production.mapper.ProductionBomStructureMapper;
import com.ruoyi.production.mapper.ProductionOperationTaskMapper;
import com.ruoyi.production.mapper.ProductionOrderMapper;
import com.ruoyi.production.mapper.ProductionOrderPickMapper;
import com.ruoyi.production.mapper.ProductionOrderPickRecordMapper;
import com.ruoyi.production.mapper.ProductionOrderRoutingOperationMapper;
import com.ruoyi.production.pojo.ProductionBomStructure;
import com.ruoyi.production.pojo.ProductionOperationTask;
import com.ruoyi.production.pojo.ProductionOrder;
import com.ruoyi.production.pojo.ProductionOrderPick;
import com.ruoyi.production.pojo.ProductionOrderPickRecord;
import com.ruoyi.production.pojo.ProductionOrderRoutingOperation;
import com.ruoyi.production.service.ProductionOrderPickService;
import com.ruoyi.production.service.ProductionOrderService;
import com.ruoyi.stock.dto.StockInventoryDto;
import com.ruoyi.stock.mapper.StockInventoryMapper;
import com.ruoyi.stock.pojo.StockInRecord;
import com.ruoyi.stock.pojo.StockInventory;
import com.ruoyi.stock.pojo.StockOutRecord;
import com.ruoyi.stock.service.StockInventoryService;
import com.ruoyi.stock.service.StockInRecordService;
import com.ruoyi.stock.service.StockOutRecordService;
import com.ruoyi.technology.mapper.TechnologyOperationMapper;
import com.ruoyi.technology.pojo.TechnologyOperation;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@@ -39,12 +53,22 @@

    private static final byte PICK_TYPE_NORMAL = 1;
    private static final byte PICK_TYPE_FEEDING = 2;
    private static final String PICK_STOCK_OUT_RECORD_TYPE = StockOutQualifiedRecordTypeEnum.PICK_STOCK_OUT.getCode();
    private static final String FEED_STOCK_OUT_RECORD_TYPE = StockOutQualifiedRecordTypeEnum.FEED_STOCK_OUT.getCode();
    private static final String PICK_RETURN_IN_RECORD_TYPE = StockInQualifiedRecordTypeEnum.PICK_RETURN_IN.getCode();
    private static final String FEED_RETURN_IN_RECORD_TYPE = StockInQualifiedRecordTypeEnum.FEED_RETURN_IN.getCode();

    private final ProductionOrderMapper productionOrderMapper;
    private final ProductionOperationTaskMapper productionOperationTaskMapper;
    private final ProductionOrderPickRecordMapper productionOrderPickRecordMapper;
    private final ProductionOrderRoutingOperationMapper productionOrderRoutingOperationMapper;
    private final ProductionBomStructureMapper productionBomStructureMapper;
    private final ProductionOrderService productionOrderService;
    private final TechnologyOperationMapper technologyOperationMapper;
    private final StockInventoryMapper stockInventoryMapper;
    private final StockInventoryService stockInventoryService;
    private final StockInRecordService stockInRecordService;
    private final StockOutRecordService stockOutRecordService;

    @Override
    @Transactional(rollbackFor = Exception.class)
@@ -52,8 +76,9 @@
        // 领料新增总流程：
        // 1) 解析前端行数据并逐行合并参数；
        // 2) 校验参数与批次；
        // 3) 先扣减库存，再落库领料主记录；
        // 4) 写入领料流水，记录数量变化轨迹。
        // 3) 先保存领料主记录；
        // 4) 再走“出库申请 + 审批通过”完成库存扣减；
        // 5) 写入领料流水，记录数量变化轨迹。
        List<ProductionOrderPickDto> pickItems = resolvePickItems(dto);
        // 逐行处理领料数据，行号用于拼装精确的报错信息。
        for (int i = 0; i < pickItems.size(); i++) {
@@ -66,11 +91,11 @@
            List<String> batchNoList = resolveBatchNoList(resolvedDto);
            String inventoryBatchNo = pickInventoryBatchNo(batchNoList);
            String storedBatchNo = formatBatchNoStorage(batchNoList);
            subtractInventory(resolvedDto.getProductModelId(), storedBatchNo, resolvedDto.getPickQuantity(), rowNo);

            // 保存领料主记录快照。
            ProductionOrderPick orderPick = new ProductionOrderPick();
            orderPick.setProductionOrderId(resolvedDto.getProductionOrderId());
            orderPick.setProductionOperationTaskId(resolvedDto.getProductionOperationTaskId());
            orderPick.setProductModelId(resolvedDto.getProductModelId());
            orderPick.setBatchNo(storedBatchNo);
            orderPick.setQuantity(resolvedDto.getPickQuantity());
@@ -82,6 +107,9 @@
            orderPick.setReturned(false);
            // 新增主记录。
            baseMapper.insert(orderPick);

            // 先新增出库申请，再审批通过，完成库存扣减。
            subtractInventory(orderPick.getId(), resolvedDto.getProductModelId(), storedBatchNo, resolvedDto.getPickQuantity(), rowNo, PICK_STOCK_OUT_RECORD_TYPE);

            // 记录本次领料流水（before=0，after=本次领料量）。
            insertPickRecord(orderPick.getId(),
@@ -176,7 +204,237 @@
        List<ProductionOrderPickVo> detailList = baseMapper.listPickedDetailByOrderId(productionOrderId);
        fillBatchNoList(detailList);
        fillSelectableBatchNoList(detailList);
        fillPickedFlagAndEffectiveQuantity(detailList);
        return detailList;
    }

    /**
     * 工序物料清单 = 订单BOM快照中属于该工序的可领用物料建议 + 该工单已领料记录。
     * 建议行 picked=false（id 为空），历史领料行 picked=true。
     */
    @Override
    public List<ProductionOrderPickVo> listTaskMaterials(Long productionOperationTaskId) {
        if (productionOperationTaskId == null) {
            return Collections.emptyList();
        }
        TaskOperationContext context = resolveTaskOperationContext(productionOperationTaskId);

        List<ProductionOrderPickVo> result = new ArrayList<>();
        // BOM 建议物料：按当前工序过滤，不带任何需求数量
        List<ProductionOrderPickVo> suggestionList =
                productionOrderService.pick(context.productionOrderId(), context.technologyOperationId());
        for (ProductionOrderPickVo suggestion : suggestionList) {
            suggestion.setId(null);
            suggestion.setPicked(false);
            suggestion.setProductionOrderId(context.productionOrderId());
            suggestion.setProductionOperationTaskId(productionOperationTaskId);
            suggestion.setTechnologyOperationId(context.technologyOperationId());
            if (StringUtils.isEmpty(suggestion.getOperationName())) {
                suggestion.setOperationName(context.operationName());
            }
            suggestion.setWorkOrderNo(context.workOrderNo());
            result.add(suggestion);
        }

        // 该工单已产生的领料记录
        List<ProductionOrderPickVo> pickedList = baseMapper.listPickedDetailByTaskId(productionOperationTaskId);
        fillBatchNoList(pickedList);
        fillSelectableBatchNoList(pickedList);
        fillPickedFlagAndEffectiveQuantity(pickedList);
        result.addAll(pickedList);
        return result;
    }

    /**
     * 工序统一领料：
     * 1) 由工单反查订单与工序，不信任前端传入的归属字段；
     * 2) 逐行校验物料、数量与批次；
     * 3) 复用出库申请 + 立即审批的库存扣减流程；
     * 4) 写入领料主记录与流水，重复领料即新增记录，不区分初领与补料。
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean savePickByTask(ProductionOrderPickDto dto) {
        if (dto == null) {
            throw new ServiceException("参数不能为空");
        }
        Long productionOperationTaskId = dto.getProductionOperationTaskId();
        if (productionOperationTaskId == null) {
            throw new ServiceException("工单ID不能为空");
        }
        TaskOperationContext context = resolveTaskOperationContext(productionOperationTaskId);

        List<ProductionOrderPickDto> pickItems = resolvePickItems(dto).stream()
                .filter(Objects::nonNull)
                .filter(item -> item.getProductModelId() != null || item.getPickQuantity() != null)
                .collect(Collectors.toList());
        if (pickItems.isEmpty()) {
            throw new ServiceException("请至少填写一条领料物料");
        }

        for (int i = 0; i < pickItems.size(); i++) {
            int rowNo = i + 1;
            ProductionOrderPickDto resolvedDto = mergeDto(dto, pickItems.get(i));
            if (resolvedDto.getProductModelId() == null) {
                throw new ServiceException("第" + rowNo + "行参数错误：产品规格不能为空");
            }
            if (resolvedDto.getPickQuantity() == null
                    || resolvedDto.getPickQuantity().compareTo(BigDecimal.ZERO) <= 0) {
                throw new ServiceException("第" + rowNo + "行参数错误：领料数量必须大于0");
            }

            List<String> batchNoList = resolveBatchNoList(resolvedDto);
            String inventoryBatchNo = pickInventoryBatchNo(batchNoList);
            String storedBatchNo = formatBatchNoStorage(batchNoList);

            ProductionOrderPick orderPick = new ProductionOrderPick();
            orderPick.setProductionOrderId(context.productionOrderId());
            orderPick.setProductionOperationTaskId(productionOperationTaskId);
            orderPick.setProductModelId(resolvedDto.getProductModelId());
            orderPick.setBatchNo(storedBatchNo);
            orderPick.setQuantity(resolvedDto.getPickQuantity());
            orderPick.setRemark(resolvedDto.getRemark());
            orderPick.setOperationName(context.operationName());
            orderPick.setTechnologyOperationId(context.technologyOperationId());
            // 扁平BOM不配置数量，领料不再有需求数量约束
            orderPick.setDemandedQuantity(null);
            orderPick.setBom(isBomMaterial(context, resolvedDto.getProductModelId()));
            orderPick.setReturned(false);
            baseMapper.insert(orderPick);

            // 立即扣减库存，失败则整个事务回滚
            subtractInventory(orderPick.getId(),
                    resolvedDto.getProductModelId(),
                    storedBatchNo,
                    resolvedDto.getPickQuantity(),
                    rowNo,
                    PICK_STOCK_OUT_RECORD_TYPE);

            insertPickRecord(orderPick.getId(),
                    context.productionOrderId(),
                    productionOperationTaskId,
                    resolvedDto.getProductModelId(),
                    inventoryBatchNo,
                    resolvedDto.getPickQuantity(),
                    BigDecimal.ZERO,
                    resolvedDto.getPickQuantity(),
                    PICK_TYPE_NORMAL,
                    resolvedDto.getRemark(),
                    null);
        }
        return true;
    }

    /**
     * 当前工序是否已有有效领料：任一物料的净领料数量（领料+补料-退料）大于0。
     */
    @Override
    public boolean hasEffectivePick(Long productionOperationTaskId) {
        if (productionOperationTaskId == null) {
            return false;
        }
        List<ProductionOrderPick> pickList = baseMapper.selectList(
                Wrappers.<ProductionOrderPick>lambdaQuery()
                        .eq(ProductionOrderPick::getProductionOperationTaskId, productionOperationTaskId));
        for (ProductionOrderPick pick : pickList) {
            if (pick == null) {
                continue;
            }
            if (resolveEffectiveQuantity(pick).compareTo(BigDecimal.ZERO) > 0) {
                return true;
            }
        }
        return false;
    }

    /**
     * 由工单解析出订单、工序快照与工序名称，并校验归属关系。
     */
    private TaskOperationContext resolveTaskOperationContext(Long productionOperationTaskId) {
        ProductionOperationTask task = productionOperationTaskMapper.selectById(productionOperationTaskId);
        if (task == null) {
            throw new ServiceException("工单不存在");
        }
        if (task.getProductionOrderId() == null) {
            throw new ServiceException("工单未关联生产订单");
        }
        ProductionOrder productionOrder = productionOrderMapper.selectById(task.getProductionOrderId());
        if (productionOrder == null) {
            throw new ServiceException("生产订单不存在");
        }
        ProductionOrderRoutingOperation routingOperation =
                productionOrderRoutingOperationMapper.selectById(task.getProductionOrderRoutingOperationId());
        if (routingOperation == null) {
            throw new ServiceException("工单对应的订单工序不存在");
        }
        if (routingOperation.getProductionOrderId() != null
                && !Objects.equals(routingOperation.getProductionOrderId(), task.getProductionOrderId())) {
            throw new ServiceException("工单与订单工序归属不一致");
        }
        if (routingOperation.getTechnologyOperationId() == null) {
            throw new ServiceException("订单工序未关联工艺工序");
        }
        String operationName = routingOperation.getOperationName();
        if (StringUtils.isEmpty(operationName)) {
            TechnologyOperation technologyOperation =
                    technologyOperationMapper.selectById(routingOperation.getTechnologyOperationId());
            operationName = technologyOperation == null ? null : technologyOperation.getName();
        }
        return new TaskOperationContext(
                task.getId(),
                task.getProductionOrderId(),
                routingOperation.getTechnologyOperationId(),
                operationName,
                task.getWorkOrderNo());
    }

    /**
     * 判断物料是否来自订单BOM快照中的当前工序。
     */
    private boolean isBomMaterial(TaskOperationContext context, Long productModelId) {
        if (productModelId == null) {
            return false;
        }
        return productionBomStructureMapper.selectCount(
                Wrappers.<ProductionBomStructure>lambdaQuery()
                        .eq(ProductionBomStructure::getProductionOrderId, context.productionOrderId())
                        .eq(ProductionBomStructure::getTechnologyOperationId, context.technologyOperationId())
                        .eq(ProductionBomStructure::getProductModelId, productModelId)) > 0;
    }

    private void fillPickedFlagAndEffectiveQuantity(List<ProductionOrderPickVo> detailList) {
        if (detailList == null || detailList.isEmpty()) {
            return;
        }
        for (ProductionOrderPickVo detail : detailList) {
            if (detail == null) {
                continue;
            }
            detail.setPicked(detail.getId() != null);
            detail.setEffectiveQuantity(resolveEffectiveQuantity(detail));
        }
    }

    /**
     * 净领料数量 = 领料数量 + 补料数量 - 退料数量。
     */
    private BigDecimal resolveEffectiveQuantity(ProductionOrderPick pick) {
        if (pick == null) {
            return BigDecimal.ZERO;
        }
        return defaultDecimal(pick.getQuantity())
                .add(defaultDecimal(pick.getFeedingQty()))
                .subtract(defaultDecimal(pick.getReturnQty()));
    }

    /**
     * 工单对应的领料上下文，避免依赖前端传入的订单/工序字段。
     */
    private record TaskOperationContext(Long productionOperationTaskId,
                                        Long productionOrderId,
                                        Long technologyOperationId,
                                        String operationName,
                                        String workOrderNo) {
    }

    private void processDeletePickIds(ProductionOrderPickDto rootDto,
@@ -201,7 +459,12 @@
            }
            String oldBatchNo = resolveInventoryBatchNoFromStored(existingPick.getBatchNo());
            BigDecimal oldQuantity = defaultDecimal(existingPick.getQuantity());
            addInventory(existingPick.getProductModelId(), oldBatchNo, oldQuantity);
            addInventory(existingPick.getId(), existingPick.getProductModelId(), oldBatchNo, oldQuantity, PICK_RETURN_IN_RECORD_TYPE);
            // 删除关联领料流水，避免遗留无主记录。
            productionOrderPickRecordMapper.delete(
                    Wrappers.<ProductionOrderPickRecord>lambdaQuery()
                            .eq(ProductionOrderPickRecord::getPickId, existingPick.getId())
            );
            int affected = baseMapper.deleteById(deleteId);
            if (affected <= 0) {
                throw new ServiceException("删除领料记录失败，ID=" + deleteId);
@@ -240,7 +503,12 @@
        for (ProductionOrderPick missingPick : missingPickList) {
            String oldBatchNo = resolveInventoryBatchNoFromStored(missingPick.getBatchNo());
            BigDecimal oldQuantity = defaultDecimal(missingPick.getQuantity());
            addInventory(missingPick.getProductModelId(), oldBatchNo, oldQuantity);
            addInventory(missingPick.getId(), missingPick.getProductModelId(), oldBatchNo, oldQuantity, PICK_RETURN_IN_RECORD_TYPE);
            // 删除关联领料流水，避免遗留无主记录。
            productionOrderPickRecordMapper.delete(
                    Wrappers.<ProductionOrderPickRecord>lambdaQuery()
                            .eq(ProductionOrderPickRecord::getPickId, missingPick.getId())
            );
            int affected = baseMapper.deleteById(missingPick.getId());
            if (affected <= 0) {
                throw new ServiceException("删除未回传领料记录失败，ID=" + missingPick.getId());
@@ -261,14 +529,15 @@
    }

    private void addNewPickInUpdate(ProductionOrderPickDto dto, int rowNo) {
        // 更新场景下新增一条领料：扣库存 -> 新增主记录 -> 写流水。
        // 更新场景下新增一条领料：
        // 新增主记录 -> 出库申请并审批 -> 写流水。
        List<String> batchNoList = resolveBatchNoList(dto);
        String inventoryBatchNo = pickInventoryBatchNo(batchNoList);
        String storedBatchNo = formatBatchNoStorage(batchNoList);
        subtractInventory(dto.getProductModelId(), storedBatchNo, dto.getPickQuantity(), rowNo);

        ProductionOrderPick orderPick = new ProductionOrderPick();
        orderPick.setProductionOrderId(dto.getProductionOrderId());
        orderPick.setProductionOperationTaskId(dto.getProductionOperationTaskId());
        orderPick.setProductModelId(dto.getProductModelId());
        orderPick.setBatchNo(storedBatchNo);
        orderPick.setQuantity(dto.getPickQuantity());
@@ -279,6 +548,9 @@
        orderPick.setBom(dto.getBom());
        orderPick.setReturned(false);
        baseMapper.insert(orderPick);

        // 先新增出库申请，再审批通过，完成库存扣减。
        subtractInventory(orderPick.getId(), dto.getProductModelId(), storedBatchNo, dto.getPickQuantity(), rowNo, PICK_STOCK_OUT_RECORD_TYPE);

        insertPickRecord(orderPick.getId(),
                dto.getProductionOrderId(),
@@ -337,7 +609,7 @@
                : formatBatchNoStorage(batchNoList);
        BigDecimal feedingQuantity = dto.getFeedingQuantity();

        subtractInventory(productModelId, inventoryBatchNo, feedingQuantity, rowNo);
        subtractInventory(oldPick.getId(), productModelId, inventoryBatchNo, feedingQuantity, rowNo, FEED_STOCK_OUT_RECORD_TYPE);

        // 计算补料前后数量并写补料流水。
        BigDecimal beforeFeedingQty = sumFeedingQuantity(dto.getProductionOrderId(), oldPick.getId());
@@ -393,19 +665,36 @@
    }

    private void updateReturnPick(ProductionOrderPickDto dto, ProductionOrderPick oldPick, int rowNo) {
        // 退料更新只改主领料记录中的退料字段与实际量。
        // 退料更新：
        // 1) returnQty 按“本次退料量”处理；
        // 2) 本次退料量回补到“生产退料入库”；
        // 3) 累加主记录退料总量并重算实际量。
        BigDecimal oldReturnQty = defaultDecimal(oldPick.getReturnQty());
        BigDecimal currentReturnQty = defaultDecimal(dto.getReturnQty());
        BigDecimal totalReturnQty = oldReturnQty.add(currentReturnQty);
        if (currentReturnQty.compareTo(BigDecimal.ZERO) > 0) {
            String returnBatchNo = resolveInventoryBatchNoFromStored(oldPick.getBatchNo());
            addInventoryRecordOnly(oldPick.getId(), oldPick.getProductModelId(), returnBatchNo, currentReturnQty, FEED_RETURN_IN_RECORD_TYPE);
        }

        BigDecimal actualQty = defaultDecimal(oldPick.getQuantity())
                .add(defaultDecimal(oldPick.getFeedingQty()))
                .subtract(totalReturnQty);
        if (actualQty.compareTo(BigDecimal.ZERO) < 0) {
            throw new ServiceException("第" + rowNo + "行退料失败：累计退料数量不能大于可用数量");
        }
        ProductionOrderPick updatePick = new ProductionOrderPick();
        updatePick.setId(oldPick.getId());
        updatePick.setReturnQty(dto.getReturnQty());
        updatePick.setActualQty(dto.getActualQty());
        updatePick.setReturned(true);
        updatePick.setReturnQty(totalReturnQty);
        updatePick.setActualQty(actualQty);
        updatePick.setReturned(totalReturnQty.compareTo(BigDecimal.ZERO) > 0);
        int affected = baseMapper.updateById(updatePick);
        if (affected <= 0) {
            throw new ServiceException("第" + rowNo + "行退料失败：更新领料主记录失败");
        }
        oldPick.setReturnQty(updatePick.getReturnQty());
        oldPick.setActualQty(updatePick.getActualQty());
        oldPick.setReturned(true);
        oldPick.setReturned(updatePick.getReturned());
    }

    private void updateExistingPick(ProductionOrderPickDto dto,
@@ -431,21 +720,30 @@
        String newStoredBatchNo = formatBatchNoStorage(newBatchNoList);
        BigDecimal newQuantity = dto.getPickQuantity();

        // 判断规格+批次是否变化，决定库存处理策略。
        // 判断规格+批次或数量是否变化，并按场景处理库存：
        // 1) 同规格同批次：按差值处理（增量扣减 / 减量回退）；
        // 2) 规格或批次变化：回退旧领料后再重提新领料。
        boolean sameStockKey = Objects.equals(oldProductModelId, newProductModelId)
                && Objects.equals(oldBatchNo, newBatchNo);
        boolean quantityChanged = oldQuantity.compareTo(newQuantity) != 0;
        boolean needReissuePickRecord = !sameStockKey || quantityChanged;
        if (sameStockKey) {
            // 规格与批次不变：只按差值增减库存。
            BigDecimal delta = newQuantity.subtract(oldQuantity);
            if (delta.compareTo(BigDecimal.ZERO) > 0) {
                subtractInventory(newProductModelId, newStoredBatchNo, delta, rowNo);
            } else if (delta.compareTo(BigDecimal.ZERO) < 0) {
                addInventory(oldProductModelId, oldBatchNo, delta.abs());
            BigDecimal deltaQuantity = newQuantity.subtract(oldQuantity);
            if (deltaQuantity.compareTo(BigDecimal.ZERO) > 0) {
                // 数量增加，只扣减新增部分。
                subtractInventory(oldPick.getId(), newProductModelId, newStoredBatchNo, deltaQuantity, rowNo, PICK_STOCK_OUT_RECORD_TYPE);
            } else if (deltaQuantity.compareTo(BigDecimal.ZERO) < 0) {
                // 数量减少，只回退差值部分。
                addInventory(oldPick.getId(), oldProductModelId, oldBatchNo, deltaQuantity.abs(), PICK_RETURN_IN_RECORD_TYPE);
            }
        } else {
            // 规格或批次变化：先回补旧库存，再扣减新库存。
            addInventory(oldProductModelId, oldBatchNo, oldQuantity);
            subtractInventory(newProductModelId, newStoredBatchNo, newQuantity, rowNo);
            // 规格或批次变化：先全量回退旧领料，再全量扣减新领料。
            addInventory(oldPick.getId(), oldProductModelId, oldBatchNo, oldQuantity, PICK_RETURN_IN_RECORD_TYPE);
            subtractInventory(oldPick.getId(), newProductModelId, newStoredBatchNo, newQuantity, rowNo, PICK_STOCK_OUT_RECORD_TYPE);
        }
        if (needReissuePickRecord) {
            // 正常领料流水按“最新领料量”重建，避免保留历史旧值。
            deleteNormalPickRecord(oldPick.getId());
        }

        oldPick.setProductModelId(newProductModelId);
@@ -454,6 +752,9 @@
        oldPick.setRemark(dto.getRemark());
        oldPick.setOperationName(dto.getOperationName());
        oldPick.setTechnologyOperationId(dto.getTechnologyOperationId());
        // 普通更新也要同步重算实际用量，避免沿用旧值。
        // 规则：实际用量 = 领料数量 + 补料数量 - 退料数量。
        oldPick.setActualQty(calculateActualQty(oldPick, oldPick.getFeedingQty()));
        if (dto.getDemandedQuantity() != null) {
            oldPick.setDemandedQuantity(dto.getDemandedQuantity());
        }
@@ -465,16 +766,15 @@
            throw new ServiceException("第" + rowNo + "行更新失败：更新领料记录失败");
        }

        // 写入更新流水，保留本次数量变化轨迹。
        BigDecimal recordQuantity = sameStockKey ? oldQuantity.subtract(newQuantity).abs() : newQuantity;
        if (recordQuantity.compareTo(BigDecimal.ZERO) > 0 || oldQuantity.compareTo(newQuantity) != 0 || !sameStockKey) {
        // 如果发生领料重提，补写一条新的正常领料流水。
        if (needReissuePickRecord) {
            insertPickRecord(oldPick.getId(),
                    dto.getProductionOrderId(),
                    dto.getProductionOperationTaskId(),
                    newProductModelId,
                    newBatchNo,
                    recordQuantity,
                    oldQuantity,
                    newQuantity,
                    BigDecimal.ZERO,
                    newQuantity,
                    dto.getPickType(),
                    dto.getRemark(),
@@ -509,11 +809,28 @@
        productionOrderPickRecordMapper.insert(pickRecord);
    }

    private void subtractInventory(Long productModelId, String batchNo, BigDecimal quantity, int rowNo) {
    private void deleteNormalPickRecord(Long pickId) {
        // 删除该领料单历史上的“正常领料”流水，保留补料/退料流水。
        if (pickId == null) {
            return;
        }
        productionOrderPickRecordMapper.delete(
                Wrappers.<ProductionOrderPickRecord>lambdaQuery()
                        .eq(ProductionOrderPickRecord::getPickId, pickId)
                        .eq(ProductionOrderPickRecord::getPickType, PICK_TYPE_NORMAL)
        );
    }

    private void subtractInventory(Long recordId,
                                   Long productModelId,
                                   String batchNo,
                                   BigDecimal quantity,
                                   int rowNo,
                                   String stockOutRecordType) {
        // 扣减库存总流程：
        // 1) 解析批次列表；
        // 2) 计算每个批次可用量与总可用量；
        // 3) 按批次顺序逐笔扣减，直到扣完目标数量；
        // 3) 按批次顺序逐笔“新增出库记录并审批通过”，直到扣完目标数量；
        // 4) 任一步失败即抛错并回滚事务。
        BigDecimal deductQuantity = defaultDecimal(quantity);
        // 领料数量小于等于0时，不需要执行库存扣减。
@@ -562,14 +879,7 @@
                continue;
            }
            BigDecimal currentDeductQuantity = remainingQuantity.min(availableQuantity);
            StockInventoryDto stockInventoryDto = new StockInventoryDto();
            stockInventoryDto.setProductModelId(productModelId);
            stockInventoryDto.setBatchNo(entry.getKey());
            stockInventoryDto.setQualitity(currentDeductQuantity);
            int affected = stockInventoryMapper.updateSubtractStockInventory(stockInventoryDto);
            if (affected <= 0) {
                throw new ServiceException("第" + rowNo + "行扣减库存失败：库存更新失败");
            }
            createAndApproveStockOutRecord(recordId, productModelId, entry.getKey(), currentDeductQuantity, rowNo, stockOutRecordType);
            remainingQuantity = remainingQuantity.subtract(currentDeductQuantity);
        }

@@ -578,19 +888,122 @@
        }
    }

    private void addInventory(Long productModelId, String batchNo, BigDecimal quantity) {
        // 回补库存（用于删除领料、改小领料、切换批次等场景）。
    private void createAndApproveStockOutRecord(Long recordId,
                                                Long productModelId,
                                                String batchNo,
                                                BigDecimal quantity,
                                                int rowNo,
                                                String stockOutRecordType) {
        // 库存扣减改为两步：
        // 1) 先调用 addStockOutRecordOnly 新增待审批出库记录；
        // 2) 再调用出库审批，审批状态固定传 1（通过）。
        try {
            StockInventoryDto stockInventoryDto = new StockInventoryDto();
            stockInventoryDto.setRecordId(recordId == null ? 0L : recordId);
            stockInventoryDto.setRecordType(stockOutRecordType);
            stockInventoryDto.setProductModelId(productModelId);
            stockInventoryDto.setBatchNo(batchNo);
            stockInventoryDto.setQualitity(quantity);
            stockInventoryService.addStockOutRecordOnly(stockInventoryDto);

            LambdaQueryWrapper<StockOutRecord> recordWrapper = Wrappers.<StockOutRecord>lambdaQuery()
                    .eq(StockOutRecord::getRecordId, stockInventoryDto.getRecordId())
                    .eq(StockOutRecord::getRecordType, stockOutRecordType)
                    .eq(StockOutRecord::getProductModelId, productModelId)
                    .eq(StockOutRecord::getType, "0")
                    .orderByDesc(StockOutRecord::getId)
                    .last("limit 1");
            if (StringUtils.isEmpty(batchNo)) {
                recordWrapper.isNull(StockOutRecord::getBatchNo);
            } else {
                recordWrapper.eq(StockOutRecord::getBatchNo, batchNo);
            }
            StockOutRecord stockOutRecord = stockOutRecordService.getOne(recordWrapper, false);
            if (stockOutRecord == null || stockOutRecord.getId() == null) {
                throw new ServiceException("第" + rowNo + "行扣减库存失败：未找到对应出库申请记录");
            }
            stockOutRecordService.batchApprove(
                    Collections.singletonList(stockOutRecord.getId()),
                    ReviewStatusEnum.APPROVED.getCode()
            );
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException("第" + rowNo + "行扣减库存失败：" + ex.getMessage());
        }
    }

    private void addInventory(Long recordId,
                              Long productModelId,
                              String batchNo,
                              BigDecimal quantity,
                              String stockInRecordType) {
        // 回补库存改为两步：
        // 1) 先新增入库申请；
        // 2) 再审批通过，确保库存立刻回补生效。
        BigDecimal addQuantity = defaultDecimal(quantity);
        if (addQuantity.compareTo(BigDecimal.ZERO) <= 0) {
            return;
        }
        StockInventoryDto stockInventoryDto = new StockInventoryDto();
        stockInventoryDto.setProductModelId(productModelId);
        stockInventoryDto.setBatchNo(batchNo);
        stockInventoryDto.setQualitity(addQuantity);
        stockInventoryDto.setRecordType(String.valueOf(StockInQualifiedRecordTypeEnum.PICK_RETURN_IN.getCode()));
        stockInventoryDto.setRecordId(0L);
        stockInventoryService.addStockInRecordOnly(stockInventoryDto);
        try {
            StockInventoryDto stockInventoryDto = new StockInventoryDto();
            stockInventoryDto.setProductModelId(productModelId);
            stockInventoryDto.setBatchNo(batchNo);
            stockInventoryDto.setQualitity(addQuantity);
            stockInventoryDto.setRecordType(stockInRecordType);
            stockInventoryDto.setRecordId(recordId == null ? 0L : recordId);
            stockInventoryService.addStockInRecordOnly(stockInventoryDto);

            LambdaQueryWrapper<StockInRecord> recordWrapper = Wrappers.<StockInRecord>lambdaQuery()
                    .eq(StockInRecord::getRecordId, stockInventoryDto.getRecordId())
                    .eq(StockInRecord::getRecordType, stockInventoryDto.getRecordType())
                    .eq(StockInRecord::getProductModelId, productModelId)
                    .eq(StockInRecord::getType, "0")
                    .orderByDesc(StockInRecord::getId)
                    .last("limit 1");
            if (StringUtils.isEmpty(batchNo)) {
                recordWrapper.isNull(StockInRecord::getBatchNo);
            } else {
                recordWrapper.eq(StockInRecord::getBatchNo, batchNo);
            }
            StockInRecord stockInRecord = stockInRecordService.getOne(recordWrapper, false);
            if (stockInRecord == null || stockInRecord.getId() == null) {
                throw new ServiceException("回补库存失败：未找到对应入库申请记录");
            }
            stockInRecordService.batchApprove(
                    Collections.singletonList(stockInRecord.getId()),
                    ReviewStatusEnum.APPROVED.getCode()
            );
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException("回补库存失败：" + ex.getMessage());
        }
    }

    private void addInventoryRecordOnly(Long recordId,
                                        Long productModelId,
                                        String batchNo,
                                        BigDecimal quantity,
                                        String stockInRecordType) {
        // 仅记录入库申请，不做审核通过。
        BigDecimal addQuantity = defaultDecimal(quantity);
        if (addQuantity.compareTo(BigDecimal.ZERO) <= 0) {
            return;
        }
        try {
            StockInventoryDto stockInventoryDto = new StockInventoryDto();
            stockInventoryDto.setProductModelId(productModelId);
            stockInventoryDto.setBatchNo(batchNo);
            stockInventoryDto.setQualitity(addQuantity);
            stockInventoryDto.setRecordType(stockInRecordType);
            stockInventoryDto.setRecordId(recordId == null ? 0L : recordId);
            stockInventoryService.addStockInRecordOnly(stockInventoryDto);
        } catch (ServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new ServiceException("退料入库记录保存失败：" + ex.getMessage());
        }
    }

    private List<ProductionOrderPickDto> resolvePickItems(ProductionOrderPickDto dto) {
@@ -769,7 +1182,7 @@
    }

    private void validateReturnParam(ProductionOrderPickDto dto, int rowNo) {
        // 校验退料参数（订单、领料ID、退料量、实际量）。
        // 校验退料参数（订单、领料ID、退料量）。
        if (dto.getProductionOrderId() == null) {
            throw new ServiceException("第" + rowNo + "行参数错误：生产订单ID不能为空");
        }
@@ -778,9 +1191,6 @@
        }
        if (dto.getReturnQty() == null || dto.getReturnQty().compareTo(BigDecimal.ZERO) < 0) {
            throw new ServiceException("第" + rowNo + "行参数错误：退料数量不能小于0");
        }
        if (dto.getActualQty() == null || dto.getActualQty().compareTo(BigDecimal.ZERO) < 0) {
            throw new ServiceException("第" + rowNo + "行参数错误：实际数量不能小于0");
        }
    }