同步已约检锅炉任务单数据

tz-module-pressure2/tz-module-pressure2-biz/src/main/java/cn/start/tz/module/pressure2/controller/admin/orderreport/OrderReportController.java

@@ -98,6 +98,12 @@ public class OrderReportController {
         orderReportService.generateBoilerOrderReport(acceptOrderId);
         return success(true);
     }
+    @GetMapping("/generateBoilerOrderReportByTaskOrder/{taskOrderId}")
+    @Operation(summary = "生成锅炉报告")
+    public CommonResult<Boolean> generateBoilerOrderReportByTaskOrder(@PathVariable String taskOrderId) {
+        orderReportService.generateBoilerOrderReportByTaskOrder(taskOrderId);
+        return success(true);
+    }
 
     @GetMapping("/generatePipeOrderReport/{acceptOrderId}")
     @Operation(summary = "生成管道报告")
@@ -105,6 +111,12 @@ public class OrderReportController {
         orderReportService.generatePipeOrderReport(acceptOrderId);
         return success(true);
     }
+  @GetMapping("/generatePipeOrderReportByTaskOrder/{taskOrderId}")
+    @Operation(summary = "生成管道报告")
+    public CommonResult<Boolean> generatePipeOrderReportByTaskOrder(@PathVariable String taskOrderId) {
+        orderReportService.generatePipeOrderReportByTaskOrder(taskOrderId);
+        return success(true);
+    }
 
     @PostMapping("/serviceFromSendEmail")
     @Operation(summary = "锅炉服务单/受理单/检验告知书邮箱发送")

tz-module-pressure2/tz-module-pressure2-biz/src/main/java/cn/start/tz/module/pressure2/framework/cron/SyncTaskBoilerEquipmentJob.java

@@ -4,18 +4,26 @@ import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.util.ObjectUtil;
 import cn.hutool.core.util.StrUtil;
 import cn.start.tz.framework.common.exception.ServiceException;
+import cn.start.tz.framework.common.pojo.CommonResult;
 import cn.start.tz.framework.mybatis.core.query.LambdaQueryWrapperX;
 import cn.start.tz.module.pressure.enums.RedisKeyEnums;
 import cn.start.tz.module.pressure.enums.TaskOrderStatusEnum;
 import cn.start.tz.module.pressure2.controller.admin.boilertaskorder.vo.BoilerTaskOrderItemVO;
+import cn.start.tz.module.pressure2.controller.admin.dynamictbins.vo.CreateInstantiateWithRuleVO;
 import cn.start.tz.module.pressure2.dal.dataobject.boilerconnectrecordreport.BoilerConnectRecordReportDO;
+import cn.start.tz.module.pressure2.dal.dataobject.boilerconnecttbservice.BoilerConnectTbServiceDO;
 import cn.start.tz.module.pressure2.dal.dataobject.boilertaskorder.BoilerTaskOrderDO;
 import cn.start.tz.module.pressure2.dal.dataobject.boilertaskorderitem.BoilerTaskOrderItemDO;
 import cn.start.tz.module.pressure2.dal.dataobject.boilertaskorderitemreport.BoilerTaskOrderItemReportDO;
 import cn.start.tz.module.pressure2.dal.dataobject.boilertaskorderuser.BoilerTaskOrderUserDO;
 import cn.start.tz.module.pressure2.dal.dataobject.dynamictb.DynamicTbDO;
+import cn.start.tz.module.pressure2.dal.dataobject.dynamictbins.DynamicTbInsDO;
 import cn.start.tz.module.pressure2.dal.dataobject.equipboiler.EquipBoilerDO;
+import cn.start.tz.module.pressure2.dal.dataobject.equipboilerschedulingitem.EquipBoilerSchedulingCheckDO;
+import cn.start.tz.module.pressure2.dal.dataobject.orderreport.OrderReportDO;
+import cn.start.tz.module.pressure2.dal.mysql.boilerconnecttbservice.BoilerConnectTbServiceMapper;
 import cn.start.tz.module.pressure2.dal.mysql.boilertaskorderuser.BoilerTaskOrderUserMapper;
+import cn.start.tz.module.pressure2.service.dynamictbins.DynamicTbInsService;
 import cn.start.tz.module.pressure2.service.boilerconnectrecordreport.BoilerConnectRecordReportService;
 import cn.start.tz.module.pressure2.service.boilertaskorder.BoilerTaskOrderService;
 import cn.start.tz.module.pressure2.service.boilertaskorderitem.BoilerTaskOrderItemService;
@@ -24,6 +32,7 @@ import cn.start.tz.module.pressure2.service.boilertaskorderuser.BoilerTaskOrderU
 import cn.start.tz.module.pressure2.service.common.RedisService;
 import cn.start.tz.module.pressure2.service.dynamictb.DynamicTbService;
 import cn.start.tz.module.pressure2.service.equipboiler.EquipBoilerService;
+import cn.start.tz.module.pressure2.service.orderreport.OrderReportService;
 import cn.start.tz.module.pressure2.service.synchronization.dto.CheckTaskDto;
 import cn.start.tz.module.pressure2.service.synchronization.dto.InformResponseVO;
 import cn.start.tz.module.pressure2.service.synchronization.dto.TaskEquipmentDto;
@@ -47,16 +56,17 @@ import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Component;
 
 import java.io.IOException;
+import java.text.SimpleDateFormat;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
+import java.time.ZoneId;
 import java.time.format.DateTimeFormatter;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
 
+
+
 /**
  * 同步任务单设备信息
  */
@@ -97,12 +107,21 @@ public class SyncTaskBoilerEquipmentJob {
     @Resource
     private EquipBoilerService equipBoilerService;
 
+    @Resource
+    private OrderReportService orderReportService;
+
     @Resource
     private ClientUnitApi clientUnitApi;
 
     @Resource
     private DeptApi deptApi;
 
+    @Resource
+    private BoilerConnectTbServiceMapper boilerConnectTbServiceMapper;
+
+    @Resource
+    private DynamicTbInsService dynamicTbInsService;
+
     // 注入自身代理对象
     @Lazy
     @Resource
@@ -307,6 +326,10 @@ public class SyncTaskBoilerEquipmentJob {
                 // 4. 处理用户关系（主检验员和检验员）
                 processTaskOrderUsers(taskOrder, taskOrderId);
 
+                // 5. 生成受理单
+                generateAcceptOrder(taskOrderId);
+
+
                 successCount++;
                 log.info("任务单处理成功，ID: {}, TASKNO: {}", taskOrder.getId(), taskOrder.getTaskNo());
 
@@ -410,6 +433,8 @@ public class SyncTaskBoilerEquipmentJob {
                 // 保存或更新任务单
 //                taskOrderService.updateById(boilerTaskOrderDO);
                 log.info("任务单已存在，更新数据，TASKNO: {}", taskOrder.getTaskNo());
+                InformResponseVO<TaskEquipmentDto> itemResponse = queryTaskEquipmentByTaskNo(taskOrder.getTaskNo());
+                log.info("根据任务单号 {} 获取设备信息", itemResponse);
                 return null;
             } else {
                 boilerTaskOrderDO = new BoilerTaskOrderDO();
@@ -923,6 +948,80 @@ public class SyncTaskBoilerEquipmentJob {
             // 不抛出异常，避免影响主流程
         }
     }
+    private final String TASK = "2";
+    private void generateAcceptOrder(String taskOrderId){
+        BoilerTaskOrderDO boilerTaskOrderDO = taskOrderService.getById(taskOrderId);
+        // 根据任务单ID查询所有设备及其报告，获取已关联的 projectId
+        List<BoilerTaskOrderItemDO> itemDOList = taskOrderItemService.list(
+                new LambdaQueryWrapperX<BoilerTaskOrderItemDO>()
+                        .eq(BoilerTaskOrderItemDO::getOrderId, taskOrderId));
+        if (CollUtil.isEmpty(itemDOList)) {
+            log.warn("任务单 {} 无设备信息，跳过受理单生成", taskOrderId);
+            return;
+        }
+        Set<String> itemIds = itemDOList.stream().map(BoilerTaskOrderItemDO::getId).collect(Collectors.toSet());
+        List<BoilerTaskOrderItemReportDO> reportDOList = taskOrderItemReportService.list(
+                new LambdaQueryWrapperX<BoilerTaskOrderItemReportDO>()
+                        .eq(BoilerTaskOrderItemReportDO::getReportType, 100)
+                        .in(BoilerTaskOrderItemReportDO::getOrderItemId, itemIds));
+        if (CollUtil.isEmpty(reportDOList)) {
+            log.warn("任务单 {} 无报告记录，跳过受理单生成", taskOrderId);
+            return;
+        }
+        // 收集所有已关联的 projectId（对应 BoilerConnectRecordReportDO.id）
+        Set<String> projectIds = reportDOList.stream()
+                .map(BoilerTaskOrderItemReportDO::getProjectId)
+                .filter(StrUtil::isNotBlank)
+                .collect(Collectors.toSet());
+        if (projectIds.isEmpty()) {
+            log.warn("任务单 {} 的报告记录中没有 projectId，跳过受理单生成", taskOrderId);
+            return;
+        }
+        // 找到主项目类型的受理单模板
+        List<BoilerConnectRecordReportDO> boilerConnectRecordReportDOS = boilerConnectRecordReportService.list(
+                new LambdaQueryWrapper<BoilerConnectRecordReportDO>()
+                        .in(BoilerConnectRecordReportDO::getId, projectIds)
+                        .eq(BoilerConnectRecordReportDO::getProjectType, "MAIN"));
+        if (CollUtil.isEmpty(boilerConnectRecordReportDOS)) {
+            log.warn("任务单 {} 未找到主项目类型的受理单模板", taskOrderId);
+            return;
+        }
+        // 一个受理单可能有多个主项目，每个主项目对应一个报告
+        for (BoilerConnectRecordReportDO boilerConnectRecordReportDO : boilerConnectRecordReportDOS) {
+            DynamicTbDO reportTemplateDO = dynamicTbService.getById(boilerConnectRecordReportDO.getAcceptOrderTemplateId());
+            if (reportTemplateDO == null) continue;
+
+            // 按 acceptOrderId + templateId 查重，避免重复生成
+            OrderReportDO exist = orderReportService.getOne(new LambdaQueryWrapperX<OrderReportDO>()
+                    .eq(OrderReportDO::getTaskOrderId, taskOrderId)
+                    .eq(OrderReportDO::getTemplateId, reportTemplateDO.getId())
+            );
+            OrderReportDO orderReportDO = exist == null ? new OrderReportDO() : exist;
+            orderReportDO.setTaskOrderId(taskOrderId);
+            orderReportDO.setOrderType(TASK);
+            orderReportDO.setTemplateId(reportTemplateDO.getId());
+
+            // 生成报表数据
+            CreateInstantiateWithRuleVO ruleVO = new CreateInstantiateWithRuleVO();
+            ruleVO.setTemplateId(reportTemplateDO.getId());
+            ruleVO.setRefId(taskOrderId);
+            ruleVO.setRefName(reportTemplateDO.getTbName());
+            ruleVO.setReportType(1);
+            com.alibaba.fastjson2.JSONObject params = new com.alibaba.fastjson2.JSONObject();
+            params.put("equipMainType", "boiler");
+            params.put("orderReportDOId", orderReportDO.getId());
+            ruleVO.setParams(params);
+
+            BoilerConnectTbServiceDO tbServiceDO = boilerConnectTbServiceMapper.selectOne(BoilerConnectTbServiceDO::getTbId, reportTemplateDO.getId());
+            if (tbServiceDO != null) {
+                ruleVO.setServiceName(tbServiceDO.getInitServiceName());
+                DynamicTbInsDO instantiateWithRule = dynamicTbInsService.createInstantiateWithRule(ruleVO);
+                orderReportDO.setInsId(instantiateWithRule.getId());
+            }
+
+            orderReportService.saveOrUpdate(orderReportDO);
+        }
+    }
 
     /**
      * 保存任务单用户关系
@@ -1080,35 +1179,43 @@ public class SyncTaskBoilerEquipmentJob {
                 log.warn("未找到任务单信息，TASKNO: {}", taskOrderItem.getTaskNo());
                 return;
             }
+            EquipBoilerDO equipBoiler = equipBoilerService.getOne(new LambdaQueryWrapper<EquipBoilerDO>().eq(EquipBoilerDO::getEquipCode, taskOrderItem.getRegisterNo()));
 
             // 解析检验项目，如 "全面检验,宏观检查,安全附件检验"
             List<String> checkItemNames = Arrays.stream(taskOrderItem.getCheckItem().split(","))
                     .map(String::trim)
                     .filter(StrUtil::isNotBlank)
-                    .map(this::convertCheckItemName) // 转换检验项目名称
+                    .map(name -> this.convertCheckItemName(name, equipBoiler)) // 转换检验项目名称
                     .collect(Collectors.toList());
 
-            if (checkItemNames.get(0).equals("内部检验")) {
+            if (checkItemNames.get(0).contains("内部检验") || checkItemNames.get(0).contains("内检")) {
                 taskOrder.setCheckType(100);
                 taskOrderService.updateById(taskOrder);
-            }else if (checkItemNames.get(0).equals("外部检验")) {
+            } else if (checkItemNames.get(0).contains("外部检验") || checkItemNames.get(0).contains("外检")) {
                 taskOrder.setCheckType(200);
                 taskOrderService.updateById(taskOrder);
-            }else {
+            } else {
                 taskOrder.setCheckType(300);
                 taskOrderService.updateById(taskOrder);
             }
 
             log.info("设备 {} 的检验项目（转换后）: {}", taskOrderItem.getRegisterNo(), checkItemNames);
 
-            // 根据检验项目查询对应的模版
-            List<BoilerConnectRecordReportDO> templates = boilerConnectRecordReportService.list(new LambdaQueryWrapperX<BoilerConnectRecordReportDO>().in(BoilerConnectRecordReportDO::getProjectName, checkItemNames));
+            // 根据检验项目查询对应的模版，按项目类型排序：MAIN-主项目, SUB-子项目, STANDALONE-独走项目
+            List<BoilerConnectRecordReportDO> templates = boilerConnectRecordReportService.list(
+                new LambdaQueryWrapperX<BoilerConnectRecordReportDO>()
+                    .in(BoilerConnectRecordReportDO::getProjectName, checkItemNames)
+                    .last("ORDER BY CASE PROJECT_TYPE WHEN 'MAIN' THEN 1 WHEN 'SUB' THEN 2 WHEN 'STANDALONE' THEN 3 ELSE 4 END")
+            );
 
             if (templates.isEmpty()) {
                 log.warn("设备 {} 未找到匹配的模版，检验项目: {}", taskOrderItem.getRegisterNo(), checkItemNames);
                 return;
             }
 
+            // 用于存储本次创建/更新的报告，便于子项目引用主项目
+            Map<String, BoilerTaskOrderItemReportDO> createdReportsMap = new HashMap<>();
+
             // 为每个模版创建或更新报告记录
             for (BoilerConnectRecordReportDO template : templates) {
                 // 尝试获取已存在的报告记录
@@ -1121,7 +1228,10 @@ public class SyncTaskBoilerEquipmentJob {
 
                 if (existingReport == null) {
                     // 不存在记录，创建新记录
-                    createTaskOrderItemReport(taskOrderItem, itemDO, taskOrderId, template);
+                    BoilerTaskOrderItemReportDO newReport = createTaskOrderItemReport(taskOrderItem, itemDO, taskOrderId, template, createdReportsMap);
+                    if (newReport != null) {
+                        createdReportsMap.put(template.getProjectType(), newReport);
+                    }
                     log.info("创建报告记录成功，设备: {}, 模版: {}", taskOrderItem.getRegisterNo(), template.getProjectName());
                 } else {
                     // 存在记录，进行更新
@@ -1154,18 +1264,22 @@ public class SyncTaskBoilerEquipmentJob {
         try {
             // 更新报告记录的基本信息（不覆盖已有状态）
             existingReport.setOrderId(taskOrderId);
-            existingReport.setTemplateId(template.getId());
+            existingReport.setTemplateId(template.getRecordTemplateId());
+            existingReport.setProjectId(template.getId());
             existingReport.setReportName(template.getProjectName());
             if (existingReport.getReportNo() == null || existingReport.getReportNo().isEmpty()) {
-                existingReport.setReportNo(generateReportNo()); // 如果没有报告编号则生成
+//                existingReport.setReportNo(generateReportNo()); // 如果没有报告编号则生成
+                BoilerTaskOrderDO taskOrderDO = taskOrderService.getById(taskOrderId);
+                String projectCode = template.getProjectCode();
+                existingReport.setReportNo(generateOrderItemSubReportNo(taskOrderDO.getDeptId(), taskOrderDO.getCheckDate(), projectCode)); // 如果没有报告编号则生成
             }
 
-            DynamicTbDO dynamicTbDO = dynamicTbService.getById(template.getId());
-
-            // 更新模版相关配置
-            if (dynamicTbDO.getReportType() != null) {
-                existingReport.setReportType(dynamicTbDO.getReportType());
-            }
+//            DynamicTbDO dynamicTbDO = dynamicTbService.getById(template.getId());
+//
+//            // 更新模版相关配置
+//            if (dynamicTbDO.getReportType() != null) {
+//                existingReport.setReportType(dynamicTbDO.getReportType());
+//            }
 
             // 设置更新时间
             LocalDateTime now = LocalDateTime.now();
@@ -1192,25 +1306,61 @@ public class SyncTaskBoilerEquipmentJob {
      * @param itemDO        设备信息
      * @param taskOrderId   任务单ID
      * @param template      报告模版
+     * @param createdReportsMap 已创建的报告映射（用于子项目获取主项目编号）
+     * @return 创建的报告对象
      */
-    private void createTaskOrderItemReport(TaskEquipmentDto taskOrderItem, BoilerTaskOrderItemDO itemDO,
-                                           String taskOrderId, BoilerConnectRecordReportDO template) {
+    private BoilerTaskOrderItemReportDO createTaskOrderItemReport(TaskEquipmentDto taskOrderItem, BoilerTaskOrderItemDO itemDO,
+                                                                   String taskOrderId, BoilerConnectRecordReportDO template,
+                                                                   Map<String, BoilerTaskOrderItemReportDO> createdReportsMap) {
         try {
             // 创建报告记录
             BoilerTaskOrderItemReportDO report = new BoilerTaskOrderItemReportDO();
             report.setOrderItemId(itemDO.getId());  // 设备ID
             report.setOrderId(taskOrderId);        // 任务单ID
             report.setTemplateId(template.getRecordTemplateId()); // 模版ID
+            report.setProjectId(template.getId()); // 模版ID
             report.setReportName(template.getProjectName()); // 报告名称使用模版名称
-            report.setReportNo(generateReportNo()); // 生成报告编号
-            report.setTaskStatus(100);             // 任务状态：待处理
+            
+            // 设置报告编号
+            if ("MAIN".equals(template.getProjectType())) {
+                BoilerTaskOrderDO taskOrderDO = taskOrderService.getById(taskOrderId);
+                String projectCode = template.getProjectCode();
+                report.setReportNo(generateOrderItemSubReportNo(taskOrderDO.getDeptId(), taskOrderDO.getCheckDate(), projectCode));
+            } else if ("SUB".equals(template.getProjectType())) {
+                // 优先从内存中获取刚创建的主项目报告
+                BoilerTaskOrderItemReportDO mainReport = createdReportsMap.get("MAIN");
+                if (mainReport != null && mainReport.getReportNo() != null) {
+                    report.setReportNo(mainReport.getReportNo());
+                    log.info("子项目 {} 使用内存中的主项目编号: {}", template.getProjectName(), mainReport.getReportNo());
+                } else {
+                    // 如果内存中没有，则从数据库查询
+                    List<BoilerTaskOrderItemReportDO> list = taskOrderItemReportService.list(new LambdaQueryWrapper<BoilerTaskOrderItemReportDO>()
+                            .eq(BoilerTaskOrderItemReportDO::getOrderItemId, itemDO.getId())
+                            .eq(BoilerTaskOrderItemReportDO::getReportType, 100));
+                    list.stream()
+                            .findFirst().ifPresent(mainProject -> report.setReportNo(mainProject.getReportNo()));
+                }
+            } else {
+                BoilerTaskOrderDO taskOrderDO = taskOrderService.getById(taskOrderId);
+                String projectCode = template.getProjectCode();
+                report.setReportNo(generateOrderItemSubReportNo(taskOrderDO.getDeptId(), taskOrderDO.getCheckDate(), projectCode));
+            }
+            report.setTaskStatus(500);             // 任务状态：待处理
             report.setStatus(100);                 // 审核状态：待审核
             report.setRecheckStatus(100);          // 校核状态：待校核
-            // 设置报告类型，避免null值
-            DynamicTbDO dynamicTbDO = dynamicTbService.getById(template.getRecordTemplateId());
-            if (dynamicTbDO.getReportType() != null) {
-                report.setReportType(dynamicTbDO.getReportType());
+            report.setReportType(200);
+            if ("MAIN".equals(template.getProjectType())) {
+                report.setReportType(100);
+            } else if ("SUB".equals(template.getProjectType())) {
+                report.setReportType(200);
+            } else if ("STANDALONE".equals(template.getProjectType())) {
+                report.setReportType(300);
             }
+            // 设置报告类型，避免null值
+//            DynamicTbDO dynamicTbDO = dynamicTbService.getById(template.getRecordTemplateId());
+//            if (dynamicTbDO.getReportType() != null) {
+//                report.setReportType(dynamicTbDO.getReportType());
+//            }
             report.setFeeConfirm(false);           // 费用确认：未确认
             report.setIsReported(false);               // 是否上报：否
             report.setIsCloseReported(false);          // 是否办结上报：否
@@ -1232,10 +1382,13 @@ public class SyncTaskBoilerEquipmentJob {
             log.info("成功创建报告记录，设备: {}, 模版: {}, 报告ID: {}",
                     taskOrderItem.getRegisterNo(), template.getProjectName(), report.getId());
 
+            return report;
+
         } catch (Exception e) {
             log.error("创建报告记录异常，设备: {}, 模版: {}",
                     taskOrderItem.getRegisterNo(), template.getProjectName(), e);
             // 不抛出异常，避免影响主流程
+            return null;
         }
     }
 
@@ -1245,40 +1398,124 @@ public class SyncTaskBoilerEquipmentJob {
      * @param originalName 原始检验项目名称
      * @return 转换后的检验项目名称
      */
-    private String convertCheckItemName(String originalName) {
+    private String convertCheckItemName(String originalName, EquipBoilerDO equipBoiler) {
         if (originalName == null || originalName.trim().isEmpty()) {
             return originalName;
         }
 
-        // 定义检验项目名称映射关系
-        switch (originalName.trim()) {
-            case "全面检验" -> {
-                return "压力容器定期检验";
-            }
-            case "宏观检查" -> {
-                return "压力容器宏观检验";
-            }
-            case "壁厚测定" -> {
-                return "壁厚测定";
-            }
-            case "安全附件检验" -> {
-                return "压力容器安全附件检验";
+        // 电站锅炉
+        if ("1".equals(equipBoiler.getType())) {
+            // 定义检验项目名称映射关系
+            switch (originalName.trim()) {
+                case "内部检验" -> {
+                    return "电站锅炉内部检验";
+                }
+                case "外部检验" -> {
+                    return "电站锅炉外部检验";
+                }
+                // 可以添加更多映射关系
+                default -> {
+                    log.info("未找到检验项目名称映射: {}", originalName);
+                    return originalName; // 如果没有映射关系，返回原始名称
+                }
             }
-            case "年度检查" -> {
-                return "压力容器年度检查";
+            // 蒸汽锅炉
+        } else if ("3".equals(equipBoiler.getType())) {
+            // 定义检验项目名称映射关系
+            switch (originalName.trim()) {
+                case "内部检验" -> {
+                    return "工业锅炉内检";
+                }
+                case "外部检验" -> {
+                    return "工业锅炉外检";
+                }
+                case "工业锅炉热力管道在线检验" -> {
+                    return "工业锅炉热力管道在线检验";
+                }
+
+                // 可以添加更多映射关系
+                default -> {
+                    log.info("未找到检验项目名称映射: {}", originalName);
+                    return originalName; // 如果没有映射关系，返回原始名称
+                }
             }
-            case "磁粉检测" -> {
-                return "磁粉检测";
+            // 有机热载体锅炉
+        } else if ("6".equals(equipBoiler.getType())) {
+            // 定义检验项目名称映射关系
+            switch (originalName.trim()) {
+                case "内部检验" -> {
+                    return "工业锅炉内检";
+                }
+                case "外部检验" -> {
+                    return "工业锅炉外检";
+                }
+                case "工业锅炉热力管道在线检验" -> {
+                    return "工业锅炉热力管道在线检验";
+                }
+                case "有机热载体炉管道全面检验" -> {
+                    return "有机热载体炉管道全面检验";
+                }
+                case "有机热载体炉管道在线检验" -> {
+                    return "有机热载体炉管道在线检验";
+                }
+
+                // 可以添加更多映射关系
+                default -> {
+                    log.info("未找到检验项目名称映射: {}", originalName);
+                    return originalName; // 如果没有映射关系，返回原始名称
+                }
             }
-            case "渗透检测" -> {
-                return "渗透检测";
+            // 小型锅炉
+        } else if ("5".equals(equipBoiler.getType())) {
+            // 定义检验项目名称映射关系
+            switch (originalName.trim()) {
+                // 可以添加更多映射关系
+                case "内部检验" -> {
+                    return "工业锅炉内检";
+                }
+                case "外部检验" -> {
+                    return "工业锅炉外检";
+                }
+                default -> {
+                    log.info("未找到检验项目名称映射: {}", originalName);
+                    return originalName; // 如果没有映射关系，返回原始名称
+                }
             }
-            case "附加检查检测" -> {
-                return "压力容器附加检验";
+            // 热水锅炉
+        } else if ("4".equals(equipBoiler.getType())) {
+            // 定义检验项目名称映射关系
+            switch (originalName.trim()) {
+                // 可以添加更多映射关系
+                case "内部检验" -> {
+                    return "工业锅炉内检";
+                }
+                case "外部检验" -> {
+                    return "工业锅炉外检";
+                }
+                default -> {
+                    log.info("未找到检验项目名称映射: {}", originalName);
+                    return originalName; // 如果没有映射关系，返回原始名称
+                }
             }
-            case "超使用年限专项检验" -> {
-                return "超设计使用年限压力容器专项评估";
+            // 工业一般锅炉
+        } else if ("2".equals(equipBoiler.getType())) {
+            // 定义检验项目名称映射关系
+            switch (originalName.trim()) {
+                // 可以添加更多映射关系
+                case "内部检验" -> {
+                    return "工业锅炉内检";
+                }
+                case "外部检验" -> {
+                    return "工业锅炉外检";
+                }
+                default -> {
+                    log.info("未找到检验项目名称映射: {}", originalName);
+                    return originalName; // 如果没有映射关系，返回原始名称
+                }
             }
+        }
+        // 定义检验项目名称映射关系
+        switch (originalName.trim()) {
             // 可以添加更多映射关系
             default -> {
                 log.info("未找到检验项目名称映射: {}", originalName);
@@ -1297,6 +1534,46 @@ public class SyncTaskBoilerEquipmentJob {
         return acceptNo;
     }
 
+    private String generateOrderItemSubReportNo(String deptId, LocalDate checkDate, String projectCode) {
+
+        // 获取部门代码
+        CommonResult<DeptRespDTO> deptResult = deptApi.getDept(deptId);
+        String deptCode = deptResult.getCheckedData().getCode();
+        // 取前两位作为部门代码
+        deptCode = deptCode.substring(0, 2);
+
+        // 生成日期部分，优先使用检验时间，如果为空则使用当前时间
+        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy"); // 4位年
+        Date dateToUse = (checkDate != null) ?
+                Date.from(checkDate.atStartOfDay(ZoneId.systemDefault()).toInstant()) :
+                new Date();
+        String dateStr = simpleDateFormat.format(dateToUse);
+
+        // 生成Redis键：TASK_ORDER + 部门代码 + 日期
+        String redisKey = cn.start.tz.module.pressure2.enums.RedisKeyEnums.TASK_ORDER_ITEM_SUB.getKey() + deptCode + dateStr;
+
+        int maxAttempts = 10; // 最大尝试次数，防止死循环
+        int attemptCount = 0;
+        while (attemptCount < maxAttempts) {
+            attemptCount++;
+
+            String reportNo = deptCode + projectCode + "-" + dateStr + redisService.generateAcceptanceNo(redisKey);
+            log.info("生成报告编号:{}", reportNo);
+            long count = taskOrderItemReportService.count(new LambdaQueryWrapperX<BoilerTaskOrderItemReportDO>().
+                    eq(BoilerTaskOrderItemReportDO::getReportNo, reportNo)
+            );
+
+            if (count == 0) {
+                // 生成报告编号不存在，可以使用
+                return reportNo;
+            }
+        }
+
+        String reportNo = deptCode + projectCode + "-" + dateStr + redisService.generateAcceptanceNo(redisKey);
+        log.info("生成报告编号:" + reportNo);
+        return reportNo;
+    }
+
     /**
      * 从文本中提取手机号
      *

tz-module-pressure2/tz-module-pressure2-biz/src/main/java/cn/start/tz/module/pressure2/service/dynamicOFData/boiler/QR0405_202400ReportOFData.java

@@ -6,11 +6,15 @@ import cn.start.tz.module.pressure2.dal.dataobject.acceptorder.AcceptOrderDO;
 import cn.start.tz.module.pressure2.dal.dataobject.boileracceptorderitem.BoilerAcceptOrderItemDO;
 import cn.start.tz.module.pressure2.dal.dataobject.boileracceptorderuser.BoilerAcceptOrderUserDO;
 import cn.start.tz.module.pressure2.dal.dataobject.boilertaskorder.BoilerTaskOrderDO;
+import cn.start.tz.module.pressure2.dal.dataobject.boilertaskorderitem.BoilerTaskOrderItemDO;
 import cn.start.tz.module.pressure2.dal.dataobject.boilertaskordersignfile.BoilerTaskOrderSignFileDO;
+import cn.start.tz.module.pressure2.dal.dataobject.boilertaskorderuser.BoilerTaskOrderUserDO;
 import cn.start.tz.module.pressure2.dal.dataobject.equipboiler.EquipBoilerDO;
 import cn.start.tz.module.pressure2.dal.dataobject.orderreport.OrderReportDO;
 import cn.start.tz.module.pressure2.dal.mysql.acceptorder.AcceptOrderMapper;
 import cn.start.tz.module.pressure2.dal.mysql.boileracceptorderitem.BoilerAcceptOrderItemMapper;
+import cn.start.tz.module.pressure2.dal.mysql.boilertaskorderitem.BoilerTaskOrderItemMapper;
+import cn.start.tz.module.pressure2.dal.mysql.boilertaskorderuser.BoilerTaskOrderUserMapper;
 import cn.start.tz.module.pressure2.dal.mysql.equipboiler.EquipBoilerMapper;
 import cn.start.tz.module.pressure2.dal.mysql.boileracceptorderuser.BoilerAcceptOrderUserMapper;
 import cn.start.tz.module.pressure2.service.boilertaskorder.BoilerTaskOrderService;
@@ -56,6 +60,13 @@ public class QR0405_202400ReportOFData implements IDynamicOFData {
     private BoilerTaskOrderSignFileService boilerTaskOrderSignFileService;
     @Resource
     private BoilerTaskOrderService boilerTaskOrderService;
+
+    @Resource
+    private BoilerTaskOrderUserMapper boilerTaskOrderUserMapper;
+
+    @Resource
+    private BoilerTaskOrderItemMapper boilerTaskOrderItemMapper;
+
     @Override
     public JSONObject getOFData(JSONObject params) {
         return null;
@@ -73,6 +84,8 @@ public class QR0405_202400ReportOFData implements IDynamicOFData {
         JSONObject result = new JSONObject();
         AcceptOrderDO acceptOrderDO = acceptOrderMapper.selectById(refId);
         if (acceptOrderDO == null) {
+            // refId 是任务单id
+            result = getDataByTaskOrder(result,refId,ruleVO);
             return result;
         }
         result.put("reportNo", acceptOrderDO.getAcceptNo());
@@ -174,4 +187,108 @@ public class QR0405_202400ReportOFData implements IDynamicOFData {
 
         return result;
     }
+
+    private JSONObject getDataByTaskOrder(JSONObject result, String refId,CreateInstantiateWithRuleVO ruleVO) {
+
+        //日期格式
+        DateTimeFormatter dateFormat = DateTimeFormatter.ofPattern("yyyy年MM月dd日");
+
+        BoilerTaskOrderDO taskOrderDO = boilerTaskOrderService.getById(refId);
+        result.put("reportNo", taskOrderDO.getOrderNo());
+        result.put("unitName", taskOrderDO.getUnitName());
+        result.put("unitAddress", taskOrderDO.getUnitAddress());
+        result.put("unitCode", taskOrderDO.getUnitCode());
+        result.put("zipCode", taskOrderDO.getZipCode());
+//        result.put("contact", acceptOrderDO.getUnitContact());
+        // 检验员签名
+        String orderReportDOId = ruleVO.getParams().getString("orderReportDOId");
+        if (orderReportDOId != null){
+            OrderReportDO orderReportDO = orderReportService.getById(orderReportDOId);
+            result.put("checkName", orderReportDO.getSignUrl());
+            result.put("checkDate", orderReportDO.getSignUrl());
+        }
+        // 填充客户签名
+        BoilerTaskOrderDO one = boilerTaskOrderService.getOne(new LambdaQueryWrapper<BoilerTaskOrderDO>().eq(BoilerTaskOrderDO::getAcceptOrderId, refId));
+        if (one != null){
+            BoilerTaskOrderSignFileDO boilerTaskOrderSignFileDO = boilerTaskOrderSignFileService.selectLastOneByOrderIdAndBusinessType(one.getId(), 100);
+            if (boilerTaskOrderSignFileDO != null){
+                result.put("contact", boilerTaskOrderSignFileDO.getSignUrl());
+                result.put("contactDate", boilerTaskOrderSignFileDO.getSignDate());
+            }
+        }
+        result.put("contactPhone", taskOrderDO.getUnitPhone());
+        result.put("applicationDate", taskOrderDO.getCreateTime().format(dateFormat));
+        result.put("checkDate", taskOrderDO.getCheckDate().format(dateFormat));
+        CommonResult<AdminUserRespDTO> user1 = adminUserApi.getUser(taskOrderDO.getCreator());
+        result.put("confirmed", user1.getCheckedData().getNickname());
+        result.put("acceptMan", user1.getCheckedData().getNickname());
+        if (taskOrderDO.getFeeNature() != null) {
+            if (taskOrderDO.getFeeNature() == 200) {
+                result.put("feeNature", "true");
+            } else if (taskOrderDO.getFeeNature() == 300) {
+                result.put("feeNature1", "true");
+            }
+        }
+        if (taskOrderDO.getFeeType() != null) {
+            if (taskOrderDO.getFeeType() == 100) {
+                result.put("feeType1", "true");
+            } else if (taskOrderDO.getFeeType() == 200) {
+                result.put("feeType", "true");
+            }
+        }
+
+        List<BoilerTaskOrderUserDO> boilerTaskOrderUserDOS = boilerTaskOrderUserMapper.selectList(BoilerTaskOrderUserDO::getOrderId, refId);
+        if (boilerTaskOrderUserDOS != null && !boilerTaskOrderUserDOS.isEmpty()) {
+            CommonResult<List<AdminUserRespDTO>> userList = adminUserApi.getUserList(boilerTaskOrderUserDOS.stream().map(BoilerTaskOrderUserDO::getUserId).toList());
+            List<String> names = new ArrayList<>();
+            if (!userList.getData().isEmpty()) {
+                for (BoilerTaskOrderUserDO boilerTaskOrderUserDO : boilerTaskOrderUserDOS) {
+                    for (AdminUserRespDTO user : userList.getData()) {
+                        if (boilerTaskOrderUserDO.getUserId().equals(user.getId())) {
+                            names.add(user.getNickname());
+                        }
+                    }
+                }
+            }
+            String collect = names.stream().map(Object::toString).collect(Collectors.joining("、"));
+            result.put("inspector", collect);
+            result.put("inspectorNum", String.valueOf(boilerTaskOrderUserDOS.size()));
+        }
+
+        List<BoilerTaskOrderItemDO> boilerTaskOrderItemDOS = boilerTaskOrderItemMapper.selectList(
+                new LambdaQueryWrapper<BoilerTaskOrderItemDO>()
+                        .eq(BoilerTaskOrderItemDO::getOrderId, refId)
+        );
+        List<EquipBoilerDO> equipBoilerDOS = equipBoilerMapper.selectList(
+                new LambdaQueryWrapper<EquipBoilerDO>()
+                        .in(EquipBoilerDO::getId, boilerTaskOrderItemDOS.stream().map(BoilerTaskOrderItemDO::getEquipId).toList())
+        );
+
+        result.put("equipNum", String.valueOf(equipBoilerDOS.size()));
+
+        for (int i = 0; i < equipBoilerDOS.size(); i++) {
+            EquipBoilerDO equipBoilerDO = equipBoilerDOS.get(i);
+            if (equipBoilerDO != null) {
+                int i1 = i + 1;
+                result.put("useRegisterNo_" + i1, equipBoilerDO.getUseRegisterNo());
+                result.put("boilerModel_" + i1, equipBoilerDO.getBoilerModel());
+                result.put("productCode_" + i1, equipBoilerDO.getProductCode());
+                result.put("equipCode_" + i1, equipBoilerDO.getEquipCode());
+                switch (taskOrderDO.getCheckType()) {
+                    case 100:
+                        result.put("checkItem_" + i1, "A");
+                        break;
+                    case 200:
+                        result.put("checkItem_" + i1, "B");
+                        break;
+                    case 300:
+                        result.put("checkItem_" + i1, "C");
+                        break;
+                    default:
+                        result.put("checkItem_" + i1, "D");
+                }
+            }
+        }
+        return result;
+    }
 }

tz-module-pressure2/tz-module-pressure2-biz/src/main/java/cn/start/tz/module/pressure2/service/dynamicOFData/boiler/QR0405_202402ReportOFData.java

@@ -1,17 +1,20 @@
 package cn.start.tz.module.pressure2.service.dynamicOFData.boiler;
 
+import cn.start.tz.framework.common.pojo.CommonResult;
 import cn.start.tz.module.pressure2.controller.admin.dynamictbins.vo.CreateInstantiateWithRuleVO;
 import cn.start.tz.module.pressure2.dal.dataobject.acceptorder.AcceptOrderDO;
 import cn.start.tz.module.pressure2.dal.dataobject.boileracceptorderitem.BoilerAcceptOrderItemDO;
 import cn.start.tz.module.pressure2.dal.dataobject.boilertaskorder.BoilerTaskOrderDO;
 import cn.start.tz.module.pressure2.dal.dataobject.boilertaskorderitem.BoilerTaskOrderItemDO;
 import cn.start.tz.module.pressure2.dal.dataobject.boilertaskordersignfile.BoilerTaskOrderSignFileDO;
+import cn.start.tz.module.pressure2.dal.dataobject.boilertaskorderuser.BoilerTaskOrderUserDO;
 import cn.start.tz.module.pressure2.dal.dataobject.equipboiler.EquipBoilerDO;
 import cn.start.tz.module.pressure2.dal.dataobject.orderreport.OrderReportDO;
 import cn.start.tz.module.pressure2.dal.mysql.acceptorder.AcceptOrderMapper;
 import cn.start.tz.module.pressure2.dal.mysql.boileracceptorderitem.BoilerAcceptOrderItemMapper;
 import cn.start.tz.module.pressure2.dal.mysql.boileracceptorderuser.BoilerAcceptOrderUserMapper;
 import cn.start.tz.module.pressure2.dal.mysql.boilertaskorderitem.BoilerTaskOrderItemMapper;
+import cn.start.tz.module.pressure2.dal.mysql.boilertaskorderuser.BoilerTaskOrderUserMapper;
 import cn.start.tz.module.pressure2.dal.mysql.equipboiler.EquipBoilerMapper;
 import cn.start.tz.module.pressure2.service.boilertaskorder.BoilerTaskOrderService;
 import cn.start.tz.module.pressure2.service.boilertaskordersignfile.BoilerTaskOrderSignFileService;
@@ -30,9 +33,11 @@ import org.springframework.stereotype.Service;
 
 import java.math.BigDecimal;
 import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.stream.Collectors;
 
 /**
  * 锅炉受理单
@@ -68,6 +73,9 @@ public class QR0405_202402ReportOFData implements IDynamicOFData {
     private BoilerTaskOrderSignFileService boilerTaskOrderSignFileService;
     @Resource
     private BoilerTaskOrderService boilerTaskOrderService;
+
+    @Resource
+    private BoilerTaskOrderUserMapper boilerTaskOrderUserMapper;
     @Override
     public JSONObject getOFData(JSONObject params) {
         return null;
@@ -85,7 +93,8 @@ public class QR0405_202402ReportOFData implements IDynamicOFData {
         JSONObject result = new JSONObject();
         AcceptOrderDO acceptOrderDO = acceptOrderMapper.selectById(refId);
         if (acceptOrderDO == null) {
-            return result;
+            // refId 是任务单id
+            return getDataByTaskOrder(result, refId, ruleVO);
         }
         result.put("reportNo", acceptOrderDO.getAcceptNo());
         result.put("unitName", acceptOrderDO.getUnitName());
@@ -192,6 +201,112 @@ public class QR0405_202402ReportOFData implements IDynamicOFData {
             }
         }
 
+        return result;
+    }
+    private JSONObject getDataByTaskOrder(JSONObject result, String refId,CreateInstantiateWithRuleVO ruleVO) {
+
+        //日期格式
+        DateTimeFormatter dateFormat = DateTimeFormatter.ofPattern("yyyy年MM月dd日");
+
+        BoilerTaskOrderDO taskOrderDO = boilerTaskOrderService.getById(refId);
+        result.put("reportNo", taskOrderDO.getOrderNo());
+        result.put("unitName", taskOrderDO.getUnitName());
+        result.put("unitAddress", taskOrderDO.getUnitAddress());
+        result.put("unitCode", taskOrderDO.getUnitCode());
+        result.put("zipCode", taskOrderDO.getZipCode());
+        result.put("contact", taskOrderDO.getUnitContact());
+
+        // 填充客户签名
+        BoilerTaskOrderSignFileDO boilerTaskOrderSignFileDO = boilerTaskOrderSignFileService.selectLastOneByOrderIdAndBusinessType(taskOrderDO.getId(), 100);
+        if (boilerTaskOrderSignFileDO != null){
+            result.put("unitPerson", boilerTaskOrderSignFileDO.getSignUrl());
+            result.put("unitPersonDate", boilerTaskOrderSignFileDO.getSignDate());
+        }
+        result.put("SLCK", "");
+        result.put("contactPhone", taskOrderDO.getUnitPhone());
+        result.put("checkDate", taskOrderDO.getCheckDate().format(dateFormat));
+        if (taskOrderDO.getFeeNature() != null) {
+            if (taskOrderDO.getFeeNature() == 200) {
+                result.put("BSMZFC", "true");
+            } else if (taskOrderDO.getFeeNature() == 300) {
+                result.put("SMZFC", "true");
+            }
+        }
+
+        List<BoilerTaskOrderItemDO> boilerTaskOrderItemDOS = boilerTaskOrderItemMapper.selectList(
+                new LambdaQueryWrapper<BoilerTaskOrderItemDO>()
+                        .eq(BoilerTaskOrderItemDO::getOrderId, refId)
+        );
+        List<EquipBoilerDO> equipBoilerDOS = equipBoilerMapper.selectList(
+                new LambdaQueryWrapper<EquipBoilerDO>()
+                        .in(EquipBoilerDO::getId, boilerTaskOrderItemDOS.stream().map(BoilerTaskOrderItemDO::getEquipId).toList())
+        );
+
+        result.put("equipNums", String.valueOf(equipBoilerDOS.size()));
+
+        AtomicReference<Boolean> isDZGL = new AtomicReference<>(false);
+        AtomicInteger number = new AtomicInteger(1);
+        equipBoilerDOS.forEach(equipBoilerDO -> {
+
+            if (equipBoilerDO.getType().equals("1")){
+                isDZGL.set(true);
+            }
+
+            result.put("value1_" + number.get(), String.valueOf(number.get()));
+            DictDataRespDTO boilerTypeDTO = dictDataApi.getDictData("system_equip_boiler_type",equipBoilerDO.getType().toString()).getData();
+            if (boilerTypeDTO != null){
+                result.put("value2_" + number.get(), boilerTypeDTO.getLabel());
+            }
+            result.put("value3_" + number.get(), equipBoilerDO.getFactoryCode());
+            result.put("value4_" + number.get(), equipBoilerDO.getUseRegisterNo());
+            result.put("value5_" + number.get(), equipBoilerDO.getEquipCode());
+            result.put("value6_" + number.get(), "-");
+            BoilerTaskOrderItemDO taskOrderItemDO = boilerTaskOrderItemMapper.selectOne(
+                    new LambdaQueryWrapper<BoilerTaskOrderItemDO>()
+                            .eq(BoilerTaskOrderItemDO::getEquipId, equipBoilerDO.getId())
+                            .eq(BoilerTaskOrderItemDO::getOrderId, taskOrderDO.getId())
+            );
+            if (taskOrderItemDO != null){
+                result.put("value7_" + number.get(), taskOrderItemDO.getFee());
+            }
+            result.put("value8_" + number.get(), "-");
+            number.getAndIncrement();
+
+        });
+
+        if (isDZGL.get()){
+            result.put("DZGL", "true");
+        }else{
+            result.put("GYGL", "true");
+        }
+
+        if (taskOrderDO.getCheckType() == 100){
+            result.put("inCheck", "true");
+        }else if (taskOrderDO.getCheckType() == 200){
+            result.put("outCheck", "true");
+        }else if (taskOrderDO.getCheckType() == 300){
+            result.put("pressureCheck", "true");
+        }
+
+        String managerId = taskOrderDO.getManagerId();
+        if (managerId != null) {
+            AdminUserRespDTO checkedData = adminUserApi.getUser(managerId).getCheckedData();
+            if (checkedData != null) {
+                result.put("confirmPerson", checkedData.getSignUrl());
+                result.put("confirmPersonDate", taskOrderDO.getConfirmDate());
+            }
+        }
+
+        result.put("recipient", taskOrderDO.getRecipient());
+        result.put("recipientPhone", taskOrderDO.getRecipientPhone());
+        result.put("recipientEmail", taskOrderDO.getRecipientEmail());
+
+        if (taskOrderDO.getShouldAmount() != null) {
+            result.put("totalAmount", taskOrderDO.getShouldAmount().setScale(2, java.math.RoundingMode.HALF_UP));
+            // 将金额转换为中文大写金额
+            result.put("money1", AmountConvertUtil.convertAmountToChineseDigits(taskOrderDO.getShouldAmount()));
+        }
+
         return result;
     }
 }

tz-module-pressure2/tz-module-pressure2-biz/src/main/java/cn/start/tz/module/pressure2/service/orderreport/OrderReportService.java

@@ -74,6 +74,16 @@ public interface OrderReportService extends IService<OrderReportDO>  {
      */
     void addPipeOrderReport(String acceptOrderId, String taskOrderId);
 
+    /**
+     * 根据任务单ID生成锅炉受理单报告
+     */
+    void generateBoilerOrderReportByTaskOrder(String taskOrderId);
+
+    /**
+     * 根据任务单ID生成管道受理单报告
+     */
+    void generatePipeOrderReportByTaskOrder(String taskOrderId);
+
     Boolean serviceFromSendEmail(@Valid TaskOrderSignFilePageReqVO pageReqVO);
 
     List<OrderReportDO> getListByOrderIdSet(Set<String> orderIdSet);

tz-module-pressure2/tz-module-pressure2-biz/src/main/java/cn/start/tz/module/pressure2/service/orderreport/OrderReportServiceImpl.java

@@ -2,6 +2,7 @@ package cn.start.tz.module.pressure2.service.orderreport;
 
 import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.core.util.StrUtil;
 import cn.start.tz.framework.common.exception.ErrorCode;
 import cn.start.tz.framework.common.exception.ServiceException;
 import cn.start.tz.framework.mybatis.core.query.LambdaQueryWrapperX;
@@ -10,6 +11,8 @@ import cn.start.tz.module.pressure2.controller.admin.dynamictbins.vo.CreateInsta
 import cn.start.tz.module.pressure2.dal.dataobject.boilerconnectrecordreport.BoilerConnectRecordReportDO;
 import cn.start.tz.module.pressure2.dal.dataobject.boilerconnecttbservice.BoilerConnectTbServiceDO;
 import cn.start.tz.module.pressure2.dal.dataobject.boilertaskorder.BoilerTaskOrderDO;
+import cn.start.tz.module.pressure2.dal.dataobject.boilertaskorderitem.BoilerTaskOrderItemDO;
+import cn.start.tz.module.pressure2.dal.dataobject.boilertaskorderitemreport.BoilerTaskOrderItemReportDO;
 import cn.start.tz.module.pressure2.dal.dataobject.dynamictb.DynamicTbDO;
 import cn.start.tz.module.pressure2.dal.dataobject.dynamictbins.DynamicTbInsDO;
 import cn.start.tz.module.pressure2.dal.dataobject.equipboilerschedulingitem.EquipBoilerSchedulingCheckDO;
@@ -21,6 +24,8 @@ import cn.start.tz.module.pressure2.dal.mysql.boilertaskorder.BoilerTaskOrderMap
 import cn.start.tz.module.pressure2.dal.mysql.notificationformreport.NotificationformReportMapper;
 import cn.start.tz.module.pressure2.dal.mysql.pipetaskorder.PipeTaskOrderMapper;
 import cn.start.tz.module.pressure2.service.boilerconnectrecordreport.BoilerConnectRecordReportService;
+import cn.start.tz.module.pressure2.service.boilertaskorderitem.BoilerTaskOrderItemService;
+import cn.start.tz.module.pressure2.service.boilertaskorderitemreport.BoilerTaskOrderItemReportService;
 import cn.start.tz.module.pressure2.service.dynamictb.DynamicTbService;
 import cn.start.tz.module.pressure2.service.dynamictbins.DynamicTbInsService;
 import cn.start.tz.module.pressure2.service.equipboilerschedulingcheck.EquipBoilerSchedulingCheckService;
@@ -40,6 +45,7 @@ import org.springframework.transaction.annotation.Transactional;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 
 import java.util.*;
+import java.util.stream.Collectors;
 
 import cn.start.tz.module.pressure2.controller.admin.orderreport.vo.*;
 import cn.start.tz.module.pressure2.dal.dataobject.orderreport.OrderReportDO;
@@ -80,6 +86,12 @@ public class OrderReportServiceImpl extends ServiceImpl<OrderReportMapper, Order
     @Resource
     private EquipPipeSchedulingCheckService equipPipeSchedulingCheckService;
 
+    @Resource
+    private BoilerTaskOrderItemService boilerTaskOrderItemService;
+
+    @Resource
+    private BoilerTaskOrderItemReportService boilerTaskOrderItemReportService;
+
     @Resource
     private BoilerConnectRecordReportService boilerConnectRecordReportService;
 
@@ -294,6 +306,147 @@ public class OrderReportServiceImpl extends ServiceImpl<OrderReportMapper, Order
         updateById(one);
     }
 
+    @Override
+    public void generateBoilerOrderReportByTaskOrder(String taskOrderId) {
+        // 根据任务单ID查询所有设备及其报告，获取已关联的 projectId
+        List<BoilerTaskOrderItemDO> itemDOList = boilerTaskOrderItemService.list(
+                new LambdaQueryWrapperX<BoilerTaskOrderItemDO>()
+                        .eq(BoilerTaskOrderItemDO::getOrderId, taskOrderId));
+        if (CollUtil.isEmpty(itemDOList)) {
+            throw new ServiceException(500, "生成报表数据失败，任务单无设备信息");
+        }
+        Set<String> itemIds = itemDOList.stream().map(BoilerTaskOrderItemDO::getId).collect(Collectors.toSet());
+        List<BoilerTaskOrderItemReportDO> reportDOList = boilerTaskOrderItemReportService.list(
+                new LambdaQueryWrapperX<BoilerTaskOrderItemReportDO>()
+                        .eq(BoilerTaskOrderItemReportDO::getReportType, 100)
+                        .in(BoilerTaskOrderItemReportDO::getOrderItemId, itemIds));
+        if (CollUtil.isEmpty(reportDOList)) {
+            throw new ServiceException(500, "生成报表数据失败，任务单无报告记录");
+        }
+        // 收集所有已关联的 projectId（对应 BoilerConnectRecordReportDO.id）
+        Set<String> projectIds = reportDOList.stream()
+                .map(BoilerTaskOrderItemReportDO::getProjectId)
+                .filter(StrUtil::isNotBlank)
+                .collect(Collectors.toSet());
+        if (projectIds.isEmpty()) {
+            throw new ServiceException(500, "生成报表数据失败，报告记录中没有 projectId");
+        }
+        // 找到主项目类型的受理单模板
+        List<BoilerConnectRecordReportDO> boilerConnectRecordReportDOS = boilerConnectRecordReportService.list(
+                new LambdaQueryWrapper<BoilerConnectRecordReportDO>()
+                        .in(BoilerConnectRecordReportDO::getId, projectIds)
+                        .eq(BoilerConnectRecordReportDO::getProjectType, "MAIN"));
+        if (boilerConnectRecordReportDOS.isEmpty()) {
+            throw new ServiceException(500, "生成报表数据失败，未找到主项目受理单配置");
+        }
+
+        // 一个受理单可能有多个主项目，每个主项目对应一个报告
+        for (BoilerConnectRecordReportDO boilerConnectRecordReportDO : boilerConnectRecordReportDOS) {
+            DynamicTbDO reportTemplateDO = dynamicTbService.getById(boilerConnectRecordReportDO.getAcceptOrderTemplateId());
+            if (reportTemplateDO == null) continue;
+
+            // 按 taskOrderId + templateId 查重，避免重复生成
+            OrderReportDO exist = getOne(new LambdaQueryWrapperX<OrderReportDO>()
+                    .eq(OrderReportDO::getAcceptOrderId, taskOrderId)
+                    .eq(OrderReportDO::getTemplateId, reportTemplateDO.getId())
+            );
+            OrderReportDO orderReportDO = exist == null ? new OrderReportDO() : exist;
+            orderReportDO.setAcceptOrderId(taskOrderId);
+            orderReportDO.setOrderType(TASK);
+            orderReportDO.setTemplateId(reportTemplateDO.getId());
+
+            // 生成报表数据
+            CreateInstantiateWithRuleVO ruleVO = new CreateInstantiateWithRuleVO();
+            ruleVO.setTemplateId(reportTemplateDO.getId());
+            ruleVO.setRefId(taskOrderId);
+            ruleVO.setRefName(reportTemplateDO.getTbName());
+            ruleVO.setReportType(1);
+            JSONObject params = new JSONObject();
+            params.put("equipMainType", "boiler");
+            params.put("orderReportDOId", orderReportDO.getId());
+            ruleVO.setParams(params);
+
+            BoilerConnectTbServiceDO tbServiceDO = boilerConnectTbServiceMapper.selectOne(BoilerConnectTbServiceDO::getTbId, reportTemplateDO.getId());
+            if (tbServiceDO != null) {
+                ruleVO.setServiceName(tbServiceDO.getInitServiceName());
+                DynamicTbInsDO instantiateWithRule = dynamicTbInsService.createInstantiateWithRule(ruleVO);
+                orderReportDO.setInsId(instantiateWithRule.getId());
+            }
+
+            orderReportMapper.insertOrUpdate(orderReportDO);
+        }
+    }
+
+    @Override
+    public void generatePipeOrderReportByTaskOrder(String taskOrderId) {
+        // 根据任务单ID查询所有设备及其报告，获取已关联的 projectId
+        List<BoilerTaskOrderItemDO> itemDOList = boilerTaskOrderItemService.list(
+                new LambdaQueryWrapperX<BoilerTaskOrderItemDO>()
+                        .eq(BoilerTaskOrderItemDO::getOrderId, taskOrderId));
+        if (CollUtil.isEmpty(itemDOList)) {
+            throw new ServiceException(500, "生成报表数据失败，任务单无设备信息");
+        }
+        Set<String> itemIds = itemDOList.stream().map(BoilerTaskOrderItemDO::getId).collect(Collectors.toSet());
+        List<BoilerTaskOrderItemReportDO> reportDOList = boilerTaskOrderItemReportService.list(
+                new LambdaQueryWrapperX<BoilerTaskOrderItemReportDO>()
+                        .eq(BoilerTaskOrderItemReportDO::getReportType, 100)
+                        .in(BoilerTaskOrderItemReportDO::getOrderItemId, itemIds));
+        if (CollUtil.isEmpty(reportDOList)) {
+            throw new ServiceException(500, "生成报表数据失败，任务单无报告记录");
+        }
+        // 收集所有已关联的 projectId（对应 BoilerConnectRecordReportDO.id）
+        Set<String> projectIds = reportDOList.stream()
+                .map(BoilerTaskOrderItemReportDO::getProjectId)
+                .filter(StrUtil::isNotBlank)
+                .collect(Collectors.toSet());
+        if (projectIds.isEmpty()) {
+            throw new ServiceException(500, "生成报表数据失败，报告记录中没有 projectId");
+        }
+        // 找到主项目类型的受理单模板
+        List<BoilerConnectRecordReportDO> boilerConnectRecordReportDOS = boilerConnectRecordReportService.list(
+                new LambdaQueryWrapper<BoilerConnectRecordReportDO>()
+                        .in(BoilerConnectRecordReportDO::getId, projectIds)
+                        .eq(BoilerConnectRecordReportDO::getProjectType, "MAIN"));
+        if (boilerConnectRecordReportDOS.isEmpty()) {
+            throw new ServiceException(500, "生成报表数据失败，未找到主项目受理单配置");
+        }
+
+        // 一个受理单可能有多个主项目，每个主项目对应一个报告
+        for (BoilerConnectRecordReportDO boilerConnectRecordReportDO : boilerConnectRecordReportDOS) {
+            DynamicTbDO reportTemplateDO = dynamicTbService.getById(boilerConnectRecordReportDO.getAcceptOrderTemplateId());
+            if (reportTemplateDO == null) continue;
+
+            // 按 taskOrderId + templateId 查重，避免重复生成
+            OrderReportDO exist = getOne(new LambdaQueryWrapperX<OrderReportDO>()
+                    .eq(OrderReportDO::getAcceptOrderId, taskOrderId)
+                    .eq(OrderReportDO::getTemplateId, reportTemplateDO.getId())
+            );
+            OrderReportDO orderReportDO = exist == null ? new OrderReportDO() : exist;
+            orderReportDO.setAcceptOrderId(taskOrderId);
+            orderReportDO.setOrderType(TASK);
+            orderReportDO.setTemplateId(reportTemplateDO.getId());
+
+            // 生成报表数据
+            CreateInstantiateWithRuleVO ruleVO = new CreateInstantiateWithRuleVO();
+            ruleVO.setTemplateId(reportTemplateDO.getId());
+            ruleVO.setRefId(taskOrderId);
+            ruleVO.setRefName(reportTemplateDO.getTbName());
+            ruleVO.setReportType(1);
+            JSONObject params = new JSONObject();
+            params.put("equipMainType", "pipe");
+            ruleVO.setParams(params);
+
+            BoilerConnectTbServiceDO tbServiceDO = boilerConnectTbServiceMapper.selectOne(BoilerConnectTbServiceDO::getTbId, reportTemplateDO.getId());
+            if (tbServiceDO != null) {
+                ruleVO.setServiceName(tbServiceDO.getInitServiceName());
+                DynamicTbInsDO instantiateWithRule = dynamicTbInsService.createInstantiateWithRule(ruleVO);
+                orderReportDO.setInsId(instantiateWithRule.getId());
+            }
+
+            orderReportMapper.insertOrUpdate(orderReportDO);
+        }
+    }
+
     @Override
     public Boolean serviceFromSendEmail(TaskOrderSignFilePageReqVO pageReqVO) {