检验情况告知表&调整

tz-module-pressure2/tz-module-pressure2-api/src/main/java/cn/start/tz/module/pressure2/constant/TemplateIdConstants.java

@@ -10,7 +10,7 @@ public final class TemplateIdConstants {
     public static final String N_D_J_C_F_W_D = "bfdbb6fac583edaafd6199bd5f014525";
 
     // 承压类特种设备检验情况告知单
-    public static final String J_Y_Q_K_G_Z_D = "48f6d537afd801b4e35ef01b692debc5";
+    public static final String J_Y_Q_K_G_Z_D = "ce26312f4e1261a65aef116070fbfd26";
 
     // 重大问题线索告知表
     public static final String Z_D_W_T_S_X_G_Z_D = "112d889939025337fe8cedc4b81744b4";

tz-module-pressure2/tz-module-pressure2-api/src/main/java/cn/start/tz/module/pressure2/enums/ErrorCodeConstants.java

@@ -123,6 +123,8 @@ public interface ErrorCodeConstants{
 
     ErrorCode PIPE_TASK_ORDER_ITEM_PRINT_NOT_EXISTS = new ErrorCode(1059, "管道设备打印记录不存在");
 
+    ErrorCode NOTIFICATIONFORM_REPORT_NOT_EXISTS = new ErrorCode(1060, "检验情况告知不存在");
+
     ErrorCode EQUIP_BOILER_NOT_EXISTS = new ErrorCode(2000, "锅炉设备不存在");
 
     ErrorCode BOILER_EQUIP_OPERATION_RECORD_NOT_EXISTS = new ErrorCode(2001, "锅炉操作记录不存在");

tz-module-pressure2/tz-module-pressure2-api/src/main/java/cn/start/tz/module/pressure2/enums/TaskOrderItemReportTypeEnum.java

@@ -15,6 +15,7 @@ public enum TaskOrderItemReportTypeEnum {
     WORK_INSTRUCTION(700, "作业指导书"),
     NON_TAX(800, "非税"),
     SUBCONTRACTED(900, "分包项目"),
+    NOTIFICATION_FORM(1000,"告知表"),
     ;
 
     /**

tz-module-pressure2/tz-module-pressure2-biz/src/main/java/cn/start/tz/module/pressure2/controller/admin/boilertaskorder/vo/BoilerTaskOrderRespVO.java

@@ -5,6 +5,7 @@ import cn.start.tz.module.pressure2.controller.admin.boilerorderexception.vo.Boi
 import cn.start.tz.module.pressure2.controller.admin.boilertaskorderfollowrecord.vo.BoilerTaskOrderFollowRecordRespVO;
 import cn.start.tz.module.pressure2.controller.admin.boilertaskorderitem.vo.BoilerTaskOrderItemRespVO;
 import cn.start.tz.module.pressure2.dal.dataobject.boilertaskorderitemreport.BoilerTaskOrderItemReportDO;
+import cn.start.tz.module.pressure2.dal.dataobject.notificationformreport.NotificationformReportDO;
 import cn.start.tz.module.system.api.user.dto.AdminUserRespDTO;
 import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.*;
@@ -407,4 +408,7 @@ public class BoilerTaskOrderRespVO {
 
     @Schema(description = "发放报告状态")
     private Integer isIssueReport;
+
+    @Schema(description = "检验情况告知表")
+    private NotificationformReportDO notificationformReport;
 }

tz-module-pressure2/tz-module-pressure2-biz/src/main/java/cn/start/tz/module/pressure2/controller/admin/notificationformreport/NotificationformReportController.java

@@ -0,0 +1,95 @@
+package cn.start.tz.module.pressure2.controller.admin.notificationformreport;
+
+import org.springframework.web.bind.annotation.*;
+import jakarta.annotation.Resource;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.security.access.prepost.PreAuthorize;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.Operation;
+
+import jakarta.validation.constraints.*;
+import jakarta.validation.*;
+import jakarta.servlet.http.*;
+import java.util.*;
+import java.io.IOException;
+
+import cn.start.tz.framework.common.pojo.PageParam;
+import cn.start.tz.framework.common.pojo.PageResult;
+import cn.start.tz.framework.common.pojo.CommonResult;
+import cn.start.tz.framework.common.util.object.BeanUtils;
+import static cn.start.tz.framework.common.pojo.CommonResult.success;
+
+import cn.start.tz.framework.excel.core.util.ExcelUtils;
+
+import cn.start.tz.framework.apilog.core.annotation.ApiAccessLog;
+import static cn.start.tz.framework.apilog.core.enums.OperateTypeEnum.*;
+
+import cn.start.tz.module.pressure2.controller.admin.notificationformreport.vo.*;
+import cn.start.tz.module.pressure2.dal.dataobject.notificationformreport.NotificationformReportDO;
+import cn.start.tz.module.pressure2.service.notificationformreport.NotificationformReportService;
+
+@Tag(name = "管理后台 - 检验情况告知")
+@RestController
+@RequestMapping("/pressure2/notificationform-report")
+@Validated
+public class NotificationformReportController {
+
+    @Resource
+    private NotificationformReportService notificationformReportService;
+
+    @PostMapping("/create")
+    @Operation(summary = "创建检验情况告知")
+    @PreAuthorize("@ss.hasPermission('pressure2:notificationform-report:create')")
+    public CommonResult<String> createNotificationformReport(@Valid @RequestBody NotificationformReportSaveReqVO createReqVO) {
+        return success(notificationformReportService.createNotificationformReport(createReqVO));
+    }
+
+    @PutMapping("/update")
+    @Operation(summary = "更新检验情况告知")
+    @PreAuthorize("@ss.hasPermission('pressure2:notificationform-report:update')")
+    public CommonResult<Boolean> updateNotificationformReport(@Valid @RequestBody NotificationformReportSaveReqVO updateReqVO) {
+        notificationformReportService.updateNotificationformReport(updateReqVO);
+        return success(true);
+    }
+
+    @DeleteMapping("/delete")
+    @Operation(summary = "删除检验情况告知")
+    @Parameter(name = "id", description = "编号", required = true)
+    @PreAuthorize("@ss.hasPermission('pressure2:notificationform-report:delete')")
+    public CommonResult<Boolean> deleteNotificationformReport(@RequestParam("id") String id) {
+        notificationformReportService.deleteNotificationformReport(id);
+        return success(true);
+    }
+
+    @GetMapping("/get")
+    @Operation(summary = "获得检验情况告知")
+    @Parameter(name = "id", description = "编号", required = true, example = "1024")
+    @PreAuthorize("@ss.hasPermission('pressure2:notificationform-report:query')")
+    public CommonResult<NotificationformReportRespVO> getNotificationformReport(@RequestParam("id") String id) {
+        NotificationformReportDO notificationformReport = notificationformReportService.getNotificationformReport(id);
+        return success(BeanUtils.toBean(notificationformReport, NotificationformReportRespVO.class));
+    }
+
+    @GetMapping("/page")
+    @Operation(summary = "获得检验情况告知分页")
+    @PreAuthorize("@ss.hasPermission('pressure2:notificationform-report:query')")
+    public CommonResult<PageResult<NotificationformReportRespVO>> getNotificationformReportPage(@Valid NotificationformReportPageReqVO pageReqVO) {
+        PageResult<NotificationformReportDO> pageResult = notificationformReportService.getNotificationformReportPage(pageReqVO);
+        return success(BeanUtils.toBean(pageResult, NotificationformReportRespVO.class));
+    }
+
+    @GetMapping("/export-excel")
+    @Operation(summary = "导出检验情况告知 Excel")
+    @PreAuthorize("@ss.hasPermission('pressure2:notificationform-report:export')")
+    @ApiAccessLog(operateType = EXPORT)
+    public void exportNotificationformReportExcel(@Valid NotificationformReportPageReqVO pageReqVO,
+              HttpServletResponse response) throws IOException {
+        pageReqVO.setPageSize(PageParam.PAGE_SIZE_NONE);
+        List<NotificationformReportDO> list = notificationformReportService.getNotificationformReportPage(pageReqVO).getList();
+        // 导出 Excel
+        ExcelUtils.write(response, "检验情况告知.xls", "数据", NotificationformReportRespVO.class,
+                        BeanUtils.toBean(list, NotificationformReportRespVO.class));
+    }
+
+}

tz-module-pressure2/tz-module-pressure2-biz/src/main/java/cn/start/tz/module/pressure2/controller/admin/notificationformreport/vo/NotificationformReportPageReqVO.java

@@ -0,0 +1,31 @@
+package cn.start.tz.module.pressure2.controller.admin.notificationformreport.vo;
+
+import lombok.*;
+import java.util.*;
+import io.swagger.v3.oas.annotations.media.Schema;
+import cn.start.tz.framework.common.pojo.PageParam;
+import org.springframework.format.annotation.DateTimeFormat;
+import java.time.LocalDateTime;
+
+import static cn.start.tz.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
+
+@Schema(description = "管理后台 - 检验情况告知分页 Request VO")
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+public class NotificationformReportPageReqVO extends PageParam {
+
+    @Schema(description = "任务单号", example = "5619")
+    private String taskOrderId;
+
+    @Schema(description = "模板ID", example = "9080")
+    private String templateId;
+
+    @Schema(description = "INSID", example = "21415")
+    private String insId;
+
+    @Schema(description = "创建时间")
+    @DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
+    private LocalDateTime[] createTime;
+
+}

tz-module-pressure2/tz-module-pressure2-biz/src/main/java/cn/start/tz/module/pressure2/controller/admin/notificationformreport/vo/NotificationformReportRespVO.java

@@ -0,0 +1,35 @@
+package cn.start.tz.module.pressure2.controller.admin.notificationformreport.vo;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.*;
+import java.util.*;
+import org.springframework.format.annotation.DateTimeFormat;
+import java.time.LocalDateTime;
+import com.alibaba.excel.annotation.*;
+
+@Schema(description = "管理后台 - 检验情况告知 Response VO")
+@Data
+@ExcelIgnoreUnannotated
+public class NotificationformReportRespVO {
+
+    @Schema(description = "主键", example = "11906")
+    @ExcelProperty("主键")
+    private String id;
+
+    @Schema(description = "任务单号", example = "5619")
+    @ExcelProperty("任务单号")
+    private String taskOrderId;
+
+    @Schema(description = "模板ID", example = "9080")
+    @ExcelProperty("模板ID")
+    private String templateId;
+
+    @Schema(description = "INSID", example = "21415")
+    @ExcelProperty("INSID")
+    private String insId;
+
+    @Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED)
+    @ExcelProperty("创建时间")
+    private LocalDateTime createTime;
+
+}

tz-module-pressure2/tz-module-pressure2-biz/src/main/java/cn/start/tz/module/pressure2/controller/admin/notificationformreport/vo/NotificationformReportSaveReqVO.java

@@ -0,0 +1,24 @@
+package cn.start.tz.module.pressure2.controller.admin.notificationformreport.vo;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.*;
+import java.util.*;
+import jakarta.validation.constraints.*;
+
+@Schema(description = "管理后台 - 检验情况告知新增/修改 Request VO")
+@Data
+public class NotificationformReportSaveReqVO {
+
+    @Schema(description = "主键", example = "11906")
+    private String id;
+
+    @Schema(description = "任务单号", example = "5619")
+    private String taskOrderId;
+
+    @Schema(description = "模板ID", example = "9080")
+    private String templateId;
+
+    @Schema(description = "INSID", example = "21415")
+    private String insId;
+
+}

tz-module-pressure2/tz-module-pressure2-biz/src/main/java/cn/start/tz/module/pressure2/controller/admin/pipetaskorder/vo/PipeTaskOrderRespVO.java

@@ -6,6 +6,7 @@ import cn.start.tz.module.pressure2.controller.admin.boilertaskorder.vo.BoilerTa
 import cn.start.tz.module.pressure2.controller.admin.boilertaskorderfollowrecord.vo.BoilerTaskOrderFollowRecordRespVO;
 import cn.start.tz.module.pressure2.controller.admin.pipetaskorderfollowrecord.vo.PipeTaskOrderFollowRecordRespVO;
 import cn.start.tz.module.pressure2.dal.dataobject.boilertaskorderitemreport.BoilerTaskOrderItemReportDO;
+import cn.start.tz.module.pressure2.dal.dataobject.notificationformreport.NotificationformReportDO;
 import cn.start.tz.module.pressure2.dal.dataobject.pipetaskorderitemreport.PipeTaskOrderItemReportDO;
 import cn.start.tz.module.system.api.user.dto.AdminUserRespDTO;
 import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
@@ -410,4 +411,7 @@ public class PipeTaskOrderRespVO {
     @Schema(description = "发放报告状态")
     private Integer isIssueReport;
 
+    @Schema(description = "检验情况告知表")
+    private NotificationformReportDO notificationformReport;
+
 }

tz-module-pressure2/tz-module-pressure2-biz/src/main/java/cn/start/tz/module/pressure2/controller/appapi/boilertaskorder/AppApiBoilerTaskOrderController.java

@@ -11,6 +11,7 @@ import cn.start.tz.module.pressure2.dal.dataobject.boilertaskorderitemreport.Boi
 import cn.start.tz.module.pressure2.service.boilertaskorder.BoilerTaskOrderService;
 import cn.start.tz.module.pressure2.service.boilertaskorderitemreport.BoilerTaskOrderItemReportService;
 import cn.start.tz.module.pressure2.service.boilertaskorderoperation.BoilerTaskOrderOperationService;
+import cn.start.tz.module.system.api.user.dto.AdminUserRespDTO;
 import com.alibaba.fastjson.JSONObject;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import io.swagger.v3.oas.annotations.Operation;
@@ -535,4 +536,12 @@ public class AppApiBoilerTaskOrderController {
         PageResult<BoilerOrderItemPageRespVO> taskOrderPage = boilerTaskOrderService.inspectionOpinionPage(pageReqVO);
         return success(taskOrderPage);
     }
+
+    @GetMapping("/recheckUser/page")
+    @Operation(summary = "获得校验用户分页列表")
+    public CommonResult<PageResult<AdminUserRespDTO>> getUserPage(@Valid BoilerRecheckUserPageReqVO pageReqVO) {
+
+        PageResult<AdminUserRespDTO> userList = boilerTaskOrderService.getRecheckUserPage(pageReqVO);
+        return success(userList);
+    }
 }

tz-module-pressure2/tz-module-pressure2-biz/src/main/java/cn/start/tz/module/pressure2/dal/dataobject/notificationformreport/NotificationformReportDO.java

@@ -0,0 +1,49 @@
+package cn.start.tz.module.pressure2.dal.dataobject.notificationformreport;
+
+import lombok.*;
+import java.util.*;
+import java.time.LocalDateTime;
+import java.time.LocalDateTime;
+import com.baomidou.mybatisplus.annotation.*;
+import cn.start.tz.framework.mybatis.core.dataobject.BaseDO;
+
+/**
+ * 检验情况告知 DO
+ *
+ * @author 特种管理员
+ */
+@TableName("pressure2_notificationform_report")
+@KeySequence("pressure2_notificationform_report_seq") // 用于 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库的主键自增。如果是 MySQL 等数据库，可不写。
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class NotificationformReportDO extends BaseDO {
+
+    /**
+     * 主键
+     */
+    @TableId(value = "id", type = IdType.ASSIGN_UUID)
+    private String id;
+    /**
+     * 任务单号
+     */
+    private String taskOrderId;
+    /**
+     * 模板ID
+     */
+    private String templateId;
+    /**
+     * INSID
+     */
+    private String insId;
+
+    private String signUrl;
+
+    private LocalDateTime signDate;
+
+    private String reportNo;
+
+}

tz-module-pressure2/tz-module-pressure2-biz/src/main/java/cn/start/tz/module/pressure2/dal/mysql/notificationformreport/NotificationformReportMapper.java

@@ -0,0 +1,29 @@
+package cn.start.tz.module.pressure2.dal.mysql.notificationformreport;
+
+import java.util.*;
+
+import cn.start.tz.framework.common.pojo.PageResult;
+import cn.start.tz.framework.mybatis.core.query.LambdaQueryWrapperX;
+import cn.start.tz.framework.mybatis.core.mapper.BaseMapperX;
+import cn.start.tz.module.pressure2.dal.dataobject.notificationformreport.NotificationformReportDO;
+import org.apache.ibatis.annotations.Mapper;
+import cn.start.tz.module.pressure2.controller.admin.notificationformreport.vo.*;
+
+/**
+ * 检验情况告知 Mapper
+ *
+ * @author 特种管理员
+ */
+@Mapper
+public interface NotificationformReportMapper extends BaseMapperX<NotificationformReportDO> {
+
+    default PageResult<NotificationformReportDO> selectPage(NotificationformReportPageReqVO reqVO) {
+        return selectPage(reqVO, new LambdaQueryWrapperX<NotificationformReportDO>()
+                .eqIfPresent(NotificationformReportDO::getTaskOrderId, reqVO.getTaskOrderId())
+                .eqIfPresent(NotificationformReportDO::getTemplateId, reqVO.getTemplateId())
+                .eqIfPresent(NotificationformReportDO::getInsId, reqVO.getInsId())
+                .betweenIfPresent(NotificationformReportDO::getCreateTime, reqVO.getCreateTime())
+                .orderByDesc(NotificationformReportDO::getId));
+    }
+
+}

tz-module-pressure2/tz-module-pressure2-biz/src/main/java/cn/start/tz/module/pressure2/service/boilertaskorder/BoilerTaskOrderServiceImpl.java

@@ -35,6 +35,7 @@ import cn.start.tz.module.pressure2.controller.admin.equipboilerscheduling.vo.Bo
 import cn.start.tz.module.pressure2.controller.admin.pipetaskorder.vo.PipeRecheckUserPageReqVO;
 import cn.start.tz.module.pressure2.controller.admin.pipetaskorder.vo.PipeTaskOrderSyncReportVO;
 import cn.start.tz.module.pressure2.dal.dataobject.businessmemberrelation.BusinessMemberRelationDO;
+import cn.start.tz.module.pressure2.dal.dataobject.notificationformreport.NotificationformReportDO;
 import cn.start.tz.module.pressure2.dal.dataobject.pipetaskorder.PipeTaskOrderDO;
 import cn.start.tz.module.pressure2.dal.dataobject.pipetaskorderitemreport.PipeTaskOrderItemReportDO;
 import cn.start.tz.module.pressure2.dal.dataobject.pipetaskorderitemreportuser.PipeTaskOrderItemReportUserDO;
@@ -42,6 +43,7 @@ import cn.start.tz.module.pressure2.dal.dataobject.pipetaskorderuser.PipeTaskOrd
 import cn.start.tz.module.pressure2.dal.mysql.boileracceptorderuser.BoilerAcceptOrderUserMapper;
 import cn.start.tz.module.pressure2.dal.mysql.boilerconnectrecordreport.BoilerConnectRecordReportMapper;
 import cn.start.tz.module.pressure2.dal.mysql.businessmemberrelation.BusinessMemberRelationMapper;
+import cn.start.tz.module.pressure2.dal.mysql.notificationformreport.NotificationformReportMapper;
 import cn.start.tz.module.pressure2.dal.mysql.pipetaskorderuser.PipeTaskOrderUserMapper;
 import cn.start.tz.module.pressure2.enums.AcceptOrderStatusEnum;
 import cn.start.tz.module.pressure2.enums.RedisKeyEnums;
@@ -263,6 +265,9 @@ public class BoilerTaskOrderServiceImpl extends ServiceImpl<BoilerTaskOrderMappe
     @Resource
     private BoilerTaskOrderReportMapper taskOrderReportMapper;
 
+    @Resource
+    private NotificationformReportMapper notificationformReportMapper;
+
     @Resource
     private BoilerTaskOrderItemReportMapper taskOrderItemReportMapper;
 
@@ -633,6 +638,13 @@ public class BoilerTaskOrderServiceImpl extends ServiceImpl<BoilerTaskOrderMappe
             boilerTaskOrderRespVO.setOrderExceptionRespVO(orderExceptionRespVO);
         }
 
+        //设置检验情况告知表数量
+        NotificationformReportDO reportDO = notificationformReportMapper.selectOne(new LambdaQueryWrapperX<NotificationformReportDO>()
+                .eq(NotificationformReportDO::getTaskOrderId, id));
+        if (reportDO != null) {
+            boilerTaskOrderRespVO.setNotificationformReport(reportDO);
+        }
+
         return boilerTaskOrderRespVO;
     }
 
@@ -3889,6 +3901,40 @@ public class BoilerTaskOrderServiceImpl extends ServiceImpl<BoilerTaskOrderMappe
             return taskOrderReportDO.getId();
         }
 
+        // 检验情况告知表
+        if (dynamicTbDO.getTbType() != null && TaskOrderItemReportTypeEnum.NOTIFICATION_FORM.getType().intValue() == dynamicTbDO.getTbType()) {
+
+            NotificationformReportDO reportDO = new NotificationformReportDO();
+
+            reportDO.setTaskOrderId(orderId);
+            reportDO.setTemplateId(dynamicTbDO.getId());
+            reportDO.setReportNo(reportNo);
+
+            notificationformReportMapper.insert(reportDO);
+
+            //生成报表数据
+            CreateInstantiateWithRuleVO ruleVO = new CreateInstantiateWithRuleVO();
+            ruleVO.setTemplateId(dynamicTbDO.getId());
+            ruleVO.setRefId(reportDO.getId());
+            ruleVO.setReportType(1);
+            com.alibaba.fastjson2.JSONObject params = new com.alibaba.fastjson2.JSONObject();
+            params.put("checkUserId",getLoginUserId());
+            params.put("equipMainType","boiler");
+            ruleVO.setParams(params);
+            //获取tbCode的服务方法名
+            BoilerConnectTbServiceDO tbServiceDO = boilerConnectTbServiceMapper.selectOne(BoilerConnectTbServiceDO::getTbId,dynamicTbDO.getId());
+            if (tbServiceDO != null){
+                ruleVO.setServiceName(tbServiceDO.getInitServiceName());
+                dynamicTbInsService.createInstantiateWithRule(ruleVO);
+            }else{
+                ruleVO.setServiceName("");
+                dynamicTbInsService.createInstantiateWithRule(ruleVO);
+            }
+
+            return reportDO.getId();
+        }
+
+
         addReport.setReportNo(reportNo);
         taskOrderItemReportMapper.insert(addReport);
 
@@ -4814,499 +4860,8 @@ public class BoilerTaskOrderServiceImpl extends ServiceImpl<BoilerTaskOrderMappe
         OrderTemplateDataRepsVO repsVO = new OrderTemplateDataRepsVO();
         // 根据订单ID查询锅炉任务订单信息
         BoilerTaskOrderDO taskOrder = boilerTaskOrderMapper.selectById(orderId);
-        // 初始化服务窗口信息
-
-        // 服务窗口名称
-        String acceptanceWindow = "";
-        // 服务窗口联系人
-        String acceptanceContact = "";
-        // 如果部门ID不为空，则获取部门联系信息
-        if (StringUtils.isNotBlank(taskOrder.getDeptId())) {
-            // 调用组织联系人API获取部门联系信息
-            OrgContactDTO contactDTO = orgContactApi.selectOne(taskOrder.getDeptId()).getData();
-            // 如果获取到联系信息，则设置服务窗口名称和联系人
-            if (contactDTO != null) {
-                acceptanceWindow = contactDTO.getName();
-                acceptanceContact = contactDTO.getContact();
-            }
-        }
-
-        // 获取负责人用户信息
-        AdminUserRespDTO managerUser = null;
-        // 如果负责人ID不为空，则获取负责人信息
-        if (StringUtils.isNotBlank(taskOrder.getManagerId())) {
-            // 调用管理员用户API获取负责人信息
-            managerUser = adminUserApi.getUser(taskOrder.getManagerId()).getCheckedData();
-        }
-
-        // 根据订单ID查询任务订单项列表
-        List<BoilerTaskOrderItemDO> acceptOrderItemDOS = boilerTaskOrderItemMapper.selectList(BoilerTaskOrderItemDO::getOrderId, orderId);
-        // 根据业务类型处理不同的报表模板数据生成逻辑
-        // 先主要处理重大问题线索
-/*        if (businessType == 100) {
-            // 定期检验业务类型处理
-            // 设置默认模板ID为定期检验服务委托单
-            String templateId = TemplateIdConstants.D_Q_J_Y_F_W_D;
-            // 年检情况，修改模板ID为年度检查服务委托单
-            if (taskOrder.getCheckType() == 200) {
-                templateId = TemplateIdConstants.N_D_J_C_F_W_D;
-            }
-            // 根据模板ID查询报表模板信息
-            ReportTemplateDO reportTemplateDO = reportTemplateMapper.selectById(templateId);
-            // 设置返回对象的模板ID和模板URL
-            repsVO.setTemplateId(templateId);
-            repsVO.setTemplateUrl(reportTemplateDO.getReportTemplateUrl());
-            // 设置标准初始化数据
-            repsVO.setStandardInitData(reportTemplateDO.getBindingPathSchema());
-
-            // 获取报表默认JSON数据
-            String defaultJson = reportTemplateDO.getReportDefaultJson();
-            // 如果默认JSON为空，则设置为默认空JSON对象
-            if (StringUtils.isBlank(defaultJson)) {
-                defaultJson = "{}";
-            }
-            // 将默认JSON字符串解析为ObjectNode对象
-            ObjectNode mergedObject = (ObjectNode) objectMapper.readTree(defaultJson);
-            //ObjectNode mergedObject = JsonUtils.parseSchema(reportTemplateDO.getBindingPathSchema());
-            // 构建需要获取的模板初始化数据分类列表
-            List<String> list = Lists.newArrayList(TemplateInitDataEnums.ClassificationEnum.GLOBAL.getKey(),
-                    TemplateInitDataEnums.ClassificationEnum.CONTAINER.getKey());
-
-            // 调用API获取模板初始化数据
-            TemplateInitDataDTO initDataDTO = templateInitDataApi.getTemplateInitData(list).getCheckedData();
-            // 将初始化数据字符串解析为ObjectNode对象
-            ObjectNode initObject = (ObjectNode) objectMapper.readTree(initDataDTO.getDataStr());
-            // 将初始化数据合并到主对象中
-            mergedObject.setAll(initObject);
-
-//          非合同收费时去掉"年度检查服务单收费另议"字段
-            // 如果费用类型为100（非合同收费），则清空ndjcfwdSfly字段
-            if (Integer.valueOf(100).equals(taskOrder.getFeeType())) {
-                mergedObject.put("ndjcfwdSfly", "");
-            }
-            // 将任务订单对象转换为JSON字符串
-            String jsonData = objectMapper.writeValueAsString(taskOrder);
-            // 将JSON字符串解析为JsonNode对象
-            JsonNode node = objectMapper.readTree(jsonData);
-            // 将任务订单数据合并到主对象中
-            mergedObject.setAll((ObjectNode) node);
-
-            // 调用部门API获取部门信息
-            DeptRespDTO deptRespDTO = deptApi.getDept(taskOrder.getDeptId()).getData();
-            // 如果部门信息存在，则设置部门名称
-            if (deptRespDTO != null) {
-                mergedObject.put("deptName", deptRespDTO.getName());
-            }
-            // 如果检验日期不为空，则格式化并设置预约日期
-            if (taskOrder.getCheckDate() != null) {
-                String appointmentDate = taskOrder.getCheckDate().format(DateTimeFormatter.ISO_LOCAL_DATE);
-                mergedObject.put("appointmentDate", appointmentDate);
-            }
-
-            // 费用性质转换处理
-            if (taskOrder.getFeeNature() != null) {
-                // 初始化费用性质字符串
-                String feeNature = "";
-                // 根据费用性质代码设置对应的中文描述
-                if (taskOrder.getFeeNature() == 100) {
-                    feeNature = "行政事业收费";
-                } else if (taskOrder.getFeeNature() == 200) {
-                    feeNature = "不属免征范畴";
-                } else if (taskOrder.getFeeNature() == 300) {
-                    feeNature = "属免征范畴";
-                }
-                // 将费用性质设置到合并对象中
-                mergedObject.put("feeNature", feeNature);
-            }
-
-            // 获取第一个订单项的设备ID
-            String equipId = acceptOrderItemDOS.get(0).getEquipId();
-            // 根据设备ID查询设备锅炉信息
-            EquipContainerDO equipContainerDO = equipContainerMapper.selectById(equipId);
-            // 将设备类型设置到合并对象中
-            mergedObject.put("type", equipContainerDO.getType());
-            // 初始化序号计数器
-            AtomicInteger index = new AtomicInteger(1);
-            // 将订单项列表转换为打印VO列表
-            List<AcceptOrderItemPrintVO> acceptOrderItemPrintVOList = acceptOrderItemDOS.stream().map(item -> {
-                // 创建订单项打印VO对象
-                AcceptOrderItemPrintVO acceptOrderItemPrint = new AcceptOrderItemPrintVO();
-                // 设置序号
-                acceptOrderItemPrint.setSerialNumber(index.getAndIncrement());
-                // 设置设备名称
-                acceptOrderItemPrint.setEquipName(item.getEquipName());
-                // 设置使用登记号
-                acceptOrderItemPrint.setUseRegisterNo(item.getUseRegisterNo());
-                // 设置产品编号
-                acceptOrderItemPrint.setProductNo(item.getProductNo());
-                // 设置设备代码
-                acceptOrderItemPrint.setEquipCode(item.getEquipCode());
-                // 如果费用不为空，则格式化费用并设置，否则设置为"0"
-                if (ObjectUtil.isNotNull(item.getFee())) {
-                    acceptOrderItemPrint.setExpense(item.getFee()
-                            .setScale(2, RoundingMode.HALF_UP).toPlainString());
-                } else {
-                    acceptOrderItemPrint.setExpense("0");
-                }
-                // 设置报告编号
-                acceptOrderItemPrint.setReportNo(item.getReportNo());
-                // 返回打印VO对象
-                return acceptOrderItemPrint;
-            }).toList();
-
-            // 将订单项打印VO列表转换为JSON字符串
-            String orderItems = objectMapper.writeValueAsString(acceptOrderItemPrintVOList);
-            // 将JSON字符串解析为JsonNode对象
-            JsonNode orderItemsNode = objectMapper.readTree(orderItems);
-            // 将订单项数据设置到合并对象中
-            mergedObject.put("orderItems", orderItemsNode);
-            // 设置受理编号
-            mergedObject.put("acceptNo", taskOrder.getOrderNo());
-            // 设置收件人
-            mergedObject.put("recipient", taskOrder.getRecipient());
-            // 设置收件人电话
-            mergedObject.put("recipientPhone", taskOrder.getRecipientPhone());
-
-            // 格式化服务金额并转换为大写中文金额
-            BigDecimal actualAmount = taskOrder.getServiceAmount().setScale(2, RoundingMode.HALF_UP);
-            String amountCapitals = Convert.digitToChinese(actualAmount);
-            // 设置实际金额和大写金额
-            mergedObject.put("actualAmount", actualAmount);
-            mergedObject.put("amountCapitals", amountCapitals);
-            // 设置使用单位社会信用代码
-            mergedObject.put("useUnitSocialCreditCode", taskOrder.getUseUnitSocialCreditCode());
-            // 设置社会信用代码
-            mergedObject.put("socialCreditCode", taskOrder.getSocialCreditCode());
-            // 设置设备数量
-            mergedObject.put("equipNum", taskOrder.getEquipNum());
-            // 设置检验日期（中文格式）
-            mergedObject.put("checkDate", taskOrder.getCheckDate().format(CHINESE_DATE_FORMATTER));
-            // 设置设备类型
-            mergedObject.put("equipType", taskOrder.getEquipType());
-
-            // 设置服务窗口信息
-            mergedObject.put("acceptanceWindow", acceptanceWindow);
-            mergedObject.put("acceptanceContact", acceptanceContact);
-            // 如果负责人用户信息存在且手机号不为空，则设置签名电话
-            if (ObjectUtil.isNotEmpty(managerUser) && StringUtils.isNotEmpty(managerUser.getMobile())) {
-                mergedObject.put("signPhone", managerUser.getMobile());
-            }
-            // 处理备注字段，将空备注填充为"无"
-            String dataStr = mergedObject.toPrettyString();
-            dataStr = processRemarkFields(dataStr);
-            // 设置数据字符串
-            repsVO.setDataStr(dataStr);
-            // 返回结果对象
-            return repsVO;
-        } else if (businessType == 200) {
-            // QC01012-2025/00 检验情况告知单业务类型处理
-
-            // 设置检验情况告知单模板ID
-            String templateId = TemplateIdConstants.J_Y_Q_K_G_Z_D;
-            // 根据模板ID查询报表模板信息
-            ReportTemplateDO reportTemplateDO = reportTemplateMapper.selectById(templateId);
-            // 设置返回对象的模板ID和模板URL
-            repsVO.setTemplateId(templateId);
-            repsVO.setTemplateUrl(reportTemplateDO.getReportTemplateUrl());
-            // 设置翻译初始化数据和标准初始化数据
-            repsVO.setTranslateInitData(reportTemplateDO.getBindingPathNameJson());
-            repsVO.setStandardInitData(reportTemplateDO.getBindingPathSchema());
-
-            // 获取记录默认JSON数据
-            String defaultJson = reportTemplateDO.getRecordDefaultJson();
-            // 如果默认JSON为空，则设置为默认空JSON对象
-            if (StringUtils.isBlank(defaultJson)) {
-                defaultJson = "{}";
-            }
-            // 将默认JSON字符串解析为ObjectNode对象
-            ObjectNode mergedObject = (ObjectNode) objectMapper.readTree(defaultJson);
-            // ObjectNode mergedObject = JsonUtils.parseSchema(reportTemplateDO.getBindingPathSchema());
-            // 构建需要获取的模板初始化数据分类列表
-            List<String> list = Lists.newArrayList(TemplateInitDataEnums.ClassificationEnum.GLOBAL.getKey(),
-                    TemplateInitDataEnums.ClassificationEnum.CONTAINER.getKey());
-
-            // 调用API获取模板初始化数据
-            TemplateInitDataDTO initDataDTO = templateInitDataApi.getTemplateInitData(list).getCheckedData();
-            // 将初始化数据字符串解析为ObjectNode对象
-            ObjectNode initObject = (ObjectNode) objectMapper.readTree(initDataDTO.getDataStr());
-            // 将初始化数据合并到主对象中
-            mergedObject.setAll(initObject);
-
-            // 将任务订单对象转换为JSON字符串
-            String jsonData = objectMapper.writeValueAsString(taskOrder);
-            // 将JSON字符串解析为JsonNode对象
-            JsonNode node = objectMapper.readTree(jsonData);
-            // 将任务订单数据合并到主对象中
-            mergedObject.setAll((ObjectNode) node);
-            // 初始化序号计数器
-            AtomicInteger number = new AtomicInteger(1);
-            // 查询订单项报告列表（排除已取消状态的报告）
-            List<TaskOrderItemReportDO> reportDOList = taskOrderItemReportMapper
-                    .selectListByOrderIdAndNotTaskStatus(orderId, TaskOrderStatusEnum.CANCEL.getStatus(),
-                            Lists.newArrayList(TaskOrderItemReportTypeEnum.MAIN_REPORT.getType(),
-                                    TaskOrderItemReportTypeEnum.SUB_REPORT.getType(),
-                                    TaskOrderItemReportTypeEnum.SOLO_TRIP_REPORT.getType()));
-
-            // 按订单项ID对报告列表进行分组
-            Map<String, List<TaskOrderItemReportDO>> listMap = reportDOList.stream()
-                    .filter(v -> StrUtil.isNotEmpty(v.getOrderItemId()))
-                    .collect(Collectors.groupingBy(TaskOrderItemReportDO::getOrderItemId));
-
-            // 将订单项列表转换为打印VO列表
-            List<Map<String, String>> acceptOrderItemPrintVOList = new ArrayList<>(acceptOrderItemDOS.stream().map(item -> {
-                // 创建Map存储订单项信息
-                Map<String, String> map = new HashMap<>();
-                // 设置序号
-                map.put("serialNumber", String.valueOf(number.getAndIncrement()));
-                // 设置设备名称
-                map.put("equipName", item.getEquipName());
-                // 设置使用登记号
-                map.put("useRegisterNo", item.getUseRegisterNo());
-                // 设置产品编号
-                map.put("productNo", item.getProductNo());
-                // 获取当前订单项的报告列表
-                List<TaskOrderItemReportDO> itemReportDOList = listMap.get(item.getId());
-                // 如果报告列表不为空
-                if (CollUtil.isNotEmpty(itemReportDOList)) {
-                    // 初始化是否存在问题标志
-                    boolean issue = false;
-                    // 创建问题集合
-                    Set<String> valueSetName = Sets.newHashSet();
-                    Set<String> valueSet = Sets.newHashSet();
-                    // 遍历报告列表
-                    for (TaskOrderItemReportDO reportDO : itemReportDOList) {
-                        // 如果报告结论为空或为"无"
-                        if (StrUtil.isEmpty(reportDO.getReportConclusion()) || "无".equals(reportDO.getReportConclusion())) {
-                            // 将报告名称添加到问题集合中
-                            valueSetName.add(reportDO.getReportName());
-                        } else {
-                            // 如果报告结论包含"不符合"或"不合格"
-                            if (StrUtil.contains(reportDO.getReportConclusion(), "不符合")
-                                    || StrUtil.contains(reportDO.getReportConclusion(), "不合格")) {
-                                // 设置存在问题标志为true
-                                issue = true;
-                                // 将报告名称添加到问题集合中
-                                valueSetName.add(reportDO.getReportName());
-
-                                try {
-                                    // 尝试将报告结论解析为字符串数组
-                                    String[] strings = objectMapper.readValue(reportDO.getReportConclusion(), String[].class);
-
-                                    // 初始化临时字符串
-                                    String tmp = reportDO.getReportName();
-                                    // 如果字符串数组不为空且长度大于0，则拼接第一个元素
-                                    if (strings != null && strings.length > 0) {
-                                        tmp = reportDO.getReportName() + strings[0];
-                                    }
-                                    // 将临时字符串添加到值集合中
-                                    valueSet.add(tmp);
-                                } catch (Exception e) {
-                                    // 如果解析异常，则将报告名称和结论拼接后添加到值集合中
-                                    valueSet.add(reportDO.getReportName() + reportDO.getReportConclusion());
-                                }
 
-                            }
-                        }
-                    }
-
-                    // 如果问题名称集合为空，则添加"无"
-                    if (valueSetName.isEmpty()) {
-                        valueSetName.add("无");
-                    }
-
-                    // 如果问题值集合为空，则添加"无"
-                    if (valueSet.isEmpty()) {
-                        valueSet.add("无");
-                    }
-                    // 设置问题名称和问题值
-                    map.put("value1", String.join(";", valueSetName));
-                    map.put("value2", String.join(";", valueSet));
-                    // 根据是否存在设置问题标志设置值
-                    if (issue) {
-                        map.put("value3", "是");
-                    } else {
-                        map.put("value3", "否");
-                    }
-
-                    // 默认设置暂停标志为否
-                    map.put("value4", "否");
-                }
-                // 返回Map对象
-                return map;
-            }).toList());
-
-            // 查询任务订单项暂停列表
-            List<TaskOrderItemSuspendDO> taskOrderItemSuspendDOS = taskOrderItemSuspendMapper.selectList(new LambdaQueryWrapperX<TaskOrderItemSuspendDO>().
-                    eq(TaskOrderItemSuspendDO::getOrderId, taskOrder.getId()).
-                    eq(TaskOrderItemSuspendDO::getIsCancel, false));
-
-            // 统计问题名称为"无"的数量
-            long count = acceptOrderItemPrintVOList.stream().filter(v -> "无".equals(v.get("value1"))).count();
-
-            // 如果暂停列表不为空
-            if (CollUtil.isNotEmpty(taskOrderItemSuspendDOS)) {
-                // 创建新的列表
-                List<Map<String, String>> list1 = new ArrayList<>();
-                // 创建检查Map
-                Map<String, String> checkMap = new HashMap<>();
-                // 遍历暂停列表
-                taskOrderItemSuspendDOS.stream().forEach(item -> {
-
-                    // 获取设备代码对应的检查值
-                    String check = checkMap.get(item.getEquipCode());
-                    // 如果检查值为空
-                    if (StringUtils.isBlank(check)) {
-                        // 创建Map存储暂停项信息
-                        Map<String, String> map = new HashMap<>();
-                        // 设置序号
-                        map.put("serialNumber", String.valueOf(number.getAndIncrement()));
-                        // 设置设备名称
-                        map.put("equipName", item.getEquipName());
-                        // 设置使用登记号
-                        map.put("useRegisterNo", item.getUseRegisterNo());
-                        // 设置产品编号
-                        map.put("productNo", item.getProductNo());
-
-                        // 设置暂停项相关信息
-                        map.put("value1", "-");
-                        map.put("value2", "-");
-                        map.put("value3", "否");
-                        map.put("value4", "是");
-                        // 将Map添加到列表中
-                        list1.add(map);
-                    }
-
-                    // 将设备代码添加到检查Map中
-                    checkMap.put(item.getEquipCode(), item.getEquipCode());
-                });
-
-                // 将暂停项列表添加到主列表中
-                acceptOrderItemPrintVOList.addAll(list1);
-            }
-
-            // 将订单项打印VO列表转换为JSON字符串
-            String tableList = objectMapper.writeValueAsString(acceptOrderItemPrintVOList);
-            // 将JSON字符串解析为JsonNode对象
-            JsonNode orderItemsNode = objectMapper.readTree(tableList);
-            // 将订单项数据设置到合并对象中
-            mergedObject.put("orderItems", orderItemsNode);
-            // 设置使用单位名称
-            mergedObject.put("useUnitName", taskOrder.getUseUnitName());
-            // 设置设备数量
-            mergedObject.put("value1", taskOrder.getEquipNum());
-            // 设置无问题数量
-            mergedObject.put("value2", count);
-            // 设置固定值15
-            mergedObject.put("value3", 15);
-            // 设置有问题数量
-            mergedObject.put("value4", taskOrder.getEquipNum() - count);
-            // 设置收件人电话
-            mergedObject.put("value5", taskOrder.getRecipientPhone());
-
-
-            // 初始化暂停数量
-            Integer suspend = 0;
-            // 如果暂停列表不为空
-            if (CollUtil.isNotEmpty(taskOrderItemSuspendDOS)) {
-                // 获取暂停设备代码集合
-                Set<String> suspendSet = taskOrderItemSuspendDOS.stream().map(TaskOrderItemSuspendDO::getEquipCode).collect(Collectors.toSet());
-                // 设置暂停数量
-                suspend = suspendSet.size();
-            }
-
-            // 设置暂停数量
-            mergedObject.put("value8", suspend);
-            // 设置订单号
-            mergedObject.put("orderNo", taskOrder.getOrderNo());
-
-            // 获取检验员名称集合
-            Set<String> checkNames = reportDOList.stream().map(TaskOrderItemReportDO::getEnterName)
-                    .filter(ObjectUtil::isNotNull)
-                    .collect(Collectors.toSet());
-
-            // 获取检验时间列表
-            List<LocalDateTime> checkDates = reportDOList.stream()
-                    .map(TaskOrderItemReportDO::getEnterTime).filter(ObjectUtil::isNotNull)
-                    .toList();
-            // 如果检验员名称集合不为空，则设置检验员名称
-            if (CollUtil.isNotEmpty(checkNames)) {
-                mergedObject.put("checkeName", String.join(",", checkNames));
-            }
-            // 获取最早的检验时间
-            LocalDateTime earliest = checkDates.stream()
-                    .min(Comparator.naturalOrder())
-                    .orElse(null); // 或者使用orElseThrow根据业务需求
-
-            // 获取最晚的检验时间
-            LocalDateTime latest = checkDates.stream()
-                    .max(Comparator.naturalOrder())
-                    .orElse(null);
-            // 如果最早和最晚时间都不为空
-            if (ObjectUtil.isNotNull(earliest) && ObjectUtil.isNotNull(latest)) {
-                // 如果最早和最晚时间为同一天，则只显示一个日期
-                if (earliest.format(CHINESE_DATE_FORMATTER).equals(latest.format(CHINESE_DATE_FORMATTER))) {
-                    mergedObject.put("enterDate", earliest.format(CHINESE_DATE_FORMATTER));
-                } else {
-                    // 否则显示日期范围
-                    mergedObject.put("enterDate", earliest.format(CHINESE_DATE_FORMATTER) + "-" + latest.format(CHINESE_DATE_FORMATTER));
-                }
-            }
-
-            // 如果负责人用户信息存在且手机号不为空，则设置签名电话
-            if (ObjectUtil.isNotEmpty(managerUser) && StringUtils.isNotEmpty(managerUser.getMobile())) {
-                mergedObject.put("signPhone", managerUser.getMobile());
-            }
-
-            // 处理备注字段，将空备注填充为"无"
-            String dataStr = mergedObject.toPrettyString();
-            dataStr = processRemarkFields(dataStr);
-            // 设置数据字符串
-            repsVO.setDataStr(dataStr);
-            // 返回结果对象
-            return repsVO;
-        } else if (businessType == 300) {
-            // 安全检查工作单业务类型处理
-            // 设置安全检查工作单模板ID
-            String templateId = TemplateIdConstants.A_Q_J_C_G_Z_D;
-            // 根据模板ID查询报表模板信息
-            ReportTemplateDO reportTemplateDO = reportTemplateMapper.selectById(templateId);
-            // 设置返回对象的模板ID
-            repsVO.setTemplateId(templateId);
-            // 记录模版
-            // 设置记录模板URL
-            repsVO.setTemplateUrl(reportTemplateDO.getRecordTemplateUrl());
-            // 设置翻译初始化数据和标准初始化数据
-            repsVO.setTranslateInitData(reportTemplateDO.getBindingPathNameJson());
-            repsVO.setStandardInitData(reportTemplateDO.getBindingPathSchema());
-
-            // ObjectNode mergedObject = JsonUtils.parseSchema(reportTemplateDO.getBindingPathSchema());
-            // 获取记录默认JSON数据
-            String defaultJson = reportTemplateDO.getRecordDefaultJson();
-            // 如果默认JSON为空，则设置为默认空JSON对象
-            if (StringUtils.isBlank(defaultJson)) {
-                defaultJson = "{}";
-            }
-            // 将默认JSON字符串解析为ObjectNode对象
-            ObjectNode mergedObject = (ObjectNode) objectMapper.readTree(defaultJson);
-
-            // 调用安全检查服务设置数据源
-            taskOrderSecurityCheckService.setDataSource(orderId, mergedObject);
-
-//            List<TaskOrderSecurityCheckDO> taskOrderSecurityCheckDOS = taskOrderSecurityCheckMapper.selectList(new LambdaQueryWrapperX<TaskOrderSecurityCheckDO>().
-//                    eq(TaskOrderSecurityCheckDO::getOrderId, orderId).
-//                    orderByDesc(TaskOrderSecurityCheckDO::getCreateTime));
-//
-//            if(CollUtil.isNotEmpty(taskOrderSecurityCheckDOS)){
-//                TaskOrderSecurityCheckDO taskOrderSecurityCheckDO = taskOrderSecurityCheckDOS.get(0);
-//                repsVO.setDataStr(taskOrderSecurityCheckDO.getJsonData());
-//            }else{
-            // 设置数据字符串
-            repsVO.setDataStr(mergedObject.toString());
-//            }
-
-            // 返回结果对象
-            return repsVO;
-        } else*/ if (businessType == 400) {
+        if (businessType == 400) {
             // 重点问题事项告知单业务类型处理
             // 根据订单项ID查询任务订单项信息
             BoilerTaskOrderItemDO taskOrderItemDO = boilerTaskOrderItemMapper.selectById(orderItemId);
@@ -5354,93 +4909,32 @@ public class BoilerTaskOrderServiceImpl extends ServiceImpl<BoilerTaskOrderMappe
             // 设置重点问题事项告知单模板ID
             String templateId = TemplateIdConstants.Z_D_W_T_S_X_G_Z_D;
             // 根据模板ID查询报表模板信息
-            //ReportTemplateDO reportTemplateDO = reportTemplateMapper.selectById(templateId);
             DynamicTbDO reportTemplateDO = dynamicTbMapper.selectById(templateId);
+            if (reportTemplateDO == null){
+                throw new ServiceException(904, "未找到重大问题线索模板");
+            }
             // 设置返回对象的模板ID和模板URL
             repsVO.setTemplateId(templateId);
-            //repsVO.setTemplateUrl(reportTemplateDO.getReportTemplateUrl());
-            // 设置标准初始化数据
-            //repsVO.setStandardInitData(reportTemplateDO.getBindingPathSchema());
-
-            // ObjectNode mergedObject = JsonUtils.parseSchema(reportTemplateDO.getBindingPathSchema());
-            // 构建需要获取的模板初始化数据分类列表
-            List<String> list = Lists.newArrayList(TemplateInitDataEnums.ClassificationEnum.GLOBAL.getKey(),
-                    TemplateInitDataEnums.ClassificationEnum.MAJOR_ISSUES.getKey());
-
-//            // 获取记录默认JSON数据
-//            //String defaultJson = reportTemplateDO.getRecordDefaultJson();
-//            String defaultJson = "";
-//            // 如果默认JSON为空，则设置为默认空JSON对象
-//            if (StringUtils.isBlank(defaultJson)) {
-//                defaultJson = "{}";
-//            }
-//            // 将默认JSON字符串解析为ObjectNode对象
-//            ObjectNode mergedObject = (ObjectNode) objectMapper.readTree(defaultJson);
-//            // 调用API获取模板初始化数据
-//            TemplateInitDataDTO initDataDTO = templateInitDataApi.getTemplateInitData(list).getCheckedData();
-//            // 将初始化数据字符串解析为ObjectNode对象
-//            ObjectNode initObject = (ObjectNode) objectMapper.readTree(initDataDTO.getDataStr());
-//            // 将初始化数据合并到主对象中
-//            mergedObject.setAll(initObject);
-//
-//            // 将任务订单对象转换为JSON字符串
-//            String jsonData = objectMapper.writeValueAsString(taskOrder);
-//            // 将JSON字符串解析为JsonNode对象
-//            JsonNode node = objectMapper.readTree(jsonData);
-//            // 将任务订单数据合并到主对象中
-//            mergedObject.setAll((ObjectNode) node);
-//
-//            // 调用部门API获取部门信息
-//            DeptRespDTO deptRespDTO = deptApi.getDept(taskOrder.getDeptId()).getData();
-//            // 如果部门信息存在，则设置部门名称
-//            if (deptRespDTO != null) {
-//                mergedObject.put("deptName", deptRespDTO.getName());
-//            }
-//            // 如果检验日期不为空，则格式化并设置预约日期
-//            if (taskOrder.getCheckDate() != null) {
-//                String appointmentDate = taskOrder.getCheckDate().format(DateTimeFormatter.ISO_LOCAL_DATE);
-//                mergedObject.put("appointmentDate", appointmentDate);
-//            }
-//            // 设置设备类型
-//            mergedObject.put("type", equipContainerDO.getType());
-//            // 设置报告编号
-//            mergedObject.put("reportNo", list1.get(0).getReportNo());
-//            // 设置单位名称
-//            mergedObject.put("unitName", taskOrder.getUnitName());
-//            // 设置单位地址
-//            mergedObject.put("unitAddress", taskOrder.getUnitAddress());
-//            // 设置法定代表人
-//            mergedObject.put("legalPerson", clientUnitDTO.getLegalPerson());
-//            // 设置安全管理负责人
-////            mergedObject.put("safeManager", equipContainerDO.getSafeManager());
-//            // 设置单位联系人
-//            mergedObject.put("unitContact", taskOrder.getUnitContact());
-//            // 设置单位电话
-//            mergedObject.put("unitPhone", taskOrder.getUnitPhone());
-//            // 设置设备名称
-//            mergedObject.put("equipName", equipContainerDO.getEquipName());
-//            // 设置设备代码
-//            mergedObject.put("equipCode", equipContainerDO.getEquipCode());
-//            // 设置设备区域
-//            mergedObject.put("equipDistrict", equipContainerDO.getEquipDistrict());
-//            // 设置设备地址
-//            mergedObject.put("equipAddress", equipContainerDO.getBoilerAddress());
-//            // 如果负责人用户信息存在且手机号不为空，则设置签名电话
-//            if (ObjectUtil.isNotEmpty(managerUser) && StringUtils.isNotEmpty(managerUser.getMobile())) {
-//                mergedObject.put("signPhone", managerUser.getMobile());
-//            }
-//            // 处理备注字段，将空备注填充为"无"
-//            String dataStr = mergedObject.toPrettyString();
-//            dataStr = processRemarkFields(dataStr);
-//            // 设置数据字符串
-//            repsVO.setDataStr(dataStr);
-            // 返回结果对象
+
+            return repsVO;
+        } else if (businessType == 1000) {
+
+            // 设置检验情况告知单模板ID
+            String templateId = TemplateIdConstants.J_Y_Q_K_G_Z_D;
+            // 根据模板ID查询报表模板信息
+            DynamicTbDO reportTemplateDO = dynamicTbMapper.selectById(templateId);
+            if (reportTemplateDO == null){
+                throw new ServiceException(904, "未找到检验情况告知单模板");
+            }
+            // 设置返回对象的模板ID和模板URL
+            repsVO.setTemplateId(templateId);
+
             return repsVO;
+
         } else {
             // 不支持的业务类型
             throw new ServiceException(904, "其他业务类型功能待完善");
         }
-
     }
 
     /**
@@ -5949,6 +5443,9 @@ public class BoilerTaskOrderServiceImpl extends ServiceImpl<BoilerTaskOrderMappe
                 return true;
             }else{
                 //throw new ServiceException(500, "生成报表数据失败，初始化服务方法未配置");
+                ruleVO.setServiceName("");
+                dynamicTbInsService.createInstantiateWithRule(ruleVO);
+                return true;
             }
 
         }

tz-module-pressure2/tz-module-pressure2-biz/src/main/java/cn/start/tz/module/pressure2/service/dynamicOFData/comm/QC01012_202500OFData.java

@@ -0,0 +1,392 @@
+package cn.start.tz.module.pressure2.service.dynamicOFData.comm;
+
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.core.util.StrUtil;
+import cn.start.tz.framework.ip.core.utils.AreaUtils;
+import cn.start.tz.module.pressure2.controller.admin.dynamictbins.vo.CreateInstantiateWithRuleVO;
+import cn.start.tz.module.pressure2.controller.admin.equipboiler.vo.EquipBoilerReportVO;
+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.equippipe.EquipPipeDO;
+import cn.start.tz.module.pressure2.dal.dataobject.notificationformreport.NotificationformReportDO;
+import cn.start.tz.module.pressure2.dal.dataobject.pipetaskorder.PipeTaskOrderDO;
+import cn.start.tz.module.pressure2.dal.dataobject.pipetaskorderitem.PipeTaskOrderItemDO;
+import cn.start.tz.module.pressure2.dal.dataobject.pipetaskorderitemreport.PipeTaskOrderItemReportDO;
+import cn.start.tz.module.pressure2.dal.dataobject.pipetaskorderitemreportuser.PipeTaskOrderItemReportUserDO;
+import cn.start.tz.module.pressure2.dal.mysql.boilertaskorder.BoilerTaskOrderMapper;
+import cn.start.tz.module.pressure2.dal.mysql.boilertaskorderitem.BoilerTaskOrderItemMapper;
+import cn.start.tz.module.pressure2.dal.mysql.boilertaskorderitemreport.BoilerTaskOrderItemReportMapper;
+import cn.start.tz.module.pressure2.dal.mysql.equipboiler.EquipBoilerMapper;
+import cn.start.tz.module.pressure2.dal.mysql.equippipe.EquipPipeMapper;
+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.dal.mysql.pipetaskorderitem.PipeTaskOrderItemMapper;
+import cn.start.tz.module.pressure2.dal.mysql.pipetaskorderitemreport.PipeTaskOrderItemReportMapper;
+import cn.start.tz.module.pressure2.enums.TaskOrderItemReportTypeEnum;
+import cn.start.tz.module.pressure2.enums.TaskOrderStatusEnum;
+import cn.start.tz.module.pressure2.service.dynamicOFData.IDynamicOFData;
+import cn.start.tz.module.pressure2.service.dynamicOFData.util.AutoDataPipeService;
+import cn.start.tz.module.system.api.clientunit.ClientUnitApi;
+import cn.start.tz.module.system.api.clientunit.dto.ClientUnitDTO;
+import cn.start.tz.module.system.api.user.AdminUserApi;
+import cn.start.tz.module.system.api.user.dto.AdminUserRespDTO;
+import com.alibaba.fastjson2.JSONArray;
+import com.alibaba.fastjson2.JSONObject;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+import jakarta.annotation.Resource;
+import org.springframework.stereotype.Service;
+
+import java.time.format.DateTimeFormatter;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
+
+/**
+ * 检验情况告知表
+ * */
+@Service("QC01012_202500OFData")
+public class QC01012_202500OFData implements IDynamicOFData {
+
+    @Resource
+    private EquipBoilerMapper equipBoilerMapper;
+
+    @Resource
+    private EquipPipeMapper equipPipeMapper;
+
+    @Resource
+    private NotificationformReportMapper notificationformReportMapper;
+
+    @Resource
+    private PipeTaskOrderItemReportMapper pipeTaskOrderItemReportMapper;
+
+    @Resource
+    private BoilerTaskOrderItemReportMapper boilerTaskOrderItemReportMapper;
+
+    @Resource
+    private BoilerTaskOrderMapper boilerTaskOrderMapper;
+
+    @Resource
+    private BoilerTaskOrderItemMapper boilerTaskOrderItemMapper;
+
+    @Resource
+    private PipeTaskOrderMapper pipeTaskOrderMapper;
+
+    @Resource
+    private PipeTaskOrderItemMapper pipeTaskOrderItemMapper;
+
+    @Resource
+    private ObjectMapper objectMapper;
+
+    @Resource
+    private AutoDataPipeService autoDataPipeService;
+
+    @Resource
+    private AdminUserApi adminUserApi;
+
+    @Resource
+    private ClientUnitApi clientUnitApi;
+
+    @Override
+    public JSONObject getOFData(JSONObject params) {
+        return null;
+    }
+
+    @Override
+    public JSONObject getOfDataByVO(CreateInstantiateWithRuleVO ruleVO) {
+
+        //日期格式
+        DateTimeFormatter dateFormat = DateTimeFormatter.ofPattern("yyyy年MM月dd日");
+        //主设备类型
+        String equipMainTpe = ruleVO.getParams().getString("equipMainType");
+
+        //设备报表ID
+        String refId = ruleVO.getRefId();
+
+        JSONObject result = new JSONObject();
+
+        if (equipMainTpe.equals("boiler")){
+
+            NotificationformReportDO formReportDO = notificationformReportMapper.selectById(refId);
+            if (formReportDO != null){
+
+                String orderId = formReportDO.getTaskOrderId();
+                BoilerTaskOrderDO taskOrderDO = boilerTaskOrderMapper.selectById(orderId);
+                List<BoilerTaskOrderItemDO> itemDOS = boilerTaskOrderItemMapper.selectList(new LambdaQueryWrapper<BoilerTaskOrderItemDO>()
+                        .eq(BoilerTaskOrderItemDO::getOrderId, orderId)
+                );
+
+                if (!itemDOS.isEmpty()){
+
+                    AtomicInteger number = new AtomicInteger(1);
+                    List<BoilerTaskOrderItemReportDO> reportDOList = boilerTaskOrderItemReportMapper
+                            .selectListByOrderIdAndNotTaskStatus(orderId, TaskOrderStatusEnum.CANCEL.getStatus(),
+                                    Lists.newArrayList(TaskOrderItemReportTypeEnum.MAIN_REPORT.getType(),
+                                            TaskOrderItemReportTypeEnum.SUB_REPORT.getType(),
+                                            TaskOrderItemReportTypeEnum.SOLO_TRIP_REPORT.getType()));
+                    Map<String, List<BoilerTaskOrderItemReportDO>> listMap = reportDOList.stream()
+                            .filter(v -> StrUtil.isNotEmpty(v.getOrderItemId()))
+                            .collect(Collectors.groupingBy(BoilerTaskOrderItemReportDO::getOrderItemId));
+
+                    JSONArray voList = new JSONArray();
+                    itemDOS.forEach(itemDO -> {
+
+                        List<BoilerTaskOrderItemReportDO> itemReportDOList = listMap.get(itemDO.getId());
+                        Set<String> valueSetName = Sets.newHashSet();
+                        Set<String> valueSet = Sets.newHashSet();
+                        for (BoilerTaskOrderItemReportDO reportDO : itemReportDOList) {
+                            if (StrUtil.contains(reportDO.getReportConclusion(), "不符合")
+                                    || StrUtil.contains(reportDO.getReportConclusion(), "不合格")
+                                    || StrUtil.contains(reportDO.getReportConclusion(), "资料不齐")
+                            ) {
+                                valueSetName.add(reportDO.getReportName());
+
+                                try {
+                                    String[] strings = objectMapper.readValue(reportDO.getReportConclusion(), String[].class);
+                                    String tmp = reportDO.getReportName();
+                                    if (strings != null && strings.length > 0) {
+                                        tmp = reportDO.getReportName() + strings[0];
+                                    }
+                                    valueSet.add(tmp);
+                                } catch (Exception e) {
+                                    valueSet.add(reportDO.getReportName() + reportDO.getReportConclusion());
+                                }
+                            }
+                        }
+
+                        if (valueSetName.isEmpty()) {
+                            valueSetName.add("无");
+                        }
+                        if (valueSet.isEmpty()) {
+                            valueSet.add("无");
+                        }
+
+                        EquipBoilerReportVO equipBoilerDO = equipBoilerMapper.selectDetailsById(itemDO.getEquipId());
+                        if (equipBoilerDO != null){
+
+                            JSONObject vo = new JSONObject();
+                            //序号
+                            vo.put("value1",String.valueOf(number.getAndIncrement()));
+                            //设备名称
+                            vo.put("value2",equipBoilerDO.getEquipName());
+                            //使用证号
+                            vo.put("value3",equipBoilerDO.getUseRegisterNo());
+                            //产品编号
+                            vo.put("value4",equipBoilerDO.getEquipCode());
+                            //需进一步检验项目
+                            vo.put("value5",valueSetName);
+
+                            //是否有检验意见通知书
+                            List<BoilerTaskOrderItemReportDO> itemReportDOS = boilerTaskOrderItemReportMapper.selectList(new LambdaQueryWrapper<BoilerTaskOrderItemReportDO>()
+                                    .eq(BoilerTaskOrderItemReportDO::getOrderId, itemDO.getId())
+                                    .eq(BoilerTaskOrderItemReportDO::getReportType, TaskOrderItemReportTypeEnum.NOTICE_OF_OPINION.getType())
+                            );
+                            if (!itemReportDOS.isEmpty()){
+                                //存在问题
+                                vo.put("value6","有");
+                                //是否出具意见通知书
+                                vo.put("value7","是");
+                            }else{
+                                vo.put("value6","无");
+                                vo.put("value7","否");
+                            }
+
+                            //是否中止检验
+                            vo.put("value8","否");
+                            voList.add(vo);
+                        }
+
+                    });
+
+                    result.put("table",voList.toJSONString());
+
+                    long equipNum2 = itemDOS.stream().filter(itemDO -> itemDO.getTaskStatus() >= TaskOrderStatusEnum.FINISH_CONFIRM.getStatus()).count();
+                    result.put("equipNum1",itemDOS.size()); //检验设备数量
+                    result.put("equipNum2",equipNum2); //已检验设备数量
+                    result.put("equipNum3",0); //中止检验设备
+                    result.put("equipNum4",itemDOS.size() - equipNum2); //进一步检验设备
+
+                    result.put("customerSign",formReportDO.getSignUrl());
+                    result.put("customerSingDate",formReportDO.getSignDate());
+                    result.put("remainDays",15);
+
+                    Set<String> checkIds = reportDOList.stream().map(BoilerTaskOrderItemReportDO::getEnterId)
+                            .filter(ObjectUtil::isNotNull)
+                            .collect(Collectors.toSet());
+                    if (!checkIds.isEmpty()){
+                        List<AdminUserRespDTO> userList = adminUserApi.getUserList(checkIds).getData();
+                        if (!userList.isEmpty()){
+                            String checkNames = userList.stream()
+                                    .map(AdminUserRespDTO::getSignUrl)
+                                    .filter(Objects::nonNull) // 过滤掉null值
+                                    .filter(signUrl -> !signUrl.isEmpty()) // 过滤掉空字符串
+                                    .collect(Collectors.joining(","));
+                            result.put("checkName",checkNames);
+                        }
+                    }
+
+                    if (formReportDO.getCreateTime() != null) {
+                        result.put("enterDate", formReportDO.getCreateTime().format(dateFormat));
+                    } else {
+                        result.put("enterDate", "-");
+                    }
+
+                    result.put("reportNo",formReportDO.getReportNo());
+                    if (taskOrderDO != null) {
+                        result.put("unitName",taskOrderDO.getUnitName());
+                        result.put("receivePhone",taskOrderDO.getUnitPhone());
+                    }
+
+                }
+
+            }
+
+        }else if (equipMainTpe.equals("pipe")){
+
+            NotificationformReportDO formReportDO = notificationformReportMapper.selectById(refId);
+            if (formReportDO != null){
+
+                String orderId = formReportDO.getTaskOrderId();
+                PipeTaskOrderDO taskOrderDO = pipeTaskOrderMapper.selectById(orderId);
+                List<PipeTaskOrderItemDO> itemDOS = pipeTaskOrderItemMapper.selectList(new LambdaQueryWrapper<PipeTaskOrderItemDO>()
+                        .eq(PipeTaskOrderItemDO::getOrderId, orderId)
+                );
+
+                if (!itemDOS.isEmpty()){
+
+                    AtomicInteger number = new AtomicInteger(1);
+                    List<PipeTaskOrderItemReportDO> reportDOList = pipeTaskOrderItemReportMapper
+                            .selectListByOrderIdAndNotTaskStatus(orderId, TaskOrderStatusEnum.CANCEL.getStatus(),
+                                    Lists.newArrayList(TaskOrderItemReportTypeEnum.MAIN_REPORT.getType(),
+                                            TaskOrderItemReportTypeEnum.SUB_REPORT.getType(),
+                                            TaskOrderItemReportTypeEnum.SOLO_TRIP_REPORT.getType()));
+                    Map<String, List<PipeTaskOrderItemReportDO>> listMap = reportDOList.stream()
+                            .filter(v -> StrUtil.isNotEmpty(v.getOrderItemId()))
+                            .collect(Collectors.groupingBy(PipeTaskOrderItemReportDO::getOrderItemId));
+
+                    JSONArray voList = new JSONArray();
+                    itemDOS.forEach(itemDO -> {
+
+                        List<PipeTaskOrderItemReportDO> itemReportDOList = listMap.get(itemDO.getId());
+                        Set<String> valueSetName = Sets.newHashSet();
+                        Set<String> valueSet = Sets.newHashSet();
+                        for (PipeTaskOrderItemReportDO reportDO : itemReportDOList) {
+                            if (StrUtil.contains(reportDO.getReportConclusion(), "不符合")
+                                    || StrUtil.contains(reportDO.getReportConclusion(), "不合格")
+                                    || StrUtil.contains(reportDO.getReportConclusion(), "资料不齐")
+                            ) {
+                                valueSetName.add(reportDO.getReportName());
+
+                                try {
+                                    String[] strings = objectMapper.readValue(reportDO.getReportConclusion(), String[].class);
+                                    String tmp = reportDO.getReportName();
+                                    if (strings != null && strings.length > 0) {
+                                        tmp = reportDO.getReportName() + strings[0];
+                                    }
+                                    valueSet.add(tmp);
+                                } catch (Exception e) {
+                                    valueSet.add(reportDO.getReportName() + reportDO.getReportConclusion());
+                                }
+                            }
+                        }
+
+                        if (valueSetName.isEmpty()) {
+                            valueSetName.add("无");
+                        }
+                        if (valueSet.isEmpty()) {
+                            valueSet.add("无");
+                        }
+
+                        EquipPipeDO equipPipeDO = equipPipeMapper.selectById(itemDO.getEquipId());
+                        if (equipPipeDO != null){
+
+                            JSONObject vo = new JSONObject();
+                            //序号
+                            vo.put("value1",String.valueOf(number.getAndIncrement()));
+                            //设备名称
+                            vo.put("value2",equipPipeDO.getProjectName());
+                            //使用证号
+                            vo.put("value3",equipPipeDO.getCertificateNo());
+                            //产品编号
+                            vo.put("value4",equipPipeDO.getProjectNo());
+                            //需进一步检验项目
+                            vo.put("value5",valueSetName);
+
+                            //是否有检验意见通知书
+                            List<PipeTaskOrderItemReportDO> itemReportDOS = pipeTaskOrderItemReportMapper.selectList(new LambdaQueryWrapper<PipeTaskOrderItemReportDO>()
+                                    .eq(PipeTaskOrderItemReportDO::getOrderId, itemDO.getId())
+                                    .eq(PipeTaskOrderItemReportDO::getReportType, TaskOrderItemReportTypeEnum.NOTICE_OF_OPINION.getType())
+                            );
+                            if (!itemReportDOS.isEmpty()){
+                                //存在问题
+                                vo.put("value6","有");
+                                //是否出具意见通知书
+                                vo.put("value7","是");
+                            }else{
+                                vo.put("value6","无");
+                                vo.put("value7","否");
+                            }
+
+                            //是否中止检验
+                            vo.put("value8","否");
+                            voList.add(vo);
+                        }
+
+                    });
+
+                    result.put("table",voList.toJSONString());
+
+                    long equipNum2 = itemDOS.stream().filter(itemDO -> itemDO.getTaskStatus() >= TaskOrderStatusEnum.FINISH_CONFIRM.getStatus()).count();
+                    result.put("equipNum1",itemDOS.size()); //检验设备数量
+                    result.put("equipNum2",equipNum2); //已检验设备数量
+                    result.put("equipNum3",0); //中止检验设备
+                    result.put("equipNum4",itemDOS.size() - equipNum2); //进一步检验设备
+
+                    result.put("customerSign",formReportDO.getSignUrl());
+                    result.put("customerSingDate",formReportDO.getSignDate());
+                    result.put("remainDays",15);
+
+                    Set<String> checkIds = reportDOList.stream().map(PipeTaskOrderItemReportDO::getEnterId)
+                            .filter(ObjectUtil::isNotNull)
+                            .collect(Collectors.toSet());
+
+                    if (!checkIds.isEmpty()){
+                        List<AdminUserRespDTO> userList = adminUserApi.getUserList(checkIds).getData();
+                        if (!userList.isEmpty()){
+                            String checkNames = userList.stream()
+                                    .map(AdminUserRespDTO::getSignUrl)
+                                    .filter(Objects::nonNull) // 过滤掉null值
+                                    .filter(signUrl -> !signUrl.isEmpty()) // 过滤掉空字符串
+                                    .collect(Collectors.joining(","));
+                            result.put("checkName",checkNames);
+                        }
+                    }
+
+                    if (formReportDO.getCreateTime() != null) {
+                        result.put("enterDate", formReportDO.getCreateTime().format(dateFormat));
+                    } else {
+                        result.put("enterDate", "-");
+                    }
+
+                    result.put("reportNo",formReportDO.getReportNo());
+                    if (taskOrderDO != null) {
+                        result.put("unitName",taskOrderDO.getUnitName());
+                        result.put("receivePhone",taskOrderDO.getUnitPhone());
+                    }
+
+                }
+
+            }
+        }
+
+        return result;
+
+    }
+}

tz-module-pressure2/tz-module-pressure2-biz/src/main/java/cn/start/tz/module/pressure2/service/notificationformreport/NotificationformReportService.java

@@ -0,0 +1,56 @@
+package cn.start.tz.module.pressure2.service.notificationformreport;
+
+import java.util.*;
+import jakarta.validation.*;
+import cn.start.tz.module.pressure2.controller.admin.notificationformreport.vo.*;
+import cn.start.tz.module.pressure2.dal.dataobject.notificationformreport.NotificationformReportDO;
+import cn.start.tz.framework.common.pojo.PageResult;
+import cn.start.tz.framework.common.pojo.PageParam;
+import com.baomidou.mybatisplus.extension.service.IService;
+
+/**
+ * 检验情况告知 Service 接口
+ *
+ * @author 特种管理员
+ */
+public interface NotificationformReportService extends IService<NotificationformReportDO>  {
+
+    /**
+     * 创建检验情况告知
+     *
+     * @param createReqVO 创建信息
+     * @return 编号
+     */
+    String createNotificationformReport(@Valid NotificationformReportSaveReqVO createReqVO);
+
+    /**
+     * 更新检验情况告知
+     *
+     * @param updateReqVO 更新信息
+     */
+    void updateNotificationformReport(@Valid NotificationformReportSaveReqVO updateReqVO);
+
+    /**
+     * 删除检验情况告知
+     *
+     * @param id 编号
+     */
+    void deleteNotificationformReport(String id);
+
+    /**
+     * 获得检验情况告知
+     *
+     * @param id 编号
+     * @return 检验情况告知
+     */
+    NotificationformReportDO getNotificationformReport(String id);
+
+    /**
+     * 获得检验情况告知分页
+     *
+     * @param pageReqVO 分页查询
+     * @return 检验情况告知分页
+     */
+    PageResult<NotificationformReportDO> getNotificationformReportPage(NotificationformReportPageReqVO pageReqVO);
+
+}

tz-module-pressure2/tz-module-pressure2-biz/src/main/java/cn/start/tz/module/pressure2/service/notificationformreport/NotificationformReportServiceImpl.java

@@ -0,0 +1,75 @@
+package cn.start.tz.module.pressure2.service.notificationformreport;
+
+import org.springframework.stereotype.Service;
+import jakarta.annotation.Resource;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.transaction.annotation.Transactional;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+
+import java.util.*;
+import cn.start.tz.module.pressure2.controller.admin.notificationformreport.vo.*;
+import cn.start.tz.module.pressure2.dal.dataobject.notificationformreport.NotificationformReportDO;
+import cn.start.tz.framework.common.pojo.PageResult;
+import cn.start.tz.framework.common.pojo.PageParam;
+import cn.start.tz.framework.common.util.object.BeanUtils;
+
+import cn.start.tz.module.pressure2.dal.mysql.notificationformreport.NotificationformReportMapper;
+
+import static cn.start.tz.framework.common.exception.util.ServiceExceptionUtil.exception;
+import static cn.start.tz.module.pressure2.enums.ErrorCodeConstants.*;
+
+/**
+ * 检验情况告知 Service 实现类
+ *
+ * @author 特种管理员
+ */
+@Service
+@Validated
+public class NotificationformReportServiceImpl extends ServiceImpl<NotificationformReportMapper, NotificationformReportDO> implements NotificationformReportService {
+
+    @Resource
+    private NotificationformReportMapper notificationformReportMapper;
+
+    @Override
+    public String createNotificationformReport(NotificationformReportSaveReqVO createReqVO) {
+        // 插入
+        NotificationformReportDO notificationformReport = BeanUtils.toBean(createReqVO, NotificationformReportDO.class);
+        notificationformReportMapper.insert(notificationformReport);
+        // 返回
+        return notificationformReport.getId();
+    }
+
+    @Override
+    public void updateNotificationformReport(NotificationformReportSaveReqVO updateReqVO) {
+        // 校验存在
+        validateNotificationformReportExists(updateReqVO.getId());
+        // 更新
+        NotificationformReportDO updateObj = BeanUtils.toBean(updateReqVO, NotificationformReportDO.class);
+        notificationformReportMapper.updateById(updateObj);
+    }
+
+    @Override
+    public void deleteNotificationformReport(String id) {
+        // 校验存在
+        validateNotificationformReportExists(id);
+        // 删除
+        notificationformReportMapper.deleteById(id);
+    }
+
+    private void validateNotificationformReportExists(String id) {
+        if (notificationformReportMapper.selectById(id) == null) {
+            throw exception(NOTIFICATIONFORM_REPORT_NOT_EXISTS);
+        }
+    }
+
+    @Override
+    public NotificationformReportDO getNotificationformReport(String id) {
+        return notificationformReportMapper.selectById(id);
+    }
+
+    @Override
+    public PageResult<NotificationformReportDO> getNotificationformReportPage(NotificationformReportPageReqVO pageReqVO) {
+        return notificationformReportMapper.selectPage(pageReqVO);
+    }
+
+}

tz-module-pressure2/tz-module-pressure2-biz/src/main/java/cn/start/tz/module/pressure2/service/pipetaskorder/PipeTaskOrderServiceImpl.java

@@ -36,9 +36,11 @@ import cn.start.tz.module.pressure2.dal.dataobject.boilertaskorderitemreportuser
 import cn.start.tz.module.pressure2.dal.dataobject.boilertaskorderuser.BoilerTaskOrderUserDO;
 import cn.start.tz.module.pressure2.dal.dataobject.businessmemberrelation.BusinessMemberRelationDO;
 import cn.start.tz.module.pressure2.dal.dataobject.equipboilerschedulingitem.EquipBoilerSchedulingCheckDO;
+import cn.start.tz.module.pressure2.dal.dataobject.notificationformreport.NotificationformReportDO;
 import cn.start.tz.module.pressure2.dal.dataobject.pipetaskorderinput.PipeTaskOrderInputDO;
 import cn.start.tz.module.pressure2.dal.mysql.boilerconnectrecordreport.BoilerConnectRecordReportMapper;
 import cn.start.tz.module.pressure2.dal.mysql.businessmemberrelation.BusinessMemberRelationMapper;
+import cn.start.tz.module.pressure2.dal.mysql.notificationformreport.NotificationformReportMapper;
 import cn.start.tz.module.pressure2.dal.mysql.pipeacceptorderuser.PipeAcceptOrderUserMapper;
 import cn.start.tz.module.pressure2.dal.mysql.pipetaskorderinput.PipeTaskOrderInputMapper;
 import cn.start.tz.module.pressure2.enums.AcceptOrderStatusEnum;
@@ -334,6 +336,9 @@ public class PipeTaskOrderServiceImpl extends ServiceImpl<PipeTaskOrderMapper, P
     @Resource
     private BoilerConnectRecordReportMapper boilerConnectRecordReportMapper;
 
+    @Resource
+    private NotificationformReportMapper notificationformReportMapper;
+
     @Resource
     private InspectionNatureService inspectionNatureService;
 
@@ -546,6 +551,13 @@ public class PipeTaskOrderServiceImpl extends ServiceImpl<PipeTaskOrderMapper, P
             TaskOrderRespVO.setOrderExceptionRespVO(orderExceptionRespVO);
         }
 
+        //设置检验情况告知表数量
+        NotificationformReportDO reportDO = notificationformReportMapper.selectOne(new LambdaQueryWrapperX<NotificationformReportDO>()
+                .eq(NotificationformReportDO::getTaskOrderId, id));
+        if (reportDO != null) {
+            TaskOrderRespVO.setNotificationformReport(reportDO);
+        }
+
         return TaskOrderRespVO;
     }
 
@@ -3072,6 +3084,39 @@ public class PipeTaskOrderServiceImpl extends ServiceImpl<PipeTaskOrderMapper, P
             reportNo = mainReport.getReportNo();
         }
 
+        // 检验情况告知表
+        if (dynamicTbDO.getTbType() != null && TaskOrderItemReportTypeEnum.NOTIFICATION_FORM.getType().intValue() == dynamicTbDO.getTbType()) {
+
+            NotificationformReportDO reportDO = new NotificationformReportDO();
+
+            reportDO.setTaskOrderId(orderId);
+            reportDO.setTemplateId(dynamicTbDO.getId());
+            reportDO.setReportNo(reportNo);
+
+            notificationformReportMapper.insert(reportDO);
+
+            //生成报表数据
+            CreateInstantiateWithRuleVO ruleVO = new CreateInstantiateWithRuleVO();
+            ruleVO.setTemplateId(dynamicTbDO.getId());
+            ruleVO.setRefId(reportDO.getId());
+            ruleVO.setReportType(1);
+            com.alibaba.fastjson2.JSONObject params = new com.alibaba.fastjson2.JSONObject();
+            params.put("checkUserId",getLoginUserId());
+            params.put("equipMainType","pipe");
+            ruleVO.setParams(params);
+            //获取tbCode的服务方法名
+            BoilerConnectTbServiceDO tbServiceDO = boilerConnectTbServiceMapper.selectOne(BoilerConnectTbServiceDO::getTbId,dynamicTbDO.getId());
+            if (tbServiceDO != null){
+                ruleVO.setServiceName(tbServiceDO.getInitServiceName());
+                dynamicTbInsService.createInstantiateWithRule(ruleVO);
+            }else{
+                ruleVO.setServiceName("");
+                dynamicTbInsService.createInstantiateWithRule(ruleVO);
+            }
+
+            return reportDO.getId();
+        }
+
         // 检验方案
 //        if (dynamicTbDO.getTbType() != null && TaskOrderItemReportTypeEnum.INSPECTION_PLAN.getType().intValue() == dynamicTbDO.getTbType()) {
 //            addReport.setPrepareJson(taskOrderMajorIssuesVO.getPrepareJson());
@@ -3688,43 +3733,10 @@ public class PipeTaskOrderServiceImpl extends ServiceImpl<PipeTaskOrderMapper, P
         OrderTemplateDataRepsVO repsVO = new OrderTemplateDataRepsVO();
         // 根据订单ID查询锅炉任务订单信息
         PipeTaskOrderDO taskOrder = pipeTaskOrderMapper.selectById(orderId);
-        // 初始化服务窗口信息
-
-        // 服务窗口名称
-        String acceptanceWindow = "";
-        // 服务窗口联系人
-        String acceptanceContact = "";
-        // 如果部门ID不为空，则获取部门联系信息
-        if (StringUtils.isNotBlank(taskOrder.getDeptId())) {
-            // 调用组织联系人API获取部门联系信息
-            OrgContactDTO contactDTO = orgContactApi.selectOne(taskOrder.getDeptId()).getData();
-            // 如果获取到联系信息，则设置服务窗口名称和联系人
-            if (contactDTO != null) {
-                acceptanceWindow = contactDTO.getName();
-                acceptanceContact = contactDTO.getContact();
-            }
-        }
-
-        // 获取负责人用户信息
-        AdminUserRespDTO managerUser = null;
-        // 如果负责人ID不为空，则获取负责人信息
-        if (StringUtils.isNotBlank(taskOrder.getManagerId())) {
-            // 调用管理员用户API获取负责人信息
-            managerUser = adminUserApi.getUser(taskOrder.getManagerId()).getCheckedData();
-        }
-
-        // 根据订单ID查询任务订单项列表
-        List<PipeTaskOrderItemDO> acceptOrderItemDOS = pipeTaskOrderItemMapper.selectList(PipeTaskOrderItemDO::getOrderId, orderId);
-        // 根据业务类型处理不同的报表模板数据生成逻辑
+
         // 先主要处理重大问题线索
         if (businessType == 400) {
             // 重点问题事项告知单业务类型处理
-            // 根据订单项ID查询任务订单项信息
-//            PipeTaskOrderItemDO taskOrderItemDO = pipeTaskOrderItemMapper.selectById(orderItemId);
-//            // 如果订单项信息为空，则抛出异常
-//            if (ObjectUtil.isEmpty(taskOrderItemDO)) {
-//                throw exception(new ErrorCode(1001, "任务单设备不存在"));
-//            }
 
             // 创建查询条件
             LambdaQueryWrapper<PipeTaskOrderItemReportDO> queryTaskOrderItemReportDO = new LambdaQueryWrapperX<>();
@@ -3744,24 +3756,6 @@ public class PipeTaskOrderServiceImpl extends ServiceImpl<PipeTaskOrderMapper, P
                 throw exception(new ErrorCode(1001, "当前设备不存在主报告信息"));
             }
 
-            // 根据设备ID查询设备锅炉信息
-//            EquipPipeDO equipContainerDO = equipPipeMapper.selectById(taskOrderItemDO.getEquipId());
-//            // 如果设备锅炉信息为空，则抛出异常
-//            if (ObjectUtil.isEmpty(equipContainerDO)) {
-//                throw exception(new ErrorCode(1001, "管道设备不存在"));
-//            }
-            // 如果设备锅炉的单位ID为空，则抛出异常
-//            if (StringUtil.isEmpty(equipContainerDO.getUnitId())) {
-//                throw exception(new ErrorCode(1001, "当前管道设备不存在企业信息"));
-//            }
-//
-//            // 调用客户端单位API获取单位信息
-//            ClientUnitDTO clientUnitDTO = clientUnitApi.getClientUnit(equipContainerDO.getUnitId()).getCheckedData();
-//            // 如果单位信息为空，则抛出异常
-//            if (ObjectUtil.isEmpty(clientUnitDTO)) {
-//                throw exception(new ErrorCode(1001, "当前管道设备不存在企业信息"));
-//            }
-
             // 设置重点问题事项告知单模板ID
             String templateId = TemplateIdConstants.Z_D_W_T_S_X_G_Z_D;
             // 根据模板ID查询报表模板信息
@@ -3769,9 +3763,6 @@ public class PipeTaskOrderServiceImpl extends ServiceImpl<PipeTaskOrderMapper, P
             DynamicTbDO reportTemplateDO = dynamicTbMapper.selectById(templateId);
             // 设置返回对象的模板ID和模板URL
             repsVO.setTemplateId(templateId);
-            //repsVO.setTemplateUrl(reportTemplateDO.getReportTemplateUrl());
-            // 设置标准初始化数据
-            //repsVO.setStandardInitData(reportTemplateDO.getBindingPathSchema());
 
             // 构建需要获取的模板初始化数据分类列表
             List<String> list = Lists.newArrayList(TemplateInitDataEnums.ClassificationEnum.GLOBAL.getKey(),
@@ -3779,6 +3770,20 @@ public class PipeTaskOrderServiceImpl extends ServiceImpl<PipeTaskOrderMapper, P
 
             // 返回结果对象
             return repsVO;
+        } else if (businessType == 1000) {
+
+            // 设置检验情况告知单模板ID
+            String templateId = TemplateIdConstants.J_Y_Q_K_G_Z_D;
+            // 根据模板ID查询报表模板信息
+            DynamicTbDO reportTemplateDO = dynamicTbMapper.selectById(templateId);
+            if (reportTemplateDO == null){
+                throw new ServiceException(904, "未找到检验情况告知单模板");
+            }
+            // 设置返回对象的模板ID和模板URL
+            repsVO.setTemplateId(templateId);
+
+            return repsVO;
+
         } else {
             // 不支持的业务类型
             throw new ServiceException(904, "其他业务类型功能待完善");

tz-module-pressure2/tz-module-pressure2-biz/src/main/resources/mapper/notificationformreport/NotificationformReportMapper.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="cn.start.tz.module.pressure2.dal.mysql.notificationformreport.NotificationformReportMapper">
+
+    <!--
+        一般情况下，尽可能使用 Mapper 进行 CRUD 增删改查即可。
+        无法满足的场景，例如说多表关联查询，才使用 XML 编写 SQL。
+        代码生成器暂时只生成 Mapper XML 文件本身，更多推荐 MybatisX 快速开发插件来生成查询。
+        文档可见：https://www.iocoder.cn/MyBatis/x-plugins/
+     -->
+
+</mapper>