feat(生产报工): 报工完成按四类区分计数零件并分流质检入库

liu

4 天以前 a5f66f55b2c176e8504b8a077e00acfe2dfb4b00

feat(生产报工): 报工完成按四类区分计数零件并分流质检入库

- 报工接收合格/轻微返工/严重返工/报废四类数量，校验合计大于0，报工结果类型由数量派生
- 合格数进入质检单（末道非质检工序直接生成入库申请），报废数进入不合格入库
- 返工数生成不合格品待处理单，接入不合格品管理的报工处理闭环
- 删除报工时级联清理未处理的返工单，已处理则禁止删除
- 质检单、不合格单支持按报工单号筛选与回显
- 报工产品大类字段及历史数据回填
- 补充上线迁移脚本（合并版）与报工分类链路集成测试

Co-Authored-By: Claude <noreply@anthropic.com>

 doc/20260918_add_major_category_to_production_product_main.sql

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,36 @@
-- éœ€æ±‚：生产报工不区分零件，只按产品大类（小提琴/大提琴/贝斯）统计
-- 1) æŠ¥å·¥ä¸»è¡¨å¢žåŠ å¤§ç±»å­—段（幂等：列已存在时跳过，可重复执行）
SET @add_major_category_ddl := (
    SELECT IF(COUNT(*) = 0,
              'ALTER TABLE production_product_main ADD COLUMN major_category VARCHAR(32) NULL COMMENT ''报工产品大类：小提琴/大提琴/贝斯'' AFTER product_no',
              'SELECT ''major_category å·²å­˜åœ¨ï¼Œè·³è¿‡''')
    FROM information_schema.COLUMNS
    WHERE TABLE_SCHEMA = DATABASE()
      AND TABLE_NAME = 'production_product_main'
      AND COLUMN_NAME = 'major_category'
);
PREPARE add_major_category_stmt FROM @add_major_category_ddl;
EXECUTE add_major_category_stmt;
DEALLOCATE PREPARE add_major_category_stmt;

-- 2) åŽ†å²æ•°æ®å›žå¡«ï¼šä¼˜å…ˆç”¨äº§å‡ºäº§å“è‡ªèº«åç§°åšå…³é”®å­—归类（现场数据“贝斯”写作“贝司”），
--    æœªå‘½ä¸­å†å–产品树父节点名称兜底；产品树顶层为“成品/原料”等库存分类，不能直接作为大类。
--    ä»æ— æ³•å½’类的保持 NULL（如琴盒/琴套/中提琴）。
UPDATE production_product_main ppm
    JOIN production_product_output ppo ON ppo.production_product_main_id = ppm.id
    JOIN product_model pm ON pm.id = ppo.product_model_id
    JOIN product p ON p.id = pm.product_id
    LEFT JOIN product pp ON pp.id = p.parent_id
SET ppm.major_category = CASE
        -- ç´ç›’/琴套等配件带“贝司”等字样（如 SA贝司套），先排除避免误归大类
        WHEN p.product_name LIKE '%琴盒%' OR p.product_name LIKE '%琴套%' OR p.product_name LIKE '%弓盒%' THEN NULL
        WHEN p.product_name LIKE '%小提琴%'
          OR COALESCE(pp.product_name, '') LIKE '%小提琴%' THEN '小提琴'
        WHEN p.product_name LIKE '%大提琴%'
          OR COALESCE(pp.product_name, '') LIKE '%大提琴%' THEN '大提琴'
        WHEN p.product_name LIKE '%贝斯%' OR p.product_name LIKE '%贝司%'
          OR COALESCE(pp.product_name, '') LIKE '%贝斯%'
          OR COALESCE(pp.product_name, '') LIKE '%贝司%' THEN '贝斯'
        ELSE NULL
    END
WHERE ppm.major_category IS NULL;

 doc/20260918_add_rework_qty_for_report_distinguish.sql

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,11 @@
-- ç”Ÿäº§æŠ¥å·¥å®ŒæˆåŽå¯¹è®¡æ•°çš„零件做区分（合格/轻微返工/严重返工/报废），进入质检入库
-- 1. æŠ¥å·¥äº§å‡ºè¡¨å¢žåŠ è¿”工分类数量列
ALTER TABLE production_product_output
    ADD COLUMN rework_minor_qty DECIMAL(18, 4) NOT NULL DEFAULT 0 COMMENT '轻微返工数量' AFTER scrap_qty,
    ADD COLUMN rework_major_qty DECIMAL(18, 4) NOT NULL DEFAULT 0 COMMENT '严重返工数量' AFTER rework_minor_qty;

-- 2. ä¸åˆæ ¼å“è¡¨å¢žåŠ æ¥æºæŠ¥å·¥å•å…³è”列（报工分类直接产生的返工待处理单）
ALTER TABLE quality_unqualified
    ADD COLUMN product_main_id BIGINT DEFAULT NULL COMMENT '关联生产报工主表id' AFTER inspect_id;

CREATE INDEX idx_quality_unqualified_product_main_id ON quality_unqualified (product_main_id);

 doc/20260918_release_report_distinguish_major_category.sql

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,69 @@
-- =============================================================================
-- ä¸Šçº¿è¿ç§»è„šæœ¬ï¼ˆåˆå¹¶ç‰ˆï¼‰  æ—¥æœŸï¼š2026-09-18
-- ç”¨é€”：生产报工「计数零件分类区分 â†’ åˆ†ç±»è¿›å…¥è´¨æ£€å…¥åº“」+「报工产品大类」
-- ç›®æ ‡åº“：MySQL 8.x（在 8.4.7 ä¸ŠéªŒè¯é€šè¿‡ï¼‰
--
-- æ‰§è¡Œå‰çŠ¶æ€æ£€æŸ¥ï¼ˆå…ˆè·‘这一段，看清楚哪些还没执行）：
--   SELECT TABLE_NAME, COLUMN_NAME FROM information_schema.COLUMNS
--   WHERE TABLE_SCHEMA = DATABASE()
--     AND ((TABLE_NAME = 'production_product_output' AND COLUMN_NAME IN ('rework_minor_qty','rework_major_qty'))
--       OR (TABLE_NAME = 'quality_unqualified'      AND COLUMN_NAME = 'product_main_id')
--       OR (TABLE_NAME = 'production_product_main'  AND COLUMN_NAME = 'major_category'));
--   è‹¥æŸ¥è¯¢ç»“果已经包含某列，对应语句就跳过，不要重复执行（MySQL 8 çš„ ADD COLUMN ä¸æ”¯æŒ IF NOT EXISTS）。
--
-- å„环境执行情况：dev（192.168.197.128 / product-inventory-management-tjxm）已执行；
--                æµ‹è¯•ã€ç”Ÿäº§çŽ¯å¢ƒéœ€æ‰§è¡Œæœ¬è„šæœ¬ã€‚
-- æ‰§è¡Œé¡ºåºï¼šâ‘  â†’ â‘¡ â†’ â‘¢ï¼Œå…¨éƒ¨æ‰§è¡Œå®Œå†å‘布新版本后端代码，否则接口会因缺列报错。
-- =============================================================================

-- -----------------------------------------------------------------------------
-- â‘  æŠ¥å·¥äº§å‡ºè¡¨ï¼šå¢žåŠ è¿”工分类数量列（与合格数、报废数一起构成"计数零件的四类区分"）
-- -----------------------------------------------------------------------------
ALTER TABLE production_product_output
    ADD COLUMN rework_minor_qty DECIMAL(18, 4) NOT NULL DEFAULT 0 COMMENT '轻微返工数量' AFTER scrap_qty,
    ADD COLUMN rework_major_qty DECIMAL(18, 4) NOT NULL DEFAULT 0 COMMENT '严重返工数量' AFTER rework_minor_qty;

-- -----------------------------------------------------------------------------
-- â‘¡ ä¸åˆæ ¼å“è¡¨ï¼šå¢žåŠ æ¥æºæŠ¥å·¥å•å…³è”列（报工区分出的返工件直接生成待处理单，靠此列回溯报工单）
-- -----------------------------------------------------------------------------
ALTER TABLE quality_unqualified
    ADD COLUMN product_main_id BIGINT DEFAULT NULL COMMENT '关联生产报工主表id' AFTER inspect_id;

CREATE INDEX idx_quality_unqualified_product_main_id ON quality_unqualified (product_main_id);

-- -----------------------------------------------------------------------------
-- â‘¢ æŠ¥å·¥ä¸»è¡¨ï¼šå¢žåŠ äº§å“å¤§ç±»åˆ— + åŽ†å²æ•°æ®å›žå¡«ï¼ˆæŠ¥å·¥ä¸åŒºåˆ†é›¶ä»¶ï¼ŒåªæŒ‰å°æç´/大提琴/贝斯统计）
-- -----------------------------------------------------------------------------
ALTER TABLE production_product_main
    ADD COLUMN major_category VARCHAR(32) NULL COMMENT '报工产品大类：小提琴/大提琴/贝斯' AFTER product_no;

-- åŽ†å²æ•°æ®å›žå¡«ï¼šä¼˜å…ˆç”¨äº§å‡ºäº§å“è‡ªèº«åç§°åšå…³é”®å­—归类（现场数据"贝斯"写作"贝司"），
-- æœªå‘½ä¸­å†å–产品树父节点名称兜底；琴盒/琴套/弓盒等配件先排除避免误归大类；仍无法归类的保持 NULL。
UPDATE production_product_main ppm
    JOIN production_product_output ppo ON ppo.production_product_main_id = ppm.id
    JOIN product_model pm ON pm.id = ppo.product_model_id
    JOIN product p ON p.id = pm.product_id
    LEFT JOIN product pp ON pp.id = p.parent_id
SET ppm.major_category = CASE
        WHEN p.product_name LIKE '%琴盒%' OR p.product_name LIKE '%琴套%' OR p.product_name LIKE '%弓盒%' THEN NULL
        WHEN p.product_name LIKE '%小提琴%'
          OR COALESCE(pp.product_name, '') LIKE '%小提琴%' THEN '小提琴'
        WHEN p.product_name LIKE '%大提琴%'
          OR COALESCE(pp.product_name, '') LIKE '%大提琴%' THEN '大提琴'
        WHEN p.product_name LIKE '%贝斯%' OR p.product_name LIKE '%贝司%'
          OR COALESCE(pp.product_name, '') LIKE '%贝斯%'
          OR COALESCE(pp.product_name, '') LIKE '%贝司%' THEN '贝斯'
        ELSE NULL
    END
WHERE ppm.major_category IS NULL;

-- -----------------------------------------------------------------------------
-- æ‰§è¡ŒåŽæ ¡éªŒï¼ˆåº”返回 4 åˆ— / 1 ç´¢å¼• / å¤§ç±»åˆ†å¸ƒï¼‰
-- -----------------------------------------------------------------------------
-- SELECT TABLE_NAME, COLUMN_NAME, COLUMN_TYPE, COLUMN_DEFAULT FROM information_schema.COLUMNS
-- WHERE TABLE_SCHEMA = DATABASE() AND COLUMN_NAME IN ('rework_minor_qty','rework_major_qty','product_main_id','major_category');
--
-- SHOW INDEX FROM quality_unqualified WHERE Key_name = 'idx_quality_unqualified_product_main_id';
--
-- SELECT major_category, COUNT(*) FROM production_product_main GROUP BY major_category;
-- =============================================================================

 src/main/java/com/ruoyi/production/bean/dto/ProductionProductMainDto.java

@@ -63,6 +63,12 @@
    @Schema(description = "报废数量")
    private BigDecimal scrapQty;

    @Schema(description = "轻微返工数量")
    private BigDecimal reworkMinorQty;

    @Schema(description = "严重返工数量")
    private BigDecimal reworkMajorQty;

    @Schema(description = "产品名称")
    private String productName;


 src/main/java/com/ruoyi/production/pojo/ProductionProductMain.java

@@ -21,6 +21,11 @@
    @Excel(name = "报工单号")
    private String productNo;

    @Schema(description = "报工产品大类：小提琴/大提琴/贝斯")
    @TableField("major_category")
    @Excel(name = "产品大类")
    private String majorCategory;

    @Schema(description = "报工人员id")
    private Long userId;


 src/main/java/com/ruoyi/production/pojo/ProductionProductOutput.java

@@ -33,6 +33,14 @@

    @Schema(description = "报废数量")
    private BigDecimal scrapQty;

    @Schema(description = "轻微返工数量")
    @TableField("rework_minor_qty")
    private BigDecimal reworkMinorQty;

    @Schema(description = "严重返工数量")
    @TableField("rework_major_qty")
    private BigDecimal reworkMajorQty;
    @Schema(description = "创建用户")
    @TableField(fill = FieldFill.INSERT)
    private Integer createUser;

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

@@ -22,7 +22,6 @@
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.bean.BeanUtils;
import com.ruoyi.procurementrecord.utils.StockUtils;
import com.ruoyi.production.bean.dto.ProductStructureDto;
import com.ruoyi.production.bean.dto.ProductionProductMainDto;
import com.ruoyi.production.enums.ProductOrderStatusEnum;
import com.ruoyi.production.mapper.*;
@@ -50,6 +49,7 @@
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
@@ -63,6 +63,16 @@
@AllArgsConstructor
@Transactional(rollbackFor = Exception.class)
public class ProductionProductMainServiceImpl extends ServiceImpl<ProductionProductMainMapper, ProductionProductMain> implements ProductionProductMainService {

    /**
     * ç”Ÿäº§æŠ¥å·¥å¤§ç±»ï¼šåªåŒºåˆ†å°æç´/大提琴/贝斯，不再区分零件。
     * key为入库规范值，value为产品名称匹配别名（现场数据贝斯写作“贝司”）。
     */
    private static final Map<String, List<String>> MAJOR_CATEGORY_PATTERNS = new LinkedHashMap<>() {{
        put("小提琴", List.of("小提琴"));
        put("大提琴", List.of("大提琴"));
        put("贝斯", List.of("贝斯", "贝司"));
    }};

    private final ProductionProductMainMapper productionProductMainMapper;
    private final SysUserMapper userMapper;
@@ -78,8 +88,6 @@
    private final ProductionAccountMapper productionAccountMapper;
    private final ProductionOperationTaskMapper productionOperationTaskMapper;
    private final ProductionOrderMapper productionOrderMapper;
    private final ProductionOrderBomMapper productionOrderBomMapper;
    private final ProductionBomStructureMapper productionBomStructureMapper;
    private final ProductionOrderRoutingOperationMapper productionOrderRoutingOperationMapper;
    private final ProductionOrderRoutingOperationParamMapper productionOrderRoutingOperationParamMapper;
    private final TechnologyRoutingOperationMapper technologyRoutingOperationMapper;
@@ -279,13 +287,31 @@
            throw new ServiceException("产品规格不存在");
        }

        // æŠ¥å·¥å®Œæˆæ—¶å¯¹è®¡æ•°çš„零件做区分：合格/轻微返工/严重返工/报废四类数量。
        BigDecimal qualifiedQty = defaultDecimal(dto.getQuantity());
        BigDecimal reworkMinorQty = defaultDecimal(dto.getReworkMinorQty());
        BigDecimal reworkMajorQty = defaultDecimal(dto.getReworkMajorQty());
        BigDecimal scrapQtyInput = defaultDecimal(dto.getScrapQty());
        if (qualifiedQty.compareTo(BigDecimal.ZERO) < 0
                || reworkMinorQty.compareTo(BigDecimal.ZERO) < 0
                || reworkMajorQty.compareTo(BigDecimal.ZERO) < 0
                || scrapQtyInput.compareTo(BigDecimal.ZERO) < 0) {
            throw new ServiceException("报工数量不能为负数");
        }
        if (qualifiedQty.add(reworkMinorQty).add(reworkMajorQty).add(scrapQtyInput).compareTo(BigDecimal.ZERO) <= 0) {
            throw new ServiceException("请按合格/轻微返工/严重返工/报废分类填写零件数量");
        }

        ProductionProductMain productionProductMain = new ProductionProductMain();
        productionProductMain.setProductNo(generateProductNo());
        productionProductMain.setMajorCategory(resolveMajorCategory(productModel));
        productionProductMain.setUserId(user == null ? dto.getUserId() : user.getUserId());
        productionProductMain.setUserName(user == null ? dto.getUserName() : user.getNickName());
        productionProductMain.setProductionOperationTaskId(taskId);
        productionProductMain.setStatus(0);
        productionProductMain.setReportType(dto.getReportType() == null ? 0 : dto.getReportType());
        productionProductMain.setReportType(dto.getReportType() != null
                ? dto.getReportType()
                : deriveReportType(qualifiedQty, reworkMinorQty, reworkMajorQty, scrapQtyInput));
        productionProductMain.setAuditStatus(dto.getAuditStatus() == null ? 0 : dto.getAuditStatus());
        productionProductMain.setAuditRemark(dto.getAuditRemark());
        productionProductMain.setWorkHour(dto.getWorkHour());
@@ -293,30 +319,21 @@
        syncOperationParamInputValue(dto, routingOperation.getId(), productionProductMain.getId());
        createReportApprovalInstance(productionProductMain);

        List<ProductStructureDto> productStructureDtos = resolveInputStructures(
                productionOrder.getId(), routingOperation, productModel.getId());
       // å¦‚果没有bom子节点了，那么投入就是他本身
        if (productStructureDtos.isEmpty()) {
            ProductStructureDto fallbackInput = new ProductStructureDto();
            fallbackInput.setProductModelId(productModel.getId());
            fallbackInput.setUnitQuantity(BigDecimal.ONE);
            productStructureDtos.add(fallbackInput);
        }
        for (ProductStructureDto item : productStructureDtos) {
            // å½“前实现按工序成品直接作为投入，后续若接入领料记录可在这里替换来源。
            ProductionProductInput productionProductInput = new ProductionProductInput();
            productionProductInput.setProductionProductMainId(productionProductMain.getId());
            productionProductInput.setProductModelId(item.getProductModelId());
            productionProductInput.setInputQuantity(item.getUnitQuantity().multiply(defaultDecimal(dto.getQuantity())));
            productionProductInput.setQuantity(productionProductInput.getInputQuantity());
            productionProductInputMapper.insert(productionProductInput);
        }
        // éœ€æ±‚变更：生产报工不再按零件（BOM结构）拆分投入，投入即本次报工的产品本身，按大类统计。
        ProductionProductInput productionProductInput = new ProductionProductInput();
        productionProductInput.setProductionProductMainId(productionProductMain.getId());
        productionProductInput.setProductModelId(productModel.getId());
        productionProductInput.setInputQuantity(qualifiedQty);
        productionProductInput.setQuantity(qualifiedQty);
        productionProductInputMapper.insert(productionProductInput);

        ProductionProductOutput productionProductOutput = new ProductionProductOutput();
        productionProductOutput.setProductionProductMainId(productionProductMain.getId());
        productionProductOutput.setProductModelId(productModel.getId());
        productionProductOutput.setQuantity(defaultDecimal(dto.getQuantity()));
        productionProductOutput.setScrapQty(defaultDecimal(dto.getScrapQty()));
        productionProductOutput.setReworkMinorQty(reworkMinorQty);
        productionProductOutput.setReworkMajorQty(reworkMajorQty);
        productionProductOutputMapper.insert(productionProductOutput);
        BigDecimal reportQty = defaultDecimal(productionProductOutput.getQuantity());
        BigDecimal scrapQty = defaultDecimal(productionProductOutput.getScrapQty());
@@ -428,7 +445,69 @@
                    productionProductMain.getId(),
                    qualifiedBatchNo);
        }
        // åŒºåˆ†å‡ºçš„返工零件生成不合格品待处理单，进入不合格品管理的报工处理闭环。
        createReworkUnqualifiedRecords(productionProductMain, productModel, reworkMinorQty, reworkMajorQty);
        return true;
    }

    private Integer deriveReportType(BigDecimal qualifiedQty, BigDecimal reworkMinorQty,
                                     BigDecimal reworkMajorQty, BigDecimal scrapQty) {
        if (qualifiedQty.compareTo(BigDecimal.ZERO) > 0) {
            return 0;
        }
        if (reworkMinorQty.compareTo(BigDecimal.ZERO) > 0) {
            return 1;
        }
        if (reworkMajorQty.compareTo(BigDecimal.ZERO) > 0) {
            return 2;
        }
        if (scrapQty.compareTo(BigDecimal.ZERO) > 0) {
            return 3;
        }
        return 0;
    }

    private void createReworkUnqualifiedRecords(ProductionProductMain productionProductMain,
                                                ProductModel productModel,
                                                BigDecimal reworkMinorQty,
                                                BigDecimal reworkMajorQty) {
        if (reworkMinorQty.compareTo(BigDecimal.ZERO) <= 0 && reworkMajorQty.compareTo(BigDecimal.ZERO) <= 0) {
            return;
        }
        Product product = productMapper.selectById(productModel.getProductId());
        if (product == null) {
            throw new ServiceException("产品不存在，无法生成报工返工待处理单");
        }
        if (reworkMinorQty.compareTo(BigDecimal.ZERO) > 0) {
            insertReworkUnqualified(productionProductMain, product, productModel, reworkMinorQty, 0);
        }
        if (reworkMajorQty.compareTo(BigDecimal.ZERO) > 0) {
            insertReworkUnqualified(productionProductMain, product, productModel, reworkMajorQty, 1);
        }
    }

    private void insertReworkUnqualified(ProductionProductMain productionProductMain,
                                         Product product,
                                         ProductModel productModel,
                                         BigDecimal quantity,
                                         int dealType) {
        QualityUnqualified qualityUnqualified = new QualityUnqualified();
        qualityUnqualified.setInspectType(1);
        qualityUnqualified.setInspectState(0);
        qualityUnqualified.setCheckTime(new Date());
        qualityUnqualified.setCheckName(productionProductMain.getUserName());
        qualityUnqualified.setProductId(product.getId());
        qualityUnqualified.setProductName(product.getProductName());
        qualityUnqualified.setModel(productModel.getModel());
        qualityUnqualified.setUnit(productModel.getUnit());
        qualityUnqualified.setQuantity(quantity);
        qualityUnqualified.setProductModelId(productModel.getId());
        qualityUnqualified.setProductMainId(productionProductMain.getId());
        qualityUnqualified.setDefectivePhenomena("生产报工【" + productionProductMain.getProductNo()
                + "】计数区分-" + (dealType == 0 ? "轻微返工" : "严重返工"));
        qualityUnqualified.setDealType(dealType);
        qualityUnqualified.setDealResult("报工");
        qualityUnqualifiedMapper.insert(qualityUnqualified);
    }

    private void createReportApprovalInstance(ProductionProductMain productionProductMain) {
@@ -468,6 +547,8 @@
        BigDecimal schedulingNum = task == null ? BigDecimal.ZERO : defaultDecimal(task.getPlanQuantity());
        BigDecimal finishedNum = output == null ? BigDecimal.ZERO : defaultDecimal(output.getQuantity());
        BigDecimal scrapQty = output == null ? BigDecimal.ZERO : defaultDecimal(output.getScrapQty());
        BigDecimal reworkMinorNum = output == null ? BigDecimal.ZERO : defaultDecimal(output.getReworkMinorQty());
        BigDecimal reworkMajorNum = output == null ? BigDecimal.ZERO : defaultDecimal(output.getReworkMajorQty());
        BigDecimal pendingNum = schedulingNum.subtract(finishedNum);
        if (pendingNum.compareTo(BigDecimal.ZERO) < 0) {
            pendingNum = BigDecimal.ZERO;
@@ -480,7 +561,9 @@
        fields.add(buildReportField("workOrderNo", "工单编号", "text", resolveWorkOrderNo(productionProductMain.getProductionOperationTaskId())));
        fields.add(buildReportField("schedulingNum", "排产数量", "number", schedulingNum));
        fields.add(buildReportField("pendingNum", "待生产数量", "number", pendingNum));
        fields.add(buildReportField("finishedNum", "生产合格数量", "number", finishedNum));
        fields.add(buildReportField("finishedNum", "合格数量", "number", finishedNum));
        fields.add(buildReportField("reworkMinorQty", "轻微返工数量", "number", reworkMinorNum));
        fields.add(buildReportField("reworkMajorQty", "严重返工数量", "number", reworkMajorNum));
        fields.add(buildReportField("scrapQty", "报废数量", "number", scrapQty));
        fields.add(buildReportField("reportType", "报工结果", "select", resolveReportTypeLabel(productionProductMain.getReportType())));
        fields.add(buildReportField("workHour", "工时", "number", productionProductMain.getWorkHour()));
@@ -497,6 +580,8 @@
        formPayload.put("pendingNum", pendingNum);
        formPayload.put("finishedNum", finishedNum);
        formPayload.put("scrapQty", scrapQty);
        formPayload.put("reworkMinorQty", reworkMinorNum);
        formPayload.put("reworkMajorQty", reworkMajorNum);
        formPayload.put("reportType", resolveReportTypeLabel(productionProductMain.getReportType()));
        formPayload.put("workHour", productionProductMain.getWorkHour());
        formPayload.put("auditStatus", resolveAuditStatusLabel(productionProductMain.getAuditStatus()));
@@ -655,62 +740,46 @@
        return target;
    }

    private List<ProductStructureDto> resolveInputStructures(Long productionOrderId,
                                                             ProductionOrderRoutingOperation routingOperation,
                                                             Long outputProductModelId) {
        if (productionOrderId == null || routingOperation == null || routingOperation.getTechnologyOperationId() == null) {
            return new ArrayList<>();
    /**
     * éœ€æ±‚：生产报工只区分产品大类（小提琴/大提琴/贝斯），不再区分零件。
     * ä»Žäº§å‡ºäº§å“è‡ªèº«åç§°å¼€å§‹æ²¿äº§å“æ ‘向上做关键字匹配，命中即取对应规范大类；未命中返回 null。
     * äº§å“æ ‘顶层为“成品/半成品/原料”等库存分类，不能直接当作大类，因此必须自底向上取第一个命中的层级。
     */
    private String resolveMajorCategory(ProductModel productModel) {
        if (productModel == null || productModel.getProductId() == null) {
            return null;
        }
        ProductionOrderBom orderBom = productionOrderBomMapper.selectOne(
                Wrappers.<ProductionOrderBom>lambdaQuery()
                        .eq(ProductionOrderBom::getProductionOrderId, productionOrderId)
                        .orderByDesc(ProductionOrderBom::getId)
                        .last("limit 1"));
        if (orderBom == null || orderBom.getId() == null) {
            return new ArrayList<>();
        }

        List<ProductionBomStructure> bomNodeList = productionBomStructureMapper.selectList(
                Wrappers.<ProductionBomStructure>lambdaQuery()
                        .eq(ProductionBomStructure::getProductionOrderBomId, orderBom.getId())
                        .orderByAsc(ProductionBomStructure::getId));
        if (bomNodeList.isEmpty()) {
            return new ArrayList<>();
        }

        Map<Long, ProductionBomStructure> nodeMap = bomNodeList.stream()
                .filter(item -> item != null && item.getId() != null)
                .collect(Collectors.toMap(ProductionBomStructure::getId, item -> item, (left, right) -> left));
        Long currentOutputModelId = routingOperation.getProductModelId() != null
                ? routingOperation.getProductModelId()
                : outputProductModelId;

        Map<Long, BigDecimal> unitQtyByProductModel = new LinkedHashMap<>();
        for (ProductionBomStructure node : bomNodeList) {
            if (node == null || node.getParentId() == null || node.getProductModelId() == null) {
                continue;
        Product product = productMapper.selectById(productModel.getProductId());
        Set<Long> visited = new LinkedHashSet<>();
        while (product != null && visited.add(product.getId())) {
            String category = matchMajorCategory(product.getProductName());
            if (category != null) {
                return category;
            }
            if (!Objects.equals(node.getTechnologyOperationId(), routingOperation.getTechnologyOperationId())) {
                continue;
            if (product.getParentId() == null || product.getParentId() == 0L) {
                break;
            }
            ProductionBomStructure parent = nodeMap.get(node.getParentId());
            if (parent == null || !Objects.equals(parent.getProductModelId(), currentOutputModelId)) {
                continue;
            }
            unitQtyByProductModel.merge(node.getProductModelId(), defaultDecimal(node.getUnitQuantity()), BigDecimal::add);
            product = productMapper.selectById(product.getParentId());
        }
        return null;
    }

        List<ProductStructureDto> result = new ArrayList<>();
        for (Map.Entry<Long, BigDecimal> entry : unitQtyByProductModel.entrySet()) {
            if (entry.getValue().compareTo(BigDecimal.ZERO) <= 0) {
                continue;
            }
            ProductStructureDto item = new ProductStructureDto();
            item.setProductModelId(entry.getKey());
            item.setUnitQuantity(entry.getValue());
            result.add(item);
    static String matchMajorCategory(String productName) {
        if (productName == null || productName.isEmpty()) {
            return null;
        }
        return result;
        // ç´ç›’/琴套等配件名称可能带“贝司”等字样（如 SA贝司套），排除后避免误归大类。
        if (productName.contains("琴盒") || productName.contains("琴套") || productName.contains("弓盒")) {
            return null;
        }
        for (Map.Entry<String, List<String>> entry : MAJOR_CATEGORY_PATTERNS.entrySet()) {
            for (String alias : entry.getValue()) {
                if (productName.contains(alias)) {
                    return entry.getKey();
                }
            }
        }
        return null;
    }

    private Boolean removeProductMainByProductionTask(ProductionProductMain productionProductMain) {
@@ -726,6 +795,13 @@
            if (qualityUnqualifieds.size() > 0 && qualityUnqualifieds.get(0).getInspectState() == 1) {
                throw new ServiceException("该条报工已经不合格处理了，不允许删除");
            }
        }
        // æŠ¥å·¥è®¡æ•°åŒºåˆ†ç›´æŽ¥äº§ç”Ÿçš„返工待处理单：已处理的不允许删除报工，未处理的随报工一并删除。
        List<QualityUnqualified> reworkUnqualifieds = qualityUnqualifiedMapper.selectList(
                Wrappers.<QualityUnqualified>lambdaQuery()
                        .eq(QualityUnqualified::getProductMainId, productionProductMain.getId()));
        if (reworkUnqualifieds.stream().anyMatch(q -> Integer.valueOf(1).equals(q.getInspectState()))) {
            throw new ServiceException("该条报工的返工零件已做不合格处理，不允许删除");
        }
        ProductionProductOutput productionProductOutput = productionProductOutputMapper.selectList(
                Wrappers.<ProductionProductOutput>lambdaQuery()
@@ -773,6 +849,8 @@
            }
        }

        qualityUnqualifiedMapper.delete(new LambdaQueryWrapper<QualityUnqualified>()
                .eq(QualityUnqualified::getProductMainId, productionProductMain.getId()));
        qualityInspectMapper.selectList(new LambdaQueryWrapper<QualityInspect>()
                .eq(QualityInspect::getProductMainId, productionProductMain.getId())).forEach(q -> {
            qualityInspectParamMapper.delete(new LambdaQueryWrapper<QualityInspectParam>()

 src/main/java/com/ruoyi/quality/dto/QualityInspectDto.java

@@ -29,4 +29,7 @@
    private String workOrderNo;
    private String purchaseContractNo;

    // æ¥æºæŠ¥å·¥å•å·ï¼ˆç”Ÿäº§æŠ¥å·¥è‡ªåŠ¨ç”Ÿæˆçš„检验单，查询/回显用）
    private String reportNo;

}

 src/main/java/com/ruoyi/quality/pojo/QualityUnqualified.java

@@ -154,6 +154,14 @@
    @Schema(description = "关联检测id")
    private Long inspectId;

    @Schema(description = "关联生产报工主表id（报工分类产生的返工/报废待处理单）")
    @TableField("product_main_id")
    private Long productMainId;

    @Schema(description = "来源报工单号（查询回显用）")
    @TableField(exist = false)
    private String reportNo;


    @Schema(description = "是否不合格处理自己新增")
    @TableField(exist = false)

 src/main/java/com/ruoyi/quality/service/impl/QualityUnqualifiedServiceImpl.java

@@ -63,7 +63,17 @@
    @Transactional(rollbackFor = Exception.class)
    public int deal(QualityUnqualified qualityUnqualified) {
        QualityUnqualified unqualified = qualityUnqualifiedMapper.selectById(qualityUnqualified.getId());
        QualityInspect qualityInspect = qualityInspectService.getById(unqualified.getInspectId());
        QualityInspect qualityInspect = unqualified.getInspectId() == null ? null
                : qualityInspectService.getById(unqualified.getInspectId());
        // æŠ¥å·¥è®¡æ•°åŒºåˆ†ç›´æŽ¥äº§ç”Ÿçš„返工待处理单（无检验单，仅有 productMainId），按报工处理闭环执行。
        if (qualityInspect == null && unqualified.getProductMainId() != null) {
            ProductionProductMain reportSourceMain = productionProductMainMapper.selectById(unqualified.getProductMainId());
            if ("报工".equals(qualityUnqualified.getDealResult())) {
                handleProductionReportResult(qualityUnqualified, unqualified, reportSourceMain);
            }
            qualityUnqualified.setInspectState(1);
            return qualityUnqualifiedMapper.updateById(qualityUnqualified);
        }
        String batchNo = qualityInspect == null ? null
                : resolveProductionBatchNo(qualityInspect.getProductMainId(), qualityInspect.getId(), qualityInspect.getProductModelId());
        if (ObjectUtils.isNotNull(qualityInspect) && qualityInspect.getInspectType() != 0) {

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

@@ -51,6 +51,8 @@
                   end as workOrderStatus,
               su.nick_name as nickName,
               ifnull(ppo.quantity, 0) as quantity,
               ifnull(ppo.rework_minor_qty, 0) as reworkMinorQty,
               ifnull(ppo.rework_major_qty, 0) as reworkMajorQty,
               ifnull(ppo.scrap_qty, 0) as scrapQty,
               p.product_name as productName,
               ifnull(p.standard_quantity, 0) as productStandardQuantity,
@@ -108,6 +110,9 @@
            <if test="c.process != null and c.process != ''">
                and poro.operation_name like concat('%', #{c.process}, '%')
            </if>
            <if test="c.majorCategory != null and c.majorCategory != ''">
                and ppm.major_category = #{c.majorCategory}
            </if>
            <if test="c.schedulingDate != null">
                and date(ppm.create_time) = #{c.schedulingDate}
            </if>

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

@@ -10,7 +10,8 @@
            </when>
            <otherwise>
                pot.work_order_no,
                po_sales.sales_contract_no
                po_sales.sales_contract_no,
                ppm.product_no as report_no
            </otherwise>
        </choose>
        FROM
@@ -60,6 +61,9 @@
        <if test="qualityInspect.workOrderNo != null and qualityInspect.workOrderNo != '' ">
            AND pot.work_order_no like concat('%',#{qualityInspect.workOrderNo},'%')
        </if>
        <if test="qualityInspect.reportNo != null and qualityInspect.reportNo != '' ">
            AND ppm.product_no like concat('%',#{qualityInspect.reportNo},'%')
        </if>
        <if test="qualityInspect.salesContractNo != null and qualityInspect.salesContractNo != '' ">
            AND po_sales.sales_contract_no like concat('%',#{qualityInspect.salesContractNo},'%')
        </if>

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

@@ -20,6 +20,9 @@
        qu.photo_urls,
        qu.deal_name,
        qu.deal_time,
        qu.inspect_id,
        qu.product_main_id,
        ppm.product_no as report_no,
        CASE
        WHEN qu.model = pm.id THEN pm.model
        ELSE qu.model
@@ -30,6 +33,7 @@
        END AS method
        FROM quality_unqualified qu
        LEFT JOIN product_model pm ON qu.model = pm.id
        LEFT JOIN production_product_main ppm ON qu.product_main_id = ppm.id
        <where>
            <if test="qualityUnqualified.inspectType != null ">
                AND inspect_type = #{qualityUnqualified.inspectType}
@@ -45,6 +49,9 @@
            </if>
            <if test="qualityUnqualified.entryDateEnd != null and qualityUnqualified.entryDateEnd != '' ">
                AND  check_time &lt;= DATE_FORMAT(#{qualityUnqualified.entryDateEnd},'%Y-%m-%d')
            </if>
            <if test="qualityUnqualified.reportNo != null and qualityUnqualified.reportNo != '' ">
                AND ppm.product_no like concat('%',#{qualityUnqualified.reportNo},'%')
            </if>
        </where>
        order by qu.create_time desc
@@ -84,6 +91,9 @@
            qu.photo_urls,
            qu.deal_name,
            qu.deal_time,
            qu.inspect_id,
            qu.product_main_id,
            ppm2.product_no as report_no,
            CASE
                WHEN qu.model = pm.id THEN pm.model
                ELSE qu.model
@@ -94,6 +104,7 @@
                END AS method
        FROM quality_unqualified qu
                 LEFT JOIN product_model pm ON qu.product_model_id = pm.id
                 LEFT JOIN production_product_main ppm2 ON qu.product_main_id = ppm2.id
        where
            1=1
        and qu.id = #{id}