newcpms/master/src/main/java/com/ruoyi/project/pssr/controller/TPssrApproveController.java

package com.ruoyi.project.pssr.controller;

import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.framework.aspectj.lang.annotation.Log;
import com.ruoyi.framework.aspectj.lang.enums.BusinessType;
import com.ruoyi.framework.web.controller.BaseController;
import com.ruoyi.framework.web.domain.AjaxResult;
import com.ruoyi.framework.web.page.TableDataInfo;
import com.ruoyi.project.approve.damain.DevTask;
import com.ruoyi.project.plant.domain.TStaffmgr;
import com.ruoyi.project.pssr.domain.*;
import com.ruoyi.project.pssr.service.*;
import com.ruoyi.project.system.domain.SysUser;
import com.ruoyi.project.system.mapper.SysUserMapper;
import com.ruoyi.project.system.service.ISysUserService;
import org.activiti.engine.*;
import org.activiti.engine.impl.identity.Authentication;
import org.activiti.engine.impl.util.CollectionUtil;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.*;

/**
 * pssr审批管理Controller
 *
 * @author ssy
 * @date 2024-09-18
 */
@RestController
@RequestMapping("/pssr/approve")
public class TPssrApproveController extends BaseController {

    @Resource
    private SysUserMapper userMapper;

    @Autowired
    private RuntimeService runtimeService;

    @Autowired
    private HistoryService historyService;

    @Autowired
    private TaskService taskService;

    @Autowired
    private ITPssrApproveService tPssrApproveService;

    @Autowired
    private ITPssrAboveallService tPssrAboveallService;

    @Autowired
    private ITPssrSubcontentService tPssrSubcontentService;

    @Autowired
    private ITPssrOverhaulExchangerService tPssrOverhaulExchangerService;

    @Autowired
    private ITPssrOverhaulFilterService tPssrOverhaulFilterService;

    @Autowired
    private ITPssrOverhaulPipeService tPssrOverhaulPipeService;

    @Autowired
    private ITPssrOverhaulTowerService tPssrOverhaulTowerService;

    @Autowired
    private ITPssrOverhaulPumpService tPssrOverhaulPumpService;

    @Autowired
    private ITPssrOverhaulValveService tPssrOverhaulValveService;

    @Autowired
    private ITPssrBlindService tPssrBlindService;

    @Autowired
    private ITPssrLockService tPssrLockService;

    @Autowired
    private ITPssrPipeService tPssrPipeService;

    @Autowired
    private ISysUserService userService;

    @Autowired
    private ITPssrHygieneService tPssrHygieneService;

    @Autowired
    private ITPssrCleaningService tPssrCleaningService;

    @Autowired
    private ITPssrAirtightService tPssrAirtightService;

    @Autowired
    private ITPssrLaboratoryService tPssrLaboratoryService;

    @Autowired
    private ITPssrMocService tPssrMocService;

    @Autowired
    private ITPssrCircuitService tPssrCircuitService;

    @Autowired
    private ITPssrPublicService tPssrPublicService;

    @Autowired
    private ITPssrSafetyBleedService tPssrSafetyBleedService;

    @Autowired
    private ITPssrSafetyBreathService tPssrSafetyBreathService;

    @Autowired
    private ITPssrSafetyBrustService tPssrSafetyBrustService;

    @Autowired
    private ITPssrSafetyFlamearresterService tPssrSafetyFlamearresterService;

    @Autowired
    private ITPssrSafetyValveService tPssrSafetyValveService;

    @Autowired
    private ITPssrFrameService tPssrFrameService;

    @Autowired
    private ITPssrMotorService tPssrMotorService;

    @Autowired
    private ITPssrInstrumentCalibrationService tPssrInstrumentCalibrationService;

    @Autowired
    private ITPssrNitrogenService tPssrNitrogenService;

    @Autowired
    private ITPssrFranklinismService tPssrFranklinismService;

    @Autowired
    private ITPssrGasdetectorService tPssrGasdetectorService;

    @Autowired
    private ITPssrAnalyzerService tPssrAnalyzerService;

    @Autowired
    private ITPssrMeasureService tPssrMeasureService;

    @Autowired
    private ITPssrProtectionService tPssrProtectionService;

    @Autowired
    private ITPssrTorchvocService tPssrTorchvocService;

    @Autowired
    private ITPssrLightingService tPssrLightingService;

    @Autowired
    private ITPssrMaterialService tPssrMaterialService;

    @Autowired
    private ITPssrMaterialRawService tPssrMaterialRawService;

    @Autowired
    private ITPssrPumpFillService tPssrPumpFillService;

    @Autowired
    private ITPssrPumpCleaningService tPssrPumpCleaningService;

    @Autowired
    private ITPssrPumpOverhaulService tPssrPumpOverhaulService;

    @Autowired
    private ITPssrInstrumentTestService tPssrInstrumentTestService;

    @Autowired
    private ITPssrAlarmService tPssrAlarmService;

    @Autowired
    private ITPssrVesselService tPssrVesselService;

    @Autowired
    private ITPssrProgrammeService tPssrProgrammeService;

    /**
     * 查询pssr审批管理列表
     */
    @PreAuthorize("@ss.hasPermi('pssr:approve:list')")
    @GetMapping("/list")
    public TableDataInfo list(TPssrApprove tPssrApprove) {
        startPage();
        List<TPssrApprove> list = tPssrApproveService.selectTPssrApproveList(tPssrApprove);
        return getDataTable(list);
    }

    /**
     * 导出pssr审批管理列表
     */
    @PreAuthorize("@ss.hasPermi('pssr:approve:export')")
    @Log(title = "pssr审批管理", businessType = BusinessType.EXPORT)
    @GetMapping("/export")
    public AjaxResult export(TPssrApprove tPssrApprove) {
        List<TPssrApprove> list = tPssrApproveService.selectTPssrApproveList(tPssrApprove);
        ExcelUtil<TPssrApprove> util = new ExcelUtil<TPssrApprove>(TPssrApprove.class);
        return util.exportExcel(list, "approve");
    }

    /**
     * 获取pssr审批管理详细信息
     */
    @PreAuthorize("@ss.hasPermi('pssr:approve:query')")
    @GetMapping(value = "/{approveId}")
    public AjaxResult getInfo(@PathVariable("approveId") Long approveId) {
        return AjaxResult.success(tPssrApproveService.selectTPssrApproveById(approveId));
    }

    /**
     * 新增pssr审批管理
     */
    @PreAuthorize("@ss.hasPermi('pssr:approve:add')")
    @Log(title = "pssr审批管理", businessType = BusinessType.INSERT)
    @PostMapping
    public AjaxResult add(@RequestBody TPssrApprove tPssrApprove) {
        return toAjax(tPssrApproveService.insertTPssrApprove(tPssrApprove));
    }

    /**
     * 修改pssr审批管理
     */
    @PreAuthorize("@ss.hasPermi('pssr:approve:edit')")
    @Log(title = "pssr审批管理", businessType = BusinessType.UPDATE)
    @PutMapping
    public AjaxResult edit(@RequestBody TPssrApprove tPssrApprove) {
        return toAjax(tPssrApproveService.updateTPssrApprove(tPssrApprove));
    }

    /**
     * 删除pssr审批管理
     */
    @PreAuthorize("@ss.hasPermi('pssr:approve:remove')")
    @Log(title = "pssr审批管理", businessType = BusinessType.DELETE)
    @DeleteMapping("/{approveIds}")
    public AjaxResult remove(@PathVariable Long[] approveIds) {
        return toAjax(tPssrApproveService.deleteTPssrApproveByIds(approveIds));
    }

    @Log(title = "pssr发起审批", businessType = BusinessType.INSERT)
    @PostMapping("/doPssrApprove/{subId}")
    public AjaxResult doApprove(@PathVariable Long subId) {
        TPssrSubcontent tPssrSubcontent = tPssrSubcontentService.selectTPssrSubcontentById(subId);
        if (judgmentOrder(tPssrSubcontent)) {
            return AjaxResult.error("请先完成前置审批流程");
        }
        tPssrSubcontent.setApproveStatus(1L);
        tPssrSubcontentService.updateTPssrSubcontent(tPssrSubcontent);
        switch (tPssrSubcontent.getForShort()) {
            case "jxxm"://检修项目
                doJxxmApprove(tPssrSubcontent);
                break;
            case "kgfa"://开工方案
                doKgfaApprove(tPssrSubcontent);
                break;
            case "sjbg"://设计变更
                doMocApprove(tPssrSubcontent);
                break;
            case "mb"://盲板
                doMbApprove(tPssrSubcontent);
                break;
            case "xcws"://现场卫生
                doXcwsApprove(tPssrSubcontent);
                break;
            case "rsfh"://人身防护
                doRsfhApprove(tPssrSubcontent);
                break;
            case "sbqjd"://设备清洁度
                doSbqjdApprove(tPssrSubcontent);
                break;
            case "qm"://气密
                doQmApprove(tPssrSubcontent);
                break;
            case "sksgfmzt"://锁开锁关阀门状态
                doSksgApprove(tPssrSubcontent);
                break;
            case "sys"://实验室
                doSysApprove(tPssrSubcontent);
                break;
            case "dj"://短接
                doDjApprove(tPssrSubcontent);
                break;
            case "dqzh"://氮气置换
                doDqzhApprove(tPssrSubcontent);
                break;
            case "xqf"://消气防设施
                doPatrolApprove(tPssrSubcontent);
                break;
            case "aqss"://安全设施
                doAqssApprove(tPssrSubcontent);
                break;
            case "txjk"://通讯监控
                doPatrolApprove(tPssrSubcontent);
                break;
            case "bxsjcy"://便携式检测仪
                doPatrolApprove(tPssrSubcontent);
                break;
            case "gygc"://公用工程
                doGygcApprove(tPssrSubcontent);
                break;
            case "hbss"://环保设施
                doHbssApprove(tPssrSubcontent);
                break;
            case "yfl"://原辅料
                doYflApprove(tPssrSubcontent);
                break;
            case "jb"://机泵
                doJbApprove(tPssrSubcontent);
                break;
            case "zdj"://支吊架
                doZdjApprove(tPssrSubcontent);
                break;
            case "tzsb"://特种设备
                doTzsbApprove(tPssrSubcontent);
                break;
            case "ybjy"://仪表校验
                doYbjyApprove(tPssrSubcontent);
                break;
            case "yblscs"://仪表联锁测试
                doYblscsApprove(tPssrSubcontent);
                break;
            case "bjlszqr"://报警联锁值确认
                doBjlszqrApprove(tPssrSubcontent);
                break;
            case "lsdy"://临时电源
                doLsdyApprove(tPssrSubcontent);
                break;
            case "djsb"://电机设备
                doDjsbApprove(tPssrSubcontent);
                break;
            case "zmdbr"://照明、电伴热
                doZmdbrApprove(tPssrSubcontent);
                break;
            case "jdjdkj"://静电接地、跨接
                doJdjdkjApprove(tPssrSubcontent);
                break;
            case "qtjcy"://气体检测仪
                doQtjcyApprove(tPssrSubcontent);
                break;
            case "zxfxy"://在线分析仪
                doZxfxyApprove(tPssrSubcontent);
                break;
            default:
                return AjaxResult.error("申请发起失败！");
        }
        return AjaxResult.success();
    }

    /**
     * 判断当前发起的审批是否满足前置条件
     */
    private boolean judgmentOrder(TPssrSubcontent sub) {
        TPssrSubcontent subcontent = new TPssrSubcontent();
        subcontent.setAboveallId(sub.getAboveallId());
        List<String> forShorts = new ArrayList<>();
        if (sub.getForShort().contains("jb,ybjy")) {

        } else if (sub.getForShort().contains("sbqjd")) {
            forShorts.add("jb");
            forShorts.add("ybjy");
        } else if (sub.getForShort().contains("jxxm,kgfa,sjbg")) {
            forShorts.add("sbqjd");
        } else if (sub.getForShort().contains("mb")) {
            forShorts.add("jxxm");
            forShorts.add("kgfa");
            forShorts.add("sjbg");
        } else if (sub.getForShort().contains("dj,aqss,sksgfmzt")) {
            forShorts.add("mb");
        } else if (sub.getForShort().contains("xcws,rsfh,xqf,txjk,qtjcy,hbss")) {
            forShorts.add("dj");
            forShorts.add("aqss");
            forShorts.add("sksgfmzt");
        } else if (sub.getForShort().contains("ssy,gygc,yfl")) {
            forShorts.add("xcws");
            forShorts.add("rsfh");
            forShorts.add("xqf");
            forShorts.add("txjk");
            forShorts.add("qtjcy");
            forShorts.add("hbss");
        } else if (sub.getForShort().contains("qm,dqzh")) {
            forShorts.add("ssy");
            forShorts.add("gygc");
            forShorts.add("yfl");
        }
        if (CollectionUtils.isNotEmpty(forShorts)) {
            subcontent.setForShorts(forShorts);
            for (TPssrSubcontent tPssrSubcontent : tPssrSubcontentService.selectTPssrSubcontentListByForShort(subcontent)) {
                if (tPssrSubcontent.getApproveStatus() != 2) {
                    return true;
                }
            }
        }
        return false;
    }

    @Log(title = "pssr负责人审批", businessType = BusinessType.UPDATE)
    @PutMapping("/handlePssrApprove")
    public AjaxResult handlePssrApprove(@RequestBody DevTask devTask) {
        TPssrApprove approve = devTask.gettPssrApprove();
        //使用任务服务完成任务(提交任务)
        String taskId = devTask.getTaskId();
        // 使用任务id,获取任务对象，获取流程实例id
        Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
        //利用任务对象，获取流程实例id
        String taskName = task.getName();//实例名
        String processInstancesId = task.getProcessInstanceId();
        String userId = getUserId().toString();

        String condition = devTask.getCondition();
        boolean allDone = false;
        TPssrSubcontent tPssrSubcontent = tPssrSubcontentService.selectTPssrSubcontentById(approve.getSubId());
        String remark = "";
        if (condition.equals("0")) {
            approve.setApproveStatus(2L);
            tPssrSubcontent.setApproveStatus(2L);
            tPssrSubcontent.setConfirmationDate(new Date());
            tPssrSubcontentService.updateTPssrSubcontent(tPssrSubcontent);
            tPssrApproveService.updateTPssrApprove(approve);
            TPssrSubcontent subcontent = new TPssrSubcontent();
            subcontent.setAboveallId(tPssrSubcontent.getAboveallId());
            for (TPssrSubcontent pssrSubcontent : tPssrSubcontentService.selectTPssrSubcontentList(subcontent)) {
                if (pssrSubcontent.getApproveStatus() != 2) {
                    allDone = false;
                    break;
                }
                allDone = true;
            }
        }
        //处理流程节点
        Map<String, Object> param = new HashMap<>();
        param.put("condition", condition);
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        //认领任务
        processEngine.getTaskService().claim(taskId, userId);
        taskService.addComment(taskId, processInstancesId, remark);
        taskService.complete(taskId, param);

        // 所有流程都结束时，发起经理审批
        if (allDone)
            doMgrApprove(tPssrSubcontent.getAboveallId());
        return AjaxResult.success();
    }

    /**
     * 子项内容确认
     */
    public static void handleConfirmApprove(TPssrApprove approve, String userId) {
        String processInstancesId = approve.getProcessId();
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        Task task = processEngine.getTaskService()//获取任务service
                .createTaskQuery()//创建查询对象
                .taskAssignee(userId)
                .processInstanceId(processInstancesId).singleResult();
        String taskId = task.getId();

        //处理流程节点
        Map<String, Object> param = new HashMap<>();
        param.put("condition", "0");
        //认领任务
        processEngine.getTaskService().claim(taskId, userId);
        taskService.addComment(taskId, processInstancesId, "通过");
        taskService.complete(taskId, param);
    }

    // pssr发起经理审批
    public void doMgrApprove(Long aboveallId) {
        String userId = getUserId().toString();
        TPssrAboveall aboveall = tPssrAboveallService.selectTPssrAboveallById(aboveallId);

        TStaffmgr tStaffmgr = new TStaffmgr();
        tStaffmgr.setActualposts("24");//装置经理
        tStaffmgr.setDeptId(103L);
        for (SysUser user : userService.selectUserPost(tStaffmgr)) {
            aboveall.setPlantMgr(user.getUserId());
            aboveall.setConfirm(user.getUserId().toString());
        }

        tStaffmgr.setActualposts("40");//ctm经理
        for (SysUser user : userService.selectUserPost(tStaffmgr)) {
            aboveall.setCtmMgr(user.getUserId());
        }

        tStaffmgr.setActualposts("42");//cta经理
        for (SysUser user : userService.selectUserPost(tStaffmgr)) {
            aboveall.setCtaMgr(user.getUserId());
        }
        List<String> executor = new ArrayList<>();
        executor.add(aboveall.getPlantMgr().toString());
        executor.add(aboveall.getCtmMgr().toString());
        executor.add(aboveall.getCtaMgr().toString());

        //设置当前申请人
        Map<String, Object> variables = new HashMap<>();
        variables.put("applyUser", userId);
        variables.put("allJlUsers", executor);
        variables.put("jlUser", aboveall.getPlantMgr());

        TPssrApprove exist = tPssrApproveService.selectTPssrApproveByAboveallId(aboveallId);
        if (exist == null) {

            TPssrApprove approve = new TPssrApprove();
            approve.setAboveallId(aboveallId);
            approve.setApproveStatus(1L);
            approve.setApNo(DateUtils.dateTimeNow() + userId);
            approve.setApproveStatus(1L);
            approve.setCreaterCode(userId);
            approve.setCreatedate(new Date());
            tPssrApproveService.insertTPssrApprove(approve);

            // 开始申请流程
            long businessKey = approve.getApproveId();
            //开始工作流、监听
            Authentication.setAuthenticatedUserId(userId);
            //采用key来启动流程定义并设置流程变量，返回流程实例
            ProcessInstance pi = runtimeService.startProcessInstanceByKey("pssrMgrConfirm", String.valueOf(businessKey), variables);
            approve.setProcessId(pi.getProcessInstanceId());
            tPssrApproveService.updateTPssrApprove(approve);

        } else {
            delProcess(exist.getProcessId(), "pssrMgrConfirm");

            // 开始申请流程
            long businessKey = exist.getApproveId();
            //开始工作流、监听
            Authentication.setAuthenticatedUserId(userId);
            //采用key来启动流程定义并设置流程变量，返回流程实例
            ProcessInstance pi = runtimeService.startProcessInstanceByKey("pssrMgrConfirm", String.valueOf(businessKey), variables);
            exist.setProcessId(pi.getProcessInstanceId());
            tPssrApproveService.updateTPssrApprove(exist);

        }
        aboveall.setApproveStatus(1L);
        tPssrAboveallService.updateTPssrAboveall(aboveall);
    }

    @PutMapping("/handleMgrApprove")
    public AjaxResult handleMgrApprove(@RequestBody DevTask devTask) {
        TPssrApprove approve = devTask.gettPssrApprove();
        //使用任务服务完成任务(提交任务)
        String taskId = devTask.getTaskId();
        // 使用任务id,获取任务对象，获取流程实例id
        Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
        //利用任务对象，获取流程实例id
        String taskName = task.getName();//实例名
        String processInstancesId = task.getProcessInstanceId();
        String userId = getUserId().toString();


        String condition = devTask.getCondition();
        TPssrAboveall aboveall = tPssrAboveallService.selectTPssrAboveallById(approve.getAboveallId());

        if (taskName.equals("所有装置经理")) {
            if (condition.equals("0")) {
                if (userId.equals(aboveall.getPlantMgr().toString())) {
                    aboveall.setPlantConfirmdate(new Date());
                } else if (userId.equals(aboveall.getCtmMgr().toString())) {
                    aboveall.setCtmConfirmdate(new Date());
                } else if (userId.equals(aboveall.getCtaMgr().toString())) {
                    aboveall.setCtaConfirmdate(new Date());
                }
            }
        }
        if (taskName.equals("装置经理")) {
            if (condition.equals("0")) {
                aboveall.setApproveStatus(2L);
                aboveall.setConfirmationDate(new Date());
            }
        }
        tPssrAboveallService.updateTPssrAboveall(aboveall);
        //处理流程节点
        Map<String, Object> param = new HashMap<>();
        param.put("condition", condition);
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        //认领任务
        processEngine.getTaskService().claim(taskId, userId);
        taskService.complete(taskId, param);

        return AjaxResult.success();
    }

    /**
     * 氮气置换审批流程发起申请
     *
     * @param sub
     */
    private void doDqzhApprove(TPssrSubcontent sub) {
        String userId = getUserId().toString();
        //修改状态
        TPssrNitrogen tPssrNitrogen = new TPssrNitrogen();
        tPssrNitrogen.setApproveStatus(0L);
        tPssrNitrogen.setSubId(sub.getId());
        Set<String> confirm1 = new HashSet<>();
        Set<String> confirm2 = new HashSet<>();
        for (TPssrNitrogen item : tPssrNitrogenService.selectTPssrNitrogenList(tPssrNitrogen)) {
            item.setApproveStatus(1L);
            item.setUpdatedate(new Date());
            item.setUpdaterCode(userId);
            tPssrNitrogenService.updateTPssrNitrogen(item);

            // 确认人1
            confirm1.add(item.getConfirm1());

            //确认人2
            confirm2.add(item.getConfirm2());
        }

        TPssrApprove exist = new TPssrApprove();
        exist.setSubId(sub.getId());
        List<TPssrApprove> tPssrApproves = tPssrApproveService.selectTPssrApproveList(exist);
        if (CollectionUtil.isEmpty(tPssrApproves)) {
            //新增审批数据
            TPssrApprove approve = new TPssrApprove();
            approve.setSubId(sub.getId());
            approve.setApNo(DateUtils.dateTimeNow() + userId);
            approve.setApproveStatus(1L);
            approve.setSubCharge(sub.getConfirm());
            approve.setCreaterCode(userId);
            approve.setCreatedate(new Date());
            tPssrApproveService.insertTPssrApprove(approve);

            pssr2confirm(approve, new ArrayList<>(confirm1), new ArrayList<>(confirm2), sub.getConfirm());
        } else {
            // 已存在流程时，删除旧流程，重新发起
            TPssrApprove approve = tPssrApproves.get(0);
            delProcess(approve.getProcessId(), "pssr2confirm");

            tPssrNitrogen = new TPssrNitrogen();
            tPssrNitrogen.setApproveStatus(1L);
            tPssrNitrogen.setSubId(sub.getId());
            for (TPssrNitrogen item : tPssrNitrogenService.selectTPssrNitrogenList(tPssrNitrogen)) {
                // 确认人1
                confirm1.add(item.getConfirm1());

                //确认人2
                confirm2.add(item.getConfirm2());
            }

            pssr2confirm(approve, new ArrayList<>(confirm1), new ArrayList<>(confirm2), sub.getConfirm());
        }
    }

    // 检修项目审批流程发起申请
    public void doJxxmApprove(TPssrSubcontent sub) {
        String userId = getUserId().toString();
        //修改所有表的审批状态
        TPssrOverhaulExchanger exchanger = new TPssrOverhaulExchanger();
        exchanger.setSubId(sub.getId());
        exchanger.setApproveStatus(1L);
        exchanger.setUpdaterCode(userId);
        exchanger.setUpdatedate(new Date());
        tPssrOverhaulExchangerService.updateAllBySubId(exchanger);
        TPssrOverhaulFilter filter = new TPssrOverhaulFilter();
        filter.setSubId(sub.getId());
        filter.setApproveStatus(1L);
        filter.setUpdaterCode(userId);
        filter.setUpdatedate(new Date());
        tPssrOverhaulFilterService.updateAllBySubId(filter);
        TPssrOverhaulPipe pipe = new TPssrOverhaulPipe();
        pipe.setSubId(sub.getId());
        pipe.setApproveStatus(1L);
        pipe.setUpdaterCode(userId);
        pipe.setUpdatedate(new Date());
        tPssrOverhaulPipeService.updateAllBySubId(pipe);
        TPssrOverhaulPump pump = new TPssrOverhaulPump();
        pump.setSubId(sub.getId());
        pump.setApproveStatus(1L);
        pump.setUpdaterCode(userId);
        pump.setUpdatedate(new Date());
        tPssrOverhaulPumpService.updateAllBySubId(pump);
        TPssrOverhaulTower tower = new TPssrOverhaulTower();
        tower.setSubId(sub.getId());
        tower.setApproveStatus(1L);
        tower.setUpdaterCode(userId);
        tower.setUpdatedate(new Date());
        tPssrOverhaulTowerService.updateAllBySubId(tower);
        TPssrOverhaulValve valve = new TPssrOverhaulValve();
        valve.setSubId(sub.getId());
        valve.setApproveStatus(1L);
        valve.setUpdaterCode(userId);
        valve.setUpdatedate(new Date());
        tPssrOverhaulValveService.updateAllBySubId(valve);

        //查询所有确认人
        exchanger = new TPssrOverhaulExchanger();
        exchanger.setSubId(sub.getId());
        exchanger.setApproveStatus(1L);
        TPssrOverhaulExchanger tPssrOverhaulExchanger = tPssrOverhaulExchangerService.selectAllConfirmedPersonBySubId(exchanger);
        String confirmers = null;
        if (tPssrOverhaulExchanger != null) {
            confirmers = tPssrOverhaulExchanger.getConfirmedPerson();
        }
        logger.info("=======================confirmers:{}", confirmers);

        List<String> confirmersList = new ArrayList<>();
        if (StringUtils.isNotEmpty(confirmers)) {
            confirmersList.addAll(Arrays.asList(confirmers.split(",")));
        }

        TPssrApprove exist = new TPssrApprove();
        exist.setSubId(sub.getId());
        List<TPssrApprove> tPssrApproves = tPssrApproveService.selectTPssrApproveList(exist);
        //如果当前子项没有审批数据
        if (CollectionUtil.isEmpty(tPssrApproves)) {
            //新增审批数据
            TPssrApprove approve = new TPssrApprove();
            approve.setSubId(sub.getId());
            approve.setApNo(DateUtils.dateTimeNow() + userId);
            approve.setApproveStatus(1L);
            approve.setSubCharge(sub.getConfirm());
            approve.setCreaterCode(userId);
            approve.setCreatedate(new Date());
            tPssrApproveService.insertTPssrApprove(approve);
            pssr1confirm(approve, confirmersList, sub.getConfirm());
        } else {
            // 已存在流程时，删除旧流程，重新发起
            TPssrApprove approve = tPssrApproves.get(0);
            delProcess(approve.getProcessId(), "pssr1confirm");
            pssr1confirm(approve, confirmersList, sub.getConfirm());
        }
    }

    // 盲板审批流程发起申请
    public void doMbApprove(TPssrSubcontent sub) {
        String userId = getUserId().toString();
        //修改状态
        TPssrBlind tPssrBlind = new TPssrBlind();
        tPssrBlind.setApproveStatus(0L);
        tPssrBlind.setSubId(sub.getId());
        Set<String> installer = new HashSet<>();
        Set<String> remover = new HashSet<>();
        for (TPssrBlind item : tPssrBlindService.selectTPssrBlindList(tPssrBlind)) {
            item.setApproveStatus(1L);
            item.setUpdatedate(new Date());
            item.setUpdaterCode(userId);
            tPssrBlindService.updateTPssrBlind(item);

            // 拆装人员
            installer.add(item.getInConfirm1());
            //确认人
            remover.add(item.getInConfirm2());
        }

        TPssrApprove exist = new TPssrApprove();
        exist.setSubId(sub.getId());
        List<TPssrApprove> tPssrApproves = tPssrApproveService.selectTPssrApproveList(exist);
        if (CollectionUtil.isEmpty(tPssrApproves)) {
            //新增审批数据
            TPssrApprove approve = new TPssrApprove();
            approve.setSubId(sub.getId());
            approve.setApNo(DateUtils.dateTimeNow() + userId);
            approve.setApproveStatus(1L);
            approve.setSubCharge(sub.getConfirm());
            approve.setCreaterCode(userId);
            approve.setCreatedate(new Date());
            tPssrApproveService.insertTPssrApprove(approve);
            pssr2confirm(approve, new ArrayList<>(installer), new ArrayList<>(remover), sub.getConfirm());
        } else {
            // 已存在流程时，删除旧流程，重新发起
            TPssrApprove approve = tPssrApproves.get(0);
            delProcess(approve.getProcessId(), "pssr2confirm");

            tPssrBlind = new TPssrBlind();
            tPssrBlind.setApproveStatus(1L);
            tPssrBlind.setSubId(sub.getId());
            for (TPssrBlind item : tPssrBlindService.selectTPssrBlindList(tPssrBlind)) {
                // 拆装人员
                installer.add(item.getInConfirm1());
                //确认人
                remover.add(item.getInConfirm2());
            }
            pssr2confirm(approve, new ArrayList<>(installer), new ArrayList<>(remover), sub.getConfirm());
        }

    }

    // 锁开锁关审批流程发起申请
    public void doSksgApprove(TPssrSubcontent sub) {
        String userId = getUserId().toString();
        //修改状态
        TPssrLock tPssrLock = new TPssrLock();
        tPssrLock.setApproveStatus(0L);
        tPssrLock.setSubId(sub.getId());
        Set<String> lockeders = new HashSet<>();
        Set<String> confirmers = new HashSet<>();
        for (TPssrLock item : tPssrLockService.selectTPssrLockList(tPssrLock)) {
            item.setApproveStatus(1L);
            item.setUpdatedate(new Date());
            item.setUpdaterCode(userId);
            tPssrLockService.updateTPssrLock(item);

            // 确认人1
            lockeders.add(item.getLockeder());

            // 确认人2
            confirmers.add(item.getConfirm());
        }

        TPssrApprove exist = new TPssrApprove();
        exist.setSubId(sub.getId());
        List<TPssrApprove> tPssrApproves = tPssrApproveService.selectTPssrApproveList(exist);
        if (CollectionUtil.isEmpty(tPssrApproves)) {
            //新增审批数据
            TPssrApprove approve = new TPssrApprove();
            approve.setSubId(sub.getId());
            approve.setApNo(DateUtils.dateTimeNow() + userId);
            approve.setApproveStatus(1L);
            approve.setSubCharge(sub.getConfirm());
            approve.setCreaterCode(userId);
            approve.setCreatedate(new Date());
            tPssrApproveService.insertTPssrApprove(approve);
            pssr2confirm(approve, new ArrayList<>(lockeders), new ArrayList<>(confirmers), sub.getConfirm());
        } else {
            // 已存在流程时，删除旧流程，重新发起
            TPssrApprove approve = tPssrApproves.get(0);
            delProcess(approve.getProcessId(), "pssr2confirm");

            tPssrLock = new TPssrLock();
            tPssrLock.setApproveStatus(1L);
            tPssrLock.setSubId(sub.getId());
            for (TPssrLock item : tPssrLockService.selectTPssrLockList(tPssrLock)) {

                // 确认人1
                lockeders.add(item.getLockeder());

                // 确认人2
                confirmers.add(item.getConfirm());
            }
            pssr2confirm(approve, new ArrayList<>(lockeders), new ArrayList<>(confirmers), sub.getConfirm());
        }

    }

    // 管道审批流程发起申请
    public void doTzsbApprove(TPssrSubcontent sub) {
        String userId = getUserId().toString();


        TPssrPipe pipe = new TPssrPipe();
        pipe.setSubId(sub.getId());
        pipe.setApproveStatus(1L);
        pipe.setUpdatedate(new Date());
        pipe.setUpdaterCode(userId);
        tPssrPipeService.updateAllBySubId(pipe);
        TPssrVessel vessel = new TPssrVessel();
        vessel.setSubId(sub.getId());
        vessel.setApproveStatus(1L);
        vessel.setUpdatedate(new Date());
        vessel.setUpdaterCode(userId);
        tPssrVesselService.updateAllBySubId(vessel);

        //查询确认人
        TPssrPipe entity = new TPssrPipe();
        entity.setSubId(sub.getId());
        entity.setApproveStatus(1L);
        TPssrPipe tPssrPipe = tPssrPipeService.selectAllConfirmedPersonBySubId(entity);
        String confirmer1s = null;
        String confirmer2s = null;
        if (tPssrPipe != null) {
            confirmer1s = tPssrPipe.getConfirmer1();
            confirmer2s = tPssrPipe.getConfirmer2();
        }
        logger.info("=======================confirmer1s:{}", confirmer1s);
        logger.info("=======================confirmer2s:{}", confirmer2s);

        Set<String> confirmerUsers1 = new HashSet<>();
        Set<String> confirmerUsers2 = new HashSet<>();
        if (StringUtils.isNotEmpty(confirmer1s)) {
            confirmerUsers1.addAll(Arrays.asList(confirmer1s.split(",")));
        }
        if (StringUtils.isNotEmpty(confirmer2s)) {
            confirmerUsers2.addAll(Arrays.asList(confirmer2s.split(",")));
        }

        TPssrApprove tPssrApprove = tPssrApproveService.selectTPssrApproveBySubId(sub.getId());
        if (tPssrApprove == null) {
            //新增审批数据
            TPssrApprove approve = new TPssrApprove();
            approve.setSubId(sub.getId());
            approve.setApNo(DateUtils.dateTimeNow() + userId);
            approve.setApproveStatus(1L);
            approve.setSubCharge(sub.getConfirm());
            approve.setCreaterCode(userId);
            approve.setCreatedate(new Date());
            tPssrApproveService.insertTPssrApprove(approve);

            pssr2confirm(approve, new ArrayList<>(confirmerUsers1), new ArrayList<>(confirmerUsers2), sub.getConfirm());
        } else {
            // 已存在流程时，删除旧流程，重新发起
            delProcess(tPssrApprove.getProcessId(), "pssr2confirm");
            entity.setApproveStatus(3L);
            tPssrPipe = tPssrPipeService.selectAllConfirmedPersonBySubId(entity);
            if (tPssrPipe != null) {
                confirmer1s = tPssrPipe.getConfirmer1();
                confirmer2s = tPssrPipe.getConfirmer2();
            }

            if (StringUtils.isNotEmpty(confirmer1s)) {
                confirmerUsers1.addAll(Arrays.asList(confirmer1s.split(",")));
            }
            if (StringUtils.isNotEmpty(confirmer2s)) {
                confirmerUsers2.addAll(Arrays.asList(confirmer2s.split(",")));
            }
            pssr2confirm(tPssrApprove, new ArrayList<>(confirmerUsers1), new ArrayList<>(confirmerUsers2), sub.getConfirm());
        }

    }

    //巡检审批流程发起申请
    public void doPatrolApprove(TPssrSubcontent sub) {
        String userId = getUserId().toString();
        TPssrApprove tPssrApprove = tPssrApproveService.selectTPssrApproveBySubId(sub.getId());
        if (tPssrApprove == null) {
            TPssrApprove approve = new TPssrApprove();//新增审批数据
            approve.setSubId(sub.getId());
            approve.setApNo(DateUtils.dateTimeNow() + userId);
            approve.setApproveStatus(1L);
            approve.setSubCharge(sub.getConfirm());
            approve.setCreaterCode(userId);
            approve.setCreatedate(new Date());
            tPssrApproveService.insertTPssrApprove(approve);

            pssr1confirm(tPssrApprove, new ArrayList<>(), sub.getConfirm());
        } else {
            delProcess(tPssrApprove.getProcessId(), "pssr1confirm");

            pssr1confirm(tPssrApprove, new ArrayList<>(), sub.getConfirm());

        }
    }

    /**
     * 安全设施审批流程发起申请
     */
    private void doAqssApprove(TPssrSubcontent sub) {
        String userId = getUserId().toString();

        //修改各表状态
        TPssrSafetyBleed bleed = new TPssrSafetyBleed();
        bleed.setSubId(sub.getId());
        bleed.setApproveStatus(1L);
        bleed.setUpdatedate(new Date());
        bleed.setUpdaterCode(userId);
        tPssrSafetyBleedService.updateAllBySubId(bleed);
        TPssrSafetyBreath breath = new TPssrSafetyBreath();
        breath.setSubId(sub.getId());
        breath.setApproveStatus(1L);
        breath.setUpdatedate(new Date());
        breath.setUpdaterCode(userId);
        tPssrSafetyBreathService.updateAllBySubId(breath);
        TPssrSafetyBrust brust = new TPssrSafetyBrust();
        brust.setSubId(sub.getId());
        brust.setApproveStatus(1L);
        brust.setUpdatedate(new Date());
        brust.setUpdaterCode(userId);
        tPssrSafetyBrustService.updateAllBySubId(brust);
        TPssrSafetyFlamearrester flamearrester = new TPssrSafetyFlamearrester();
        flamearrester.setSubId(sub.getId());
        flamearrester.setApproveStatus(1L);
        flamearrester.setUpdatedate(new Date());
        flamearrester.setUpdaterCode(userId);
        tPssrSafetyFlamearresterService.updateAllBySubId(flamearrester);
        TPssrSafetyValve valve = new TPssrSafetyValve();
        valve.setSubId(sub.getId());
        valve.setApproveStatus(1L);
        valve.setUpdatedate(new Date());
        valve.setUpdaterCode(userId);
        tPssrSafetyValveService.updateAllBySubId(valve);

        // 查询确认人
        TPssrSafetyBleed entity = new TPssrSafetyBleed();
        entity.setSubId(sub.getId());
        entity.setApproveStatus(1L);
        TPssrSafetyBleed tPssrSafetyBleed = tPssrSafetyBleedService.selectAllConfirmedPersonBySubId(entity);
        String confirmer1s = null;
        String confirmer2s = null;
        if (tPssrSafetyBleed != null) {
            confirmer1s = tPssrSafetyBleed.getConfirmer1();
            confirmer2s = tPssrSafetyBleed.getConfirmer2();
        }
        logger.info("=======================confirmer1s:{}", confirmer1s);
        logger.info("=======================confirmer2s:{}", confirmer2s);

        Set<String> confirmerUsers1 = new HashSet<>();
        Set<String> confirmerUsers2 = new HashSet<>();
        if (StringUtils.isNotEmpty(confirmer1s)) {
            confirmerUsers1.addAll(Arrays.asList(confirmer1s.split(",")));
        }
        if (StringUtils.isNotEmpty(confirmer2s)) {
            confirmerUsers2.addAll(Arrays.asList(confirmer2s.split(",")));
        }
        //查询是否已存在审批流程
        TPssrApprove tPssrApprove = tPssrApproveService.selectTPssrApproveBySubId(sub.getId());
        if (tPssrApprove == null) {
            TPssrApprove approve = new TPssrApprove();
            approve.setSubId(sub.getId());
            approve.setApNo(DateUtils.dateTimeNow() + userId);
            approve.setApproveStatus(1L);
            approve.setSubCharge(sub.getConfirm());
            approve.setCreaterCode(userId);
            approve.setCreatedate(new Date());
            tPssrApproveService.insertTPssrApprove(approve);

            pssr2confirm(approve, new ArrayList<>(confirmerUsers1), new ArrayList<>(confirmerUsers2), sub.getConfirm());
        } else {
            delProcess(tPssrApprove.getProcessId(), "pssr2confirm");
            entity.setSubId(sub.getId());
            entity.setApproveStatus(3L);
            tPssrSafetyBleed = tPssrSafetyBleedService.selectAllConfirmedPersonBySubId(entity);
            if (tPssrSafetyBleed != null) {
                confirmer1s = tPssrSafetyBleed.getConfirmer1();
                confirmer2s = tPssrSafetyBleed.getConfirmer2();
            }

            if (StringUtils.isNotEmpty(confirmer1s)) {
                confirmerUsers1.addAll(Arrays.asList(confirmer1s.split(",")));
            }
            if (StringUtils.isNotEmpty(confirmer2s)) {
                confirmerUsers2.addAll(Arrays.asList(confirmer2s.split(",")));
            }
            pssr2confirm(tPssrApprove, new ArrayList<>(confirmerUsers1), new ArrayList<>(confirmerUsers2), sub.getConfirm());
        }
    }

    // 现场卫生流程发起申请
    public void doXcwsApprove(TPssrSubcontent sub) {
        String userId = getUserId().toString();
        //修改状态
        TPssrHygiene tPssrHygiene = new TPssrHygiene();
        tPssrHygiene.setApproveStatus(0L);
        tPssrHygiene.setSubId(sub.getId());
        Set<String> installer = new HashSet<>();
        Set<String> remover = new HashSet<>();
        for (TPssrHygiene item : tPssrHygieneService.selectTPssrHygieneList(tPssrHygiene)) {
            item.setApproveStatus(1L);
            item.setUpdatedate(new Date());
            item.setUpdaterCode(userId);
            tPssrHygieneService.updateTPssrHygiene(item);

            // 安装人员
            installer.add(item.getConfirm1());

            //拆除人员
            remover.add(item.getConfirm2());
        }

        TPssrApprove exist = new TPssrApprove();
        exist.setSubId(sub.getId());
        List<TPssrApprove> tPssrApproves = tPssrApproveService.selectTPssrApproveList(exist);
        if (CollectionUtil.isEmpty(tPssrApproves)) {
            //新增审批数据
            TPssrApprove approve = new TPssrApprove();
            approve.setSubId(sub.getId());
            approve.setApNo(DateUtils.dateTimeNow() + userId);
            approve.setApproveStatus(1L);
            approve.setSubCharge(sub.getConfirm());
            approve.setCreaterCode(userId);
            approve.setCreatedate(new Date());
            tPssrApproveService.insertTPssrApprove(approve);

            pssr2confirm(approve, new ArrayList<>(installer), new ArrayList<>(remover), sub.getConfirm());
        } else {
            // 已存在流程时，删除旧流程，重新发起
            TPssrApprove approve = tPssrApproves.get(0);
            delProcess(approve.getProcessId(), "pssr2confirm");

            tPssrHygiene = new TPssrHygiene();
            tPssrHygiene.setApproveStatus(1L);
            tPssrHygiene.setSubId(sub.getId());
            for (TPssrHygiene item : tPssrHygieneService.selectTPssrHygieneList(tPssrHygiene)) {
                // 安装人员
                installer.add(item.getConfirm1());

                //拆除人员
                remover.add(item.getConfirm2());
            }
            pssr2confirm(approve, new ArrayList<>(installer), new ArrayList<>(remover), sub.getConfirm());
        }

    }

    // 设备清洁度流程发起申请
    public void doSbqjdApprove(TPssrSubcontent sub) {
        String userId = getUserId().toString();
        //修改状态
        TPssrCleaning tPssrCleaning = new TPssrCleaning();
        tPssrCleaning.setApproveStatus(0L);
        tPssrCleaning.setSubId(sub.getId());
        Set<String> installer = new HashSet<>();
        Set<String> remover = new HashSet<>();
        for (TPssrCleaning item : tPssrCleaningService.selectTPssrCleaningList(tPssrCleaning)) {
            item.setApproveStatus(1L);
            item.setUpdatedate(new Date());
            item.setUpdaterCode(userId);
            tPssrCleaningService.updateTPssrCleaning(item);

            // 安装人员
            installer.add(item.getConfirm1());

            //拆除人员
            remover.add(item.getConfirm2());
        }

        TPssrApprove exist = new TPssrApprove();
        exist.setSubId(sub.getId());
        List<TPssrApprove> tPssrApproves = tPssrApproveService.selectTPssrApproveList(exist);
        if (CollectionUtil.isEmpty(tPssrApproves)) {
            //新增审批数据
            TPssrApprove approve = new TPssrApprove();
            approve.setSubId(sub.getId());
            approve.setApNo(DateUtils.dateTimeNow() + userId);
            approve.setApproveStatus(1L);
            approve.setSubCharge(sub.getConfirm());
            approve.setCreaterCode(userId);
            approve.setCreatedate(new Date());
            tPssrApproveService.insertTPssrApprove(approve);
            pssr2confirm(approve, new ArrayList<>(installer), new ArrayList<>(remover), sub.getConfirm());
        } else {
            // 已存在流程时，删除旧流程，重新发起
            TPssrApprove approve = tPssrApproves.get(0);
            delProcess(approve.getProcessId(), "pssr2confirm");

            tPssrCleaning = new TPssrCleaning();
            tPssrCleaning.setApproveStatus(1L);
            tPssrCleaning.setSubId(sub.getId());
            for (TPssrCleaning item : tPssrCleaningService.selectTPssrCleaningList(tPssrCleaning)) {
                // 安装人员
                installer.add(item.getConfirm1());

                //拆除人员
                remover.add(item.getConfirm2());
            }
            pssr2confirm(approve, new ArrayList<>(installer), new ArrayList<>(remover), sub.getConfirm());
        }

    }

    // 气密流程发起申请
    public void doQmApprove(TPssrSubcontent sub) {
        String userId = getUserId().toString();
        //修改状态
        TPssrAirtight tPssrAirtight = new TPssrAirtight();
        tPssrAirtight.setApproveStatus(0L);
        tPssrAirtight.setSubId(sub.getId());
        Set<String> installer = new HashSet<>();
        Set<String> remover = new HashSet<>();
        for (TPssrAirtight item : tPssrAirtightService.selectTPssrAirtightList(tPssrAirtight)) {
            item.setApproveStatus(1L);
            item.setUpdatedate(new Date());
            item.setUpdaterCode(userId);
            tPssrAirtightService.updateTPssrAirtight(item);

            // 安装人员
            installer.add(item.getConfirm1());

            //拆除人员
            remover.add(item.getConfirm2());
        }

        TPssrApprove exist = new TPssrApprove();
        exist.setSubId(sub.getId());
        List<TPssrApprove> tPssrApproves = tPssrApproveService.selectTPssrApproveList(exist);
        if (CollectionUtil.isEmpty(tPssrApproves)) {
            //新增审批数据
            TPssrApprove approve = new TPssrApprove();
            approve.setSubId(sub.getId());
            approve.setApNo(DateUtils.dateTimeNow() + userId);
            approve.setApproveStatus(1L);
            approve.setSubCharge(sub.getConfirm());
            approve.setCreaterCode(userId);
            approve.setCreatedate(new Date());
            tPssrApproveService.insertTPssrApprove(approve);
            pssr2confirm(approve, new ArrayList<>(installer), new ArrayList<>(remover), sub.getConfirm());
        } else {
            // 已存在流程时，删除旧流程，重新发起
            TPssrApprove approve = tPssrApproves.get(0);
            delProcess(approve.getProcessId(), "pssr2confirm");

            tPssrAirtight = new TPssrAirtight();
            tPssrAirtight.setApproveStatus(1L);
            tPssrAirtight.setSubId(sub.getId());
            for (TPssrAirtight item : tPssrAirtightService.selectTPssrAirtightList(tPssrAirtight)) {
                // 安装人员
                installer.add(item.getConfirm1());

                //拆除人员
                remover.add(item.getConfirm2());
            }
            pssr2confirm(approve, new ArrayList<>(installer), new ArrayList<>(remover), sub.getConfirm());
        }

    }

    // 实验室流程发起申请
    public void doSysApprove(TPssrSubcontent sub) {
        String userId = getUserId().toString();
        //修改状态
        TPssrLaboratory tPssrLaboratory = new TPssrLaboratory();
        tPssrLaboratory.setApproveStatus(0L);
        tPssrLaboratory.setSubId(sub.getId());
        Set<String> installer = new HashSet<>();
        Set<String> remover = new HashSet<>();
        for (TPssrLaboratory item : tPssrLaboratoryService.selectTPssrLaboratoryList(tPssrLaboratory)) {
            item.setApproveStatus(1L);
            item.setUpdatedate(new Date());
            item.setUpdaterCode(userId);
            tPssrLaboratoryService.updateTPssrLaboratory(item);

            // 安装人员
            installer.add(item.getConfirm1());

            //拆除人员
            remover.add(item.getConfirm2());
        }

        TPssrApprove exist = new TPssrApprove();
        exist.setSubId(sub.getId());
        List<TPssrApprove> tPssrApproves = tPssrApproveService.selectTPssrApproveList(exist);
        if (CollectionUtil.isEmpty(tPssrApproves)) {
            //新增审批数据
            TPssrApprove approve = new TPssrApprove();
            approve.setSubId(sub.getId());
            approve.setApNo(DateUtils.dateTimeNow() + userId);
            approve.setApproveStatus(1L);
            approve.setSubCharge(sub.getConfirm());
            approve.setCreaterCode(userId);
            approve.setCreatedate(new Date());
            tPssrApproveService.insertTPssrApprove(approve);
            pssr2confirm(approve, new ArrayList<>(installer), new ArrayList<>(remover), sub.getConfirm());
        } else {
            // 已存在流程时，删除旧流程，重新发起
            TPssrApprove approve = tPssrApproves.get(0);
            delProcess(approve.getProcessId(), "pssr2confirm");

            tPssrLaboratory = new TPssrLaboratory();
            tPssrLaboratory.setApproveStatus(1L);
            tPssrLaboratory.setSubId(sub.getId());
            for (TPssrLaboratory item : tPssrLaboratoryService.selectTPssrLaboratoryList(tPssrLaboratory)) {
                // 安装人员
                installer.add(item.getConfirm1());

                //拆除人员
                remover.add(item.getConfirm2());
            }
            pssr2confirm(approve, new ArrayList<>(installer), new ArrayList<>(remover), sub.getConfirm());
        }

    }

    // 短接流程发起申请
    public void doDjApprove(TPssrSubcontent sub) {
        String userId = getUserId().toString();
        //修改状态
        TPssrCircuit tPssrCircuit = new TPssrCircuit();
        tPssrCircuit.setApproveStatus(0L);
        tPssrCircuit.setSubId(sub.getId());
        Set<String> installer = new HashSet<>();
        Set<String> remover = new HashSet<>();
        for (TPssrCircuit item : tPssrCircuitService.selectTPssrCircuitList(tPssrCircuit)) {
            item.setApproveStatus(1L);
            item.setUpdatedate(new Date());
            item.setUpdaterCode(userId);
            tPssrCircuitService.updateTPssrCircuit(item);

            // 安装人员
            installer.add(item.getConfirm1());

            //拆除人员
            remover.add(item.getConfirm2());
        }

        TPssrApprove exist = new TPssrApprove();
        exist.setSubId(sub.getId());
        List<TPssrApprove> tPssrApproves = tPssrApproveService.selectTPssrApproveList(exist);
        if (CollectionUtil.isEmpty(tPssrApproves)) {
            //新增审批数据
            TPssrApprove approve = new TPssrApprove();
            approve.setSubId(sub.getId());
            approve.setApNo(DateUtils.dateTimeNow() + userId);
            approve.setApproveStatus(1L);
            approve.setSubCharge(sub.getConfirm());
            approve.setCreaterCode(userId);
            approve.setCreatedate(new Date());
            tPssrApproveService.insertTPssrApprove(approve);

            pssr2confirm(approve, new ArrayList<>(installer), new ArrayList<>(remover), sub.getConfirm());
        } else {
            // 已存在流程时，删除旧流程，重新发起
            TPssrApprove approve = tPssrApproves.get(0);
            delProcess(approve.getProcessId(), "pssr2confirm");

            tPssrCircuit = new TPssrCircuit();
            tPssrCircuit.setApproveStatus(1L);
            tPssrCircuit.setSubId(sub.getId());
            for (TPssrCircuit item : tPssrCircuitService.selectTPssrCircuitList(tPssrCircuit)) {
                // 安装人员
                installer.add(item.getConfirm1());

                //拆除人员
                remover.add(item.getConfirm2());
            }

            pssr2confirm(approve, new ArrayList<>(installer), new ArrayList<>(remover), sub.getConfirm());
        }
    }

    // 公用工程流程发起申请
    public void doGygcApprove(TPssrSubcontent sub) {
        String userId = getUserId().toString();
        //修改状态
        TPssrPublic tPssrPublic = new TPssrPublic();
        tPssrPublic.setApproveStatus(0L);
        tPssrPublic.setSubId(sub.getId());
        Set<String> installer = new HashSet<>();
        Set<String> remover = new HashSet<>();
        for (TPssrPublic item : tPssrPublicService.selectTPssrPublicList(tPssrPublic)) {
            item.setApproveStatus(1L);
            item.setUpdatedate(new Date());
            item.setUpdaterCode(userId);
            tPssrPublicService.updateTPssrPublic(item);

            // 安装人员
            installer.add(item.getConfirm1());

            //拆除人员
            remover.add(item.getConfirm2());
        }

        TPssrApprove exist = new TPssrApprove();
        exist.setSubId(sub.getId());
        List<TPssrApprove> tPssrApproves = tPssrApproveService.selectTPssrApproveList(exist);
        if (CollectionUtil.isEmpty(tPssrApproves)) {
            //新增审批数据
            TPssrApprove approve = new TPssrApprove();
            approve.setSubId(sub.getId());
            approve.setApNo(DateUtils.dateTimeNow() + userId);
            approve.setApproveStatus(1L);
            approve.setSubCharge(sub.getConfirm());
            approve.setCreaterCode(userId);
            approve.setCreatedate(new Date());
            tPssrApproveService.insertTPssrApprove(approve);

            pssr2confirm(approve, new ArrayList<>(installer), new ArrayList<>(remover), sub.getConfirm());
        } else {
            // 已存在流程时，删除旧流程，重新发起
            TPssrApprove approve = tPssrApproves.get(0);
            delProcess(approve.getProcessId(), "pssr2confirm");

            tPssrPublic = new TPssrPublic();
            tPssrPublic.setApproveStatus(1L);
            tPssrPublic.setSubId(sub.getId());
            for (TPssrPublic item : tPssrPublicService.selectTPssrPublicList(tPssrPublic)) {
                // 安装人员
                installer.add(item.getConfirm1());

                //拆除人员
                remover.add(item.getConfirm2());
            }

            pssr2confirm(approve, new ArrayList<>(installer), new ArrayList<>(remover), sub.getConfirm());
        }
    }

    // 环保设施流程发起申请
    public void doHbssApprove(TPssrSubcontent sub) {
        String userId = getUserId().toString();
        //修改状态
        TPssrTorchvoc tPssrTorchvoc = new TPssrTorchvoc();
        tPssrTorchvoc.setApproveStatus(0L);
        tPssrTorchvoc.setSubId(sub.getId());
        Set<String> installer = new HashSet<>();
        Set<String> remover = new HashSet<>();
        for (TPssrTorchvoc item : tPssrTorchvocService.selectTPssrTorchvocList(tPssrTorchvoc)) {
            item.setApproveStatus(1L);
            item.setUpdatedate(new Date());
            item.setUpdaterCode(userId);
            tPssrTorchvocService.updateTPssrTorchvoc(item);

            // 安装人员
            installer.add(item.getConfirm1());

            //拆除人员
            remover.add(item.getConfirm2());
        }

        TPssrApprove exist = new TPssrApprove();
        exist.setSubId(sub.getId());
        List<TPssrApprove> tPssrApproves = tPssrApproveService.selectTPssrApproveList(exist);
        if (CollectionUtil.isEmpty(tPssrApproves)) {
            //新增审批数据
            TPssrApprove approve = new TPssrApprove();
            approve.setSubId(sub.getId());
            approve.setApNo(DateUtils.dateTimeNow() + userId);
            approve.setApproveStatus(1L);
            approve.setSubCharge(sub.getConfirm());
            approve.setCreaterCode(userId);
            approve.setCreatedate(new Date());
            tPssrApproveService.insertTPssrApprove(approve);

            pssr2confirm(approve, new ArrayList<>(installer), new ArrayList<>(remover), sub.getConfirm());
        } else {
            // 已存在流程时，删除旧流程，重新发起
            TPssrApprove approve = tPssrApproves.get(0);
            delProcess(approve.getProcessId(), "pssr2confirm");

            tPssrTorchvoc = new TPssrTorchvoc();
            tPssrTorchvoc.setApproveStatus(1L);
            tPssrTorchvoc.setSubId(sub.getId());
            for (TPssrTorchvoc item : tPssrTorchvocService.selectTPssrTorchvocList(tPssrTorchvoc)) {
                // 安装人员
                installer.add(item.getConfirm1());

                //拆除人员
                remover.add(item.getConfirm2());
            }

            pssr2confirm(approve, new ArrayList<>(installer), new ArrayList<>(remover), sub.getConfirm());
        }
    }

    // 照明、电伴热流程发起申请
    public void doZmdbrApprove(TPssrSubcontent sub) {
        String userId = getUserId().toString();
        //修改状态
        TPssrLighting tPssrLighting = new TPssrLighting();
        tPssrLighting.setApproveStatus(0L);
        tPssrLighting.setSubId(sub.getId());
        Set<String> installer = new HashSet<>();
        Set<String> remover = new HashSet<>();
        for (TPssrLighting item : tPssrLightingService.selectTPssrLightingList(tPssrLighting)) {
            item.setApproveStatus(1L);
            item.setUpdatedate(new Date());
            item.setUpdaterCode(userId);
            tPssrLightingService.updateTPssrLighting(item);

            // 安装人员
            installer.add(item.getConfirm1());

            //拆除人员
            remover.add(item.getConfirm2());
        }

        TPssrApprove exist = new TPssrApprove();
        exist.setSubId(sub.getId());
        List<TPssrApprove> tPssrApproves = tPssrApproveService.selectTPssrApproveList(exist);
        if (CollectionUtil.isEmpty(tPssrApproves)) {
            //新增审批数据
            TPssrApprove approve = new TPssrApprove();
            approve.setSubId(sub.getId());
            approve.setApNo(DateUtils.dateTimeNow() + userId);
            approve.setApproveStatus(1L);
            approve.setSubCharge(sub.getConfirm());
            approve.setCreaterCode(userId);
            approve.setCreatedate(new Date());
            tPssrApproveService.insertTPssrApprove(approve);

            pssr2confirm(approve, new ArrayList<>(installer), new ArrayList<>(remover), sub.getConfirm());
        } else {
            // 已存在流程时，删除旧流程，重新发起
            TPssrApprove approve = tPssrApproves.get(0);
            delProcess(approve.getProcessId(), "pssr2confirm");

            tPssrLighting = new TPssrLighting();
            tPssrLighting.setApproveStatus(1L);
            tPssrLighting.setSubId(sub.getId());
            for (TPssrLighting item : tPssrLightingService.selectTPssrLightingList(tPssrLighting)) {
                // 安装人员
                installer.add(item.getConfirm1());

                //拆除人员
                remover.add(item.getConfirm2());
            }

            pssr2confirm(approve, new ArrayList<>(installer), new ArrayList<>(remover), sub.getConfirm());
        }
    }

    // 支吊架流程发起申请
    public void doZdjApprove(TPssrSubcontent sub) {
        String userId = getUserId().toString();
        //修改状态
        TPssrFrame tPssrFrame = new TPssrFrame();
        tPssrFrame.setApproveStatus(0L);
        tPssrFrame.setSubId(sub.getId());
        Set<String> installer = new HashSet<>();
        Set<String> remover = new HashSet<>();
        for (TPssrFrame item : tPssrFrameService.selectTPssrFrameList(tPssrFrame)) {
            item.setApproveStatus(1L);
            item.setUpdatedate(new Date());
            item.setUpdaterCode(userId);
            tPssrFrameService.updateTPssrFrame(item);

            // 安装人员
            installer.add(item.getConfirm1());

            //拆除人员
            remover.add(item.getConfirm2());
        }

        TPssrApprove exist = new TPssrApprove();
        exist.setSubId(sub.getId());
        List<TPssrApprove> tPssrApproves = tPssrApproveService.selectTPssrApproveList(exist);
        if (CollectionUtil.isEmpty(tPssrApproves)) {
            //新增审批数据
            TPssrApprove approve = new TPssrApprove();
            approve.setSubId(sub.getId());
            approve.setApNo(DateUtils.dateTimeNow() + userId);
            approve.setApproveStatus(1L);
            approve.setSubCharge(sub.getConfirm());
            approve.setCreaterCode(userId);
            approve.setCreatedate(new Date());
            tPssrApproveService.insertTPssrApprove(approve);

            pssr2confirm(approve, new ArrayList<>(installer), new ArrayList<>(remover), sub.getConfirm());
        } else {
            // 已存在流程时，删除旧流程，重新发起
            TPssrApprove approve = tPssrApproves.get(0);
            delProcess(approve.getProcessId(), "pssr2confirm");

            tPssrFrame = new TPssrFrame();
            tPssrFrame.setApproveStatus(1L);
            tPssrFrame.setSubId(sub.getId());
            for (TPssrFrame item : tPssrFrameService.selectTPssrFrameList(tPssrFrame)) {
                // 安装人员
                installer.add(item.getConfirm1());

                //拆除人员
                remover.add(item.getConfirm2());
            }

            pssr2confirm(approve, new ArrayList<>(installer), new ArrayList<>(remover), sub.getConfirm());
        }
    }

    // 仪表校验流程发起申请
    public void doYbjyApprove(TPssrSubcontent sub) {
        String userId = getUserId().toString();
        //修改状态
        TPssrInstrumentCalibration tPssrInstrumentCalibration = new TPssrInstrumentCalibration();
        tPssrInstrumentCalibration.setApproveStatus(0L);
        tPssrInstrumentCalibration.setSubId(sub.getId());
        Set<String> installer = new HashSet<>();
        Set<String> remover = new HashSet<>();
        for (TPssrInstrumentCalibration item : tPssrInstrumentCalibrationService.selectTPssrInstrumentCalibrationList(tPssrInstrumentCalibration)) {
            item.setApproveStatus(1L);
            item.setUpdatedate(new Date());
            item.setUpdaterCode(userId);
            tPssrInstrumentCalibrationService.updateTPssrInstrumentCalibration(item);

            // 安装人员
            installer.add(item.getConfirm1());

            //拆除人员
            remover.add(item.getConfirm2());
        }

        TPssrApprove exist = new TPssrApprove();
        exist.setSubId(sub.getId());
        List<TPssrApprove> tPssrApproves = tPssrApproveService.selectTPssrApproveList(exist);
        if (CollectionUtil.isEmpty(tPssrApproves)) {
            //新增审批数据
            TPssrApprove approve = new TPssrApprove();
            approve.setSubId(sub.getId());
            approve.setApNo(DateUtils.dateTimeNow() + userId);
            approve.setApproveStatus(1L);
            approve.setSubCharge(sub.getConfirm());
            approve.setCreaterCode(userId);
            approve.setCreatedate(new Date());
            tPssrApproveService.insertTPssrApprove(approve);

            pssr2confirm(approve, new ArrayList<>(installer), new ArrayList<>(remover), sub.getConfirm());
        } else {
            // 已存在流程时，删除旧流程，重新发起
            TPssrApprove approve = tPssrApproves.get(0);
            delProcess(approve.getProcessId(), "pssr2confirm");

            tPssrInstrumentCalibration = new TPssrInstrumentCalibration();
            tPssrInstrumentCalibration.setApproveStatus(1L);
            tPssrInstrumentCalibration.setSubId(sub.getId());
            for (TPssrInstrumentCalibration item : tPssrInstrumentCalibrationService.selectTPssrInstrumentCalibrationList(tPssrInstrumentCalibration)) {
                // 安装人员
                installer.add(item.getConfirm1());

                //拆除人员
                remover.add(item.getConfirm2());
            }

            pssr2confirm(approve, new ArrayList<>(installer), new ArrayList<>(remover), sub.getConfirm());
        }
    }

    //临时电源流程发起申请
    public void doLsdyApprove(TPssrSubcontent sub) {
        String userId = getUserId().toString();
        //修改状态
        TPssrMotor tPssrMotor = new TPssrMotor();
        tPssrMotor.setApproveStatus(0L);
        tPssrMotor.setSubId(sub.getId());
        Set<String> installer = new HashSet<>();
        Set<String> remover = new HashSet<>();
        for (TPssrMotor item : tPssrMotorService.selectTPssrMotorList(tPssrMotor)) {
            item.setApproveStatus(1L);
            item.setUpdatedate(new Date());
            item.setUpdaterCode(userId);
            tPssrMotorService.updateTPssrMotor(item);

            // 安装人员
            installer.add(item.getConfirm1());

            //拆除人员
            remover.add(item.getConfirm2());
        }

        TPssrApprove exist = new TPssrApprove();
        exist.setSubId(sub.getId());
        List<TPssrApprove> tPssrApproves = tPssrApproveService.selectTPssrApproveList(exist);
        if (CollectionUtil.isEmpty(tPssrApproves)) {
            //新增审批数据
            TPssrApprove approve = new TPssrApprove();
            approve.setSubId(sub.getId());
            approve.setApNo(DateUtils.dateTimeNow() + userId);
            approve.setApproveStatus(1L);
            approve.setSubCharge(sub.getConfirm());
            approve.setCreaterCode(userId);
            approve.setCreatedate(new Date());
            tPssrApproveService.insertTPssrApprove(approve);

            pssr2confirm(approve, new ArrayList<>(installer), new ArrayList<>(remover), sub.getConfirm());
        } else {
            // 已存在流程时，删除旧流程，重新发起
            TPssrApprove approve = tPssrApproves.get(0);
            delProcess(approve.getProcessId(), "pssr2confirm");

            tPssrMotor = new TPssrMotor();
            tPssrMotor.setApproveStatus(1L);
            tPssrMotor.setSubId(sub.getId());
            for (TPssrMotor item : tPssrMotorService.selectTPssrMotorList(tPssrMotor)) {
                // 安装人员
                installer.add(item.getConfirm1());

                //拆除人员
                remover.add(item.getConfirm2());
            }

            pssr2confirm(approve, new ArrayList<>(installer), new ArrayList<>(remover), sub.getConfirm());
        }
    }

    //电机设备流程发起申请
    public void doDjsbApprove(TPssrSubcontent sub) {
        String userId = getUserId().toString();
        //修改状态
        TPssrMotor tPssrMotor = new TPssrMotor();
        tPssrMotor.setApproveStatus(0L);
        tPssrMotor.setSubId(sub.getId());
        Set<String> installer = new HashSet<>();
        Set<String> remover = new HashSet<>();
        for (TPssrMotor item : tPssrMotorService.selectTPssrMotorList(tPssrMotor)) {
            item.setApproveStatus(1L);
            item.setUpdatedate(new Date());
            item.setUpdaterCode(userId);
            tPssrMotorService.updateTPssrMotor(item);

            // 安装人员
            installer.add(item.getConfirm1());

            //拆除人员
            remover.add(item.getConfirm2());
        }

        TPssrApprove exist = new TPssrApprove();
        exist.setSubId(sub.getId());
        List<TPssrApprove> tPssrApproves = tPssrApproveService.selectTPssrApproveList(exist);
        if (CollectionUtil.isEmpty(tPssrApproves)) {
            //新增审批数据
            TPssrApprove approve = new TPssrApprove();
            approve.setSubId(sub.getId());
            approve.setApNo(DateUtils.dateTimeNow() + userId);
            approve.setApproveStatus(1L);
            approve.setSubCharge(sub.getConfirm());
            approve.setCreaterCode(userId);
            approve.setCreatedate(new Date());
            tPssrApproveService.insertTPssrApprove(approve);

            pssr2confirm(approve, new ArrayList<>(installer), new ArrayList<>(remover), sub.getConfirm());
        } else {
            // 已存在流程时，删除旧流程，重新发起
            TPssrApprove approve = tPssrApproves.get(0);
            delProcess(approve.getProcessId(), "pssr2confirm");

            tPssrMotor = new TPssrMotor();
            tPssrMotor.setApproveStatus(1L);
            tPssrMotor.setSubId(sub.getId());
            for (TPssrMotor item : tPssrMotorService.selectTPssrMotorList(tPssrMotor)) {
                // 安装人员
                installer.add(item.getConfirm1());

                //拆除人员
                remover.add(item.getConfirm2());
            }

            pssr2confirm(approve, new ArrayList<>(installer), new ArrayList<>(remover), sub.getConfirm());
        }
    }

    //静电接地、跨接流程发起申请
    public void doJdjdkjApprove(TPssrSubcontent sub) {
        String userId = getUserId().toString();
        //修改状态
        TPssrFranklinism tPssrFranklinism = new TPssrFranklinism();
        tPssrFranklinism.setApproveStatus(0L);
        tPssrFranklinism.setSubId(sub.getId());
        Set<String> installer = new HashSet<>();
        Set<String> remover = new HashSet<>();
        for (TPssrFranklinism item : tPssrFranklinismService.selectTPssrFranklinismList(tPssrFranklinism)) {
            item.setApproveStatus(1L);
            item.setUpdatedate(new Date());
            item.setUpdaterCode(userId);
            tPssrFranklinismService.updateTPssrFranklinism(item);

            // 安装人员
            installer.add(item.getConfirm1());

            //拆除人员
            remover.add(item.getConfirm2());
        }

        TPssrApprove exist = new TPssrApprove();
        exist.setSubId(sub.getId());
        List<TPssrApprove> tPssrApproves = tPssrApproveService.selectTPssrApproveList(exist);
        if (CollectionUtil.isEmpty(tPssrApproves)) {
            //新增审批数据
            TPssrApprove approve = new TPssrApprove();
            approve.setSubId(sub.getId());
            approve.setApNo(DateUtils.dateTimeNow() + userId);
            approve.setApproveStatus(1L);
            approve.setSubCharge(sub.getConfirm());
            approve.setCreaterCode(userId);
            approve.setCreatedate(new Date());
            tPssrApproveService.insertTPssrApprove(approve);

            pssr2confirm(approve, new ArrayList<>(installer), new ArrayList<>(remover), sub.getConfirm());
        } else {
            // 已存在流程时，删除旧流程，重新发起
            TPssrApprove approve = tPssrApproves.get(0);
            delProcess(approve.getProcessId(), "pssr2confirm");

            tPssrFranklinism = new TPssrFranklinism();
            tPssrFranklinism.setApproveStatus(1L);
            tPssrFranklinism.setSubId(sub.getId());
            for (TPssrFranklinism item : tPssrFranklinismService.selectTPssrFranklinismList(tPssrFranklinism)) {
                // 安装人员
                installer.add(item.getConfirm1());

                //拆除人员
                remover.add(item.getConfirm2());
            }

            pssr2confirm(approve, new ArrayList<>(installer), new ArrayList<>(remover), sub.getConfirm());
        }
    }

    //气体检测仪流程发起申请
    public void doQtjcyApprove(TPssrSubcontent sub) {
        String userId = getUserId().toString();
        //修改状态
        TPssrGasdetector tPssrGasdetector = new TPssrGasdetector();
        tPssrGasdetector.setApproveStatus(0L);
        tPssrGasdetector.setSubId(sub.getId());
        Set<String> installer = new HashSet<>();
        Set<String> remover = new HashSet<>();
        for (TPssrGasdetector item : tPssrGasdetectorService.selectTPssrGasdetectorList(tPssrGasdetector)) {
            item.setApproveStatus(1L);
            item.setUpdatedate(new Date());
            item.setUpdaterCode(userId);
            tPssrGasdetectorService.updateTPssrGasdetector(item);

            // 安装人员
            installer.add(item.getConfirm1());

            //拆除人员
            remover.add(item.getConfirm2());
        }

        TPssrApprove exist = new TPssrApprove();
        exist.setSubId(sub.getId());
        List<TPssrApprove> tPssrApproves = tPssrApproveService.selectTPssrApproveList(exist);
        if (CollectionUtil.isEmpty(tPssrApproves)) {
            //新增审批数据
            TPssrApprove approve = new TPssrApprove();
            approve.setSubId(sub.getId());
            approve.setApNo(DateUtils.dateTimeNow() + userId);
            approve.setApproveStatus(1L);
            approve.setSubCharge(sub.getConfirm());
            approve.setCreaterCode(userId);
            approve.setCreatedate(new Date());
            tPssrApproveService.insertTPssrApprove(approve);

            pssr2confirm(approve, new ArrayList<>(installer), new ArrayList<>(remover), sub.getConfirm());
        } else {
            // 已存在流程时，删除旧流程，重新发起
            TPssrApprove approve = tPssrApproves.get(0);
            delProcess(approve.getProcessId(), "pssr2confirm");

            tPssrGasdetector = new TPssrGasdetector();
            tPssrGasdetector.setApproveStatus(1L);
            tPssrGasdetector.setSubId(sub.getId());
            for (TPssrGasdetector item : tPssrGasdetectorService.selectTPssrGasdetectorList(tPssrGasdetector)) {
                // 安装人员
                installer.add(item.getConfirm1());

                //拆除人员
                remover.add(item.getConfirm2());
            }

            pssr2confirm(approve, new ArrayList<>(installer), new ArrayList<>(remover), sub.getConfirm());
        }
    }

    //在线分析仪流程发起申请
    public void doZxfxyApprove(TPssrSubcontent sub) {
        String userId = getUserId().toString();
        //修改状态
        TPssrAnalyzer tPssrAnalyzer = new TPssrAnalyzer();
        tPssrAnalyzer.setApproveStatus(0L);
        tPssrAnalyzer.setSubId(sub.getId());
        Set<String> installer = new HashSet<>();
        Set<String> remover = new HashSet<>();
        for (TPssrAnalyzer item : tPssrAnalyzerService.selectTPssrAnalyzerList(tPssrAnalyzer)) {
            item.setApproveStatus(1L);
            item.setUpdatedate(new Date());
            item.setUpdaterCode(userId);
            tPssrAnalyzerService.updateTPssrAnalyzer(item);

            // 安装人员
            installer.add(item.getConfirm1());

            //拆除人员
            remover.add(item.getConfirm2());
        }

        TPssrApprove exist = new TPssrApprove();
        exist.setSubId(sub.getId());
        List<TPssrApprove> tPssrApproves = tPssrApproveService.selectTPssrApproveList(exist);
        if (CollectionUtil.isEmpty(tPssrApproves)) {
            //新增审批数据
            TPssrApprove approve = new TPssrApprove();
            approve.setSubId(sub.getId());
            approve.setApNo(DateUtils.dateTimeNow() + userId);
            approve.setApproveStatus(1L);
            approve.setSubCharge(sub.getConfirm());
            approve.setCreaterCode(userId);
            approve.setCreatedate(new Date());
            tPssrApproveService.insertTPssrApprove(approve);

            pssr2confirm(approve, new ArrayList<>(installer), new ArrayList<>(remover), sub.getConfirm());
        } else {
            // 已存在流程时，删除旧流程，重新发起
            TPssrApprove approve = tPssrApproves.get(0);
            delProcess(approve.getProcessId(), "pssr2confirm");

            tPssrAnalyzer = new TPssrAnalyzer();
            tPssrAnalyzer.setApproveStatus(1L);
            tPssrAnalyzer.setSubId(sub.getId());
            for (TPssrAnalyzer item : tPssrAnalyzerService.selectTPssrAnalyzerList(tPssrAnalyzer)) {
                // 安装人员
                installer.add(item.getConfirm1());

                //拆除人员
                remover.add(item.getConfirm2());
            }

            pssr2confirm(approve, new ArrayList<>(installer), new ArrayList<>(remover), sub.getConfirm());
        }
    }

    // 开工方案流程发起申请
    public void doKgfaApprove(TPssrSubcontent sub) {
        String userId = getUserId().toString();
        //修改状态
        TPssrProgramme tPssrProgramme = new TPssrProgramme();
        tPssrProgramme.setApproveStatus(0L);
        tPssrProgramme.setSubId(sub.getId());
        Set<String> confirm1 = new HashSet<>();
        Set<String> confirm2 = new HashSet<>();
        for (TPssrProgramme item : tPssrProgrammeService.selectTPssrProgrammeList(tPssrProgramme)) {
            item.setApproveStatus(1L);
            item.setUpdatedate(new Date());
            item.setUpdaterCode(userId);
            tPssrProgrammeService.updateTPssrProgramme(item);

            // 安装人员
            confirm1.add(item.getConfirm1());

            //拆除人员
            confirm2.add(item.getConfirm2());
        }

        TPssrApprove exist = new TPssrApprove();
        exist.setSubId(sub.getId());
        List<TPssrApprove> tPssrApproves = tPssrApproveService.selectTPssrApproveList(exist);
        if (CollectionUtil.isEmpty(tPssrApproves)) {
            //新增审批数据
            TPssrApprove approve = new TPssrApprove();
            approve.setSubId(sub.getId());
            approve.setApNo(DateUtils.dateTimeNow() + userId);
            approve.setApproveStatus(1L);
            approve.setSubCharge(sub.getConfirm());
            approve.setCreaterCode(userId);
            approve.setCreatedate(new Date());
            tPssrApproveService.insertTPssrApprove(approve);

            pssr2confirm(approve, new ArrayList<>(confirm1), new ArrayList<>(confirm2), sub.getConfirm());
        } else {
            // 已存在流程时，删除旧流程，重新发起
            TPssrApprove approve = tPssrApproves.get(0);
            delProcess(approve.getProcessId(), "pssr2confirm");

            tPssrProgramme = new TPssrProgramme();
            tPssrProgramme.setApproveStatus(1L);
            tPssrProgramme.setSubId(sub.getId());
            for (TPssrProgramme item : tPssrProgrammeService.selectTPssrProgrammeList(tPssrProgramme)) {
                // 安装人员
                confirm1.add(item.getConfirm1());

                //拆除人员
                confirm2.add(item.getConfirm2());
            }

            pssr2confirm(approve, new ArrayList<>(confirm1), new ArrayList<>(confirm2), sub.getConfirm());
        }
    }

    /**
     * 设计变更发起流程
     */
    private void doMocApprove(TPssrSubcontent sub) {
        String userId = getUserId().toString();
        //修改状态
        TPssrMoc tPssrMoc = new TPssrMoc();
        tPssrMoc.setApproveStatus(0L);
        tPssrMoc.setSubId(sub.getId());
        Set<String> confirm1 = new HashSet<>();
        Set<String> confirm2 = new HashSet<>();
        for (TPssrMoc item : tPssrMocService.selectTPssrMocList(tPssrMoc)) {
            item.setApproveStatus(1L);
            item.setUpdatedate(new Date());
            item.setUpdaterCode(userId);
            tPssrMocService.updateTPssrMoc(item);

            // 安装人员
            confirm1.add(item.getConfirm1());

            //拆除人员
            confirm2.add(item.getConfirm2());
        }

        TPssrApprove exist = new TPssrApprove();
        exist.setSubId(sub.getId());
        List<TPssrApprove> tPssrApproves = tPssrApproveService.selectTPssrApproveList(exist);
        if (CollectionUtil.isEmpty(tPssrApproves)) {
            //新增审批数据
            TPssrApprove approve = new TPssrApprove();
            approve.setSubId(sub.getId());
            approve.setApNo(DateUtils.dateTimeNow() + userId);
            approve.setApproveStatus(1L);
            approve.setSubCharge(sub.getConfirm());
            approve.setCreaterCode(userId);
            approve.setCreatedate(new Date());
            tPssrApproveService.insertTPssrApprove(approve);

            pssr2confirm(approve, new ArrayList<>(confirm1), new ArrayList<>(confirm2), sub.getConfirm());
        } else {
            // 已存在流程时，删除旧流程，重新发起
            TPssrApprove approve = tPssrApproves.get(0);
            delProcess(approve.getProcessId(), "pssr2confirm");

            tPssrMoc = new TPssrMoc();
            tPssrMoc.setApproveStatus(1L);
            tPssrMoc.setSubId(sub.getId());
            for (TPssrMoc item : tPssrMocService.selectTPssrMocList(tPssrMoc)) {
                // 安装人员
                confirm1.add(item.getConfirm1());

                //拆除人员
                confirm2.add(item.getConfirm2());
            }

            pssr2confirm(approve, new ArrayList<>(confirm1), new ArrayList<>(confirm2), sub.getConfirm());
        }
    }

    /**
     * 人身防护审批流程发起申请
     *
     * @param sub 子表对象
     */
    private void doRsfhApprove(TPssrSubcontent sub) {
        String userId = getUserId().toString();

        //修改各表状态
        TPssrMeasure measure = new TPssrMeasure();
        measure.setSubId(sub.getId());
        measure.setApproveStatus(1L);
        measure.setUpdatedate(new Date());
        measure.setUpdaterCode(userId);
        tPssrMeasureService.updateAllBySubId(measure);
        TPssrProtection protection = new TPssrProtection();
        protection.setSubId(sub.getId());
        protection.setApproveStatus(1L);
        protection.setUpdatedate(new Date());
        protection.setUpdaterCode(userId);
        tPssrProtectionService.updateAllBySubId(protection);

        // 查询确认人
        TPssrProtection entity = new TPssrProtection();
        entity.setSubId(sub.getId());
        entity.setApproveStatus(1L);
        TPssrProtection tPssrProtection = tPssrProtectionService.selectAllConfirmedPersonBySubId(entity);
        String confirmer1s = null;
        String confirmer2s = null;
        if (tPssrProtection != null) {
            confirmer1s = tPssrProtection.getConfirm1();
            confirmer2s = tPssrProtection.getConfirm2();
        }
        logger.info("=======================confirmer1s:{}", confirmer1s);
        logger.info("=======================confirmer2s:{}", confirmer2s);

        Set<String> confirmerUsers1 = new HashSet<>();
        Set<String> confirmerUsers2 = new HashSet<>();
        if (StringUtils.isNotEmpty(confirmer1s)) {
            confirmerUsers1.addAll(Arrays.asList(confirmer1s.split(",")));
        }
        if (StringUtils.isNotEmpty(confirmer2s)) {
            confirmerUsers2.addAll(Arrays.asList(confirmer2s.split(",")));
        }
        //查询是否已存在审批流程
        TPssrApprove tPssrApprove = tPssrApproveService.selectTPssrApproveBySubId(sub.getId());
        if (tPssrApprove == null) {
            TPssrApprove approve = new TPssrApprove();
            approve.setSubId(sub.getId());
            approve.setApNo(DateUtils.dateTimeNow() + userId);
            approve.setApproveStatus(1L);
            approve.setSubCharge(sub.getConfirm());
            approve.setCreaterCode(userId);
            approve.setCreatedate(new Date());
            tPssrApproveService.insertTPssrApprove(approve);

            pssr2confirm(approve, new ArrayList<>(confirmerUsers1), new ArrayList<>(confirmerUsers2), sub.getConfirm());
        } else {
            delProcess(tPssrApprove.getProcessId(), "pssr2confirm");
            entity.setSubId(sub.getId());
            entity.setApproveStatus(3L);
            tPssrProtection = tPssrProtectionService.selectAllConfirmedPersonBySubId(entity);
            if (tPssrProtection != null) {
                confirmer1s = tPssrProtection.getConfirm1();
                confirmer2s = tPssrProtection.getConfirm2();
            }

            if (StringUtils.isNotEmpty(confirmer1s)) {
                confirmerUsers1.addAll(Arrays.asList(confirmer1s.split(",")));
            }
            if (StringUtils.isNotEmpty(confirmer2s)) {
                confirmerUsers2.addAll(Arrays.asList(confirmer2s.split(",")));
            }
            pssr2confirm(tPssrApprove, new ArrayList<>(confirmerUsers1), new ArrayList<>(confirmerUsers2), sub.getConfirm());
        }
    }

    /**
     * 原辅料审批发起申请
     */
    private void doYflApprove(TPssrSubcontent sub) {
        String userId = getUserId().toString();

        //修改各表状态
        TPssrMaterial material = new TPssrMaterial();
        material.setSubId(sub.getId());
        material.setApproveStatus(1L);
        material.setUpdatedate(new Date());
        material.setUpdaterCode(userId);
        tPssrMaterialService.updateAllBySubId(material);
        TPssrMaterialRaw materialRaw = new TPssrMaterialRaw();
        materialRaw.setSubId(sub.getId());
        materialRaw.setApproveStatus(1L);
        materialRaw.setUpdatedate(new Date());
        materialRaw.setUpdaterCode(userId);
        tPssrMaterialRawService.updateAllBySubId(materialRaw);

        // 查询确认人
        TPssrMaterial entity = new TPssrMaterial();
        entity.setSubId(sub.getId());
        entity.setApproveStatus(1L);
        TPssrMaterial tPssrMaterial = tPssrMaterialService.selectAllConfirmedPersonBySubId(entity);
        String confirmer1s = null;
        if (tPssrMaterial != null) {
            confirmer1s = tPssrMaterial.getConfirm1();
        }
        logger.info("=======================confirmer1s:{}", confirmer1s);

        Set<String> confirmerUsers1 = new HashSet<>();
        if (StringUtils.isNotEmpty(confirmer1s)) {
            confirmerUsers1.addAll(Arrays.asList(confirmer1s.split(",")));
        }
        //查询是否已存在审批流程
        TPssrApprove tPssrApprove = tPssrApproveService.selectTPssrApproveBySubId(sub.getId());
        if (tPssrApprove == null) {
            TPssrApprove approve = new TPssrApprove();
            approve.setSubId(sub.getId());
            approve.setApNo(DateUtils.dateTimeNow() + userId);
            approve.setApproveStatus(1L);
            approve.setSubCharge(sub.getConfirm());
            approve.setCreaterCode(userId);
            approve.setCreatedate(new Date());
            tPssrApproveService.insertTPssrApprove(approve);

            pssr1confirm(approve, new ArrayList<>(confirmerUsers1), sub.getConfirm());
        } else {
            delProcess(tPssrApprove.getProcessId(), "pssr1confirm");
            entity.setSubId(sub.getId());
            entity.setApproveStatus(3L);
            tPssrMaterial = tPssrMaterialService.selectAllConfirmedPersonBySubId(entity);
            if (tPssrMaterial != null) {
                confirmer1s = tPssrMaterial.getConfirm1();
            }

            if (StringUtils.isNotEmpty(confirmer1s)) {
                confirmerUsers1.addAll(Arrays.asList(confirmer1s.split(",")));
            }
            pssr1confirm(tPssrApprove, new ArrayList<>(confirmerUsers1), sub.getConfirm());
        }
    }

    /**
     * 机泵审批发起申请
     */
    private void doJbApprove(TPssrSubcontent sub) {
        String userId = getUserId().toString();

        //修改各表状态
        TPssrPumpCleaning cleaning = new TPssrPumpCleaning();
        cleaning.setSubId(sub.getId());
        cleaning.setApproveStatus(1L);
        cleaning.setUpdatedate(new Date());
        cleaning.setUpdaterCode(userId);
        tPssrPumpCleaningService.updateAllBySubId(cleaning);
        TPssrPumpFill fill = new TPssrPumpFill();
        fill.setSubId(sub.getId());
        fill.setApproveStatus(1L);
        fill.setUpdatedate(new Date());
        fill.setUpdaterCode(userId);
        tPssrPumpFillService.updateAllBySubId(fill);
        TPssrPumpOverhaul overhaul = new TPssrPumpOverhaul();
        overhaul.setSubId(sub.getId());
        overhaul.setApproveStatus(1L);
        overhaul.setUpdatedate(new Date());
        overhaul.setUpdaterCode(userId);
        tPssrPumpOverhaulService.updateAllBySubId(overhaul);

        // 查询确认人
        TPssrPumpFill entity = new TPssrPumpFill();
        entity.setSubId(sub.getId());
        entity.setApproveStatus(1L);
        TPssrPumpFill queryData = tPssrPumpFillService.selectAllConfirmedPersonBySubId(entity);
        String confirmer1s = null;
        String confirmer2s = null;
        if (queryData != null) {
            confirmer1s = queryData.getConfirmer1();
            confirmer2s = queryData.getConfirmer2();
        }
        logger.info("=======================confirmer1s:{}", confirmer1s);
        logger.info("=======================confirmer2s:{}", confirmer2s);

        Set<String> confirmerUsers1 = new HashSet<>();
        Set<String> confirmerUsers2 = new HashSet<>();
        if (StringUtils.isNotEmpty(confirmer1s)) {
            confirmerUsers1.addAll(Arrays.asList(confirmer1s.split(",")));
        }
        if (StringUtils.isNotEmpty(confirmer2s)) {
            confirmerUsers2.addAll(Arrays.asList(confirmer2s.split(",")));
        }
        //查询是否已存在审批流程
        TPssrApprove tPssrApprove = tPssrApproveService.selectTPssrApproveBySubId(sub.getId());
        if (tPssrApprove == null) {
            TPssrApprove approve = new TPssrApprove();
            approve.setSubId(sub.getId());
            approve.setApNo(DateUtils.dateTimeNow() + userId);
            approve.setApproveStatus(1L);
            approve.setSubCharge(sub.getConfirm());
            approve.setCreaterCode(userId);
            approve.setCreatedate(new Date());
            tPssrApproveService.insertTPssrApprove(approve);

            pssr2confirm(approve, new ArrayList<>(confirmerUsers1), new ArrayList<>(confirmerUsers2), sub.getConfirm());
        } else {
            delProcess(tPssrApprove.getProcessId(), "pssr2confirm");
            entity.setSubId(sub.getId());
            entity.setApproveStatus(3L);
            queryData = tPssrPumpFillService.selectAllConfirmedPersonBySubId(entity);
            if (queryData != null) {
                confirmer1s = queryData.getConfirmer1();
                confirmer2s = queryData.getConfirmer2();
            }

            if (StringUtils.isNotEmpty(confirmer1s)) {
                confirmerUsers1.addAll(Arrays.asList(confirmer1s.split(",")));
            }
            if (StringUtils.isNotEmpty(confirmer2s)) {
                confirmerUsers2.addAll(Arrays.asList(confirmer2s.split(",")));
            }
            pssr2confirm(tPssrApprove, new ArrayList<>(confirmerUsers1), new ArrayList<>(confirmerUsers2), sub.getConfirm());
        }
    }

    /**
     * 仪表联锁测试审批发起申请
     */
    private void doYblscsApprove(TPssrSubcontent sub) {
        String userId = getUserId().toString();

        //修改表状态
        TPssrInstrumentTest instrumentTest = new TPssrInstrumentTest();
        instrumentTest.setSubId(sub.getId());
        for (TPssrInstrumentTest test : tPssrInstrumentTestService.selectTPssrInstrumentTestList(instrumentTest)) {
            test.setApproveStatus(2L);
            test.setUpdatedate(new Date());
            test.setUpdaterCode(userId);
            tPssrInstrumentTestService.updateTPssrInstrumentTest(test);
        }
        //查询是否已存在审批流程
        TPssrApprove tPssrApprove = tPssrApproveService.selectTPssrApproveBySubId(sub.getId());
        if (tPssrApprove == null) {
            TPssrApprove approve = new TPssrApprove();
            approve.setSubId(sub.getId());
            approve.setApNo(DateUtils.dateTimeNow() + userId);
            approve.setApproveStatus(1L);
            approve.setSubCharge(sub.getConfirm());
            approve.setCreaterCode(userId);
            approve.setCreatedate(new Date());
            tPssrApproveService.insertTPssrApprove(approve);

            pssr1confirm(approve, new ArrayList<>(), sub.getConfirm());
        } else {
            delProcess(tPssrApprove.getProcessId(), "pssr1confirm");
            pssr1confirm(tPssrApprove, new ArrayList<>(), sub.getConfirm());
        }

    }

    /**
     * 仪表联锁测试审批发起申请
     */
    private void doBjlszqrApprove(TPssrSubcontent sub) {
        String userId = getUserId().toString();

        //修改表状态
        TPssrAlarm alarm = new TPssrAlarm();
        alarm.setSubId(sub.getId());
        for (TPssrAlarm test : tPssrAlarmService.selectTPssrAlarmList(alarm)) {
            test.setApproveStatus(2L);
            test.setUpdatedate(new Date());
            test.setUpdaterCode(userId);
            tPssrAlarmService.updateTPssrAlarm(test);
        }
        //查询是否已存在审批流程
        TPssrApprove tPssrApprove = tPssrApproveService.selectTPssrApproveBySubId(sub.getId());
        if (tPssrApprove == null) {
            TPssrApprove approve = new TPssrApprove();
            approve.setSubId(sub.getId());
            approve.setApNo(DateUtils.dateTimeNow() + userId);
            approve.setApproveStatus(1L);
            approve.setSubCharge(sub.getConfirm());
            approve.setCreaterCode(userId);
            approve.setCreatedate(new Date());
            tPssrApproveService.insertTPssrApprove(approve);

            pssr1confirm(approve, new ArrayList<>(), sub.getConfirm());
        } else {
            delProcess(tPssrApprove.getProcessId(), "pssr1confirm");
            pssr1confirm(tPssrApprove, new ArrayList<>(), sub.getConfirm());
        }

    }

    /**
     * 单确认人发起流程
     */
    private void pssr1confirm(TPssrApprove approve, List<String> confirmUsers, String confirm) {
        String userId = getUserId().toString();

        // 开始申请流程
        long businessKey = approve.getApproveId();
        //开始工作流、监听
        Authentication.setAuthenticatedUserId(userId);//设置当前申请人
        Map<String, Object> variables = new HashMap<>();
        variables.put("applyUser", userId);
        variables.put("confirmUsers", confirmUsers);
        variables.put("chargePerson", confirm);
        //采用key来启动流程定义并设置流程变量，返回流程实例
        ProcessInstance pi = runtimeService.startProcessInstanceByKey("pssr1confirm", String.valueOf(businessKey), variables);
        approve.setProcessId(pi.getProcessInstanceId());
        tPssrApproveService.updateTPssrApprove(approve);
    }

    /**
     * 双确认人发起流程
     */
    private void pssr2confirm(TPssrApprove approve, List<String> confirmUsers1, List<String> confirmUsers2, String confirm) {
        String userId = getUserId().toString();

        // 开始申请流程
        long businessKey = approve.getApproveId();
        //开始工作流、监听
        Authentication.setAuthenticatedUserId(userId);//设置当前申请人
        Map<String, Object> variables = new HashMap<>();
        variables.put("applyUser", userId);
        variables.put("confirmUsers1", confirmUsers1);
        variables.put("confirmUsers2", confirmUsers2);
        variables.put("chargePerson", confirm);
        //采用key来启动流程定义并设置流程变量，返回流程实例
        ProcessInstance pi = runtimeService.startProcessInstanceByKey("pssr2confirm", String.valueOf(businessKey), variables);
        approve.setProcessId(pi.getProcessInstanceId());
        tPssrApproveService.updateTPssrApprove(approve);
    }

    /**
     * 三确认人发起流程
     */
    private void pssr3confirm(TPssrApprove approve, List<String> confirmUsers1, List<String> confirmUsers2, List<String> confirmUsers3, String confirm) {
        String userId = getUserId().toString();

        // 开始申请流程
        long businessKey = approve.getApproveId();
        //开始工作流、监听
        Authentication.setAuthenticatedUserId(userId);//设置当前申请人
        Map<String, Object> variables = new HashMap<>();
        variables.put("applyUser", userId);
        variables.put("confirmUsers1", confirmUsers1);
        variables.put("confirmUsers2", confirmUsers2);
        variables.put("confirmUsers3", confirmUsers3);
        variables.put("chargePerson", confirm);
        //采用key来启动流程定义并设置流程变量，返回流程实例
        ProcessInstance pi = runtimeService.startProcessInstanceByKey("pssr3confirm", String.valueOf(businessKey), variables);
        approve.setProcessId(pi.getProcessInstanceId());
        tPssrApproveService.updateTPssrApprove(approve);
    }

    /**
     * 删除已存在流程
     */
    private void delProcess(String processId, String processName) {
        try {
            runtimeService.deleteProcessInstance(processId, processName);
            historyService.deleteHistoricProcessInstance(processId);
        } catch (Exception e) {
            logger.info("无运行时流程");
        }
    }

}