AppApi接口添加&网关配置修改

tz-gateway/src/main/resources/application.yaml

@@ -145,6 +145,12 @@ spring:
             - Path=/app-api/pressure/**
           filters:
             - RewritePath=/app-api/pressure/v3/api-docs, /v3/api-docs
+        - id: pressure-appapi # 路由的编号
+          uri: grayLb://pressure-server
+          predicates: # 断言，作为路由的匹配条件，对应 RouteDefinition 数组
+            - Path=/appapi/pressure/**
+          filters:
+            - RewritePath=/appapi/pressure/v3/api-docs, /v3/api-docs # 配置，保证转发到 /v3/api-docs
         ## quartz-server 服务
         - id: quartz-admin-api # 路由的编号
           uri: grayLb://quartz-server
@@ -159,18 +165,18 @@ spring:
             - Path=/admin-api/pressure2/**
           filters:
             - RewritePath=/admin-api/pressure2/v3/api-docs, /v3/api-docs # 配置，保证转发到 /v3/api-docs
-        - id: pressure-platform-api # 路由的编号
+        - id: pressure2-platform-api # 路由的编号
           uri: grayLb://pressure2-server
           predicates: # 断言，作为路由的匹配条件，对应 RouteDefinition 数组
             - Path=/platform-api/pressure2/**
           filters:
             - RewritePath=/platform-api/pressure2/v3/api-docs, /v3/api-docs
-        - id: system-app-api # 路由的编号
+        - id: pressure2-appapi # 路由的编号
           uri: grayLb://pressure2-server
           predicates: # 断言，作为路由的匹配条件，对应 RouteDefinition 数组
-            - Path=/app-api/pressure2/**
+            - Path=/appapi/pressure2/**
           filters:
-            - RewritePath=/app-api/pressure2/v3/api-docs, /v3/api-docs
+            - RewritePath=/appapi/pressure2/v3/api-docs, /v3/api-docs # 配置，保证转发到 /v3/api-docs
 
       x-forwarded:
         prefix-enabled: false # 避免 Swagger 重复带上额外的 /admin-api/system 前缀

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

@@ -0,0 +1,528 @@
+package cn.start.tz.module.pressure2.controller.appapi.boilertaskorder;
+
+import cn.start.tz.framework.common.exception.ErrorCode;
+import cn.start.tz.framework.common.pojo.CommonResult;
+import cn.start.tz.framework.common.pojo.PageResult;
+import cn.start.tz.module.pressure2.controller.admin.boilertaskorder.vo.*;
+import cn.start.tz.module.pressure2.controller.admin.boilertaskorderoperation.vo.BoilerTaskOrderOperationSaveReqVO;
+import cn.start.tz.module.pressure2.controller.admin.bpmtaskinfo.vo.BpmTaskRespVO;
+import cn.start.tz.module.pressure2.controller.admin.costfield.vo.CostFieldRespVO;
+import cn.start.tz.module.pressure2.dal.dataobject.boilertaskorderitemreport.BoilerTaskOrderItemReportDO;
+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 com.alibaba.fastjson.JSONObject;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.annotation.Resource;
+import jakarta.servlet.http.HttpServletResponse;
+import jakarta.validation.Valid;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+import java.io.IOException;
+import java.util.List;
+
+import static cn.start.tz.framework.common.exception.util.ServiceExceptionUtil.exception;
+import static cn.start.tz.framework.common.pojo.CommonResult.success;
+import static cn.start.tz.framework.web.core.util.WebFrameworkUtils.getLoginUserId;
+
+@Tag(name = "管理后台 - 锅炉检验任务确认")
+@RestController
+@RequestMapping("/pressure2/boiler-task-order")
+@Validated
+public class AppApiBoilerTaskOrderController {
+
+    @Resource
+    private BoilerTaskOrderService boilerTaskOrderService;
+
+    @Resource
+    private BoilerTaskOrderOperationService boilerTaskOrderOperationService;
+
+    @Resource
+    private BoilerTaskOrderItemReportService boilerTaskOrderItemReportService;
+
+//    @PostMapping("/create")
+//    @Operation(summary = "创建锅炉检验任务确认")
+//    //@PreAuthorize("@ss.hasPermission('pressure2:boiler-task-order:create')")
+//    public CommonResult<String> createBoilerTaskOrder(@Valid @RequestBody BoilerTaskOrderSaveReqVO createReqVO) {
+//        return success(boilerTaskOrderService.createBoilerTaskOrder(createReqVO));
+//    }
+//
+//    @DeleteMapping("/delete")
+//    @Operation(summary = "删除锅炉检验任务确认")
+//    @Parameter(name = "id", description = "编号", required = true)
+//    //@PreAuthorize("@ss.hasPermission('pressure2:boiler-task-order:delete')")
+//    public CommonResult<Boolean> deleteBoilerTaskOrder(@RequestParam("id") String id) {
+//        boilerTaskOrderService.deleteBoilerTaskOrder(id);
+//        return success(true);
+//    }
+
+    @PutMapping("/update")
+    @Operation(summary = "更新锅炉检验任务确认")
+    //@PreAuthorize("@ss.hasPermission('pressure2:boiler-task-order:update')")
+    public CommonResult<Boolean> updateBoilerTaskOrder(@Valid @RequestBody BoilerTaskOrderSaveReqVO updateReqVO) {
+        boilerTaskOrderService.updateBoilerTaskOrder(updateReqVO);
+        return success(true);
+    }
+
+    @GetMapping("/get")
+    @Operation(summary = "获得锅炉任务单")
+    @Parameter(name = "id", description = "编号", required = true, example = "1024")
+    //@PreAuthorize("@ss.hasPermission('pressure2:boiler-task-order:query')")
+    public CommonResult<BoilerTaskOrderRespVO> getBoilerTaskOrder(@RequestParam("id") String id) {
+        return success(boilerTaskOrderService.getBoilerTaskOrder(id));
+    }
+
+    @PostMapping("/page")
+    @Operation(summary = "获得锅炉检验任务确认分页")
+    //@PreAuthorize("@ss.hasPermission('pressure2:boiler-task-order:query')")
+    public CommonResult<PageResult<BoilerTaskOrderRespVO>> postBoilerTaskOrderPage(@RequestBody @Valid BoilerTaskOrderPageReqVO pageReqVO) {
+        pageReqVO.setUserId(getLoginUserId());
+        PageResult<BoilerTaskOrderRespVO> pageResult = boilerTaskOrderService.getBoilerTaskOrderPage(pageReqVO);
+        return success(pageResult);
+    }
+
+    @GetMapping("/page")
+    @Operation(summary = "获得锅炉检验任务确认分页")
+    //@PreAuthorize("@ss.hasPermission('pressure2:boiler-task-order:query')")
+    public CommonResult<PageResult<BoilerTaskOrderRespVO>> getBoilerTaskOrderPage(@Valid BoilerTaskOrderPageReqVO pageReqVO) {
+        pageReqVO.setUserId(getLoginUserId());
+        PageResult<BoilerTaskOrderRespVO> pageResult = boilerTaskOrderService.getBoilerTaskOrderPage(pageReqVO);
+        return success(pageResult);
+    }
+
+
+    @GetMapping("/page/boilers")
+    @Operation(summary = "确认编辑,锅炉分页")
+    public CommonResult<PageResult<BoilerTaskOrderBoilersPageRespVO>> getTaskOrderEquipsPage(@Valid BoilerTaskOrderEquipsPageReqVO pageReqVO) {
+        PageResult<BoilerTaskOrderBoilersPageRespVO> pageResult = boilerTaskOrderService.getBoilersPage(pageReqVO);
+        return success(pageResult);
+    }
+
+    @PostMapping("/confirm")
+    @Operation(summary = "任务单确认")
+    public CommonResult<Boolean> taskOrderConfirm(@RequestBody BoilerTaskOrderConfirmVO taskOrderConfirmVO) {
+        boilerTaskOrderService.confirm(taskOrderConfirmVO);
+        return success(true);
+    }
+
+    @GetMapping("/order-item/page")
+    @Operation(summary = "任务单设备项列表")
+    public CommonResult<PageResult<BoilerOrderItemPageRespVO>> getOrderItemPage(@Valid BoilerTaskOrderPageReqVO pageReqVO) {
+        PageResult<BoilerOrderItemPageRespVO> taskOrderPage = boilerTaskOrderService.getOrderItemPage(pageReqVO);
+        return success(taskOrderPage);
+    }
+
+    //设备认领
+    @PostMapping("/order-item/claim")
+    @Operation(summary = "任务单- 我的任务认领")
+    public CommonResult<Boolean> orderItemClaim(@RequestBody BoilerOrderItemClaimVO orderItemIdVO) {
+        return success(boilerTaskOrderService.orderItemClaim(orderItemIdVO));
+    }
+
+    @PostMapping("/order-item/cancelClaim")
+    @Operation(summary = "任务单- 我的任务取消认领")
+    public CommonResult<Boolean> orderItemCancelClaim(@RequestBody BoilerOrderItemClaimVO orderItemIdVO) {
+        return success(boilerTaskOrderService.orderItemCancelClaim(orderItemIdVO));
+    }
+
+    @PutMapping("/order-item/update/users")
+    @Operation(summary = "任务单-设备项更新检验员")
+    //@PreAuthorize("@ss.hasPermission('pressure:task-order:update')")
+    public CommonResult<Boolean> updateTaskOrderItemUser(@Valid @RequestBody BoilerTaskOrderUserVO updateReqVO) {
+        boilerTaskOrderService.updateTaskOrderItemUser(updateReqVO);
+        return success(true);
+    }
+
+    @PutMapping("/order-item/insert/boilers")
+    @Operation(summary = "任务单-设备项更新设备")
+//    //@PreAuthorize("@ss.hasPermission('pressure:task-order:update')")
+    public CommonResult<Boolean> insertTaskOrderItemBoilers(@Valid @RequestBody BoilerTaskOrderItemVO updateReqVO) {
+        boilerTaskOrderService.insertTaskOrderItemBoilers(updateReqVO);
+        return success(true);
+    }
+
+    @PostMapping("/operation-record/create")
+    @Operation(summary = "修改任务单生成变更记录")
+//    //@PreAuthorize("@ss.hasPermission('pressure:task-order-operation:create')")
+    public CommonResult<String> createTaskOrderOperation(@Valid @RequestBody BoilerTaskOrderOperationSaveReqVO createReqVO) {
+        return success(boilerTaskOrderOperationService.createBoilerTaskOrderOperation(createReqVO));
+    }
+
+    @PostMapping("/cost/itemInfoList")
+    @Operation(summary = "费用项目选择列表")
+    public CommonResult<List<BoilerOrderItemCostInfoRepsVO>> itemInfoList(@Valid @RequestBody BoilerOrderItemCostInfoReqVO reqVO) {
+        List<BoilerOrderItemCostInfoRepsVO> result = boilerTaskOrderService.costItemInfoList(reqVO);
+        return success(result);
+    }
+
+    @PostMapping("/scheduling/cost/itemInfoList")
+    @Operation(summary = "费用项目选择列表")
+    public CommonResult<List<BoilerOrderItemCostInfoRepsVO>> schedulingItemInfoList(@Valid @RequestBody BoilerOrderItemCostInfoReqVO reqVO) {
+        List<BoilerOrderItemCostInfoRepsVO> result = boilerTaskOrderService.schedulingCostItemInfoList(reqVO);
+        return success(result);
+    }
+
+    @PostMapping("/order-item/add-report-v2")
+    @Operation(summary = "任务单-设备项添加检验项目")
+    public CommonResult<Boolean> orderItemAddReportV2(@RequestBody BoilerOrderItemAddReportV2VO orderItemEnterVO) {
+        boilerTaskOrderService.addReportV2(orderItemEnterVO);
+        return success(true);
+    }
+
+    @PostMapping("/order-item/add-report-v3")
+    @Operation(summary = "任务单-设备项添加检验项目v3")
+    public CommonResult<Boolean> orderItemAddReportV3(@RequestBody BoilerOrderItemAddReportV2VO orderItemEnterVO) {
+        boilerTaskOrderService.addReportV3(orderItemEnterVO);
+        return success(true);
+    }
+
+    @PostMapping("/order-item/add-report-part")
+    @Operation(summary = "任务单-设备部件项添加检验项目")
+    public CommonResult<Boolean> orderItemAddReportPart(@RequestBody BoilerOrderItemAddReportV2VO orderItemEnterVO) {
+        boilerTaskOrderService.addReportPart(orderItemEnterVO);
+        return success(true);
+    }
+
+    @GetMapping("/order-item/major-issues/page")
+    @Operation(summary = "任务单- 重大问题/检验方案/作业指导书 审核列表分页")
+    public CommonResult<PageResult<BoilerMajorIssuesPageRespVO>> majorIssuesPage(@Valid BoilerMajorIssuesPageReqVO pageReqVO) throws IOException {
+        PageResult<BoilerMajorIssuesPageRespVO> pageResult = boilerTaskOrderService.majorIssuesPage(pageReqVO);
+        return success(pageResult);
+    }
+
+    /**
+     * 主报告编制列表
+     * */
+    @GetMapping("/order-item/prepare-report/page")
+    @Operation(summary = "任务单-主报告编制列表")
+    public CommonResult<PageResult<BoilerOrderItemPageRespVO>> prepareReportPage(@Valid BoilerTaskOrderPageReqVO pageReqVO) {
+        PageResult<BoilerOrderItemPageRespVO> pageResult = boilerTaskOrderService.prepareReportPage(pageReqVO);
+        return success(pageResult);
+    }
+
+
+    /**
+     *   任务单-设备项更新检验员
+     * */
+    @PutMapping("/boiler-order-item/report/update-users")
+    @Operation(summary = "任务单-报告更新检验员")
+    public CommonResult<Boolean> updateTaskOrderItemReportUser(@Valid @RequestBody BoilerTaskOrderReportUserVO updateReqVO) {
+        boilerTaskOrderService.updateTaskOrderItemReportUser(updateReqVO);
+        return success(true);
+    }
+
+    /**
+     * 任务单-设备项删除
+     */
+    @DeleteMapping("/boiler-order-item/report/cancel")
+    @Operation(summary = "任务单-报告作废")
+    public CommonResult<Boolean> orderItemCancel(@Valid @RequestBody BoilerOrderItemUpdateByIdVO orderItemRatifyVO) {
+        boilerTaskOrderService.orderItemCancel(orderItemRatifyVO);
+        return success(true);
+    }
+
+    /**
+     * 校核列表
+     */
+    @GetMapping("/order-item/recheck/page")
+    @Operation(summary = "任务单-设备校核列表")
+    public CommonResult<PageResult<BoilerOrderItemPageRespVO>> recheckOrderItemPage(@Valid BoilerTaskOrderPageReqVO pageReqVO) {
+        PageResult<BoilerOrderItemPageRespVO> pageResult = boilerTaskOrderService.recheckOrderItemPage(pageReqVO);
+        return success(pageResult);
+    }
+
+    @GetMapping("/order-item/get")
+    @Operation(summary = "任务单-设备项详情")
+    public CommonResult<BoilerOrderItemDetailVO> getOrderItem(String id) {
+        BoilerOrderItemDetailVO orderItemDetail = boilerTaskOrderService.getOrderItemDetail(id);
+        return success(orderItemDetail);
+    }
+
+    @PostMapping("/order-item/recheck/approve")
+    @Operation(summary = "任务单-设备校核审批通过")
+    public CommonResult<Boolean> recheckOrderItemApprove(@RequestBody BoilerTaskOrderAuditSingleVO taskOrderAuditSingleVO) {
+        boilerTaskOrderService.recheckOrderItemApprove(taskOrderAuditSingleVO);
+        return success(true);
+    }
+
+    @PostMapping("/order-item/recheck/reject")
+    @Operation(summary = "任务单-设备校核审批拒绝")
+    public CommonResult<Boolean> recheckOrderItemReject(@RequestBody BoilerTaskOrderAuditSingleVO taskOrderAuditSingleVO) {
+        boilerTaskOrderService.recheckOrderItemReject(taskOrderAuditSingleVO);
+        return success(true);
+    }
+
+    @GetMapping("/order-item/sub-report")
+    @Operation(summary = "任务单-通过主报告查询所有子报告")
+    public CommonResult<List<BoilerTaskOrderItemReportDO>> getSubReport(@RequestParam String id) {
+        List<BoilerTaskOrderItemReportDO> list = boilerTaskOrderService.getSubReport(id);
+        return success(list);
+    }
+
+    @PutMapping("/order-item/report/prepare/save")
+    @Operation(summary = "任务单-报告编制录入提交")
+    public CommonResult<Boolean> orderItemPrepareSave(@RequestBody BoilerOrderItemPrepareVO orderItemPrepareVO) {
+        boilerTaskOrderService.updateOrderItemPrepareSave(orderItemPrepareVO);
+        return success(true);
+    }
+
+    @PutMapping("/order-item/report/prepare/submit")
+    @Operation(summary = "任务单-报告编制录入提交")
+    public CommonResult<Boolean> orderItemPrepare(@RequestBody BoilerOrderItemPrepareVO orderItemPrepareVO) {
+        boilerTaskOrderService.updateOrderItemPrepare(orderItemPrepareVO);
+        return success(true);
+    }
+
+    @PostMapping("/order-item/addMajorIssues")
+    @Operation(summary = "任务单-添加重大问题隐患/检验方案/作业指导书")
+    public CommonResult<String> addMajorIssues(@RequestBody TaskOrderMajorIssuesVO taskOrderMajorIssuesVO) {
+        String result = boilerTaskOrderService.addMajorIssues(taskOrderMajorIssuesVO);
+        return success(result);
+    }
+
+    @PutMapping("/order-item/initiateApproval")
+    @Operation(summary = "任务单-检验意见通知书（重大事故）发起审批")
+    public CommonResult<Boolean> opinionNoticeInitiateApproval(@RequestBody MajorIssuesSubmitVO majorIssuesSubmitVO) {
+        Boolean result = boilerTaskOrderService.opinionNotice(majorIssuesSubmitVO);
+        return success(result);
+    }
+    @PutMapping("/order-item/initiateApproval/approve")
+    @Operation(summary = "任务单-检验意见通知书（重大事故）通过审批")
+    public CommonResult<Boolean> opinionNoticeInitiateApprovalApprove(@RequestBody TaskOrderAuditVO reqVO) {
+        Boolean result = boilerTaskOrderService.approveOpinionNotice(reqVO);
+        return success(result);
+    }
+    @PutMapping("/order-item/initiateApproval/reject")
+    @Operation(summary = "任务单-检验意见通知书（重大事故）拒绝审批")
+    public CommonResult<Boolean> opinionNoticeInitiateApprovalReject(@RequestBody  TaskOrderAuditVO reqVO) {
+        Boolean result = boilerTaskOrderService.rejectOpinionNotice(reqVO);
+        return success(result);
+    }
+
+
+    @PostMapping("/order-item/report/notice-book")
+    @Operation(summary = "任务单-报告 意见通知书")
+    public CommonResult<Boolean> orderItemReportNoticeBook(@RequestBody BoilerOrderItemIdVO orderItemIdVO) {
+        boilerTaskOrderService.orderItemReportNoticeBook(orderItemIdVO);
+        return success(true);
+    }
+
+    /**
+     * 记录录入
+     ***/
+    @PutMapping("/order-item/record-enter")
+    @Operation(summary = "任务单-设备项记录录入")
+    public CommonResult<Boolean> orderItemEnter(@RequestBody BoilerOrderItemEnterVO orderItemEnterVO) {
+        boilerTaskOrderService.updateOrderItemEnter(orderItemEnterVO);
+        return success(true);
+    }
+    @PutMapping("/order-item/app-record-enter")
+    @Operation(summary = "任务单app-设备项记录录入")
+    public CommonResult<Boolean> appOrderItemEnter(@RequestBody BoilerOrderItemEnterVO orderItemEnterVO) {
+        boilerTaskOrderService.updateAppOrderItemEnter(orderItemEnterVO);
+        return success(true);
+    }
+
+    @PutMapping("/order-item/report/fee-confirm")
+    @Operation(summary = "任务单-报告费用确认")
+    public CommonResult<Boolean> orderItemFee(@RequestBody OrderItemReportFeeVO orderItemReportFeeVO) throws JsonProcessingException {
+        boilerTaskOrderService.updateOrderItemFee(orderItemReportFeeVO);
+        return success(true);
+    }
+
+    @PutMapping("/order-item/report/sort")
+    @Operation(summary = "任务单设备-更新报告排序")
+    public CommonResult<Boolean> updateReportSort(@RequestBody UpdateReportSortVO updateReportSortVO) {
+        boilerTaskOrderService.updateReportSort(updateReportSortVO);
+        return success(true);
+    }
+
+    @PostMapping("/order-item/updateReportFee")
+    @Operation(summary = "任务单-设备项更新检验项目费用")
+    public CommonResult<Boolean> updateReportFee(@RequestBody BoilerOrderItemUpdateReportFeeVO vo) {
+        boilerTaskOrderService.updateReportFee(vo);
+        return success(true);
+    }
+
+    @PostMapping("/order-item/report/upload")
+    @Operation(summary = "任务单-报告 更新附件")
+    public CommonResult<Boolean> orderItemReportUpload(@RequestBody ReportUploadVO reportUploadVO) {
+        boilerTaskOrderItemReportService.orderItemReportUpload(reportUploadVO);
+        return success(true);
+    }
+
+    @PutMapping("/order-item/report/batch-recheck")
+    public CommonResult<Boolean> batchRecheckOrderItem(@RequestBody BatchRecheckOrderItemVO recheckOrderItemVO) {
+        Boolean result = boilerTaskOrderService.batchRecheckOrderItem(recheckOrderItemVO);
+        return success(result);
+    }
+
+    @PutMapping("/order-item/choice/recheck")
+    @Operation(summary = "任务单-设备项选择校核人")
+    public CommonResult<Boolean> recheckOrderItem(@RequestBody RecheckOrderItemVO recheckOrderItemVO) {
+        Boolean result = boilerTaskOrderService.recheckOrderItem(recheckOrderItemVO);
+        return success(result);
+    }
+
+    @PostMapping("/inspection-opinion/approval")
+    @Operation(summary = "检验意见通知书材料审核")
+    public CommonResult<Boolean> inspectionOpinionApproval(@Valid @RequestBody InspectionOpinionApprovalVo reqVo) {
+        boilerTaskOrderItemReportService.inspectionOpinionApproval(reqVo);
+        return success(true);
+    }
+
+    @PutMapping("/order-item/update/main-check")
+    @Operation(summary = "任务单-修改主检人")
+    public CommonResult<Boolean> updateTaskMainCheck(@Valid @RequestBody TaskOrderMainCheckVO updateReqVO) {
+        boilerTaskOrderService.updateTaskMainCheck(updateReqVO);
+        return success(true);
+    }
+
+    @PutMapping("/order-item/report/approve/submit")
+    @Operation(summary = "任务单-报告审核提交")
+    public CommonResult<Boolean> orderItemApprove(@RequestBody OrderItemApprovalVO orderItemPrepareVO) {
+        boilerTaskOrderService.updateOrderItemApprove(orderItemPrepareVO);
+        return success(true);
+    }
+
+    @GetMapping("/order-item/initiateApproval/circulationRecord")
+    @Operation(summary = "任务单-流转列表")
+    public CommonResult<List<BpmTaskRespVO>> approveOpinionNoticeCirculationRecord(
+            @RequestParam(name = "id") String id,@RequestParam(required = false) Integer reportType) {
+        List<BpmTaskRespVO> pageResult = boilerTaskOrderService.approveOpinionNoticeCirculationRecord(id,reportType);
+        return success(pageResult);
+    }
+
+    @PutMapping("/checkDingJian")
+    @Operation(summary = "校验定检记录字段")
+    public CommonResult<List<CheckDingJianVo>> checkDingJian(@RequestParam("id") String id,@RequestParam("reportId") String reportId, @Valid @RequestBody(required = false) JSONObject jsonObject) {
+        return success(boilerTaskOrderService.checkDingJian(id,reportId, jsonObject));
+    }
+
+    @GetMapping("/service-from/orderForm")
+    @Operation(summary = "获得承压任务单相关服务单信息")
+    public CommonResult<OrderTemplateDataRepsVO> getOrderForm(@RequestParam(name = "businessType", defaultValue = "100") Integer businessType,
+                                                              @RequestParam(name = "orderId", required = true) String orderId,
+                                                              @RequestParam(name = "orderItemId", required = false) String orderItemId) throws Exception {
+        return CommonResult.success(boilerTaskOrderService.getOrderFrom(orderId, businessType, orderItemId));
+    }
+    @GetMapping("/cost/getPreFillField")
+    @Operation(summary = "获得费用预填写字段")
+    public CommonResult<List<CostFieldRespVO>> getPreFillField(@RequestParam("equipId") String equipId,
+                                                               @RequestParam("templateId") String templateId) {
+        List<CostFieldRespVO> result = boilerTaskOrderService.getPreFillField(equipId, templateId);
+        return success(result);
+    }
+
+    /**
+     * 修改主检人
+     */
+    @PutMapping("/order-item/main-checker")
+    @Operation(summary = "任务单-设备校核修改主检人")
+    public CommonResult<Boolean> updateMainChecker(@RequestBody UpdateMainCheckerVO taskOrderAuditorVO) {
+        boilerTaskOrderService.updateMainChecker(taskOrderAuditorVO);
+        return success(true);
+    }
+
+    /**
+     * 任务单-设备部件删除
+     */
+    @DeleteMapping("/part/delete")
+    @Operation(summary = "任务单-删除设备部件")
+    public CommonResult<Boolean> orderItemPartDelete(@Valid @RequestBody BoilerItemPartDeleteVO deleteVO) {
+        boilerTaskOrderService.orderItemPartDelete(deleteVO);
+        return success(true);
+    }
+    /**
+     * 通过接口
+     **/
+    @PutMapping("/approve")
+    @Operation(summary = "通过")
+    public CommonResult<Boolean> taskOrderApprove(@Valid @RequestBody BoilerTaskOrderAuditVO reqVO) {
+        Boolean approve = boilerTaskOrderService.approve( reqVO);
+        return success(approve);
+    }
+
+
+    @PutMapping("/reject")
+    @Operation(summary = "拒绝")
+    public CommonResult<Boolean> approveTask(@Valid @RequestBody BoilerTaskOrderAuditVO reqVO) {
+        Boolean reject = boilerTaskOrderService.reject(reqVO);
+        return success(reject);
+    }
+    /**
+     * 任务单-结束检验
+     */
+    @PostMapping("/item/endCheckDate")
+    @Operation(summary = "任务单-结束检验")
+    public CommonResult<Boolean> orderItemEndCheck(@Valid @RequestBody BoilerItemCheckDateVO dateVO) {
+        boilerTaskOrderService.orderItemEndCheck(dateVO);
+        return success(true);
+    }
+
+    @PutMapping("/order-item/report/batch-recheck/approve")
+    public CommonResult<Boolean> batchRecheckBatchApprove(@RequestBody OrderItemReportApproveBatchVO orderItemReportApproveBatchVO) {
+        Boolean result = boilerTaskOrderService.batchRecheckApprove(orderItemReportApproveBatchVO);
+        return success(result);
+    }
+
+    @PutMapping("/service-from/update")
+    @Operation(summary = "编辑承压任务单葡萄城受理单")
+    public CommonResult<Boolean> serviceFromUpdate(@Valid @RequestBody OrderFormEnterReqVO reqVO) throws Exception {
+        boilerTaskOrderService.serviceFromUpdate(reqVO);
+        return CommonResult.success(Boolean.TRUE);
+    }
+
+    @GetMapping("/order-item/initiateApproval/page")
+    @Operation(summary = "任务单-审核列表")
+    public CommonResult<PageResult<BoilerOrderItemPageRespVO>> approveOpinionNoticePage(@Valid BoilerTaskOrderPageReqVO pageReqVO) {
+        PageResult<BoilerOrderItemPageRespVO> pageResult = boilerTaskOrderService.approveOpinionNoticePage(pageReqVO);
+        return success(pageResult);
+    }
+
+    @PutMapping("/confirm/finish")
+    @Operation(summary = "任务单-确认完成")
+    public CommonResult<Boolean> orderConfirmFinish(@RequestBody OrderConfirmFinishVO orderConfirmFinishVO) {
+        boilerTaskOrderService.orderConfirmFinish(orderConfirmFinishVO);
+        return success(true);
+    }
+
+    @GetMapping("/generateReportPdf")
+    @Operation(summary = "出具pdf")
+    public void generateReportPdf(@RequestParam(value = "orderItemId") String orderItemId,
+                                  HttpServletResponse response) throws Exception {
+
+        byte[] pdfByte = boilerTaskOrderService.getRecordOutputStreamMerge(orderItemId);
+        if (pdfByte != null) {
+            response.getOutputStream().write(pdfByte);
+        }else{
+            throw exception(new ErrorCode(500, "没有需要出具的报告"));
+        }
+    }
+
+    @PutMapping("/syncReportData")
+    @Operation(summary = "同步报表数据")
+    public CommonResult<Boolean> syncReportData(@Valid @RequestBody BoilerTaskOrderSyncReportVO reqVO) {
+        Boolean approve = boilerTaskOrderService.syncReportData(reqVO);
+        return success(approve);
+    }
+
+    @PutMapping("/syncAllReportData")
+    @Operation(summary = "同步记录、报告和结论报告数据")
+    public CommonResult<Boolean> syncAllReportData(@Valid @RequestBody BoilerTaskOrderSyncReportVO reqVO) {
+        Boolean approve = boilerTaskOrderService.syncAllReportData(reqVO);
+        return success(approve);
+    }
+
+    @GetMapping("/inspection-opinion/page")
+    @Operation(summary = "检验意见通知书")
+    @Tag(name = "检验意见通知书")
+    public CommonResult<PageResult<BoilerOrderItemPageRespVO>> inspectionOpinionPage(@Valid BoilerTaskOrderPageReqVO pageReqVO) {
+        PageResult<BoilerOrderItemPageRespVO> taskOrderPage = boilerTaskOrderService.inspectionOpinionPage(pageReqVO);
+        return success(taskOrderPage);
+    }
+}

tz-module-pressure2/tz-module-pressure2-biz/src/main/java/cn/start/tz/module/pressure2/controller/appapi/boilertaskordersecuritycheck/AppApiBoilerTaskOrderSecurityCheckController.java

@@ -0,0 +1,106 @@
+package cn.start.tz.module.pressure2.controller.appapi.boilertaskordersecuritycheck;
+
+import cn.start.tz.framework.common.pojo.CommonResult;
+import cn.start.tz.framework.common.pojo.PageResult;
+import cn.start.tz.framework.common.util.object.BeanUtils;
+import cn.start.tz.module.pressure2.controller.admin.boilertaskordersecuritycheck.vo.BoilerTaskOrderSecurityCheckPageReqVO;
+import cn.start.tz.module.pressure2.controller.admin.boilertaskordersecuritycheck.vo.BoilerTaskOrderSecurityCheckReportVO;
+import cn.start.tz.module.pressure2.controller.admin.boilertaskordersecuritycheck.vo.BoilerTaskOrderSecurityCheckRespVO;
+import cn.start.tz.module.pressure2.controller.admin.boilertaskordersecuritycheck.vo.BoilerTaskOrderSecurityCheckSaveReqVO;
+import cn.start.tz.module.pressure2.service.boilertaskordersecuritycheck.BoilerTaskOrderSecurityCheckService;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.annotation.Resource;
+import jakarta.validation.Valid;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+import static cn.start.tz.framework.common.pojo.CommonResult.success;
+
+@Tag(name = "管理后台 - 安全检查记录")
+@RestController
+@RequestMapping("/pressure2/boiler-task-order-security-check")
+@Validated
+public class AppApiBoilerTaskOrderSecurityCheckController {
+
+    @Resource
+    private BoilerTaskOrderSecurityCheckService boilerTaskOrderSecurityCheckService;
+//
+//    @Resource
+//    private TaskOrderSignFileService taskOrderSignFileService;
+
+   @PostMapping("/create")
+   @Operation(summary = "创建安全检查记录")
+   //@PreAuthorize("@ss.hasPermission('pressure:task-order-security-check:create')")
+   public CommonResult<String> createTaskOrderSecurityCheck(@Valid @RequestBody BoilerTaskOrderSecurityCheckSaveReqVO createReqVO) {
+       return success(boilerTaskOrderSecurityCheckService.createTaskOrderSecurityCheck(createReqVO));
+   }
+
+    /* @PutMapping("/update")
+     @Operation(summary = "更新安全检查记录")
+     //@PreAuthorize("@ss.hasPermission('pressure:task-order-security-check:update')")
+     public CommonResult<Boolean> updateTaskOrderSecurityCheck(@Valid @RequestBody TaskOrderSecurityCheckSaveReqVO updateReqVO) {
+         taskOrderSecurityCheckService.updateTaskOrderSecurityCheck(updateReqVO);
+         return success(true);
+     }
+  */
+    @GetMapping("/default-template")
+    @Operation(summary = "获得安全检查记录 模版")
+    //@PreAuthorize("@ss.hasPermission('pressure:task-order-security-check:query')")
+    public CommonResult<BoilerTaskOrderSecurityCheckReportVO> getTemplate(@RequestParam(required = false) String orderId) throws JsonProcessingException {
+        BoilerTaskOrderSecurityCheckReportVO reportTemplateDO = boilerTaskOrderSecurityCheckService.getDefaultTemplate(orderId);
+        return success(reportTemplateDO);
+    }
+/*
+
+    @GetMapping("/get")
+    @Operation(summary = "获得安全检查记录")
+    @Parameter(name = "id", description = "编号", required = true, example = "1024")
+    //@PreAuthorize("@ss.hasPermission('pressure:task-order-security-check:query')")
+    public CommonResult<TaskOrderSecurityCheckRespVO> getTaskOrderSecurityCheck(@RequestParam("id") String id) {
+        TaskOrderSecurityCheckDO taskOrderSecurityCheck = taskOrderSecurityCheckService.getTaskOrderSecurityCheck(id);
+        TaskOrderSecurityCheckRespVO taskOrderSecurityCheckRespVO = BeanUtils.toBean(taskOrderSecurityCheck, TaskOrderSecurityCheckRespVO.class);
+        if (Objects.nonNull(taskOrderSecurityCheckRespVO)) {
+            List<TaskOrderSignFileDO> list = taskOrderSignFileService.list(new LambdaQueryWrapper<TaskOrderSignFileDO>()
+                    .eq(TaskOrderSignFileDO::getSecurityCheckId, taskOrderSecurityCheckRespVO.getId()));
+            if (CollUtil.isNotEmpty(list)) {
+                taskOrderSecurityCheckRespVO.setSignFilePdf(list.get(0).getSignFilePdf());
+            }
+        }
+        return success(taskOrderSecurityCheckRespVO);
+    }
+*/
+    @GetMapping("/page")
+    @Operation(summary = "获得安全检查记录分页")
+    //@PreAuthorize("@ss.hasPermission('pressure:task-order-security-check:query')")
+    public CommonResult<PageResult<BoilerTaskOrderSecurityCheckRespVO>> getTaskOrderSecurityCheckPage(@Valid BoilerTaskOrderSecurityCheckPageReqVO pageReqVO) {
+        PageResult<BoilerTaskOrderSecurityCheckRespVO> pageResult = boilerTaskOrderSecurityCheckService.getTaskOrderSecurityCheckPage(pageReqVO);
+        return success(BeanUtils.toBean(pageResult, BoilerTaskOrderSecurityCheckRespVO.class));
+    }
+/*
+    @GetMapping("/reportPreview")
+    @Operation(summary = "安全检查记录 xlsx/pdf预览接口 fileType 默认100 xlsx ,200 pdf")
+    public void reportPreviewPost(HttpServletResponse response, @RequestParam String id, @RequestParam Integer fileType) throws Exception {
+        try (ByteArrayOutputStream outputStream = taskOrderSecurityCheckService.getRecordOutputStreamReport(id, fileType)) {
+            ServletOutputStream responseOutputStream = response.getOutputStream();
+            outputStream.writeTo(responseOutputStream);
+        } catch (Exception e) {
+            // 5. 错误处理
+            response.reset();
+            response.setContentType("application/json");
+            response.setCharacterEncoding("UTF-8");
+            response.getWriter().write("{\"error\":\"文件生成失败: " + e.getMessage() + "\"}");
+        }
+    }*/
+
+    @DeleteMapping("/delete")
+    @Operation(summary = "删除安全检查记录")
+    @Parameter(name = "id", description = "编号", required = true)
+    //@PreAuthorize("@ss.hasPermission('pressure:task-order-security-check:delete')")
+    public CommonResult<Boolean> deleteTaskOrderSecurityCheck(@RequestParam("id") String id) {
+        boilerTaskOrderSecurityCheckService.deleteTaskOrderSecurityCheck(id);
+        return success(true);
+    }
+}

tz-module-pressure2/tz-module-pressure2-biz/src/main/java/cn/start/tz/module/pressure2/controller/appapi/equipboiler/AppApiEquipBoilerController.java

@@ -0,0 +1,106 @@
+package cn.start.tz.module.pressure2.controller.appapi.equipboiler;
+
+import cn.start.tz.framework.apilog.core.annotation.ApiAccessLog;
+import cn.start.tz.framework.common.pojo.CommonResult;
+import cn.start.tz.framework.common.pojo.PageParam;
+import cn.start.tz.framework.common.pojo.PageResult;
+import cn.start.tz.framework.common.util.object.BeanUtils;
+import cn.start.tz.framework.excel.core.util.ExcelUtils;
+import cn.start.tz.module.pressure2.controller.admin.equipboiler.vo.EquipBoilerPageReqVO;
+import cn.start.tz.module.pressure2.controller.admin.equipboiler.vo.EquipBoilerPageRespVO;
+import cn.start.tz.module.pressure2.controller.admin.equipboiler.vo.EquipBoilerRespVO;
+import cn.start.tz.module.pressure2.controller.admin.equipboiler.vo.EquipBoilerSaveReqVO;
+import cn.start.tz.module.pressure2.dal.dataobject.equipboiler.EquipBoilerDO;
+import cn.start.tz.module.pressure2.service.equipboiler.EquipBoilerService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.annotation.Resource;
+import jakarta.servlet.http.HttpServletResponse;
+import jakarta.validation.Valid;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+
+import static cn.start.tz.framework.apilog.core.enums.OperateTypeEnum.EXPORT;
+import static cn.start.tz.framework.common.pojo.CommonResult.success;
+
+@Tag(name = "管理后台 - 锅炉设备")
+@RestController
+@RequestMapping("/pressure2/equip-boiler")
+@Validated
+@Slf4j
+public class AppApiEquipBoilerController {
+
+    @Resource
+    private EquipBoilerService equipBoilerService;
+
+    @Resource
+    private JdbcTemplate jdbcTemplate;
+
+    @PostMapping("/create")
+    @Operation(summary = "创建锅炉设备")
+    //@PreAuthorize("@ss.hasPermission('pressure2:equip-boiler:create')")
+    public CommonResult<String> createEquipBoiler(@Valid @RequestBody EquipBoilerSaveReqVO createReqVO) {
+        return success(equipBoilerService.createEquipBoiler(createReqVO));
+    }
+
+    @PutMapping("/update")
+    @Operation(summary = "更新锅炉设备")
+    //@PreAuthorize("@ss.hasPermission('pressure2:equip-boiler:update')")
+    public CommonResult<Boolean> updateEquipBoiler(@Valid @RequestBody EquipBoilerSaveReqVO updateReqVO) {
+        equipBoilerService.updateEquipBoiler(updateReqVO);
+        return success(true);
+    }
+
+    @DeleteMapping("/delete")
+    @Operation(summary = "删除锅炉设备")
+    @Parameter(name = "id", description = "编号", required = true)
+    //@PreAuthorize("@ss.hasPermission('pressure2:equip-boiler:delete')")
+    public CommonResult<Boolean> deleteEquipBoiler(@RequestParam("id") String id) {
+        equipBoilerService.deleteEquipBoiler(id);
+        return success(true);
+    }
+
+    @GetMapping("/get")
+    @Operation(summary = "获得锅炉设备")
+    @Parameter(name = "id", description = "编号", required = true, example = "1024")
+    //@PreAuthorize("@ss.hasPermission('pressure2:equip-boiler:query')")
+    public CommonResult<EquipBoilerRespVO> getEquipBoiler(@RequestParam("id") String id) {
+        EquipBoilerDO equipBoiler = equipBoilerService.getEquipBoiler(id);
+        return success(BeanUtils.toBean(equipBoiler, EquipBoilerRespVO.class));
+    }
+
+    @GetMapping("/page")
+    @Operation(summary = "获得锅炉设备分页")
+    //@PreAuthorize("@ss.hasPermission('pressure2:equip-boiler:query')")
+    public CommonResult<PageResult<EquipBoilerPageRespVO>> getEquipBoilerPage(@Valid EquipBoilerPageReqVO pageReqVO) {
+        PageResult<EquipBoilerPageRespVO> pageResult = equipBoilerService.getEquipBoilerPage(pageReqVO);
+        return success(pageResult);
+    }
+
+    @GetMapping("/export-excel")
+    @Operation(summary = "导出锅炉设备 Excel")
+    //@PreAuthorize("@ss.hasPermission('pressure2:equip-boiler:export')")
+    @ApiAccessLog(operateType = EXPORT)
+    public void exportEquipBoilerExcel(@Valid EquipBoilerPageReqVO pageReqVO,
+              HttpServletResponse response) throws IOException {
+        pageReqVO.setPageSize(PageParam.PAGE_SIZE_NONE);
+        List<EquipBoilerPageRespVO> list = equipBoilerService.getEquipBoilerPage(pageReqVO).getList();
+        // 导出 Excel
+        ExcelUtils.write(response, "锅炉设备.xls", "数据", EquipBoilerRespVO.class,
+                        BeanUtils.toBean(list, EquipBoilerRespVO.class));
+    }
+
+    @PostMapping("/getNameByIds")
+    @Operation(summary = "根据Ids获取锅炉设备名称")
+    //@PreAuthorize("@ss.hasPermission('pressure2:equip-boiler:query')")
+    public CommonResult<List<Map<String ,String>>> getNameByIds(@RequestBody List<String> ids) {
+        return success(equipBoilerService.getNameByIds(ids));
+    }
+}

tz-module-pressure2/tz-module-pressure2-biz/src/main/java/cn/start/tz/module/pressure2/controller/appapi/equipboilercheckhistory/AppApiEquipBoilerCheckHistoryController.java

@@ -0,0 +1,49 @@
+package cn.start.tz.module.pressure2.controller.appapi.equipboilercheckhistory;
+
+import cn.start.tz.framework.common.pojo.CommonResult;
+import cn.start.tz.framework.common.pojo.PageResult;
+import cn.start.tz.framework.common.util.object.BeanUtils;
+import cn.start.tz.module.pressure2.controller.admin.equipboilercheckhistory.vo.EquipBoilerCheckHistoryPageReqVO;
+import cn.start.tz.module.pressure2.controller.admin.equipboilercheckhistory.vo.EquipBoilerCheckHistoryRespVO;
+import cn.start.tz.module.pressure2.dal.dataobject.equipboilercheckhistory.EquipBoilerCheckHistoryDO;
+import cn.start.tz.module.pressure2.service.equipboilercheckhistory.EquipBoilerCheckHistoryService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.annotation.Resource;
+import jakarta.validation.Valid;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import static cn.start.tz.framework.common.pojo.CommonResult.success;
+
+@Tag(name = "管理后台 - 锅炉设备检验历史")
+@RestController
+@RequestMapping("/pressure2/equip-boiler-check-history")
+@Validated
+public class AppApiEquipBoilerCheckHistoryController {
+
+    @Resource
+    private EquipBoilerCheckHistoryService equipBoilerCheckHistoryService;
+
+    @GetMapping("/get")
+    @Operation(summary = "获得锅炉设备检验历史")
+    @Parameter(name = "id", description = "编号", required = true, example = "1024")
+    //@PreAuthorize("@ss.hasPermission('pressure2:equip-boiler-check-history:query')")
+    public CommonResult<EquipBoilerCheckHistoryRespVO> getEquipBoilerCheckHistory(@RequestParam("id") String id) {
+        EquipBoilerCheckHistoryDO equipBoilerCheckHistory = equipBoilerCheckHistoryService.getEquipBoilerCheckHistory(id);
+        return success(BeanUtils.toBean(equipBoilerCheckHistory, EquipBoilerCheckHistoryRespVO.class));
+    }
+
+    @GetMapping("/page")
+    @Operation(summary = "获得锅炉设备检验历史分页")
+    //@PreAuthorize("@ss.hasPermission('pressure2:equip-boiler-check-history:query')")
+    public CommonResult<PageResult<EquipBoilerCheckHistoryRespVO>> getEquipBoilerCheckHistoryPage(@Valid EquipBoilerCheckHistoryPageReqVO pageReqVO) {
+        PageResult<EquipBoilerCheckHistoryDO> pageResult = equipBoilerCheckHistoryService.getEquipBoilerCheckHistoryPage(pageReqVO);
+        return success(BeanUtils.toBean(pageResult, EquipBoilerCheckHistoryRespVO.class));
+    }
+
+}

tz-module-pressure2/tz-module-pressure2-biz/src/main/java/cn/start/tz/module/pressure2/controller/appapi/equippipe/AppApiEquipPipeController.java

@@ -0,0 +1,131 @@
+package cn.start.tz.module.pressure2.controller.appapi.equippipe;
+
+import cn.start.tz.framework.apilog.core.annotation.ApiAccessLog;
+import cn.start.tz.framework.common.pojo.CommonResult;
+import cn.start.tz.framework.common.pojo.PageParam;
+import cn.start.tz.framework.common.pojo.PageResult;
+import cn.start.tz.framework.common.util.object.BeanUtils;
+import cn.start.tz.framework.excel.core.util.ExcelUtils;
+import cn.start.tz.framework.ip.core.Area;
+import cn.start.tz.framework.ip.core.utils.AreaUtils;
+import cn.start.tz.module.pressure2.controller.admin.equippipe.vo.EquipPipePageReqVO;
+import cn.start.tz.module.pressure2.controller.admin.equippipe.vo.EquipPipeRespVO;
+import cn.start.tz.module.pressure2.controller.admin.equippipe.vo.EquipPipeSaveReqVO;
+import cn.start.tz.module.pressure2.dal.dataobject.equippipe.EquipPipeDO;
+import cn.start.tz.module.pressure2.service.equippipe.EquipPipeService;
+import com.alibaba.fastjson2.JSONObject;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.annotation.Resource;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import jakarta.validation.Valid;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.util.List;
+
+import static cn.start.tz.framework.apilog.core.enums.OperateTypeEnum.EXPORT;
+import static cn.start.tz.framework.common.pojo.CommonResult.success;
+
+@Tag(name = "管理后台 - 管道设备")
+@RestController
+@RequestMapping("/pressure2/equip-pipe")
+@Validated
+public class AppApiEquipPipeController {
+
+    @Resource
+    private EquipPipeService equipPipeService;
+
+    @PostMapping("/create")
+    @Operation(summary = "创建管道设备")
+    //@PreAuthorize("@ss.hasPermission('pressure2:equip-pipe:create')")
+    public CommonResult<String> createEquipPipe(@Valid @RequestBody EquipPipeSaveReqVO createReqVO,HttpServletRequest request) throws IOException {
+        // TODO 不知道为什么获取不了部分字段
+        StringBuilder stringBuilder = new StringBuilder();
+        BufferedReader reader = request.getReader();
+        String line;
+        while ((line = reader.readLine()) != null) {
+            stringBuilder.append(line);
+        }
+        EquipPipeSaveReqVO test = JSONObject.parseObject(stringBuilder.toString(), EquipPipeSaveReqVO.class);
+        return success(equipPipeService.createEquipPipe(test));
+    }
+
+    @PutMapping("/update")
+    @Operation(summary = "更新管道设备")
+    //@PreAuthorize("@ss.hasPermission('pressure2:equip-pipe:update')")
+    public CommonResult<Boolean> updateEquipPipe(@Valid @RequestBody EquipPipeSaveReqVO updateReqVO,HttpServletRequest request) throws IOException {
+        // TODO 不知道为什么获取不了部分字段
+        StringBuilder stringBuilder = new StringBuilder();
+        BufferedReader reader = request.getReader();
+        String line;
+        while ((line = reader.readLine()) != null) {
+            stringBuilder.append(line);
+        }
+        EquipPipeSaveReqVO test = JSONObject.parseObject(stringBuilder.toString(), EquipPipeSaveReqVO.class);
+        equipPipeService.updateEquipPipe(test,null);
+        return success(true);
+    }
+
+    @DeleteMapping("/delete")
+    @Operation(summary = "删除管道设备")
+    @Parameter(name = "id", description = "编号", required = true)
+    //@PreAuthorize("@ss.hasPermission('pressure2:equip-pipe:delete')")
+    public CommonResult<Boolean> deleteEquipPipe(@RequestParam("id") String id) {
+        equipPipeService.deleteEquipPipe(id);
+        return success(true);
+    }
+
+    @GetMapping("/get")
+    @Operation(summary = "获得管道设备")
+    @Parameter(name = "id", description = "编号", required = true, example = "1024")
+    //@PreAuthorize("@ss.hasPermission('pressure2:equip-pipe:query')")
+    public CommonResult<EquipPipeRespVO> getEquipPipe(@RequestParam("id") String id) {
+        return success(equipPipeService.getEquipPipe(id));
+    }
+
+    @GetMapping("/page")
+    @Operation(summary = "获得管道设备分页")
+    //@PreAuthorize("@ss.hasPermission('pressure2:equip-pipe:query')")
+    public CommonResult<PageResult<EquipPipeRespVO>> getEquipPipePage(@Valid EquipPipePageReqVO pageReqVO) {
+        PageResult<EquipPipeDO> pageResult = equipPipeService.getEquipPipePage(pageReqVO);
+        PageResult<EquipPipeRespVO> bean = BeanUtils.toBean(pageResult, EquipPipeRespVO.class);
+        bean.getList().forEach(equipPipeRespVO -> {
+            Area area = AreaUtils.getArea(equipPipeRespVO.getEquipStreet());
+            if (area != null) {
+                equipPipeRespVO.setEquipStreetName(area.getName());
+            }
+
+            area = AreaUtils.getArea(equipPipeRespVO.getEquipDistrict());
+            if (area != null) {
+                equipPipeRespVO.setEquipDistrictName(area.getName());
+            }
+        });
+        return success(bean);
+    }
+
+    @GetMapping("/export-excel")
+    @Operation(summary = "导出管道设备 Excel")
+    //@PreAuthorize("@ss.hasPermission('pressure2:equip-pipe:export')")
+    @ApiAccessLog(operateType = EXPORT)
+    public void exportEquipPipeExcel(@Valid EquipPipePageReqVO pageReqVO,
+              HttpServletResponse response) throws IOException {
+        pageReqVO.setPageSize(PageParam.PAGE_SIZE_NONE);
+        List<EquipPipeDO> list = equipPipeService.getEquipPipePage(pageReqVO).getList();
+        // 导出 Excel
+        ExcelUtils.write(response, "管道设备.xls", "数据", EquipPipeRespVO.class,
+                        BeanUtils.toBean(list, EquipPipeRespVO.class));
+    }
+    @GetMapping("/getHistoryPipeEquipment")
+    @Operation(summary = "获得历史容器管道设备")
+    @Parameter(name = "id", description = "编号", required = true, example = "1024")
+    //@PreAuthorize("@ss.hasPermission('pressure2:pipe-equipment:queryHistory')")
+    public CommonResult<EquipPipeRespVO> getHistoryPipeEquipment(@RequestParam("projectNo") String projectNo) {
+        EquipPipeRespVO pipeEquipment = equipPipeService.getHistoryPipeEquipment(projectNo);
+        return success(pipeEquipment);
+    }
+}

tz-module-pressure2/tz-module-pressure2-biz/src/main/java/cn/start/tz/module/pressure2/controller/appapi/equippipecheckhistory/AppApiEquipPipeCheckHistoryController.java

@@ -0,0 +1,49 @@
+package cn.start.tz.module.pressure2.controller.appapi.equippipecheckhistory;
+
+import cn.start.tz.framework.common.pojo.CommonResult;
+import cn.start.tz.framework.common.pojo.PageResult;
+import cn.start.tz.framework.common.util.object.BeanUtils;
+import cn.start.tz.module.pressure2.controller.admin.equippipecheckhistory.vo.EquipPipeCheckHistoryPageReqVO;
+import cn.start.tz.module.pressure2.controller.admin.equippipecheckhistory.vo.EquipPipeCheckHistoryRespVO;
+import cn.start.tz.module.pressure2.dal.dataobject.equippipecheckhistory.EquipPipeCheckHistoryDO;
+import cn.start.tz.module.pressure2.service.equippipecheckhistory.EquipPipeCheckHistoryService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.annotation.Resource;
+import jakarta.validation.Valid;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import static cn.start.tz.framework.common.pojo.CommonResult.success;
+
+@Tag(name = "管理后台 - 管道设备检验历史")
+@RestController
+@RequestMapping("/pressure2/equip-pipe-check-history")
+@Validated
+public class AppApiEquipPipeCheckHistoryController {
+
+    @Resource
+    private EquipPipeCheckHistoryService equipPipeCheckHistoryService;
+
+    @GetMapping("/get")
+    @Operation(summary = "获得管道设备检验历史")
+    @Parameter(name = "id", description = "编号", required = true, example = "1024")
+    //@PreAuthorize("@ss.hasPermission('pressure2:equip-pipe-check-history:query')")
+    public CommonResult<EquipPipeCheckHistoryRespVO> getEquipPipeCheckHistory(@RequestParam("id") String id) {
+        EquipPipeCheckHistoryDO equipPipeCheckHistory = equipPipeCheckHistoryService.getEquipPipeCheckHistory(id);
+        return success(BeanUtils.toBean(equipPipeCheckHistory, EquipPipeCheckHistoryRespVO.class));
+    }
+
+    @GetMapping("/page")
+    @Operation(summary = "获得管道设备检验历史分页")
+    //@PreAuthorize("@ss.hasPermission('pressure2:equip-pipe-check-history:query')")
+    public CommonResult<PageResult<EquipPipeCheckHistoryRespVO>> getEquipPipeCheckHistoryPage(@Valid EquipPipeCheckHistoryPageReqVO pageReqVO) {
+        PageResult<EquipPipeCheckHistoryDO> pageResult = equipPipeCheckHistoryService.getEquipPipeCheckHistoryPage(pageReqVO);
+        return success(BeanUtils.toBean(pageResult, EquipPipeCheckHistoryRespVO.class));
+    }
+
+}

tz-module-pressure2/tz-module-pressure2-biz/src/main/java/cn/start/tz/module/pressure2/controller/appapi/pipetaskorder/AppApiPipeTaskOrderController.java

@@ -0,0 +1,544 @@
+package cn.start.tz.module.pressure2.controller.appapi.pipetaskorder;
+
+import cn.start.tz.framework.common.exception.ErrorCode;
+import cn.start.tz.framework.common.pojo.CommonResult;
+import cn.start.tz.framework.common.pojo.PageResult;
+import cn.start.tz.module.pressure2.controller.admin.boilertaskorder.vo.*;
+import cn.start.tz.module.pressure2.controller.admin.boilertaskorderoperation.vo.BoilerTaskOrderOperationSaveReqVO;
+import cn.start.tz.module.pressure2.controller.admin.bpmtaskinfo.vo.BpmTaskRespVO;
+import cn.start.tz.module.pressure2.controller.admin.costfield.vo.CostFieldRespVO;
+import cn.start.tz.module.pressure2.controller.admin.pipetaskorder.vo.*;
+import cn.start.tz.module.pressure2.controller.admin.pipetaskorderitemreport.vo.OrderItemReportUpdateVO;
+import cn.start.tz.module.pressure2.dal.dataobject.pipetaskorderitemreport.PipeTaskOrderItemReportDO;
+import cn.start.tz.module.pressure2.service.pipetaskorder.PipeTaskOrderService;
+import cn.start.tz.module.pressure2.service.pipetaskorderitemreport.PipeTaskOrderItemReportService;
+import cn.start.tz.module.pressure2.service.pipetaskorderoperation.PipeTaskOrderOperationService;
+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;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.annotation.Resource;
+import jakarta.servlet.http.HttpServletResponse;
+import jakarta.validation.Valid;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+import java.io.IOException;
+import java.util.List;
+
+import static cn.start.tz.framework.common.exception.util.ServiceExceptionUtil.exception;
+import static cn.start.tz.framework.common.pojo.CommonResult.success;
+import static cn.start.tz.framework.web.core.util.WebFrameworkUtils.getLoginUserId;
+
+@Tag(name = "管理后台 - 管道检验任务确认")
+@RestController
+@RequestMapping("/pressure2/pipe-task-order")
+@Validated
+public class AppApiPipeTaskOrderController {
+
+    @Resource
+    private PipeTaskOrderService pipeTaskOrderService;
+
+    @Resource
+    private PipeTaskOrderOperationService pipeTaskOrderOperationService;
+
+    @Resource
+    private PipeTaskOrderItemReportService pipeTaskOrderItemReportService;
+
+    @PutMapping("/update")
+    @Operation(summary = "更新管道检验任务确认")
+    public CommonResult<Boolean> updateBoilerTaskOrder(@Valid @RequestBody BoilerTaskOrderSaveReqVO updateReqVO) {
+        pipeTaskOrderService.updatePipeTaskOrder(updateReqVO);
+        return success(true);
+    }
+
+    @GetMapping("/get")
+    @Operation(summary = "获得管道任务单")
+    @Parameter(name = "id", description = "编号", required = true, example = "1024")
+    public CommonResult<PipeTaskOrderRespVO> getPipeTaskOrder(@RequestParam("id") String id) {
+        return success(pipeTaskOrderService.getPipeTaskOrder(id));
+    }
+
+    @PostMapping("/page")
+    @Operation(summary = "获得管道检验任务确认分页")
+    public CommonResult<PageResult<PipeTaskOrderRespVO>> postBoilerTaskOrderPage(@RequestBody @Valid BoilerTaskOrderPageReqVO pageReqVO) {
+        pageReqVO.setUserId(getLoginUserId());
+        PageResult<PipeTaskOrderRespVO> pageResult = pipeTaskOrderService.getPipeTaskOrderPage(pageReqVO);
+        return success(pageResult);
+    }
+
+    @GetMapping("/page")
+    @Operation(summary = "获得管道检验任务确认分页")
+    public CommonResult<PageResult<PipeTaskOrderRespVO>> getBoilerTaskOrderPage(@Valid BoilerTaskOrderPageReqVO pageReqVO) {
+        pageReqVO.setUserId(getLoginUserId());
+        PageResult<PipeTaskOrderRespVO> pageResult = pipeTaskOrderService.getPipeTaskOrderPage(pageReqVO);
+        return success(pageResult);
+    }
+
+
+    @GetMapping("/page/pipes")
+    @Operation(summary = "确认编辑,管道分页")
+    public CommonResult<PageResult<PipeTaskOrderBoilersPageRespVO>> getTaskOrderEquipsPage(@Valid PipeTaskOrderEquipsPageReqVO pageReqVO) {
+        PageResult<PipeTaskOrderBoilersPageRespVO> pageResult = pipeTaskOrderService.getPipesPage(pageReqVO);
+        return success(pageResult);
+    }
+
+    @PostMapping("/confirm")
+    @Operation(summary = "任务单确认")
+    public CommonResult<Boolean> taskOrderConfirm(@RequestBody BoilerTaskOrderConfirmVO taskOrderConfirmVO) {
+        pipeTaskOrderService.confirm(taskOrderConfirmVO);
+        return success(true);
+    }
+
+    @GetMapping("/order-item/page")
+    @Operation(summary = "任务单设备项列表")
+    public CommonResult<PageResult<PipeOrderItemPageRespVO>> getOrderItemPage(@Valid BoilerTaskOrderPageReqVO pageReqVO) {
+        PageResult<PipeOrderItemPageRespVO> taskOrderPage = pipeTaskOrderService.getOrderItemPage(pageReqVO);
+        return success(taskOrderPage);
+    }
+
+    //设备认领
+    @PostMapping("/order-item/claim")
+    @Operation(summary = "任务单- 我的任务认领")
+    public CommonResult<Boolean> orderItemClaim(@RequestBody PipeOrderItemClaimVO orderItemIdVO) {
+        return success(pipeTaskOrderService.orderItemClaim(orderItemIdVO));
+    }
+
+    @PostMapping("/order-item/cancelClaim")
+    @Operation(summary = "任务单- 我的任务取消认领")
+    public CommonResult<Boolean> orderItemCancelClaim(@RequestBody PipeOrderItemClaimVO orderItemIdVO) {
+        return success(pipeTaskOrderService.orderItemCancelClaim(orderItemIdVO));
+    }
+
+    @PutMapping("/order-item/update/users")
+    @Operation(summary = "任务单-设备项更新检验员")
+    ////@PreAuthorize("@ss.hasPermission('pressure:task-order:update')")
+    public CommonResult<Boolean> updateTaskOrderItemUser(@Valid @RequestBody PipeTaskOrderUserVO updateReqVO) {
+        pipeTaskOrderService.updateTaskOrderItemUser(updateReqVO);
+        return success(true);
+    }
+
+    @PutMapping("/order-item/insert/pipes")
+    @Operation(summary = "任务单-设备项更新设备")
+    ////@PreAuthorize("@ss.hasPermission('pressure:task-order:update')")
+    public CommonResult<Boolean> insertTaskOrderItemPipes(@Valid @RequestBody PipeTaskOrderItemVO updateReqVO) {
+        pipeTaskOrderService.insertTaskOrderItemPipes(updateReqVO);
+        return success(true);
+    }
+
+    @PostMapping("/operation-record/create")
+    @Operation(summary = "修改任务单生成变更记录")
+    ////@PreAuthorize("@ss.hasPermission('pressure:task-order-operation:create')")
+    public CommonResult<String> createTaskOrderOperation(@Valid @RequestBody BoilerTaskOrderOperationSaveReqVO createReqVO) {
+        return success(pipeTaskOrderOperationService.createPipeTaskOrderOperation(createReqVO));
+    }
+
+    @PostMapping("/cost/itemInfoList")
+    @Operation(summary = "费用项目选择列表")
+    public CommonResult<List<BoilerOrderItemCostInfoRepsVO>> itemInfoList(@Valid @RequestBody BoilerOrderItemCostInfoReqVO reqVO) {
+        List<BoilerOrderItemCostInfoRepsVO> result = pipeTaskOrderService.costItemInfoList(reqVO);
+        return success(result);
+    }
+
+    @PostMapping("/scheduling/cost/itemInfoList")
+    @Operation(summary = "费用项目选择列表")
+    public CommonResult<List<BoilerOrderItemCostInfoRepsVO>> schedulingItemInfoList(@Valid @RequestBody BoilerOrderItemCostInfoReqVO reqVO) {
+        List<BoilerOrderItemCostInfoRepsVO> result = pipeTaskOrderService.schedulingCostItemInfoList(reqVO);
+        return success(result);
+    }
+
+    @PostMapping("/order-item/add-report-v2")
+    @Operation(summary = "任务单-设备项添加检验项目")
+    public CommonResult<Boolean> orderItemAddReportV2(@RequestBody PipeOrderItemAddReportV2VO orderItemEnterVO) {
+        pipeTaskOrderService.addReportV2(orderItemEnterVO);
+        return success(true);
+    }
+
+    @PostMapping("/order-item/add-report-v3")
+    @Operation(summary = "任务单-设备项添加检验项目v3")
+    public CommonResult<Boolean> orderItemAddReportV3(@RequestBody PipeOrderItemAddReportV2VO orderItemEnterVO) {
+        pipeTaskOrderService.addReportV3(orderItemEnterVO);
+        return success(true);
+    }
+
+    @GetMapping("/order-item/major-issues/page")
+    @Operation(summary = "任务单- 重大问题/检验方案/作业指导书 审核列表分页")
+    public CommonResult<PageResult<BoilerMajorIssuesPageRespVO>> majorIssuesPage(@Valid BoilerMajorIssuesPageReqVO pageReqVO) throws IOException {
+        PageResult<BoilerMajorIssuesPageRespVO> pageResult = pipeTaskOrderService.majorIssuesPage(pageReqVO);
+        return success(pageResult);
+    }
+
+    /**
+     * 主报告编制列表
+     * */
+    @GetMapping("/order-item/prepare-report/page")
+    @Operation(summary = "任务单-主报告编制列表")
+    public CommonResult<PageResult<PipeOrderItemPageRespVO>> prepareReportPage(@Valid BoilerTaskOrderPageReqVO pageReqVO) {
+        PageResult<PipeOrderItemPageRespVO> pageResult = pipeTaskOrderService.prepareReportPage(pageReqVO);
+        return success(pageResult);
+    }
+
+
+    /**
+     *   任务单-设备项更新检验员
+     * */
+    @PutMapping("/pipe-order-item/report/update-users")
+    @Operation(summary = "任务单-报告更新检验员")
+    public CommonResult<Boolean> updateTaskOrderItemReportUser(@Valid @RequestBody PipeTaskOrderReportUserVO updateReqVO) {
+        pipeTaskOrderService.updateTaskOrderItemReportUser(updateReqVO);
+        return success(true);
+    }
+
+    /**
+     * 任务单-设备项删除
+     */
+    @DeleteMapping("/pipe-order-item/report/cancel")
+    @Operation(summary = "任务单-报告作废")
+    public CommonResult<Boolean> orderItemCancel(@Valid @RequestBody BoilerOrderItemUpdateByIdVO orderItemRatifyVO) {
+        pipeTaskOrderService.orderItemCancel(orderItemRatifyVO);
+        return success(true);
+    }
+
+    /**
+     * 校核列表
+     */
+    @GetMapping("/order-item/recheck/page")
+    @Operation(summary = "任务单-设备校核列表")
+    public CommonResult<PageResult<PipeOrderItemPageRespVO>> recheckOrderItemPage(@Valid BoilerTaskOrderPageReqVO pageReqVO) {
+        PageResult<PipeOrderItemPageRespVO> pageResult = pipeTaskOrderService.recheckOrderItemPage(pageReqVO);
+        return success(pageResult);
+    }
+
+    @GetMapping("/order-item/get")
+    @Operation(summary = "任务单-设备项详情")
+    public CommonResult<PipeOrderItemDetailVO> getOrderItem(String id) {
+        PipeOrderItemDetailVO orderItemDetail = pipeTaskOrderService.getOrderItemDetail(id);
+        return success(orderItemDetail);
+    }
+
+    @PostMapping("/order-item/recheck/approve")
+    @Operation(summary = "任务单-设备校核审批通过")
+    public CommonResult<Boolean> recheckOrderItemApprove(@RequestBody BoilerTaskOrderAuditSingleVO taskOrderAuditSingleVO) {
+        pipeTaskOrderService.recheckOrderItemApprove(taskOrderAuditSingleVO);
+        return success(true);
+    }
+
+    @PostMapping("/order-item/recheck/reject")
+    @Operation(summary = "任务单-设备校核审批拒绝")
+    public CommonResult<Boolean> recheckOrderItemReject(@RequestBody BoilerTaskOrderAuditSingleVO taskOrderAuditSingleVO) {
+        pipeTaskOrderService.recheckOrderItemReject(taskOrderAuditSingleVO);
+        return success(true);
+    }
+
+    @GetMapping("/order-item/sub-report")
+    @Operation(summary = "任务单-通过主报告查询所有子报告")
+    public CommonResult<List<PipeTaskOrderItemReportDO>> getSubReport(@RequestParam String id) {
+        List<PipeTaskOrderItemReportDO> list = pipeTaskOrderService.getSubReport(id);
+        return success(list);
+    }
+
+    @PutMapping("/order-item/report/prepare/save")
+    @Operation(summary = "任务单-报告编制录入提交")
+    public CommonResult<Boolean> orderItemPrepareSave(@RequestBody BoilerOrderItemPrepareVO orderItemPrepareVO) {
+        pipeTaskOrderService.updateOrderItemPrepareSave(orderItemPrepareVO);
+        return success(true);
+    }
+
+    @PutMapping("/order-item/report/prepare/submit")
+    @Operation(summary = "任务单-报告编制录入提交")
+    public CommonResult<Boolean> orderItemPrepare(@RequestBody BoilerOrderItemPrepareVO orderItemPrepareVO) throws Exception {
+        pipeTaskOrderService.updateOrderItemPrepare(orderItemPrepareVO);
+        return success(true);
+    }
+
+    @PostMapping("/order-item/addMajorIssues")
+    @Operation(summary = "任务单-添加重大问题隐患/检验方案/作业指导书")
+    public CommonResult<String> addMajorIssues(@RequestBody TaskOrderMajorIssuesVO taskOrderMajorIssuesVO) {
+        String result = pipeTaskOrderService.addMajorIssues(taskOrderMajorIssuesVO);
+        return success(result);
+    }
+
+    @PutMapping("/order-item/initiateApproval")
+    @Operation(summary = "任务单-检验意见通知书（重大事故）发起审批")
+    public CommonResult<Boolean> opinionNoticeInitiateApproval(@RequestBody MajorIssuesSubmitVO majorIssuesSubmitVO) {
+        Boolean result = pipeTaskOrderService.opinionNotice(majorIssuesSubmitVO);
+        return success(result);
+    }
+    @PutMapping("/order-item/initiateApproval/approve")
+    @Operation(summary = "任务单-检验意见通知书（重大事故）通过审批")
+    public CommonResult<Boolean> opinionNoticeInitiateApprovalApprove(@RequestBody TaskOrderAuditVO reqVO) {
+        Boolean result = pipeTaskOrderService.approveOpinionNotice(reqVO);
+        return success(result);
+    }
+    @PutMapping("/order-item/initiateApproval/reject")
+    @Operation(summary = "任务单-检验意见通知书（重大事故）拒绝审批")
+    public CommonResult<Boolean> opinionNoticeInitiateApprovalReject(@RequestBody  TaskOrderAuditVO reqVO) {
+        Boolean result = pipeTaskOrderService.rejectOpinionNotice(reqVO);
+        return success(result);
+    }
+
+
+    @PostMapping("/order-item/report/notice-book")
+    @Operation(summary = "任务单-报告 意见通知书")
+    public CommonResult<Boolean> orderItemReportNoticeBook(@RequestBody BoilerOrderItemIdVO orderItemIdVO) {
+        pipeTaskOrderService.orderItemReportNoticeBook(orderItemIdVO);
+        return success(true);
+    }
+
+    /**
+     * 记录录入
+     ***/
+    @PutMapping("/order-item/record-enter")
+    @Operation(summary = "任务单-设备项记录录入")
+    public CommonResult<Boolean> orderItemEnter(@RequestBody BoilerOrderItemEnterVO orderItemEnterVO) {
+        pipeTaskOrderService.updateOrderItemEnter(orderItemEnterVO);
+        return success(true);
+    }
+    @PutMapping("/order-item/app-record-enter")
+    @Operation(summary = "任务单app-设备项记录录入")
+    public CommonResult<Boolean> appOrderItemEnter(@RequestBody BoilerOrderItemEnterVO orderItemEnterVO) {
+        pipeTaskOrderService.updateAppOrderItemEnter(orderItemEnterVO);
+        return success(true);
+    }
+
+    @PutMapping("/order-item/report/fee-confirm")
+    @Operation(summary = "任务单-报告费用确认")
+    public CommonResult<Boolean> orderItemFee(@RequestBody OrderItemReportFeeVO orderItemReportFeeVO) throws JsonProcessingException {
+        pipeTaskOrderService.updateOrderItemFee(orderItemReportFeeVO);
+        return success(true);
+    }
+
+    @PutMapping("/order-item/report/sort")
+    @Operation(summary = "任务单设备-更新报告排序")
+    public CommonResult<Boolean> updateReportSort(@RequestBody UpdateReportSortVO updateReportSortVO) {
+        pipeTaskOrderService.updateReportSort(updateReportSortVO);
+        return success(true);
+    }
+
+    @PostMapping("/order-item/updateReportFee")
+    @Operation(summary = "任务单-设备项更新检验项目费用")
+    public CommonResult<Boolean> updateReportFee(@RequestBody BoilerOrderItemUpdateReportFeeVO vo) {
+        pipeTaskOrderService.updateReportFee(vo);
+        return success(true);
+    }
+
+    @PostMapping("/order-item/report/upload")
+    @Operation(summary = "任务单-报告 更新附件")
+    public CommonResult<Boolean> orderItemReportUpload(@RequestBody ReportUploadVO reportUploadVO) {
+        pipeTaskOrderItemReportService.orderItemReportUpload(reportUploadVO);
+        return success(true);
+    }
+
+    @PutMapping("/order-item/report/batch-recheck")
+    public CommonResult<Boolean> batchRecheckOrderItem(@RequestBody BatchRecheckOrderItemVO recheckOrderItemVO) {
+        Boolean result = pipeTaskOrderService.batchRecheckOrderItem(recheckOrderItemVO);
+        return success(result);
+    }
+
+    @PutMapping("/order-item/choice/recheck")
+    @Operation(summary = "任务单-设备项选择校核人")
+    public CommonResult<Boolean> recheckOrderItem(@RequestBody RecheckOrderItemVO recheckOrderItemVO) {
+        Boolean result = pipeTaskOrderService.recheckOrderItem(recheckOrderItemVO);
+        return success(result);
+    }
+
+    @PostMapping("/inspection-opinion/approval")
+    @Operation(summary = "检验意见通知书材料审核")
+    public CommonResult<Boolean> inspectionOpinionApproval(@Valid @RequestBody InspectionOpinionApprovalVo reqVo) {
+        pipeTaskOrderItemReportService.inspectionOpinionApproval(reqVo);
+        return success(true);
+    }
+
+    @PutMapping("/order-item/update/main-check")
+    @Operation(summary = "任务单-修改主检人")
+    public CommonResult<Boolean> updateTaskMainCheck(@Valid @RequestBody TaskOrderMainCheckVO updateReqVO) {
+        pipeTaskOrderService.updateTaskMainCheck(updateReqVO);
+        return success(true);
+    }
+
+    @PutMapping("/order-item/report/approve/submit")
+    @Operation(summary = "任务单-报告审核提交")
+    public CommonResult<Boolean> orderItemApprove(@RequestBody OrderItemApprovalVO orderItemPrepareVO) {
+        pipeTaskOrderService.updateOrderItemApprove(orderItemPrepareVO);
+        return success(true);
+    }
+
+    @GetMapping("/order-item/initiateApproval/circulationRecord")
+    @Operation(summary = "任务单-流转列表")
+    public CommonResult<List<BpmTaskRespVO>> approveOpinionNoticeCirculationRecord(
+            @RequestParam(name = "id") String id,@RequestParam(required = false) Integer reportType) {
+        List<BpmTaskRespVO> pageResult = pipeTaskOrderService.approveOpinionNoticeCirculationRecord(id,reportType);
+        return success(pageResult);
+    }
+
+    @PutMapping("/checkDingJian")
+    @Operation(summary = "校验定检记录字段")
+    public CommonResult<List<CheckDingJianVo>> checkDingJian(@RequestParam("id") String id,@RequestParam("reportId") String reportId, @Valid @RequestBody(required = false) JSONObject jsonObject) {
+        return success(pipeTaskOrderService.checkDingJian(id,reportId, jsonObject));
+    }
+
+    @GetMapping("/service-from/orderForm")
+    @Operation(summary = "获得承压任务单相关服务单信息")
+    public CommonResult<OrderTemplateDataRepsVO> getOrderForm(@RequestParam(name = "businessType", defaultValue = "100") Integer businessType,
+                                                              @RequestParam(name = "orderId", required = true) String orderId,
+                                                              @RequestParam(name = "orderItemId", required = false) String orderItemId) throws Exception {
+        return CommonResult.success(pipeTaskOrderService.getOrderFrom(orderId, businessType, orderItemId));
+    }
+    @GetMapping("/cost/getPreFillField")
+    @Operation(summary = "获得费用预填写字段")
+    public CommonResult<List<CostFieldRespVO>> getPreFillField(@RequestParam("equipId") String equipId,
+                                                               @RequestParam("templateId") String templateId) {
+        List<CostFieldRespVO> result = pipeTaskOrderService.getPreFillField(equipId, templateId);
+        return success(result);
+    }
+
+    /**
+     * 修改主检人
+     */
+    @PutMapping("/order-item/main-checker")
+    @Operation(summary = "任务单-设备校核修改主检人")
+    public CommonResult<Boolean> updateMainChecker(@RequestBody UpdateMainCheckerVO taskOrderAuditorVO) {
+        pipeTaskOrderService.updateMainChecker(taskOrderAuditorVO);
+        return success(true);
+    }
+
+    /**
+     * 通过接口
+     **/
+    @PutMapping("/approve")
+    @Operation(summary = "通过")
+    public CommonResult<Boolean> taskOrderApprove(@Valid @RequestBody BoilerTaskOrderAuditVO reqVO) {
+        Boolean approve = pipeTaskOrderService.approve( reqVO);
+        return success(approve);
+    }
+
+
+    @PutMapping("/reject")
+    @Operation(summary = "拒绝")
+    public CommonResult<Boolean> approveTask(@Valid @RequestBody BoilerTaskOrderAuditVO reqVO) {
+        Boolean reject = pipeTaskOrderService.reject(reqVO);
+        return success(reject);
+    }
+    /**
+     * 任务单-结束检验
+     */
+    @PostMapping("/item/endCheckDate")
+    @Operation(summary = "任务单-结束检验")
+    public CommonResult<Boolean> orderItemEndCheck(@Valid @RequestBody PipeItemCheckDateVO dateVO) {
+        pipeTaskOrderService.orderItemEndCheck(dateVO);
+        return success(true);
+    }
+
+    @PutMapping("/order-item/report/batch-recheck/approve")
+    public CommonResult<Boolean> batchRecheckBatchApprove(@RequestBody OrderItemReportApproveBatchVO orderItemReportApproveBatchVO) {
+        Boolean result = pipeTaskOrderService.batchRecheckApprove(orderItemReportApproveBatchVO);
+        return success(result);
+    }
+
+    @PutMapping("/service-from/update")
+    @Operation(summary = "编辑承压任务单葡萄城受理单")
+    public CommonResult<Boolean> serviceFromUpdate(@Valid @RequestBody OrderFormEnterReqVO reqVO) throws Exception {
+        pipeTaskOrderService.serviceFromUpdate(reqVO);
+        return CommonResult.success(Boolean.TRUE);
+    }
+
+    @GetMapping("/getDetailByOrderItemId")
+    @Operation(summary = "查询工程单")
+    public CommonResult<List<PipeOrderItemProjectVO>> getDetailByOrderItemId(@Valid PipeOrderItemProjectReqVO pageReqVO) {
+        List<PipeOrderItemProjectVO> list = pipeTaskOrderService.getDetailByOrderItemId(pageReqVO);
+        return success(list);
+    }
+    @GetMapping("/getDetailByOrderId")
+    @Operation(summary = "查询工程单")
+    public CommonResult<List<PipeOrderItemProjectVO>> getDetailByOrderId(@Valid PipeOrderItemProjectReqVO pageReqVO) {
+        List<PipeOrderItemProjectVO> list = pipeTaskOrderService.getDetailByOrderId(pageReqVO);
+        return success(list);
+    }
+    @GetMapping("/getDetailByEquipId")
+    @Operation(summary = "查询工程单")
+    public CommonResult<List<PipeOrderItemProjectVO>> getDetailByEquipId(@Valid PipeOrderItemProjectReqVO pageReqVO) {
+        List<PipeOrderItemProjectVO> list = pipeTaskOrderService.getDetailByEquipId(pageReqVO);
+        return success(list);
+    }
+
+    @GetMapping("/order-item/initiateApproval/page")
+    @Operation(summary = "任务单-审核列表")
+    public CommonResult<PageResult<PipeOrderItemPageRespVO>> approveOpinionNoticePage(@Valid BoilerTaskOrderPageReqVO pageReqVO) {
+        PageResult<PipeOrderItemPageRespVO> pageResult = pipeTaskOrderService.approveOpinionNoticePage(pageReqVO);
+        return success(pageResult);
+    }
+
+    @PutMapping("/confirm/finish")
+    @Operation(summary = "任务单-确认完成")
+    public CommonResult<Boolean> orderConfirmFinish(@RequestBody OrderConfirmFinishVO orderConfirmFinishVO) {
+        pipeTaskOrderService.orderConfirmFinish(orderConfirmFinishVO);
+        return success(true);
+    }
+
+    @GetMapping("/generateReportPdf")
+    @Operation(summary = "根据任务单号出具pdf")
+    public void generateReportPdf(@RequestParam(value = "orderId") String orderId,
+                       HttpServletResponse response) throws Exception {
+
+        byte[] pdfByte = pipeTaskOrderService.getRecordOutputStreamMerge(orderId);
+        if (pdfByte != null) {
+            response.getOutputStream().write(pdfByte);
+        }else{
+            throw exception(new ErrorCode(500, "没有需要出具的报告"));
+        }
+    }
+
+    @GetMapping("/recheckUser/page")
+    @Operation(summary = "获得校验用户分页列表")
+    public CommonResult<PageResult<AdminUserRespDTO>> getUserPage(@Valid PipeRecheckUserPageReqVO pageReqVO) {
+
+        PageResult<AdminUserRespDTO> userList = pipeTaskOrderService.getRecheckUserPage(pageReqVO);
+        return success(userList);
+    }
+
+    @PutMapping("/order-item/report/setPipeDetail")
+    @Operation(summary = "任务单-设置报告管线")
+    public CommonResult<Boolean> updateReportPipeDetail(@RequestBody OrderItemReportUpdateVO updateVO) {
+        pipeTaskOrderService.updateReportPipeDetail(updateVO);
+        return success(true);
+    }
+
+    @GetMapping("/order-item/getPipeByOrderId")
+    @Operation(summary = "根据任务单ID查询管道")
+    public CommonResult<List<PipeOrderItemEquipPipeRespVO>> getPipeByOrderId(@Valid PipeOrderItemEquipPipeReqVO pageReqVO) {
+        List<PipeOrderItemEquipPipeRespVO> list = pipeTaskOrderService.getPipeByOrderId(pageReqVO);
+        return success(list);
+    }
+
+    @PutMapping("/syncReportData")
+    @Operation(summary = "同步报表数据")
+    public CommonResult<Boolean> syncReportData(@Valid @RequestBody BoilerTaskOrderSyncReportVO reqVO) {
+        Boolean approve = pipeTaskOrderService.syncReportData(reqVO);
+        return success(approve);
+    }
+
+    @PutMapping("/syncAllReportData")
+    @Operation(summary = "同步记录、报告和结论报告数据")
+    public CommonResult<Boolean> syncAllReportData(@Valid @RequestBody BoilerTaskOrderSyncReportVO reqVO) {
+        Boolean approve = pipeTaskOrderService.syncAllReportData(reqVO);
+        return success(approve);
+    }
+
+    @GetMapping("/getEquipsByOrderId")
+    @Operation(summary = "通过任务单ID获得设备列表")
+    public CommonResult<List<PipeEquipInfoVO>> getEquipsByOrderId(@RequestParam("orderId") String orderId) {
+
+        List<PipeEquipInfoVO> equipList = pipeTaskOrderService.getEquipsByOrderId(orderId);
+        return success(equipList);
+    }
+
+    @GetMapping("/inspection-opinion/page")
+    @Operation(summary = "检验意见通知书")
+    @Tag(name = "检验意见通知书")
+    public CommonResult<PageResult<PipeOrderItemPageRespVO>> inspectionOpinionPage(@Valid BoilerTaskOrderPageReqVO pageReqVO) {
+        PageResult<PipeOrderItemPageRespVO> taskOrderPage = pipeTaskOrderService.inspectionOpinionPage(pageReqVO);
+        return success(taskOrderPage);
+    }
+}

tz-module-pressure2/tz-module-pressure2-biz/src/main/java/cn/start/tz/module/pressure2/controller/appapi/pipetaskordersecuritycheck/AppApiPipeTaskOrderSecurityCheckController.java

@@ -0,0 +1,102 @@
+package cn.start.tz.module.pressure2.controller.appapi.pipetaskordersecuritycheck;
+
+import cn.start.tz.framework.apilog.core.annotation.ApiAccessLog;
+import cn.start.tz.framework.common.pojo.CommonResult;
+import cn.start.tz.framework.common.pojo.PageParam;
+import cn.start.tz.framework.common.pojo.PageResult;
+import cn.start.tz.framework.common.util.object.BeanUtils;
+import cn.start.tz.framework.excel.core.util.ExcelUtils;
+import cn.start.tz.module.pressure2.controller.admin.boilertaskordersecuritycheck.vo.BoilerTaskOrderSecurityCheckReportVO;
+import cn.start.tz.module.pressure2.controller.admin.pipetaskordersecuritycheck.vo.PipeTaskOrderSecurityCheckPageReqVO;
+import cn.start.tz.module.pressure2.controller.admin.pipetaskordersecuritycheck.vo.PipeTaskOrderSecurityCheckRespVO;
+import cn.start.tz.module.pressure2.controller.admin.pipetaskordersecuritycheck.vo.PipeTaskOrderSecurityCheckSaveReqVO;
+import cn.start.tz.module.pressure2.dal.dataobject.pipetaskordersecuritycheck.PipeTaskOrderSecurityCheckDO;
+import cn.start.tz.module.pressure2.service.pipetaskordersecuritycheck.PipeTaskOrderSecurityCheckService;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.annotation.Resource;
+import jakarta.servlet.http.HttpServletResponse;
+import jakarta.validation.Valid;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+import java.io.IOException;
+import java.util.List;
+
+import static cn.start.tz.framework.apilog.core.enums.OperateTypeEnum.EXPORT;
+import static cn.start.tz.framework.common.pojo.CommonResult.success;
+
+@Tag(name = "管理后台 - 管道安全检查记录")
+@RestController
+@RequestMapping("/pressure2/pipe-task-order-security-check")
+@Validated
+public class AppApiPipeTaskOrderSecurityCheckController {
+
+    @Resource
+    private PipeTaskOrderSecurityCheckService pipeTaskOrderSecurityCheckService;
+
+    @PostMapping("/create")
+    @Operation(summary = "创建管道安全检查记录")
+    //@PreAuthorize("@ss.hasPermission('pressure2:pipe-task-order-security-check:create')")
+    public CommonResult<String> createPipeTaskOrderSecurityCheck(@Valid @RequestBody PipeTaskOrderSecurityCheckSaveReqVO createReqVO) {
+        return success(pipeTaskOrderSecurityCheckService.createPipeTaskOrderSecurityCheck(createReqVO));
+    }
+
+    @PutMapping("/update")
+    @Operation(summary = "更新管道安全检查记录")
+    //@PreAuthorize("@ss.hasPermission('pressure2:pipe-task-order-security-check:update')")
+    public CommonResult<Boolean> updatePipeTaskOrderSecurityCheck(@Valid @RequestBody PipeTaskOrderSecurityCheckSaveReqVO updateReqVO) {
+        pipeTaskOrderSecurityCheckService.updatePipeTaskOrderSecurityCheck(updateReqVO);
+        return success(true);
+    }
+
+    @DeleteMapping("/delete")
+    @Operation(summary = "删除管道安全检查记录")
+    @Parameter(name = "id", description = "编号", required = true)
+    //@PreAuthorize("@ss.hasPermission('pressure2:pipe-task-order-security-check:delete')")
+    public CommonResult<Boolean> deletePipeTaskOrderSecurityCheck(@RequestParam("id") String id) {
+        pipeTaskOrderSecurityCheckService.deletePipeTaskOrderSecurityCheck(id);
+        return success(true);
+    }
+
+    @GetMapping("/get")
+    @Operation(summary = "获得管道安全检查记录")
+    @Parameter(name = "id", description = "编号", required = true, example = "1024")
+    //@PreAuthorize("@ss.hasPermission('pressure2:pipe-task-order-security-check:query')")
+    public CommonResult<PipeTaskOrderSecurityCheckRespVO> getPipeTaskOrderSecurityCheck(@RequestParam("id") String id) {
+        PipeTaskOrderSecurityCheckDO pipeTaskOrderSecurityCheck = pipeTaskOrderSecurityCheckService.getPipeTaskOrderSecurityCheck(id);
+        return success(BeanUtils.toBean(pipeTaskOrderSecurityCheck, PipeTaskOrderSecurityCheckRespVO.class));
+    }
+
+    @GetMapping("/page")
+    @Operation(summary = "获得管道安全检查记录分页")
+    //@PreAuthorize("@ss.hasPermission('pressure2:pipe-task-order-security-check:query')")
+    public CommonResult<PageResult<PipeTaskOrderSecurityCheckRespVO>> getPipeTaskOrderSecurityCheckPage(@Valid PipeTaskOrderSecurityCheckPageReqVO pageReqVO) {
+        PageResult<PipeTaskOrderSecurityCheckRespVO> pageResult = pipeTaskOrderSecurityCheckService.getTaskOrderSecurityCheckPage(pageReqVO);
+        return success(BeanUtils.toBean(pageResult, PipeTaskOrderSecurityCheckRespVO.class));
+    }
+
+    @GetMapping("/export-excel")
+    @Operation(summary = "导出管道安全检查记录 Excel")
+    //@PreAuthorize("@ss.hasPermission('pressure2:pipe-task-order-security-check:export')")
+    @ApiAccessLog(operateType = EXPORT)
+    public void exportPipeTaskOrderSecurityCheckExcel(@Valid PipeTaskOrderSecurityCheckPageReqVO pageReqVO,
+              HttpServletResponse response) throws IOException {
+        pageReqVO.setPageSize(PageParam.PAGE_SIZE_NONE);
+        List<PipeTaskOrderSecurityCheckDO> list = pipeTaskOrderSecurityCheckService.getPipeTaskOrderSecurityCheckPage(pageReqVO).getList();
+        // 导出 Excel
+        ExcelUtils.write(response, "管道安全检查记录.xls", "数据", PipeTaskOrderSecurityCheckRespVO.class,
+                        BeanUtils.toBean(list, PipeTaskOrderSecurityCheckRespVO.class));
+    }
+
+    @GetMapping("/default-template")
+    @Operation(summary = "获得安全检查记录 模版")
+    //@PreAuthorize("@ss.hasPermission('pressure:task-order-security-check:query')")
+    public CommonResult<BoilerTaskOrderSecurityCheckReportVO> getTemplate(@RequestParam(required = false) String orderId) throws JsonProcessingException {
+        BoilerTaskOrderSecurityCheckReportVO reportTemplateDO = pipeTaskOrderSecurityCheckService.getDefaultTemplate(orderId);
+        return success(reportTemplateDO);
+    }
+
+}