fix:1.生产报工优化

liding

2026-05-20 4d99e718536ac77dff26dde8da7a59cdc9b52de8

fix:1.生产报工优化

 src/main/java/com/ruoyi/production/mapper/ProductionProductMainMapper.java

@@ -19,14 +19,12 @@
    IPage<ProductionProductMainDto> listPageProductionProductMainDto(Page page, @Param("c") ProductionProductMainDto productionProductMainDto);

    /**
     * 根据工单ID批量删除生产主表数据
     * 根据工单 ID 批量删除报工主表数据。
     */
    int deleteByWorkOrderIds(@Param("workOrderIds") List<Long> workOrderIds);

    /**
     * 根据报工id查询生产订单
     * @param productMainId
     * @return
     * 根据报工 ID 查询生产订单。
     */
    ProductOrder getOrderByMainId(@Param("productMainId") Long productMainId);

@@ -37,10 +35,7 @@
    List<ProductionProductMainDto> getByProductWorkOrderId(Long productWorkOrderId);

    /**
     * 检查之前的工序是否有被隔离的不合格记录
     * @param productRouteId 当前工序的路由ID
     * @param currentDragSort 当前工序的排序
     * @return 是否有隔离的不合格记录
     * 校验同一生产订单下的上一道工序是否已经报工。
     */
    boolean checkPreviousProcessReported(@Param("productRouteId") Long productRouteId, @Param("currentDragSort") Integer currentDragSort);
    boolean checkPreviousProcessReported(@Param("workOrderId") Long workOrderId, @Param("currentDragSort") Integer currentDragSort);
}

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

@@ -69,7 +69,7 @@
            } else {
                // 上一个工序是否已报工
                boolean isPreviousReported = productionProductMainMapper.checkPreviousProcessReported(
                        record.getProductRouteId(),
                        record.getId(),
                        currentDragSort
                );
                record.setIsCanReport(isPreviousReported);
@@ -94,7 +94,13 @@
                        }

                        // 检查之前的工序是否有被隔离的不合格记录
                        List<QualityUnqualified> unqualifiedList = qualityUnqualifiedMapper.selectUnqualifiedByProcessNames(previousProcessNames);
                        List<QualityUnqualified> unqualifiedList = Collections.emptyList();
                        if (CollectionUtils.isNotEmpty(previousProcessNames)) {
                            unqualifiedList = qualityUnqualifiedMapper.selectUnqualifiedByProductOrderAndProcessNames(
                                    record.getProductOrderId(),
                                    previousProcessNames
                            );
                        }
                        if (CollectionUtils.isNotEmpty(unqualifiedList)) {
                            record.setIsCanReport(false);
                        }
@@ -231,4 +237,4 @@
        }
        return productWorkOrderDtos;
    }
}
}

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

@@ -17,6 +17,7 @@
import com.ruoyi.common.enums.StockOutQualifiedRecordTypeEnum;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.bean.BeanUtils;
import com.ruoyi.procurementrecord.utils.StockUtils;
import com.ruoyi.production.dto.ProductStructureDto;
@@ -52,50 +53,29 @@
    private static final String PROCESS_VOLTAGE_SORT = "电压分选";
    private static final String PROCESS_OPTICAL_INSPECTION = "光检外观";
    private static final String PROCESS_PACKAGING = "包装";
    private static final Object PRODUCT_MAIN_NO_LOCK = new Object();

    private IQualityInspectService qualityInspectService;
    private ProductionProductMainMapper productionProductMainMapper;


    private ProductWorkOrderMapper productWorkOrderMapper;

    private ProductProcessRouteItemMapper productProcessRouteItemMapper;
    private SysUserMapper userMapper;

    private ProductionProductOutputMapper productionProductOutputMapper;


    private ProductModelMapper productModelMapper;

    private QualityInspectMapper qualityInspectMapper;
    private QualityUnqualifiedMapper qualityUnqualifiedMapper;

    private ProductProcessMapper productProcessMapper;
    private ProductProcessRouteMapper productProcessRouteMapper;

    private ProductMapper productMapper;


    private QualityTestStandardParamMapper qualityTestStandardParamMapper;
    private QualityTestStandardMapper qualityTestStandardMapper;

    private QualityInspectParamMapper qualityInspectParamMapper;

    private ProductStructureMapper productStructureMapper;

    private ProductionProductInputMapper productionProductInputMapper;

    private ProductOrderMapper productOrderMapper;

    private SalesLedgerProductionAccountingMapper salesLedgerProductionAccountingMapper;

    private StockUtils stockUtils;

    /**
     * 解析生产报工对应的成品入库维度。
     */
    private FinishedProductStockDimensionResolver finishedProductStockDimensionResolver;

    private ISysNoticeService sysNoticeService;

    @Override
@@ -103,124 +83,246 @@
        return productionProductMainMapper.listPageProductionProductMainDto(page, productionProductMainDto);
    }

    /**
     * 新增报工，并根据当前工序处理质检和入库逻辑。
     */
    // 新增报工，并按照报工主流程处理投入扣库、产出、质检、入库、工单订单进度和核算数据
    @Override
    public Boolean addProductMain(ProductionProductMainDto dto) {
        SysUser user = userMapper.selectUserById(dto.getUserId());
        ProductionProductMain productionProductMain = new ProductionProductMain();
        //当前工艺路线对应的工序详情
        ProductProcessRouteItem productProcessRouteItem = productProcessRouteItemMapper.selectById(dto.getProductProcessRouteItemId());
        if (productProcessRouteItem == null) {
            throw new RuntimeException("工艺路线工序项不存在");
        // 第一步：先校验报工入参，避免空值和非法数量进入后续流程
        if (dto == null) {
            throw new ServiceException("报工参数不能为空");
        }
        //检查上一个工序是否已报工
        if (dto.getProductProcessRouteItemId() == null) {
            throw new ServiceException("工艺路线工序项不能为空");
        }
        if (dto.getWorkOrderId() == null) {
            throw new ServiceException("生产工单不能为空");
        }

        BigDecimal reportQty = dto.getQuantity();
        BigDecimal scrapQty = dto.getScrapQty() == null ? BigDecimal.ZERO : dto.getScrapQty();
        if (reportQty == null || reportQty.compareTo(BigDecimal.ZERO) <= 0) {
            throw new ServiceException("报工数量必须大于0");
        }
        if (scrapQty.compareTo(BigDecimal.ZERO) < 0) {
            throw new ServiceException("报废数量不能小于0");
        }
        if (scrapQty.compareTo(reportQty) > 0) {
            throw new ServiceException("报废数量不能大于报工数量");
        }

        // 第二步：加载当前工序、工单、工艺路线和订单数据，并校验基础关联关系
        ProductProcessRouteItem productProcessRouteItem =
                productProcessRouteItemMapper.selectById(dto.getProductProcessRouteItemId());
        if (productProcessRouteItem == null) {
            throw new ServiceException("工艺路线工序项不存在");
        }

        ProductProcess productProcess = productProcessMapper.selectById(productProcessRouteItem.getProcessId());
        if (productProcess == null) {
            throw new ServiceException("当前工序不存在");
        }

        ProductModel productModel = productModelMapper.selectById(productProcessRouteItem.getProductModelId());
        if (productModel == null) {
            throw new ServiceException("当前工序对应的产品型号不存在");
        }

        ProductProcessRoute productProcessRoute =
                productProcessRouteMapper.selectById(productProcessRouteItem.getProductRouteId());
        if (productProcessRoute == null) {
            throw new ServiceException("工艺路线不存在");
        }

        ProductWorkOrder productWorkOrder = productWorkOrderMapper.selectById(dto.getWorkOrderId());
        if (productWorkOrder == null) {
            throw new ServiceException("生产工单不存在");
        }
        if (!Objects.equals(productWorkOrder.getProductProcessRouteItemId(), productProcessRouteItem.getId())) {
            throw new ServiceException("生产工单与当前工序不匹配");
        }

        ProductOrder productOrder = productOrderMapper.selectById(productWorkOrder.getProductOrderId());
        if (productOrder == null) {
            throw new ServiceException("生产订单不存在");
        }

        // 第三步：校验工序流转逻辑，必须是同一订单的上一道工序已报工且前序无未解除隔离记录
        Integer currentDragSort = productProcessRouteItem.getDragSort();
        if (currentDragSort != null && currentDragSort > 1) {
            boolean isPreviousReported = productionProductMainMapper.checkPreviousProcessReported(
                    productProcessRouteItem.getProductRouteId(),
                    productWorkOrder.getId(),
                    currentDragSort
            );
            if (!isPreviousReported) {
                throw new RuntimeException("上一道工序尚未报工，当前工序不能报工");
                throw new ServiceException("上一道工序尚未报工，当前工序不能报工");
            }

            // 查询所有之前的工序（排序号小于当前工序）
            ProductProcessRouteItem previousRouteItem = productProcessRouteItemMapper.selectOne(
                    Wrappers.<ProductProcessRouteItem>lambdaQuery()
                            .eq(ProductProcessRouteItem::getProductRouteId, productProcessRouteItem.getProductRouteId())
                            .eq(ProductProcessRouteItem::getDragSort, currentDragSort - 1)
            );
            if (previousRouteItem == null) {
                throw new ServiceException("上一道工序不存在");
            }

            ProductWorkOrder previousWorkOrder = productWorkOrderMapper.selectOne(
                    Wrappers.<ProductWorkOrder>lambdaQuery()
                            .eq(ProductWorkOrder::getProductOrderId, productOrder.getId())
                            .eq(ProductWorkOrder::getProductProcessRouteItemId, previousRouteItem.getId())
            );
            if (previousWorkOrder == null) {
                throw new ServiceException("上一道工序工单不存在");
            }

            BigDecimal currentReportedQty = BigDecimal.ZERO;
            List<ProductionProductMain> currentMainList = productionProductMainMapper.selectList(
                    Wrappers.<ProductionProductMain>lambdaQuery()
                            .eq(ProductionProductMain::getWorkOrderId, productWorkOrder.getId())
            );
            if (CollectionUtils.isNotEmpty(currentMainList)) {
                List<Long> currentMainIds = currentMainList.stream().map(ProductionProductMain::getId).collect(Collectors.toList());
                List<ProductionProductOutput> currentOutputList = productionProductOutputMapper.selectList(
                        Wrappers.<ProductionProductOutput>lambdaQuery()
                                .in(ProductionProductOutput::getProductMainId, currentMainIds)
                );
                currentReportedQty = currentOutputList.stream()
                        .map(ProductionProductOutput::getQuantity)
                        .filter(Objects::nonNull)
                        .reduce(BigDecimal.ZERO, BigDecimal::add);
            }

            BigDecimal previousCompleteQty =
                    previousWorkOrder.getCompleteQuantity() == null ? BigDecimal.ZERO : previousWorkOrder.getCompleteQuantity();
            if (currentReportedQty.add(reportQty).compareTo(previousCompleteQty) > 0) {
                throw new ServiceException("本次报工数量超过上道工序可流转数量");
            }

            List<ProductProcessRouteItem> previousItems = productProcessRouteItemMapper.selectList(
                    Wrappers.<ProductProcessRouteItem>lambdaQuery()
                            .eq(ProductProcessRouteItem::getProductRouteId, productProcessRouteItem.getProductRouteId())
                            .lt(ProductProcessRouteItem::getDragSort, currentDragSort)
            );

            if (CollectionUtils.isNotEmpty(previousItems)) {
                // 提取之前工序的名称列表
                List<String> previousProcessNames = new ArrayList<>();
                for (ProductProcessRouteItem item : previousItems) {
                    ProductProcess process = productProcessMapper.selectById(item.getProcessId());
                    if (process != null) {
                        previousProcessNames.add(process.getName());
                    if (process != null && StringUtils.isNotBlank(process.getName())) {
                        previousProcessNames.add(process.getName().trim());
                    }
                }

                // 检查之前的工序是否有被隔离的不合格记录
                List<QualityUnqualified> unqualifiedList = qualityUnqualifiedMapper.selectUnqualifiedByProcessNames(previousProcessNames);
                if (CollectionUtils.isNotEmpty(unqualifiedList)) {
                    throw new RuntimeException("前序工序存在隔离记录，当前工序不能报工");
                if (CollectionUtils.isNotEmpty(previousProcessNames)) {
                    List<QualityUnqualified> unqualifiedList =
                            qualityUnqualifiedMapper.selectUnqualifiedByProductOrderAndProcessNames(productOrder.getId(), previousProcessNames);
                    if (CollectionUtils.isNotEmpty(unqualifiedList)) {
                        throw new ServiceException("前序工序存在隔离记录，当前工序不能报工");
                    }
                }
            }
        }
        //当前具体工序
        ProductProcess productProcess = productProcessMapper.selectById(productProcessRouteItem.getProcessId());
        //工艺路线中当前工序对应的产出规格型号
        ProductModel productModel = productModelMapper.selectById(productProcessRouteItem.getProductModelId());
        //查询该生产订单对应的bom
        ProductProcessRoute productProcessRoute = productProcessRouteMapper.selectById(productProcessRouteItem.getProductRouteId());
        /*新增报工主表*/
        //查询最大报工编号
        String datePrefix = "BG" + LocalDate.now().format(DateTimeFormatter.ofPattern("yyMMdd"));
        QueryWrapper<ProductionProductMain> queryWrapper = new QueryWrapper<>();
        queryWrapper.select("MAX(product_no) as maxNo")
                .likeRight("product_no", datePrefix);
        List<Map<String, Object>> resultList = productionProductMainMapper.selectMaps(queryWrapper);
        int sequenceNumber = 1;
        if (resultList != null && !resultList.isEmpty()) {
            Map<String, Object> result = resultList.get(0);
            if (result != null) {
                Object maxNoObj = result.get("maxNo");
                if (maxNoObj != null) {
                    String lastNo = maxNoObj.toString();

        // 第四步：控制当前工单总报工量不能超过计划量
        BigDecimal currentWorkOrderReportedQty = BigDecimal.ZERO;
        List<ProductionProductMain> workOrderMainList = productionProductMainMapper.selectList(
                Wrappers.<ProductionProductMain>lambdaQuery()
                        .eq(ProductionProductMain::getWorkOrderId, productWorkOrder.getId())
        );
        if (CollectionUtils.isNotEmpty(workOrderMainList)) {
            List<Long> workOrderMainIds = workOrderMainList.stream().map(ProductionProductMain::getId).collect(Collectors.toList());
            List<ProductionProductOutput> workOrderOutputList = productionProductOutputMapper.selectList(
                    Wrappers.<ProductionProductOutput>lambdaQuery()
                            .in(ProductionProductOutput::getProductMainId, workOrderMainIds)
            );
            currentWorkOrderReportedQty = workOrderOutputList.stream()
                    .map(ProductionProductOutput::getQuantity)
                    .filter(Objects::nonNull)
                    .reduce(BigDecimal.ZERO, BigDecimal::add);
        }
        if (productWorkOrder.getPlanQuantity() != null
                && currentWorkOrderReportedQty.add(reportQty).compareTo(productWorkOrder.getPlanQuantity()) > 0) {
            throw new ServiceException("本次报工数量超过工单可报数量");
        }

        // 第五步：生成报工单号并确定报工人信息
        String productNo;
        synchronized (PRODUCT_MAIN_NO_LOCK) {
            String datePrefix = "BG" + LocalDate.now().format(DateTimeFormatter.ofPattern("yyMMdd"));
            QueryWrapper<ProductionProductMain> queryWrapper = new QueryWrapper<>();
            queryWrapper.select("MAX(product_no) as maxNo")
                    .likeRight("product_no", datePrefix);
            List<Map<String, Object>> resultList = productionProductMainMapper.selectMaps(queryWrapper);

            int sequenceNumber = 1;
            if (CollectionUtils.isNotEmpty(resultList)) {
                Map<String, Object> result = resultList.get(0);
                if (result != null && result.get("maxNo") != null) {
                    String lastNo = result.get("maxNo").toString();
                    if (lastNo.startsWith(datePrefix)) {
                        try {
                            String seqStr = lastNo.substring(datePrefix.length());
                            sequenceNumber = Integer.parseInt(seqStr) + 1;
                            sequenceNumber = Integer.parseInt(lastNo.substring(datePrefix.length())) + 1;
                        } catch (NumberFormatException e) {
                            sequenceNumber = 1;
                        }
                    }
                }
            }
            productNo = String.format("%s%03d", datePrefix, sequenceNumber);
        }
        String productNo = String.format("%s%03d", datePrefix, sequenceNumber);
        productionProductMain.setProductNo(productNo);

        Long userId = dto.getUserId();
        String userName = dto.getUserName();
        if (userId == null) {
            userId = SecurityUtils.getLoginUser().getUserId();
            userName = SecurityUtils.getLoginUser().getNickName();
        } else if (StringUtils.isBlank(userName)) {
            SysUser user = userMapper.selectUserById(userId);
            userName = user == null ? null : user.getNickName();
        }

        // 第六步：先写报工主表
        ProductionProductMain productionProductMain = new ProductionProductMain();
        productionProductMain.setProductNo(productNo);
        productionProductMain.setUserId(userId);
        productionProductMain.setUserName(userName);
        productionProductMain.setProductProcessRouteItemId(dto.getProductProcessRouteItemId());
        productionProductMain.setWorkOrderId(dto.getWorkOrderId());
        productionProductMain.setStatus(0);
        productionProductMainMapper.insert(productionProductMain);
        /*新增报工投入表*/
        List<ProductStructureDto> productStructureDtos = productStructureMapper.listBybomAndProcess(productProcessRoute.getBomId(), productProcess.getId());
        if (productStructureDtos.isEmpty()) {
            //如果该工序没有产品结构的投入品,那这个投入品和产出品是同一个

        // 第七步：根据 BOM 生成投入记录并扣减原料库存
        List<ProductStructureDto> productStructureDtos =
                productStructureMapper.listBybomAndProcess(productProcessRoute.getBomId(), productProcess.getId());

        if (CollectionUtils.isEmpty(productStructureDtos)) {
            ProductStructureDto productStructureDto = new ProductStructureDto();
            productStructureDto.setProductModelId(productProcessRouteItem.getProductModelId());
            productStructureDto.setUnitQuantity(BigDecimal.ONE);
            productStructureDtos.add(productStructureDto);
        }

        Set<Long> parentIds = productStructureDtos.stream()
                .map(ProductStructureDto::getParentId)
                .filter(Objects::nonNull)
                .collect(Collectors.toSet());

        Map<Long, ProductStructureDto> parentMap = new HashMap<>();
        if (!parentIds.isEmpty()) {
        if (CollectionUtils.isNotEmpty(parentIds)) {
            parentMap = productStructureMapper.selectByIds(parentIds)
                    .stream()
                    .collect(Collectors.toMap(
                            ProductStructureDto::getId,
                            Function.identity()
                    ));
                    .collect(Collectors.toMap(ProductStructureDto::getId, Function.identity(), (a, b) -> a));
        }

        for (ProductStructureDto productStructureDto : productStructureDtos) {
            ProductionProductInput productionProductInput = new ProductionProductInput();
            productionProductInput.setProductModelId(productStructureDto.getProductModelId());
//            productionProductInput.setQuantity(productStructureDto.getUnitQuantity().multiply(dto.getQuantity()));
            if (productStructureDto.getProductModelId() == null) {
                throw new ServiceException("投入物料产品型号不能为空");
            }

            BigDecimal childQty = productStructureDto.getUnitQuantity();
            if (childQty == null || childQty.compareTo(BigDecimal.ZERO) <= 0) {
                throw new ServiceException("投入物料用量必须大于0");
            }

            BigDecimal parentQty = BigDecimal.ONE;
            if (productStructureDto.getParentId() != null) {
                ProductStructureDto parent = parentMap.get(productStructureDto.getParentId());
@@ -229,104 +331,140 @@
                }
            }

            // 核心计算
            BigDecimal needQty = childQty.divide(parentQty, 6, RoundingMode.HALF_UP).multiply(dto.getQuantity());
            if (parentQty == null || parentQty.compareTo(BigDecimal.ZERO) <= 0) {
                throw new ServiceException("父级物料用量必须大于0");
            }

            BigDecimal needQty = childQty
                    .divide(parentQty, 6, RoundingMode.HALF_UP)
                    .multiply(reportQty);

            ProductionProductInput productionProductInput = new ProductionProductInput();
            productionProductInput.setProductModelId(productStructureDto.getProductModelId());
            productionProductInput.setQuantity(needQty);
            productionProductInput.setProductMainId(productionProductMain.getId());
            productionProductInputMapper.insert(productionProductInput);
            stockUtils.substractStock(productStructureDto.getProductModelId(), productionProductInput.getQuantity(),
                    StockOutQualifiedRecordTypeEnum.PRODUCTION_REPORT_STOCK_OUT.getCode(), productionProductMain.getId(), null);

            stockUtils.substractStock(
                    productStructureDto.getProductModelId(),
                    needQty,
                    StockOutQualifiedRecordTypeEnum.PRODUCTION_REPORT_STOCK_OUT.getCode(),
                    productionProductMain.getId(),
                    null
            );
        }
        /*新增报工产出表*/

        // 第八步：写产出记录并计算本次合格数量
        ProductionProductOutput productionProductOutput = new ProductionProductOutput();
        productionProductOutput.setProductMainId(productionProductMain.getId());
        productionProductOutput.setProductModelId(productProcessRouteItem.getProductModelId());
        productionProductOutput.setQuantity(dto.getQuantity() != null ? dto.getQuantity() : BigDecimal.ZERO);
        productionProductOutput.setScrapQty(dto.getScrapQty() != null ? dto.getScrapQty() : BigDecimal.ZERO);
        productionProductOutput.setOtherData(dto.getOtherData() != null ? dto.getOtherData() : "");
        productionProductOutput.setQuantity(reportQty);
        productionProductOutput.setScrapQty(scrapQty);
        productionProductOutput.setOtherData(dto.getOtherData() == null ? "" : dto.getOtherData());
        productionProductOutputMapper.insert(productionProductOutput);

        ProductWorkOrder productWorkOrder = productWorkOrderMapper.selectById(dto.getWorkOrderId());
        ProductOrder productOrder = productOrderMapper.selectById(productWorkOrder.getProductOrderId());
        BigDecimal qualifiedQty = reportQty.subtract(scrapQty);

        //合格数量=报工数量-报废数量
        BigDecimal productQty = productionProductOutput.getQuantity().subtract(productionProductOutput.getScrapQty());
        List<ProductProcessRouteItem> productProcessRouteItems = productProcessRouteItemMapper.selectList(
                Wrappers.<ProductProcessRouteItem>lambdaQuery()
                        .eq(ProductProcessRouteItem::getProductRouteId, productProcessRouteItem.getProductRouteId())
        );
        boolean isRouteLastProcess = productProcessRouteItem.getDragSort() == productProcessRouteItems.size();
        ReportStockRule reportStockRule = resolveReportStockRule(productProcessRouteItem, productProcess, productProcessRouteItems);

        String processCategory = null;
        String voltage = null;
        if (productQty.compareTo(BigDecimal.ZERO) > 0 && reportStockRule.isFinishedGoodsStockIn()) {
            processCategory = finishedProductStockDimensionResolver.resolveProcessCategory(productionProductMain.getId());
            voltage = finishedProductStockDimensionResolver.resolveVoltage(productionProductMain.getId());
        }
        Integer maxDragSort = productProcessRouteItems.stream()
                .map(ProductProcessRouteItem::getDragSort)
                .filter(Objects::nonNull)
                .max(Integer::compareTo)
                .orElse(null);

        if (productQty.compareTo(BigDecimal.ZERO) > 0) {
            /*新增质检*/
            if (productProcessRouteItem.getIsQuality()) {
                //对应的过程检或者出厂检
        boolean isRouteLastProcess = Objects.equals(productProcessRouteItem.getDragSort(), maxDragSort);
        ReportStockRule reportStockRule =
                resolveReportStockRule(productProcessRouteItem, productProcess, productProcessRouteItems);

        // 第九步：如果有合格数量，则根据是否质检决定走质检或直接入库
        if (qualifiedQty.compareTo(BigDecimal.ZERO) > 0) {
            if (Boolean.TRUE.equals(productProcessRouteItem.getIsQuality())) {
                Product product = productMapper.selectById(productModel.getProductId());
                if (product == null) {
                    throw new ServiceException("质检产品不存在");
                }

                int inspectType = 1;
                String process = productProcess.getName();
                if (reportStockRule.isFinishedGoodsStockIn()) {

                if (reportStockRule.finishedGoodsStockIn) {
                    inspectType = 2;
                    process = null;
                }
                Product product = productMapper.selectById(productModel.getProductId());

                QualityInspect qualityInspect = new QualityInspect();
                qualityInspect.setProductId(product.getId());
                qualityInspect.setProductName(product.getProductName());
                qualityInspect.setModel(productModel.getModel());
                qualityInspect.setUnit(productModel.getUnit());
                qualityInspect.setQuantity(productionProductOutput.getQuantity());
                qualityInspect.setQuantity(reportQty);
                qualityInspect.setProcess(process);
                qualityInspect.setInspectState(0);
                qualityInspect.setInspectType(inspectType);
                qualityInspect.setDefectiveQuantity(productionProductOutput.getScrapQty());
                qualityInspect.setDefectiveQuantity(scrapQty);
                qualityInspect.setProductMainId(productionProductMain.getId());
                qualityInspect.setProductModelId(productModel.getId());
                qualityInspectMapper.insert(qualityInspect);
                List<QualityTestStandard> qualityTestStandard = qualityTestStandardMapper.getQualityTestStandardByProductId(product.getId(), inspectType, process);
                if (qualityTestStandard.size() > 0) {
                    qualityInspect.setTestStandardId(qualityTestStandard.get(0).getId());

                List<QualityTestStandard> qualityTestStandardList =
                        qualityTestStandardMapper.getQualityTestStandardByProductId(product.getId(), inspectType, process);

                if (CollectionUtils.isNotEmpty(qualityTestStandardList)) {
                    QualityTestStandard qualityTestStandard = qualityTestStandardList.get(0);
                    qualityInspect.setTestStandardId(qualityTestStandard.getId());
                    qualityInspectMapper.updateById(qualityInspect);

                    qualityTestStandardParamMapper.selectList(
                                    Wrappers.<QualityTestStandardParam>lambdaQuery()
                                            .eq(QualityTestStandardParam::getTestStandardId, qualityTestStandard.get(0).getId())
                            )
                            .forEach(qualityTestStandardParam -> {
                                QualityInspectParam param = new QualityInspectParam();
                                BeanUtils.copyProperties(qualityTestStandardParam, param);
                                param.setId(null);
                                param.setInspectId(qualityInspect.getId());
                                qualityInspectParamMapper.insert(param);
                            });
                            Wrappers.<QualityTestStandardParam>lambdaQuery()
                                    .eq(QualityTestStandardParam::getTestStandardId, qualityTestStandard.getId())
                    ).forEach(qualityTestStandardParam -> {
                        QualityInspectParam param = new QualityInspectParam();
                        BeanUtils.copyProperties(qualityTestStandardParam, param);
                        param.setId(null);
                        param.setInspectId(qualityInspect.getId());
                        qualityInspectParamMapper.insert(param);
                    });
                }
            } else {
                if (reportStockRule.shouldCreateStockIn()) {
                    if (reportStockRule.isFinishedGoodsStockIn()) {
                        stockUtils.addStock(productProcessRouteItem.getProductModelId(), productQty,
                                StockInQualifiedRecordTypeEnum.PRODUCTION_REPORT_STOCK_IN.getCode(), productionProductMain.getId(),
                                processCategory, voltage);
                    } else {
                        stockUtils.addStockNoReview(productProcessRouteItem.getProductModelId(), productQty,
                                StockInQualifiedRecordTypeEnum.PRODUCTION_REPORT_STOCK_IN.getCode(), productionProductMain.getId());
                    }
                }
                if (productionProductOutput.getScrapQty().compareTo(BigDecimal.ZERO) > 0) {
                    stockUtils.addUnStockNoReview(productProcessRouteItem.getProductModelId(), productionProductOutput.getScrapQty(),
                            StockInUnQualifiedRecordTypeEnum.QUALITYINSPECT_UNSTOCK_IN.getCode(), productionProductMain.getId());
            } else if (reportStockRule.createStockIn) {
                //成品入库需要电压，工序类别（铜，银）
                if (reportStockRule.finishedGoodsStockIn) {
                    String processCategory =
                            finishedProductStockDimensionResolver.resolveProcessCategory(productionProductMain.getId());
                    String voltage =
                            finishedProductStockDimensionResolver.resolveVoltage(productionProductMain.getId());

                    stockUtils.addStock(
                            productProcessRouteItem.getProductModelId(),
                            qualifiedQty,
                            StockInQualifiedRecordTypeEnum.PRODUCTION_REPORT_STOCK_IN.getCode(),
                            productionProductMain.getId(),
                            processCategory,
                            voltage
                    );
                } else {
                    stockUtils.addStockNoReview(
                            productProcessRouteItem.getProductModelId(),
                            qualifiedQty,
                            StockInQualifiedRecordTypeEnum.PRODUCTION_REPORT_STOCK_IN.getCode(),
                            productionProductMain.getId()
                    );
                }
            }

            productWorkOrder.setCompleteQuantity(productWorkOrder.getCompleteQuantity().add(productQty));
            // 第十步：更新工单、订单完成进度和计件核算数据
            BigDecimal workOrderCompleteQuantity =
                    productWorkOrder.getCompleteQuantity() == null ? BigDecimal.ZERO : productWorkOrder.getCompleteQuantity();
            productWorkOrder.setCompleteQuantity(workOrderCompleteQuantity.add(qualifiedQty));

            if (ObjectUtils.isNull(productWorkOrder.getActualStartTime())) {
                productWorkOrder.setActualStartTime(LocalDate.now());
            }
            if (productWorkOrder.getCompleteQuantity().compareTo(productWorkOrder.getPlanQuantity()) == 0) {
            if (productWorkOrder.getPlanQuantity() != null
                    && productWorkOrder.getCompleteQuantity().compareTo(productWorkOrder.getPlanQuantity()) >= 0) {
                productWorkOrder.setActualEndTime(LocalDate.now());
            }
            productWorkOrderMapper.updateById(productWorkOrder);
@@ -334,98 +472,139 @@
            if (ObjectUtils.isNull(productOrder.getStartTime())) {
                productOrder.setStartTime(LocalDateTime.now());
            }

            if (isRouteLastProcess) {
                productOrder.setCompleteQuantity(productOrder.getCompleteQuantity().add(productQty));
                if (productOrder.getCompleteQuantity().compareTo(productOrder.getQuantity()) == 0) {
                BigDecimal orderCompleteQuantity =
                        productOrder.getCompleteQuantity() == null ? BigDecimal.ZERO : productOrder.getCompleteQuantity();
                productOrder.setCompleteQuantity(orderCompleteQuantity.add(qualifiedQty));

                if (productOrder.getQuantity() != null
                        && productOrder.getCompleteQuantity().compareTo(productOrder.getQuantity()) >= 0) {
                    productOrder.setEndTime(LocalDateTime.now());
                }
            }
            productOrderMapper.updateById(productOrder);

            SalesLedgerProductionAccounting salesLedgerProductionAccounting = SalesLedgerProductionAccounting.builder()
                    .productMainId(productionProductMain.getId())
                    .schedulingUserId(userId)
                    .schedulingUserName(userName)
                    .finishedNum(productQty)
                    .workHours(productProcess.getSalaryQuota())
                    .process(productProcess.getName())
                    .schedulingDate(LocalDate.now())
                    .tenantId(dto.getTenantId())
                    .build();
            SalesLedgerProductionAccounting salesLedgerProductionAccounting =
                    SalesLedgerProductionAccounting.builder()
                            .productMainId(productionProductMain.getId())
                            .schedulingUserId(userId)
                            .schedulingUserName(userName)
                            .finishedNum(qualifiedQty)
                            .workHours(productProcess.getSalaryQuota())
                            .process(productProcess.getName())
                            .schedulingDate(LocalDate.now())
                            .tenantId(dto.getTenantId())
                            .build();
            salesLedgerProductionAccountingMapper.insert(salesLedgerProductionAccounting);
        }

        // 第十一步：统一处理报废数量入不合格库存，避免在主流程中重复入库
        handleScrapStock(productModel.getId(), scrapQty, isRouteLastProcess, productionProductMain.getId());

        return true;
    }

    /**
     * 判断当前报工是否需要入库，以及是否按成品入库处理。
     */
    // 判断当前报工是否需要入库，以及是否按成品入库处理
    private ReportStockRule resolveReportStockRule(ProductProcessRouteItem currentRouteItem,
                                                   ProductProcess currentProcess,
                                                   List<ProductProcessRouteItem> routeItems) {
        boolean isRouteLastProcess = currentRouteItem.getDragSort() != null
                && CollectionUtils.isNotEmpty(routeItems)
                && currentRouteItem.getDragSort().equals(routeItems.size());
        String currentProcessName = normalizeProcessName(currentProcess == null ? null : currentProcess.getName());
        Integer maxDragSort = CollectionUtils.isEmpty(routeItems)
                ? null
                : routeItems.stream()
                .map(ProductProcessRouteItem::getDragSort)
                .filter(Objects::nonNull)
                .max(Integer::compareTo)
                .orElse(null);

        boolean isRouteLastProcess = Objects.equals(currentRouteItem.getDragSort(), maxDragSort);
        String currentProcessName = currentProcess == null || currentProcess.getName() == null
                ? ""
                : currentProcess.getName().trim();

        if (PROCESS_VOLTAGE_SORT.equals(currentProcessName)) {
            return new ReportStockRule(false, false);
        }

        Map<Long, String> processNameMap = loadRouteProcessNameMap(routeItems);
        boolean hasVoltageSort = containsProcess(routeItems, processNameMap, PROCESS_VOLTAGE_SORT);
        boolean hasOpticalInspection = containsProcess(routeItems, processNameMap, PROCESS_OPTICAL_INSPECTION);
        boolean hasPackaging = containsProcess(routeItems, processNameMap, PROCESS_PACKAGING);
        Set<Long> processIds = CollectionUtils.isEmpty(routeItems)
                ? Collections.emptySet()
                : routeItems.stream()
                .map(ProductProcessRouteItem::getProcessId)
                .filter(Objects::nonNull)
                .collect(Collectors.toSet());

        Map<Long, String> processNameMap = new HashMap<>();
        if (CollectionUtils.isNotEmpty(processIds)) {
            processNameMap = productProcessMapper.selectBatchIds(processIds)
                    .stream()
                    .collect(Collectors.toMap(
                            ProductProcess::getId,
                            process -> process.getName() == null ? "" : process.getName().trim(),
                            (a, b) -> a
                    ));
        }

        Set<String> routeProcessNames = CollectionUtils.isEmpty(routeItems)
                ? Collections.emptySet()
                : routeItems.stream()
                .map(ProductProcessRouteItem::getProcessId)
                .map(processNameMap::get)
                .filter(StringUtils::isNotBlank)
                .collect(Collectors.toSet());

        boolean hasVoltageSort = routeProcessNames.contains(PROCESS_VOLTAGE_SORT);
        boolean hasOpticalInspection = routeProcessNames.contains(PROCESS_OPTICAL_INSPECTION);
        boolean hasPackaging = routeProcessNames.contains(PROCESS_PACKAGING);

        if (hasPackaging && PROCESS_PACKAGING.equals(currentProcessName)) {
            return new ReportStockRule(true, true);
        }

        if (hasPackaging && PROCESS_OPTICAL_INSPECTION.equals(currentProcessName)) {
            return new ReportStockRule(false, false);
        }
        if (!hasPackaging && hasVoltageSort && hasOpticalInspection && PROCESS_OPTICAL_INSPECTION.equals(currentProcessName)) {

        if (!hasPackaging
                && hasVoltageSort
                && hasOpticalInspection
                && PROCESS_OPTICAL_INSPECTION.equals(currentProcessName)) {
            return new ReportStockRule(true, true);
        }

        return new ReportStockRule(true, isRouteLastProcess);
    }

    /**
     * 批量加载工艺路线中的工序名称。
     */
    private Map<Long, String> loadRouteProcessNameMap(List<ProductProcessRouteItem> routeItems) {
        if (CollectionUtils.isEmpty(routeItems)) {
            return Collections.emptyMap();
    // 统一处理报废数量入不合格库存，避免重复入库
    private void handleScrapStock(Long productModelId,
                                  BigDecimal scrapQty,
                                  boolean isRouteLastProcess,
                                  Long productMainId) {
        if (productModelId == null) {
            throw new ServiceException("报废产品型号不能为空");
        }
        Set<Long> processIds = routeItems.stream()
                .map(ProductProcessRouteItem::getProcessId)
                .filter(Objects::nonNull)
                .collect(Collectors.toSet());
        if (processIds.isEmpty()) {
            return Collections.emptyMap();

        if (scrapQty == null || scrapQty.compareTo(BigDecimal.ZERO) <= 0) {
            return;
        }
        return productProcessMapper.selectBatchIds(processIds).stream()
                .collect(Collectors.toMap(ProductProcess::getId, process -> normalizeProcessName(process.getName())));

        if (isRouteLastProcess) {
            stockUtils.addUnStock(
                    productModelId,
                    scrapQty,
                    StockInUnQualifiedRecordTypeEnum.PRODUCTION_SCRAP.getCode(),
                    productMainId
            );
        } else {
            stockUtils.addUnStockNoReview(
                    productModelId,
                    scrapQty,
                    StockInUnQualifiedRecordTypeEnum.PRODUCTION_SCRAP.getCode(),
                    productMainId
            );
        }
    }

    /**
     * 判断工艺路线中是否包含指定工序。
     */
    private boolean containsProcess(List<ProductProcessRouteItem> routeItems, Map<Long, String> processNameMap, String processName) {
        return routeItems.stream()
                .map(ProductProcessRouteItem::getProcessId)
                .map(processNameMap::get)
                .anyMatch(processName::equals);
    }

    /**
     * 统一工序名称格式，避免规则匹配时受空白字符影响。
     */
    private String normalizeProcessName(String processName) {
        return processName == null ? "" : processName.trim();
    }

    /**
     * 单次报工对应的入库规则。
     */
    // 单次报工对应的入库规则
    private static final class ReportStockRule {
        private final boolean createStockIn;
        private final boolean finishedGoodsStockIn;
@@ -434,27 +613,20 @@
            this.createStockIn = createStockIn;
            this.finishedGoodsStockIn = finishedGoodsStockIn;
        }

        private boolean shouldCreateStockIn() {
            return createStockIn;
        }

        private boolean isFinishedGoodsStockIn() {
            return finishedGoodsStockIn;
        }
    }

    @Override
    public Boolean removeProductMain(Long id) {
        // 删除报工前先检查是否已经完成不合格处理
        List<QualityInspect> qualityInspects = qualityInspectMapper.selectList(
                Wrappers.<QualityInspect>lambdaQuery().eq(QualityInspect::getProductMainId, id)
        );
        if (qualityInspects.size() > 0) {
        if (!qualityInspects.isEmpty()) {
            List<QualityUnqualified> qualityUnqualifieds = qualityUnqualifiedMapper.selectList(
                    Wrappers.<QualityUnqualified>lambdaQuery()
                            .in(QualityUnqualified::getInspectId, qualityInspects.stream().map(QualityInspect::getId).collect(Collectors.toList()))
            );
            if (qualityUnqualifieds.size() > 0 && qualityUnqualifieds.get(0).getInspectState() == 1) {
            if (!qualityUnqualifieds.isEmpty() && qualityUnqualifieds.get(0).getInspectState() == 1) {
                throw new ServiceException("该报工已完成不合格处理，不能删除");
            }
        }

 src/main/java/com/ruoyi/quality/mapper/QualityUnqualifiedMapper.java

@@ -3,7 +3,6 @@
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.quality.pojo.QualityInspect;
import com.ruoyi.quality.pojo.QualityUnqualified;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
@@ -13,22 +12,21 @@
@Mapper
public interface QualityUnqualifiedMapper extends BaseMapper<QualityUnqualified> {


    IPage<QualityUnqualified> qualityUnqualifiedListPage(Page page, @Param("qualityUnqualified") QualityUnqualified qualityUnqualified);

    List<QualityUnqualified> qualityUnqualifiedExport(@Param("qualityUnqualified") QualityUnqualified qualityUnqualified);

    QualityUnqualified getUnqualified(@Param("id") Integer id);

    //手动新增不合格的时候,根据产品名称和规格型号查出对应的规格型号id
    // 手动新增不合格时，根据产品名称和规格型号查询对应的产品型号 ID
    Long getModelId(@Param("productName") String productName, @Param("model") String model);
    
    //根据工序名称列表查询被隔离的不合格记录
    List<QualityUnqualified> selectUnqualifiedByProcessNames(@Param("processNames") List<String> processNames);

    // 根据生产订单和前序工序名称列表查询未解除隔离的不合格记录
    List<QualityUnqualified> selectUnqualifiedByProductOrderAndProcessNames(@Param("productOrderId") Long productOrderId,
                                                                            @Param("processNames") List<String> processNames);

    /**
     * 查询不合格记录的生产订单信息
     * @return
     * 查询不合格记录关联的生产订单信息。
     */
    List<QualityUnqualified> selectUnqualifiedWithProductionOrder();
}
}

 src/main/java/com/ruoyi/sales/service/ISalesLedgerService.java

@@ -38,7 +38,7 @@

    List<MonthlyAmountDto> getAmountHalfYear(Integer type);

    IPage<SalesLedger> selectSalesLedgerListPage(Page page, SalesLedgerDto salesLedgerDto);
    IPage<SalesLedgerDto> selectSalesLedgerListPage(Page page, SalesLedgerDto salesLedgerDto);

    AjaxResult importData(MultipartFile file);


 src/main/resources/mapper/production/ProductionProductMainMapper.xml

@@ -154,10 +154,13 @@

    <select id="checkPreviousProcessReported" resultType="java.lang.Boolean">
        SELECT CASE WHEN COUNT(*) > 0 THEN TRUE ELSE FALSE END
        FROM production_product_main ppm
        JOIN product_work_order pwo ON ppm.work_order_id = pwo.id
        JOIN product_process_route_item ppri ON pwo.product_process_route_item_id = ppri.id
        WHERE ppri.product_route_id = #{productRouteId}
        AND ppri.drag_sort = #{currentDragSort} - 1
        FROM product_work_order current_pwo
        JOIN product_process_route_item current_ppri ON current_pwo.product_process_route_item_id = current_ppri.id
        JOIN product_work_order previous_pwo ON previous_pwo.product_order_id = current_pwo.product_order_id
        JOIN product_process_route_item previous_ppri ON previous_pwo.product_process_route_item_id = previous_ppri.id
        JOIN production_product_main ppm ON ppm.work_order_id = previous_pwo.id
        WHERE current_pwo.id = #{workOrderId}
        AND previous_ppri.product_route_id = current_ppri.product_route_id
        AND previous_ppri.drag_sort = #{currentDragSort} - 1
    </select>
</mapper>

 src/main/resources/mapper/quality/QualityUnqualifiedMapper.xml

@@ -40,9 +40,10 @@
            AND check_time &gt;= DATE_FORMAT(#{qualityUnqualified.entryDateStart},'%Y-%m-%d')
        </if>
        <if test="qualityUnqualified.entryDateEnd != null and qualityUnqualified.entryDateEnd != '' ">
            AND  check_time &lt;= DATE_FORMAT(#{qualityUnqualified.entryDateEnd},'%Y-%m-%d')
            AND check_time &lt;= DATE_FORMAT(#{qualityUnqualified.entryDateEnd},'%Y-%m-%d')
        </if>
    </select>

    <select id="qualityUnqualifiedExport" resultType="com.ruoyi.quality.pojo.QualityUnqualified">
        SELECT
        qu.*,
@@ -61,6 +62,7 @@
            AND product_name = #{qualityUnqualified.productName}
        </if>
    </select>

    <select id="getUnqualified" resultType="com.ruoyi.quality.pojo.QualityUnqualified">
        SELECT
            qu.id,
@@ -84,27 +86,32 @@
                ELSE false
                END AS method
        FROM quality_unqualified qu
                 LEFT JOIN product_model pm ON qu.model = pm.model AND pm.product_id = qu.product_id
                 LEFT JOIN quality_inspect qi ON qu.inspect_id = qi.id
        LEFT JOIN product_model pm ON qu.model = pm.model AND pm.product_id = qu.product_id
        LEFT JOIN quality_inspect qi ON qu.inspect_id = qi.id
        where
            1=1
        and qu.id = #{id}
            and qu.id = #{id}
    </select>

    <select id="getModelId" resultType="java.lang.Long">
        select pm.id
        from product_model pm
        left join product p on pm.product_id=p.id
        where pm.model=#{model}
          and  p.product_name=#{productName}
        left join product p on pm.product_id = p.id
        where pm.model = #{model}
          and p.product_name = #{productName}
    </select>
    <select id="selectUnqualifiedByProcessNames" resultType="com.ruoyi.quality.pojo.QualityUnqualified">

    <select id="selectUnqualifiedByProductOrderAndProcessNames" resultType="com.ruoyi.quality.pojo.QualityUnqualified">
        SELECT DISTINCT qu.*
        FROM quality_unqualified qu
        JOIN quality_inspect qi ON qu.inspect_id = qi.id
        JOIN production_product_main ppm ON qi.product_main_id = ppm.id
        JOIN product_work_order pwo ON ppm.work_order_id = pwo.id
        WHERE qi.process IN
        <foreach collection="processNames" item="processName" open="(" separator="," close=")">
            #{processName}
        </foreach>
        AND pwo.product_order_id = #{productOrderId}
        AND qu.deal_result = '隔离'
        AND qu.quarantine_lifted = false
    </select>
@@ -121,4 +128,4 @@
        WHERE po.id IS NOT NULL
        GROUP BY po.id
    </select>
</mapper>
</mapper>