feat: 工序添加是否领料,用于后续生产订单领料

gongchunyi

9 小时以前 a8188d1675594d7756eddccc3eda60601325942a

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

@@ -22,6 +22,8 @@
import com.ruoyi.production.bean.vo.ProductionOrderVo;
import com.ruoyi.production.bean.vo.ProductionPlanVo;
import com.ruoyi.production.bean.vo.ProductionOrderWorkOrderDetailVo;
import com.ruoyi.production.bean.vo.ProcessRouteStatusVo;
import com.ruoyi.production.bean.vo.ProductionOrderProcessTaskVo;
import com.ruoyi.production.enums.ProductOrderStatusEnum;
import com.ruoyi.production.mapper.*;
import com.ruoyi.production.pojo.*;
@@ -32,6 +34,7 @@
import com.ruoyi.quality.pojo.QualityInspectFile;
import com.ruoyi.quality.pojo.QualityInspectParam;
import com.ruoyi.production.service.ProductionOrderService;
import com.ruoyi.production.util.TaskPlanQuantityUtil;
import com.ruoyi.sales.mapper.SalesLedgerMapper;
import com.ruoyi.sales.mapper.SalesLedgerProductMapper;
import com.ruoyi.stock.mapper.StockInventoryMapper;
@@ -59,6 +62,7 @@
    private final ProductionOperationTaskMapper productionOperationTaskMapper;
    private final ProductionOrderBomMapper productionOrderBomMapper;
    private final ProductionBomStructureMapper productionBomStructureMapper;
    private final ProductionOrderMapper productionOrderMapper;
    private final ProductionProductMainMapper productionProductMainMapper;
    private final ProductionProductOutputMapper productionProductOutputMapper;
    private final ProductionOrderPickMapper productionOrderPickMapper;
@@ -82,20 +86,25 @@

    @Override
    public IPage<ProductionOrderVo> pageProductionOrder(Page<ProductionOrderDto> page, ProductionOrderDto dto) {
        // 分页查询生产订单
        Page<ProductionOrderVo> result = (Page<ProductionOrderVo>) baseMapper.pageProductionOrder(page, dto);
        fillProductImages(result.getRecords());
        fillProcessRouteStatus(result.getRecords());
        return result;
    }

    @Override
    public List<ProductionOrderVo> listProductionOrder(ProductionOrderDto dto) {
        // 查询生产订单列表
        List<ProductionOrderVo> records = baseMapper.listProductionOrder(dto);
        fillProductImages(records);
        fillProcessRouteStatus(records);
        return records;
    }

    @Override
    public ProductionOrderVo getProductionOrderInfo(Long id) {
        // 获取生产订单详情
        ProductionOrderVo item = baseMapper.getProductionOrderInfo(id);
        if (item == null) {
            return null;
@@ -106,6 +115,7 @@

    @Override
    public boolean saveProductionOrder(ProductionOrder productionOrder) {
        // 保存生产订单
        ProductionOrder oldOrder = productionOrder.getId() == null ? null : this.getById(productionOrder.getId());
        // 下单入口统一补齐来源单据、计划和工艺信息，避免前端分别传多套字段。
        validateAndFillOrder(productionOrder, oldOrder);
@@ -128,7 +138,7 @@
                || !Objects.equals(oldOrder.getProductModelId(), productionOrder.getProductModelId())
                || compareDecimal(oldOrder.getQuantity(), productionOrder.getQuantity()) != 0
                || productionOrderRoutingMapper.selectCount(Wrappers.<ProductionOrderRouting>lambdaQuery()
                        .eq(ProductionOrderRouting::getProductionOrderId, productionOrder.getId())) == 0);
                .eq(ProductionOrderRouting::getProductionOrderId, productionOrder.getId())) == 0);
        if (needSync) {
            syncProductionOrderSnapshot(productionOrder.getId());
        }
@@ -137,6 +147,7 @@

    @Override
    public boolean removeProductionOrder(List<Long> ids) {
        // 删除生产订单
        if (ids == null || ids.isEmpty()) {
            return false;
        }
@@ -150,6 +161,7 @@

    @Override
    public Integer bindingRoute(ProductionOrderDto productionOrderDto) {
        // 为订单绑定工艺路线
        if (productionOrderDto == null || productionOrderDto.getId() == null) {
            throw new ServiceException("生产订单ID不能为空");
        }
@@ -193,6 +205,7 @@

    @Override
    public List<ProductionPlanVo> getSource(Long id) {
        // 查询订单关联来源计划
        ProductionOrder productionOrder = baseMapper.selectById(id);
        if (productionOrder != null && productionOrder.getProductionPlanIds() != null) {
            List<Long> planIds = parsePlanIds(productionOrder.getProductionPlanIds());
@@ -203,7 +216,9 @@

    @Override
    public int syncProductionOrderSnapshot(Long productionOrderId) {
        // 同步订单工艺、工序、参数和BOM快照
        ProductionOrder productionOrder = this.getById(productionOrderId);
        // 参数与前置条件校验
        if (productionOrder == null) {
            throw new ServiceException("生产订单不存在");
        }
@@ -218,6 +233,7 @@
        clearProductionSnapshot(productionOrderId);
        ProductionOrderBom orderBom = syncProductionOrderBomSnapshot(productionOrder, technologyRouting);

        //生产订单工艺路线表
        ProductionOrderRouting orderRouting = new ProductionOrderRouting();
        orderRouting.setProductionOrderId(productionOrder.getId());
        orderRouting.setTechnologyRoutingId(technologyRouting.getId());
@@ -229,12 +245,28 @@
        productionOrderRoutingMapper.insert(orderRouting);

        int syncedParamCount = 0;
        // 查询并准备业务数据
        List<TechnologyRoutingOperation> routingOperations = technologyRoutingOperationMapper.selectList(
                Wrappers.<TechnologyRoutingOperation>lambdaQuery()
                        .eq(TechnologyRoutingOperation::getTechnologyRoutingId, technologyRouting.getId())
                        .orderByDesc(TechnologyRoutingOperation::getDragSort)
                        .orderByDesc(TechnologyRoutingOperation::getId));
        // 工单计划数量直接使用订单 BOM 快照中的需求量，避免与 BOM 页面展示口径不一致。
        Long rootProductModelId = orderBom != null && orderBom.getProductModelId() != null
                ? orderBom.getProductModelId()
                : productionOrder.getProductModelId();
        List<ProductionBomStructure> orderBomStructureList = orderBom == null || orderBom.getId() == null
                ? Collections.emptyList()
                : productionBomStructureMapper.selectList(
                Wrappers.<ProductionBomStructure>lambdaQuery()
                        .eq(ProductionBomStructure::getProductionOrderBomId, orderBom.getId())
                        .orderByAsc(ProductionBomStructure::getId));
        Map<String, BigDecimal> operationDemandedQuantityMap =
                TaskPlanQuantityUtil.buildOperationDemandedQuantityMap(orderBomStructureList, rootProductModelId);
        Map<Long, Set<Long>> operationOutputProductModelMap =
                TaskPlanQuantityUtil.buildOperationOutputProductModelMap(orderBomStructureList, rootProductModelId);
        Map<Long, String> operationNameMap = technologyOperationMapper.selectBatchIds(
                        // 遍历处理数据并组装结果
                        routingOperations.stream()
                                .map(TechnologyRoutingOperation::getTechnologyOperationId)
                                .filter(Objects::nonNull)
@@ -252,12 +284,18 @@
            targetOperation.setProductionOrderId(productionOrder.getId());
            targetOperation.setTechnologyRoutingOperationId(sourceOperation.getId());
            targetOperation.setOrderRoutingId(orderRouting.getId());
            targetOperation.setProductModelId(sourceOperation.getProductModelId());
            Long outputProductModelId = TaskPlanQuantityUtil.resolveOperationOutputProductModelId(
                    sourceOperation.getTechnologyOperationId(),
                    sourceOperation.getProductModelId(),
                    operationOutputProductModelMap,
                    rootProductModelId);
            targetOperation.setProductModelId(outputProductModelId);
            targetOperation.setDragSort(sourceOperation.getDragSort());
            targetOperation.setIsProduction(sourceOperation.getIsProduction());
            targetOperation.setIsQuality(sourceOperation.getIsQuality());
            targetOperation.setOperationName(operationNameMap.get(sourceOperation.getTechnologyOperationId()));
            targetOperation.setTechnologyOperationId(sourceOperation.getTechnologyOperationId());
            targetOperation.setType(sourceOperation.getType());
            productionOrderRoutingOperationMapper.insert(targetOperation);

            boolean isLastOperation = lastDragSort != null && Objects.equals(sourceOperation.getDragSort(), lastDragSort);
@@ -265,7 +303,11 @@
                ProductionOperationTask task = new ProductionOperationTask();
                task.setProductionOrderRoutingOperationId(targetOperation.getId());
                task.setProductionOrderId(productionOrder.getId());
                task.setPlanQuantity(defaultDecimal(productionOrder.getQuantity()));
                task.setPlanQuantity(TaskPlanQuantityUtil.resolveTaskPlanQuantity(
                        targetOperation,
                        operationDemandedQuantityMap,
                        productionOrder.getQuantity(),
                        rootProductModelId));
                task.setCompleteQuantity(BigDecimal.ZERO);
                task.setWorkOrderNo(generateNextTaskNo());
                task.setStatus(2);
@@ -301,6 +343,7 @@
    }

    private ProductionOrderBom syncProductionOrderBomSnapshot(ProductionOrder productionOrder, TechnologyRouting technologyRouting) {
        // 同步订单BOM快照结构
        if (technologyRouting.getBomId() == null) {
            return null;
        }
@@ -308,10 +351,12 @@
        if (technologyBom == null) {
            throw new ServiceException("工艺BOM不存在");
        }
        // 查询并准备业务数据
        List<TechnologyBomStructure> structureList = technologyBomStructureMapper.selectList(
                Wrappers.<TechnologyBomStructure>lambdaQuery()
                        .eq(TechnologyBomStructure::getBomId, technologyBom.getId())
                        .orderByAsc(TechnologyBomStructure::getId));
        // 遍历处理数据并组装结果
        TechnologyBomStructure root = structureList.stream().filter(item -> item.getParentId() == null).findFirst().orElse(null);
        BigDecimal orderQuantity = defaultDecimal(productionOrder.getQuantity());

@@ -322,9 +367,13 @@
        orderBom.setRemark(technologyBom.getRemark());
        orderBom.setBomNo(technologyBom.getBomNo());
        orderBom.setVersion(technologyBom.getVersion());
        // 持久化或输出处理结果
        productionOrderBomMapper.insert(orderBom);

        Map<Long, Long> idMap = new HashMap<>();
        Map<Long, Boolean> operationPickMap = loadOperationPickMap(structureList.stream()
                .map(TechnologyBomStructure::getOperationId)
                .collect(Collectors.toList()));
        for (TechnologyBomStructure source : structureList) {
            // 子节点 parentId 需要映射成新快照节点 id，才能保留原始 BOM 层级。
            ProductionBomStructure target = new ProductionBomStructure();
@@ -333,8 +382,10 @@
            target.setParentId(source.getParentId() == null ? null : idMap.get(source.getParentId()));
            target.setProductModelId(source.getProductModelId());
            target.setTechnologyOperationId(source.getOperationId());
            target.setIsPick(operationPickMap.getOrDefault(source.getOperationId(), Boolean.FALSE));
            target.setUnitQuantity(source.getUnitQuantity());
            target.setDemandedQuantity(source.getUnitQuantity().multiply(orderQuantity));
            target.setDemandedQuantity(defaultDecimal(orderQuantity)
                    .multiply(defaultDecimal(source.getUnitQuantity())));
            target.setUnit(source.getUnit());
            productionBomStructureMapper.insert(target);
            idMap.put(source.getId(), target.getId());
@@ -342,17 +393,40 @@
        return orderBom;
    }

    /**
     * 批量读取工序的“是否领料”标记，避免BOM快照逐行查询工序表。
     */
    private Map<Long, Boolean> loadOperationPickMap(List<Long> technologyOperationIds) {
        if (technologyOperationIds == null || technologyOperationIds.isEmpty()) {
            return Collections.emptyMap();
        }
        Set<Long> operationIdSet = technologyOperationIds.stream()
                .filter(Objects::nonNull)
                .collect(Collectors.toSet());
        if (operationIdSet.isEmpty()) {
            return Collections.emptyMap();
        }
        return technologyOperationMapper.selectBatchIds(operationIdSet).stream()
                .filter(item -> item != null && item.getId() != null)
                .collect(Collectors.toMap(TechnologyOperation::getId,
                        item -> Boolean.TRUE.equals(item.getIsPick()),
                        (left, right) -> left));
    }

    private void clearProductionSnapshot(Long productionOrderId) {
        // 已产生领料记录后禁止重建，避免备料/投料依据与订单快照脱节。
        // 清理订单已生成的工艺与BOM快照数据
        boolean hasPickRecord = productionOrderPickRecordMapper.selectCount(
                // 查询并准备业务数据
                Wrappers.<ProductionOrderPickRecord>lambdaQuery()
                        .eq(ProductionOrderPickRecord::getProductionOrderId, productionOrderId)) > 0;
        // 参数与前置条件校验
        if (hasPickRecord) {
            throw new ServiceException("生产订单已存在领料记录，不能重新生成快照");
        }
        List<Long> taskIds = productionOperationTaskMapper.selectList(
                        Wrappers.<ProductionOperationTask>lambdaQuery()
                                .eq(ProductionOperationTask::getProductionOrderId, productionOrderId))
                // 遍历处理数据并组装结果
                .stream().map(ProductionOperationTask::getId).collect(Collectors.toList());
        if (!taskIds.isEmpty()) {
            // 已有报工记录说明订单已开工，此时不允许再重建快照。
@@ -380,6 +454,7 @@
    }

    private LambdaQueryWrapper<ProductionOrder> buildQueryWrapper(ProductionOrderDto dto) {
        // 按条件动态构建数据库查询条件
        ProductionOrder query = dto == null ? new ProductionOrder() : dto;
        return Wrappers.<ProductionOrder>lambdaQuery()
                .eq(query.getId() != null, ProductionOrder::getId, query.getId())
@@ -390,6 +465,7 @@
    }

    private String generateNextOrderNo() {
        // 生成下一个生产订单号
        String datePrefix = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd"));
        String prefix = "SC" + datePrefix;
        ProductionOrder latestOrder = this.getOne(Wrappers.<ProductionOrder>lambdaQuery()
@@ -408,6 +484,7 @@
    }

    private String generateNextTaskNo() {
        // 生成下一个生产工单号
        String datePrefix = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd"));
        String prefix = "GD" + datePrefix;
        ProductionOperationTask lastTask = productionOperationTaskMapper.selectOne(
@@ -427,10 +504,46 @@
    }

    private BigDecimal defaultDecimal(BigDecimal value) {
        // 将空数量兜底为0，避免空指针异常
        return value == null ? BigDecimal.ZERO : value;
    }

    /**
     * 批次号按前缀日期升序排序（格式如 20260703-ed01-001，日期早的在前）
     */
    private void sortBatchNoList(List<String> batchNoList) {
        if (batchNoList == null || batchNoList.size() < 2) {
            return;
        }
        batchNoList.sort(Comparator
                .comparingLong(this::batchDateKey)
                .thenComparing(batchNo -> batchNo == null ? "" : batchNo));
    }

    /**
     * 提取批次号开头的数字作为排序键（yyyyMMdd），无数字时放到最后
     */
    private long batchDateKey(String batchNo) {
        if (batchNo == null) {
            return Long.MAX_VALUE;
        }
        String trimmed = batchNo.trim();
        int end = 0;
        while (end < trimmed.length() && Character.isDigit(trimmed.charAt(end))) {
            end++;
        }
        if (end == 0) {
            return Long.MAX_VALUE;
        }
        try {
            return Long.parseLong(trimmed.substring(0, end));
        } catch (NumberFormatException e) {
            return Long.MAX_VALUE;
        }
    }

    private void validateAndFillOrder(ProductionOrder productionOrder, ProductionOrder oldOrder) {
        // 校验订单参数并补齐默认值
        if (productionOrder == null) {
            throw new ServiceException("生产订单不能为空");
        }
@@ -463,7 +576,9 @@
    }

    private void fillFromProductionPlans(ProductionOrder productionOrder) {
        // 从关联生产计划回填订单关键字段
        List<Long> planIds = parsePlanIds(productionOrder.getProductionPlanIds());
        // 参数与前置条件校验
        if (planIds.isEmpty()) {
            return;
        }
@@ -472,6 +587,7 @@
        if (productionPlans.size() != planIds.size()) {
            throw new ServiceException("部分生产计划不存在");
        }
        // 遍历处理数据并组装结果
        Map<Long, ProductionPlan> planMap = productionPlans.stream()
                .collect(Collectors.toMap(ProductionPlan::getId, item -> item, (left, right) -> left));
        ProductionPlan mainPlan = planMap.get(planIds.get(0));
@@ -510,6 +626,7 @@
    }

    private void releaseProductionPlanIssueStatus(ProductionOrder productionOrder) {
        // 回退生产计划下发状态
        if (productionOrder == null) {
            return;
        }
@@ -522,6 +639,7 @@

    //生产订单删除，生产计划的已下发数量对应变更
    private void updatePlanIssuedFlag(List<Long> planIds, BigDecimal remainingAssignedQuantity) {
        // 更新计划下发标记和下发数量
        if (planIds == null || planIds.isEmpty()) {
            return;
        }
@@ -551,6 +669,7 @@
    }

    private BigDecimal resolveRemainingQuantity(ProductionPlan plan) {
        // 计算当前计划或记录的剩余数量
        if (plan == null) {
            return BigDecimal.ZERO;
        }
@@ -569,6 +688,7 @@
    }

    private int resolvePlanStatus(BigDecimal requiredQuantity, BigDecimal issuedQuantity) {
        // 根据需求量和下发量推导计划状态
        if (requiredQuantity == null || requiredQuantity.compareTo(BigDecimal.ZERO) <= 0) {
            return 0;
        }
@@ -579,6 +699,7 @@
    }

    private List<Long> parsePlanIds(String productionPlanIds) {
        // 将计划ID字符串解析为Long列表
        if (productionPlanIds == null || productionPlanIds.trim().isEmpty()) {
            return new ArrayList<>();
        }
@@ -595,6 +716,7 @@
    }

    private String formatPlanIds(List<Long> planIds) {
        // 将计划ID集合格式化为[1,2,3]字符串
        if (planIds == null || planIds.isEmpty()) {
            return null;
        }
@@ -605,6 +727,7 @@
    }

    private LocalDate resolvePlanCompleteDate(ProductionPlan productionPlan) {
        // 解析计划完成日期
        if (productionPlan == null) {
            return null;
        }
@@ -618,13 +741,16 @@
    }

    private int compareDecimal(BigDecimal left, BigDecimal right) {
        // 安全比较两个数量值大小
        return defaultDecimal(left).compareTo(defaultDecimal(right));
    }

    private void fillProductImages(List<ProductionOrderVo> records) {
        // 填充产品图片
        if (records == null || records.isEmpty()) {
            return;
        }
        // 遍历处理数据并组装结果
        List<Long> productModelIds = records.stream()
                .map(ProductionOrderVo::getProductModelId)
                .filter(Objects::nonNull)
@@ -634,6 +760,7 @@
            return;
        }

        // 查询并准备业务数据
        List<StorageAttachment> attachments = storageAttachmentMapper.selectList(
                Wrappers.<StorageAttachment>lambdaQuery()
                        .in(StorageAttachment::getRecordId, productModelIds)
@@ -675,7 +802,45 @@
        }
    }

    private void fillProcessRouteStatus(List<ProductionOrderVo> records) {
        if (records == null || records.isEmpty()) {
            return;
        }
        List<Long> orderIds = records.stream()
                .map(ProductionOrderVo::getId)
                .filter(Objects::nonNull)
                .distinct()
                .collect(Collectors.toList());
        if (orderIds.isEmpty()) {
            return;
        }

        List<ProductionOrderProcessTaskVo> tasks = productionOperationTaskMapper.listProcessStatusByOrderIds(orderIds);
        Map<Long, List<ProcessRouteStatusVo>> statusMap = new LinkedHashMap<>();
        if (tasks != null) {
            for (ProductionOrderProcessTaskVo task : tasks) {
                if (task == null || task.getProductionOrderId() == null) {
                    continue;
                }
                ProcessRouteStatusVo status = new ProcessRouteStatusVo();
                status.setName(task.getOperationName() != null && !task.getOperationName().isBlank()
                        ? task.getOperationName()
                        : "未知工序");
                BigDecimal percentage = task.getCompletionStatus() == null
                        ? BigDecimal.ZERO
                        : task.getCompletionStatus();
                status.setPercentage(percentage);
                statusMap.computeIfAbsent(task.getProductionOrderId(), key -> new ArrayList<>()).add(status);
            }
        }

        for (ProductionOrderVo record : records) {
            record.setProcessRouteStatus(statusMap.getOrDefault(record.getId(), Collections.emptyList()));
        }
    }

    private StorageBlobVO toStorageBlobVO(StorageBlob blob) {
        // 将存储文件对象转换为VO
        StorageBlobVO vo = BeanUtil.copyProperties(blob, StorageBlobVO.class);
        vo.setPreviewURL(fileUtil.buildSignedPreviewUrl(vo));
        vo.setDownloadURL(fileUtil.buildSignedDownloadUrl(vo));
@@ -684,8 +849,10 @@

    @Override
    public ProductionOrderWorkOrderDetailVo getWorkOrderReportInspectDetail(ProductionOrderDto dto) {
        // 获取工单订单报工质检明细
        Long productionOrderId = resolveProductionOrderId(dto);
        ProductionOrderVo orderInfo = getProductionOrderInfo(productionOrderId);
        // 参数与前置条件校验
        if (orderInfo == null) {
            throw new ServiceException("生产订单不存在");
        }
@@ -699,11 +866,21 @@
                new Page<ProductionOperationTaskVo>(1, -1), taskQuery);
        List<ProductionOperationTaskVo> workOrderList = workOrderPage == null || workOrderPage.getRecords() == null
                ? Collections.emptyList()
                // 遍历处理数据并组装结果
                : workOrderPage.getRecords().stream()
                .filter(Objects::nonNull)
                .sorted(Comparator.comparing(ProductionOperationTaskVo::getId, Comparator.nullsLast(Comparator.naturalOrder())))
                .collect(Collectors.toList());
        if (workOrderList == null || workOrderList.isEmpty()) {
                .toList();
        if (!workOrderList.isEmpty()) {
            // 工序进度需要按工艺路线工序顺序（drag_sort 升序）从左到右展示，任务 id 仅作为兜底排序
            Map<Long, Integer> routingOperationDragSortMap = loadRoutingOperationDragSortMap(workOrderList);
            Comparator<ProductionOperationTaskVo> workOrderComparator = Comparator
                    .comparing((ProductionOperationTaskVo task) -> routingOperationDragSortMap.get(task.getProductionOrderRoutingOperationId()),
                            Comparator.nullsLast(Comparator.<Integer>naturalOrder()))
                    .thenComparing(ProductionOperationTaskVo::getId,
                            Comparator.nullsLast(Comparator.<Long>naturalOrder()));
            workOrderList = workOrderList.stream().sorted(workOrderComparator).toList();
        }
        if (workOrderList.isEmpty()) {
            detailVo.setWorkOrderList(Collections.emptyList());
            return detailVo;
        }
@@ -714,6 +891,7 @@
                .collect(Collectors.toList());
        List<ProductionProductMain> reportMainList = workOrderIdList.isEmpty()
                ? Collections.emptyList()
                // 查询并准备业务数据
                : productionProductMainMapper.selectList(
                Wrappers.<ProductionProductMain>lambdaQuery()
                        .in(ProductionProductMain::getProductionOperationTaskId, workOrderIdList)
@@ -744,12 +922,10 @@
                if (reportOutput == null) {
                    continue;
                }
                Long reportMainId = reportOutput.getProductionProductMainId() != null
                        ? reportOutput.getProductionProductMainId()
                        : reportOutput.getProductMainId();
                if (reportMainId == null) {
                if (reportOutput.getProductionProductMainId() == null) {
                    continue;
                }
                Long reportMainId = reportOutput.getProductionProductMainId();
                reportOutputMap.computeIfAbsent(reportMainId, k -> new ArrayList<>()).add(reportOutput);
            }

@@ -824,6 +1000,7 @@

                ProductionOrderWorkOrderDetailVo.ReportDetail reportDetail = new ProductionOrderWorkOrderDetailVo.ReportDetail();
                reportDetail.setReportMain(reportMain);
                reportDetail.setWorkHour(reportMain.getWorkHour());
                reportDetail.setReportOutputList(reportOutputMap.getOrDefault(reportMainId, Collections.emptyList()));
                reportDetail.setReportParamList(reportParamMap.getOrDefault(reportMainId, Collections.emptyList()));
                reportDetailList.add(reportDetail);
@@ -834,6 +1011,7 @@
                    inspectDetail.setReportId(reportMainId);
                    inspectDetail.setReportNo(reportMain.getProductNo());
                    inspectDetail.setReportMain(reportMain);
                    inspectDetail.setWorkHour(reportMain.getWorkHour());
                    inspectDetail.setInspect(inspect);
                    inspectDetail.setInspectParamList(inspectParamMap.getOrDefault(inspect.getId(), Collections.emptyList()));
                    inspectDetail.setInspectFileList(inspectFileMap.getOrDefault(inspect.getId(), Collections.emptyList()));
@@ -850,7 +1028,25 @@
        return detailVo;
    }

    /**
     * 查询工单对应工艺路线工序的拖动排序，用于按工序先后顺序展示工序进度
     */
    private Map<Long, Integer> loadRoutingOperationDragSortMap(List<ProductionOperationTaskVo> workOrderList) {
        Set<Long> routingOperationIds = workOrderList.stream()
                .map(ProductionOperationTaskVo::getProductionOrderRoutingOperationId)
                .filter(Objects::nonNull)
                .collect(Collectors.toSet());
        if (routingOperationIds.isEmpty()) {
            return Collections.emptyMap();
        }
        return productionOrderRoutingOperationMapper.selectBatchIds(routingOperationIds).stream()
                .filter(Objects::nonNull)
                .filter(operation -> operation.getId() != null && operation.getDragSort() != null)
                .collect(Collectors.toMap(ProductionOrderRoutingOperation::getId, ProductionOrderRoutingOperation::getDragSort, (a, b) -> a));
    }

    private Long resolveProductionOrderId(ProductionOrderDto dto) {
        // 从入参中解析生产订单ID并校验
        if (dto == null) {
            throw new ServiceException("请传入生产订单ID或生产订单号");
        }
@@ -872,10 +1068,12 @@

    @Override
    public List<ProductionOrderPickVo> pick(Long productionOrderId) {
        // 查询订单领料、投料与退料明细
        if (productionOrderId == null) {
            return Collections.emptyList();
        }

        // 查询并准备业务数据
        ProductionOrderBom orderBom = productionOrderBomMapper.selectOne(
                Wrappers.<ProductionOrderBom>lambdaQuery()
                        .eq(ProductionOrderBom::getProductionOrderId, productionOrderId)
@@ -885,12 +1083,81 @@
            return Collections.emptyList();
        }

        List<ProductionBomStructureVo> bomStructureList = productionBomStructureMapper.pickByBomId(orderBom.getId());
        // 查询完整的BOM结构（包括根节点），每个节点独立计算需求数量
        List<ProductionBomStructureVo> bomStructureList = productionBomStructureMapper.listByBomId(orderBom.getId());
        if (bomStructureList == null || bomStructureList.isEmpty()) {
            return Collections.emptyList();
        }

        List<Long> productModelIds = bomStructureList.stream()
        // 查询生产订单获取订单数量
        ProductionOrder productionOrder = productionOrderMapper.selectById(productionOrderId);
        BigDecimal orderQuantity = productionOrder != null ? defaultDecimal(productionOrder.getQuantity()) : BigDecimal.ZERO;

        for (ProductionBomStructureVo structure : bomStructureList) {
            if (structure != null) {
                structure.setDemandedQuantity(orderQuantity
                        .multiply(defaultDecimal(structure.getUnitQuantity())));
            }
        }

        // production_bom_structure.is_pick 是生产计划下发时的工序领料标记快照；
        // 领料台账读取时以工序主数据的最新标记为准，保证工序上的“是否领料”调整后无需重新下发即可生效；
        // 工序已被删除时保留快照值，避免历史订单的领料范围丢失。
        Map<Long, Boolean> operationPickMap = loadOperationPickMap(bomStructureList.stream()
                .filter(Objects::nonNull)
                .map(ProductionBomStructureVo::getTechnologyOperationId)
                .collect(Collectors.toList()));
        for (ProductionBomStructureVo structure : bomStructureList) {
            if (structure == null || structure.getTechnologyOperationId() == null) {
                continue;
            }
            Boolean latestPick = operationPickMap.get(structure.getTechnologyOperationId());
            if (latestPick != null) {
                structure.setIsPick(latestPick);
            }
        }

        // 收集订单成品规格ID：生产订单成品规格 + 订单BOM快照的根节点规格，用于排除“自己”这一物料。
        // 注意：BOM结构里领料物料本身也可能是 parent_id 为空的独立节点，这里不能再把所有根节点都当成成品排除，
        // 否则“领料”工序下的物料会被整体过滤掉。
        Set<Long> finishedProductModelIds = new HashSet<>();
        if (productionOrder != null && productionOrder.getProductModelId() != null) {
            finishedProductModelIds.add(productionOrder.getProductModelId());
        }
        if (orderBom.getProductModelId() != null) {
            finishedProductModelIds.add(orderBom.getProductModelId());
        }

        // 收集所有被引用为父级的节点ID：BOM从最后一道工序往里配置前一道工序，
        // 中间节点是上一道工序的产出（自制），旧口径只有每条分支最里层的叶子节点才是真正需要领用的物料。
        Set<Long> parentNodeIds = bomStructureList.stream()
                .filter(s -> s != null && s.getParentId() != null && s.getParentId() != 0)
                .map(ProductionBomStructureVo::getParentId)
                .filter(Objects::nonNull)
                .collect(Collectors.toSet());

        // 领料范围以工序的“是否领料”标记为准：只有标记了领料的工序，其消耗的物料才进入领料台账。
        // 注意：领料物料在BOM结构中可能是独立节点（parent_id 为空），所以这里不限制层级，只看工序标记；
        // 只排除与订单成品同规格的物料（成品本身无需领料）。
        List<ProductionBomStructureVo> markedPickStructureList = bomStructureList.stream()
                .filter(s -> s != null && Boolean.TRUE.equals(s.getIsPick()))
                .filter(s -> s.getProductModelId() == null || !finishedProductModelIds.contains(s.getProductModelId()))
                .collect(Collectors.toList());

        // 实际领料项：优先使用工序领料标记；
        // 兼容历史数据：当该订单BOM结构里没有任何工序标记领料时，回退为原来的“叶子节点领料”规则，
        // 避免尚未启用“是否领料”标记的客户打开领料台账时数据突然为空。
        List<ProductionBomStructureVo> childStructureList = markedPickStructureList;
        if (childStructureList.isEmpty()) {
            childStructureList = bomStructureList.stream()
                    .filter(s -> s != null && s.getParentId() != null && s.getParentId() != 0)
                    .filter(s -> s.getId() == null || !parentNodeIds.contains(s.getId()))
                    .filter(s -> s.getProductModelId() == null || !finishedProductModelIds.contains(s.getProductModelId()))
                    .collect(Collectors.toList());
        }

        // 遍历处理数据并组装结果
        List<Long> productModelIds = childStructureList.stream()
                .map(ProductionBomStructureVo::getProductModelId)
                .filter(Objects::nonNull)
                .distinct()
@@ -900,7 +1167,8 @@
        if (!productModelIds.isEmpty()) {
            List<StockInventory> stockList = stockInventoryMapper.selectList(
                    Wrappers.<StockInventory>lambdaQuery()
                            .in(StockInventory::getProductModelId, productModelIds));
                            .in(StockInventory::getProductModelId, productModelIds)
                            .gt(StockInventory::getQualitity, BigDecimal.ZERO));
            for (StockInventory stockItem : stockList) {
                if (stockItem == null || stockItem.getProductModelId() == null) {
                    continue;
@@ -915,7 +1183,7 @@
        }

        Map<String, ProductionOrderPickVo> mergedPickMap = new LinkedHashMap<>();
        for (ProductionBomStructureVo structure : bomStructureList) {
        for (ProductionBomStructureVo structure : childStructureList) {
            if (structure == null || structure.getProductModelId() == null) {
                continue;
            }
@@ -934,6 +1202,7 @@
                List<String> batchNoList = stockBatchNoMap.get(productModelId) == null
                        ? Collections.emptyList()
                        : new ArrayList<>(stockBatchNoMap.get(productModelId));
                sortBatchNoList(batchNoList);
                vo.setBatchNoList(batchNoList);
                vo.setStockQuantity(stockQuantityMap.getOrDefault(productModelId, BigDecimal.ZERO));
                vo.setBom(true);
@@ -946,6 +1215,7 @@

    @Override
    public int updateOrder(ProductionOrderDto productionOrderDto) {
        // 更新生产订单主数据
        productionOrderDto.setStatus(5);
        return baseMapper.updateById(productionOrderDto);
    }