【业务功能篇39】中篇：Springboot+activiti7 工作流引擎增加网关组件、Assignment分配权限

╰+攻爆jí腚メ 2024-03-17 14:52 33阅读 0赞

### service层 电子流分析服务接口实现类 ###

package com.service.impl.process;
    
    import static com.constants.process.CompFailConstants.COMP_FAIL_COMP_CODE;
    import static com.constants.process.CompFailConstants.COMP_FAIL_FA_ID;
    import static com.constants.process.CompFailConstants.COMP_FAIL_GATEWAY_ANALYSIS_NORMAL_ADVANCE;
    import static com.constants.process.CompFailConstants.COMP_FAIL_GATEWAY_APPLICATION_NORMAL_ADVANCE;
    import static com.constants.process.CompFailConstants.COMP_FAIL_GATEWAY_CLOSE_REVIEW_NORMAL_ADVANCE;
    import static com.constants.process.CompFailConstants.COMP_FAIL_GATEWAY_CONTACT_REVIEW_NORMAL_ADVANCE;
    import static com.constants.process.CompFailConstants.COMP_FAIL_GATEWAY_ML_REVIEW_NORMAL_ADVANCE;
    import static com.constants.process.CompFailConstants.COMP_FAIL_GATEWAY_PM_REVIEW_NORMAL_ADVANCE;
    import static com.constants.process.CompFailConstants.COMP_FAIL_GATEWAY_RISK_NORMAL_ADVANCE;
    import static com.constants.process.CompFailConstants.COMP_FAIL_PROCESS_BUSINESS_PREFIX;
    import static com.constants.process.CompFailConstants.COMP_FAIL_PROCESS_DEF_KEY;
    import static com.constants.process.CompFailConstants.COMP_FAIL_TASK_ANALYSIS_ASSIGNEE;
    import static com.constants.process.CompFailConstants.COMP_FAIL_TASK_ANALYSIS_OPINION;
    import static com.constants.process.CompFailConstants.COMP_FAIL_TASK_APPLICATION_ASSIGNEE;
    import static com.constants.process.CompFailConstants.COMP_FAIL_TASK_CLOSE_REVIEW_ASSIGNEE;
    import static com.constants.process.CompFailConstants.COMP_FAIL_TASK_CLOSE_REVIEW_OPINION;
    import static com.constants.process.CompFailConstants.COMP_FAIL_TASK_CONTACT_REVIEW_ASSIGNEE;
    import static com.constants.process.CompFailConstants.COMP_FAIL_TASK_CONTACT_REVIEW_IMPORTANCE;
    import static com.constants.process.CompFailConstants.COMP_FAIL_TASK_CONTACT_REVIEW_IS_START_ANALYSIS;
    import static com.constants.process.CompFailConstants.COMP_FAIL_TASK_CONTACT_REVIEW_OPINION;
    import static com.constants.process.CompFailConstants.COMP_FAIL_TASK_FEEDBACK_ADVISE;
    import static com.constants.process.CompFailConstants.COMP_FAIL_TASK_FEEDBACK_ASSIGNEE;
    import static com.constants.process.CompFailConstants.COMP_FAIL_TASK_FEEDBACK_EVALUATION;
    import static com.constants.process.CompFailConstants.COMP_FAIL_TASK_FEEDBACK_SATISFACTION;
    import static com.constants.process.CompFailConstants.COMP_FAIL_TASK_ML_REVIEW_ASSIGNEE;
    import static com.constants.process.CompFailConstants.COMP_FAIL_TASK_ML_REVIEW_OPINION;
    import static com.constants.process.CompFailConstants.COMP_FAIL_TASK_PM_REVIEW_ASSIGNEE;
    import static com.constants.process.CompFailConstants.COMP_FAIL_TASK_PM_REVIEW_OPINION;
    import static com.constants.process.CompFailConstants.COMP_FAIL_TASK_PM_REVIEW_SHARE;
    import static com.constants.process.CompFailConstants.COMP_FAIL_TASK_RISK_ASSIGNEE;
    import static com.constants.process.CompFailConstants.COMP_FAIL_TASK_RISK_OPINION;
    import static com.enums.process.CompFailProcessTask.COMP_FAIL_TASK_APPLICATION;
    
    import com.adapter.UserAdapter;
    import com.constants.process.CompFailConstants;
    import com.domain.entity.VerifyInfo;
    import com.domain.entity.process.CompFailProcessContent;
    import com.domain.entity.process.CompProcessReview;
    import com.domain.entity.user.UserModel;
    import com.domain.model.DpProcessMessage;
    import com.domain.vo.UserVo;
    import com.domain.vo.process.CompFailTitleVo;
    import com.domain.vo.process.CompRelCertTaskInfo;
    import com.enums.State;
    import com.enums.process.CompFailProcessTask;
    import com.enums.process.CompFailState;
    import com.enums.process.CompTableType;
    import com.model.CompFailAnalysisParam;
    import com.model.CompFailApplicationParam;
    import com.model.CompFailCloseReviewParam;
    import com.model.CompFailContactReviewParam;
    import com.model.CompFailCreateParam;
    import com.model.CompFailFeedbackParam;
    import com.model.CompFailMlReviewParam;
    import com.model.CompFailOverview;
    import com.model.CompFailPmReviewParam;
    import com.model.CompFailRiskParam;
    import com.model.OneFaIdParam;
    import com.model.ResponseVo;
    import com.service.UserService;
    import com.service.dao.CompFailDaoService;
    import com.service.dao.ProcessCommonDaoService;
    import com.service.process.ProcessCompFailService;
    import com.service.process.ProcessMessage;
    import com.utils.MyStringUtils;
    import com.utils.ResponseUtils;
    
    import lombok.extern.slf4j.Slf4j;
    
    import org.activiti.engine.HistoryService;
    import org.activiti.engine.RuntimeService;
    import org.activiti.engine.TaskService;
    import org.activiti.engine.history.HistoricProcessInstance;
    import org.activiti.engine.repository.ProcessDefinition;
    import org.activiti.engine.runtime.ProcessInstance;
    import org.activiti.engine.task.Task;
    import org.activiti.engine.task.TaskInfo;
    import org.apache.commons.lang3.ObjectUtils;
    import org.apache.commons.lang3.StringUtils;
    import org.springframework.stereotype.Service;
    
    import java.text.SimpleDateFormat;
    import java.time.Instant;
    import java.time.ZoneId;
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Comparator;
    import java.util.Date;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.List;
    import java.util.Map;
    import java.util.Objects;
    import java.util.Optional;
    import java.util.Set;
    import java.util.concurrent.locks.ReentrantLock;
    import java.util.function.Consumer;
    import java.util.stream.Collectors;
    
    import javax.annotation.Resource;
    
    /**
     * ProcessCompFailServiceImpl
     *
     */
    @Slf4j
    @Service
    public class ProcessCompFailServiceImpl extends ProcessMessage implements ProcessCompFailService {
        private static final ReentrantLock LOCK = new ReentrantLock();
    
        @Resource
        RuntimeService runtimeService;
    
        @Resource
        UserService userService;
    
        @Resource
        private ProcessCommonDaoService processCommonDaoService;
    
        @Resource
        private CompFailDaoService compFailDaoService;
    
        @Resource
        private TaskService taskService;
    
        @Resource
        UserAdapter userAdapter;
    
        @Resource
        HistoryService historyService;
    
    
        /**
         * buildMessage
         * 
         * @param id id
         * @param time time
         * @param consumer consumer
         */
        private void buildMessage(String id, Date time, Consumer<DpProcessMessage> consumer) {
            DpProcessMessage message = new DpProcessMessage();
            message.setProcessType("失效分析电子流");
            consumer.accept(message);
    
            Map<String, Task> runnableTaskMap = processCommonDaoService.getRunnableTaskMap();
            message.setStatus(readCurState(runnableTaskMap.get(id)));
    
            Map<String, Object> variables = processCommonDaoService.getVariables(id);
            message.setMessage(String.format("编码：%s", variables.get(COMP_FAIL_COMP_CODE)));
            message.setProcessCode(variables.get(COMP_FAIL_FA_ID).toString());
    
            String name = userAdapter.getUserInfo(variables.get(COMP_FAIL_TASK_APPLICATION_ASSIGNEE).toString())
                .getNameCn();
            message.setCreateUser(String.format("%s  %s", name, variables.get(COMP_FAIL_TASK_APPLICATION_ASSIGNEE)));
            message.setProcessUrl(String.format("/itemAnalysisDetail?faId=%s", message.getProcessCode()));
            Instant instant = time.toInstant();
            ZoneId zoneId = ZoneId.systemDefault();
            message.setCreateTime(instant.atZone(zoneId).toLocalDateTime());
            sendMessage(message);
            sendMessage(message);
        }
    
    
        /**
         * buildMessage
         * 
         * @param processInstance processInstance
         * @param consumer consumer
         */
        private void buildMessage(HistoricProcessInstance processInstance, Consumer<DpProcessMessage> consumer) {
            buildMessage(processInstance.getId(), processInstance.getStartTime(), consumer);
        }
    
    
        /**
         * buildMessage
         * 
         * @param processInstance processInstance
         * @param Id Id
         */
        private void buildMessage(HistoricProcessInstance processInstance, String Id) {
            buildMessage(processInstance.getId(), processInstance.getStartTime(), message -> {
                String name = userAdapter.getUserInfo(Id).getNameCn();
                message.setDealUser(String.format("%s  %s", name, Id));
            });
        }
    
    
        /**
         * createProcessInst
         * 
         * @param failureAnalysisCreateParam failureAnalysisCreateParam
         * @return VerifyInfo
         */
        @Override
        public VerifyInfo createProcessInst(CompFailCreateParam failureAnalysisCreateParam) {
            VerifyInfo result = new VerifyInfo();
            ProcessDefinition processDef = processCommonDaoService.getProcessDefinition(COMP_FAIL_PROCESS_DEF_KEY);
            if (processDef == null) {
                return result.notPassed("system error: 未找到 失效分析 流程定义");
            }
            UserVo user = userService.getUser();
            if (user == null) {
                return result.notPassed("获取用户信息失败");
            }
            if (ObjectUtils.isEmpty(failureAnalysisCreateParam.getCompCode())) {
                return result.notPassed("编码不能为空");
            }
            try {
                LOCK.lock();
                String faId = processCommonDaoService.createProcessInstBusinessId(COMP_FAIL_PROCESS_BUSINESS_PREFIX);
                Map<String, Object> var = updateCreateVar(faId, user, failureAnalysisCreateParam);
                ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(COMP_FAIL_PROCESS_DEF_KEY, var);
                if (processInstance == null) {
                    return result.notPassed("create component reliability certification failed, system error");
                }
    
                buildMessage(processInstance.getId(), processInstance.getStartTime(), message -> {
                    message.setDealUser(String.format("%s  %s", user.getNameCn(), user.getAccount()));
                });
                return result.pass(faId);
            } catch (Exception e) {
                log.error("create component reliability certification failed, reason is: {}", e.getMessage());
            } finally {
                LOCK.unlock();
            }
            return result.pass("");
        }
    
    
        /**
         * cancelProcess
         * 
         * @param oneFaIdParam oneFaIdParam
         * @return VerifyInfo
         */
        @Override
        public VerifyInfo cancelProcess(OneFaIdParam oneFaIdParam) {
            VerifyInfo result = new VerifyInfo();
            CompFailProcessContent content = getProcessContent(oneFaIdParam.getFaId());
            if (content == null) {
                return result.notPassed("流程不存在");
            }
            TaskInfo curTask = content.getCurTask();
            if (curTask == null || !StringUtils.equals(curTask.getTaskDefinitionKey(),
                COMP_FAIL_TASK_APPLICATION.getDefinitionKey())) {
                return result.notPassed("认证申请已提交, 无法撤销");
            }
            taskService.setVariable(curTask.getId(), COMP_FAIL_GATEWAY_APPLICATION_NORMAL_ADVANCE,
                Boolean.FALSE.toString());
            taskService.complete(curTask.getId());
            deleteMessage(oneFaIdParam.getFaId());
            return result.pass("撤销成功");
        }
    
    
        /**
         * getProcessTitle
         * 
         * @param faId faId
         * @return CompFailTitleVo
         */
        @Override
        public CompFailTitleVo getProcessTitle(String faId) {
            CompFailTitleVo result = new CompFailTitleVo();
            CompFailProcessContent content = getProcessContent(faId);
            if (content == null) {
                return null;
            }
    
            String procInstId = content.getProcessInstance().getId();
            Map<String, Object> variables = processCommonDaoService.getVariables(procInstId);
            UserVo user = userService.getUser();
            if (!isShareProcess(procInstId, variables) && !variables.containsValue(user.getAccount())) {
                return null;
            }
    
            result.setFaId(faId);
            result.setCreatedDate(content.getProcessInstance().getStartTime());
            result.setCloseDate(content.getProcessInstance().getEndTime());
    
            TaskInfo curTask = content.getCurTask();
            result.setCurState(readCurState(curTask));
            if (curTask != null) {
                result.setCurHandler(userAdapter.getUserInfo(curTask.getAssignee()));
                result.setCurTaskInfo(getCurTaskInfo(curTask, content.getPreTask()));
                return result;
            }
            result.setCurTaskInfo(new CompRelCertTaskInfo());
            return result;
        }
    
    
        /**
         * submitApplication
         * 
         * @param applicationParam applicationParam
         * @return VerifyInfo
         */
        @Override
        public VerifyInfo submitApplication(CompFailApplicationParam applicationParam) {
            CompFailProcessContent content = getProcessContent(applicationParam.getFaId());
            TaskInfo curTask = judgeProcess(applicationParam, content);
            if (curTask == null) {
                return new VerifyInfo().notPassed("处理失败, 流程所处状态错误");
            }
            // 将本任务独有变量存入数据库
            compFailDaoService.commitApplication(content, applicationParam);
            // 将本流程全局变量存入Activity引擎
            Map<String, Object> variableMap = new HashMap<>();
            variableMap.put(COMP_FAIL_GATEWAY_APPLICATION_NORMAL_ADVANCE, Boolean.TRUE.toString());
            variableMap.put(COMP_FAIL_TASK_CONTACT_REVIEW_ASSIGNEE, applicationParam.getAppReviewerId()); // 设置下一流程处理人
            taskService.setVariables(curTask.getId(), variableMap);
            taskService.complete(curTask.getId());
            buildMessage(content.getProcessInstance(), applicationParam.getAppReviewerId());
            return new VerifyInfo().pass("提交申请成功");
        }
    
    
        /**
         * withdrawApplication
         * 
         * @param faId faId
         * @return VerifyInfo
         */
        @Override
        public VerifyInfo withdrawApplication(String faId) {
            CompFailContactReviewParam contactReviewParam = new CompFailContactReviewParam();
            contactReviewParam.setFaId(faId);
            contactReviewParam.setReviewPass(CompProcessReview.NOT_PASSED);
            return submitContactReview(contactReviewParam);
        }
    
    
        /**
         * judgeProcess
         * 
         * @param applicationParam applicationParam
         * @param content content
         * @return TaskInfo
         */
        private TaskInfo judgeProcess(CompFailApplicationParam applicationParam, CompFailProcessContent content) {
            if (content == null) {
                return null;
            }
            TaskInfo curTask = content.getCurTask();
            if (curTask == null || !StringUtils.equals(curTask.getTaskDefinitionKey(),
                COMP_FAIL_TASK_APPLICATION.getDefinitionKey())) {
                return null;
            }
            return curTask;
        }
    
    
        /**
         * draftApplication
         * 
         * @param applicationParam applicationParam
         * @return VerifyInfo
         */
        @Override
        public VerifyInfo draftApplication(CompFailApplicationParam applicationParam) {
            CompFailProcessContent content = getProcessContent(applicationParam.getFaId());
            TaskInfo curTask = judgeProcess(applicationParam, content);
            if (curTask == null) {
                return new VerifyInfo().notPassed("处理失败, 流程所处状态错误");
            }
            compFailDaoService.draftApplication(content, applicationParam);
            Map<String, String> variableMap = new HashMap<>();
            variableMap.put(COMP_FAIL_TASK_CONTACT_REVIEW_ASSIGNEE, applicationParam.getAppReviewerId());
            taskService.setVariables(curTask.getId(), variableMap);
            return new VerifyInfo().pass("保存草稿成功");
        }
    
    
        /**
         * getApplication
         * 
         * @param faId faId
         * @return CompFailApplicationParam
         */
        @Override
        public CompFailApplicationParam getApplication(String faId) {
            CompFailApplicationParam result = compFailDaoService.getApplication(faId);
            Map<String, Object> variables = processCommonDaoService.getVariables(
                processCommonDaoService.getProcessInstanceByBusinessId(COMP_FAIL_FA_ID, faId).getId());
    
            String Id = (String) variables.get(COMP_FAIL_TASK_APPLICATION_ASSIGNEE);
            Optional<UserModel> userModel = userAdapter.getFullUserInfo(Id);
            userModel.ifPresent(user -> {
                result.setDelegatorId(user.getId());
                result.setDelegatorDept(user.getDeptNameLevelMin());
            });
            result.setItemCode((String) variables.get(COMP_FAIL_COMP_CODE));
            // 若被驳回，就会有接口人的审核意见
            result.setAppReviewerId((String) variables.get(COMP_FAIL_TASK_CONTACT_REVIEW_ASSIGNEE));
            result.setHandlerSuggestion((String) variables.get(COMP_FAIL_TASK_CONTACT_REVIEW_OPINION));
            return result;
        }
    
    
        /**
         * submitContactReview
         * 
         * @param contactReviewParam contactReviewParam
         * @return VerifyInfo
         */
        @Override
        public VerifyInfo submitContactReview(CompFailContactReviewParam contactReviewParam) {
            VerifyInfo result = new VerifyInfo();
            String faId = contactReviewParam.getFaId();
            CompFailProcessContent content = getProcessContent(faId);
            if (content == null) {
                return result.notPassed("流程单号未找到");
            }
            TaskInfo curTask = content.getCurTask();
            if (curTask == null || !StringUtils.equals(curTask.getTaskDefinitionKey(),
                CompFailProcessTask.COMP_FAIL_TASK_CONTACT_REVIEW.getDefinitionKey())) {
                return result.notPassed("处理失败, 流程所处状态错误");
            }
    
            String procInstId = content.getProcessInstance().getId();
            Map<String, Object> variables = processCommonDaoService.getVariables(procInstId);
            String assignee = (String) variables.get(COMP_FAIL_TASK_CONTACT_REVIEW_ASSIGNEE);
            UserVo user = userService.getUser();
            if (!user.getAccount().equals(assignee)) {
                return result.notPassed("处理失败, 无权限处理该流程");
            }
    
            String taskId = curTask.getId();
            CompProcessReview review = new CompProcessReview(contactReviewParam.getReviewPass());
            if (review.isTransferred()) {
                String latestAssignee = contactReviewParam.getAnalystId();
                taskService.setAssignee(curTask.getId(), latestAssignee);
                taskService.setVariable(curTask.getId(), COMP_FAIL_TASK_CONTACT_REVIEW_ASSIGNEE, latestAssignee);
    
                buildMessage(content.getProcessInstance(), latestAssignee);
                return result.pass("转单成功，您已不是当前流程的处理人");
            }
    
            Map<String, Object> variableMap = new HashMap<>();
            // 接口人意见
            variableMap.put(COMP_FAIL_TASK_CONTACT_REVIEW_OPINION, contactReviewParam.getAppReviewOpinion());
            if (review.isNotPass()) {
                variableMap.put(COMP_FAIL_GATEWAY_CONTACT_REVIEW_NORMAL_ADVANCE, Boolean.FALSE.toString());
                compFailDaoService.rejectApplication(faId);
                taskService.setVariables(taskId, variableMap);
                taskService.complete(taskId);
    
                buildMessage(content.getProcessInstance(), message -> {
                    TaskInfo mCurTask = Objects.requireNonNull(getProcessContent(faId)).getCurTask();
                    String name = userAdapter.getUserInfo(mCurTask.getAssignee()).getNameCn();
                    message.setDealUser(String.format("%s  %s", name, mCurTask.getAssignee()));
                });
                return result.pass("已驳回委托人申请");
            }
    
            variableMap.put(COMP_FAIL_GATEWAY_CONTACT_REVIEW_NORMAL_ADVANCE, Boolean.TRUE.toString());
            // 设置下一流程处理人
            variableMap.put(COMP_FAIL_TASK_ANALYSIS_ASSIGNEE, contactReviewParam.getAnalystId());
            variableMap.put(COMP_FAIL_TASK_CONTACT_REVIEW_IMPORTANCE, contactReviewParam.getImportance());
            variableMap.put(COMP_FAIL_TASK_CONTACT_REVIEW_IS_START_ANALYSIS, contactReviewParam.getIsStartAnalysis());
            taskService.setVariables(taskId, variableMap);
            taskService.complete(taskId);
    
            buildMessage(content.getProcessInstance(), contactReviewParam.getAnalystId());
            return result.pass("分配分析人员成功");
        }
    
    
        /**
         * getContactReview
         * 
         * @param faId faId
         * @return CompFailContactReviewParam
         */
        @Override
        public CompFailContactReviewParam getContactReview(String faId) {
            CompFailContactReviewParam result = new CompFailContactReviewParam();
            Map<String, Object> variables = processCommonDaoService.getVariables(
                processCommonDaoService.getProcessInstanceByBusinessId(COMP_FAIL_FA_ID, faId).getId());
            result.setReviewPass(CompProcessReview.PASSED);
            result.setAnalystId((String) variables.get(COMP_FAIL_TASK_ANALYSIS_ASSIGNEE));
            result.setAppReviewOpinion((String) variables.get(COMP_FAIL_TASK_CONTACT_REVIEW_OPINION));
            result.setIsStartAnalysis((Boolean) variables.get(COMP_FAIL_TASK_CONTACT_REVIEW_IS_START_ANALYSIS));
    
            result.setImportance((String) variables.get(COMP_FAIL_TASK_CONTACT_REVIEW_IMPORTANCE));
            // 若被驳回，则显示分析人意见
            result.setAnalystId((String) variables.get(COMP_FAIL_TASK_ANALYSIS_ASSIGNEE));
            result.setHandlerSuggestion((String) variables.get(COMP_FAIL_TASK_ANALYSIS_OPINION));
            return result;
        }
    
    
        /**
         * judgeAnalysis
         * 
         * @param analysisParam analysisParam
         * @param content content
         * @return TaskInfo
         */
        private TaskInfo judgeAnalysis(CompFailAnalysisParam analysisParam, CompFailProcessContent content) {
            if (content == null) {
                return null;
            }
            TaskInfo curTask = content.getCurTask();
            if (curTask == null || !StringUtils.equals(curTask.getTaskDefinitionKey(),
                CompFailProcessTask.COMP_FAIL_TASK_ANALYSIS.getDefinitionKey())) {
                return null;
            }
            return curTask;
        }
    
        /**
         * submitAnalysis
         * 
         * @param analysisParam analysisParam
         * @return VerifyInfo
         */
        @Override
        public VerifyInfo submitAnalysis(CompFailAnalysisParam analysisParam) {
            CompFailProcessContent content = getProcessContent(analysisParam.getFaId());
            TaskInfo curTask = judgeAnalysis(analysisParam, content);
            if (content == null || curTask == null) {
                return new VerifyInfo().notPassed("处理失败, 流程所处状态错误");
            }
            String procInstId = content.getProcessInstance().getId();
            Map<String, Object> variables = processCommonDaoService.getVariables(procInstId);
            String assignee = (String) variables.get(COMP_FAIL_TASK_ANALYSIS_ASSIGNEE);
            UserVo user = userService.getUser();
            if (!user.getAccount().equals(assignee)) {
                return new VerifyInfo().notPassed("处理失败, 无权限处理该流程");
            }
            String taskId = curTask.getId();
            CompProcessReview review = new CompProcessReview(analysisParam.getReviewPass());
            if (review.isTransferred()) {
                String latestAssignee = analysisParam.getAssessId();
                taskService.setAssignee(curTask.getId(), latestAssignee);
                taskService.setVariable(curTask.getId(), COMP_FAIL_TASK_ANALYSIS_ASSIGNEE, latestAssignee);
    
                buildMessage(content.getProcessInstance(), latestAssignee);
                return new VerifyInfo().pass("转单成功，您已不是当前流程的处理人");
            }
            Map<String, Object> variableMap = new HashMap<>();
            variableMap.put(COMP_FAIL_TASK_ANALYSIS_OPINION, "");
            if (review.isNotPass()) {
                variableMap.put(COMP_FAIL_GATEWAY_ANALYSIS_NORMAL_ADVANCE, Boolean.FALSE.toString());
                taskService.setVariables(taskId, variableMap);
                taskService.complete(taskId);
                buildMessage(content.getProcessInstance(), message -> {
                    TaskInfo mCurTask = Objects.requireNonNull(getProcessContent(analysisParam.getFaId())).getCurTask();
                    String name = userAdapter.getUserInfo(mCurTask.getAssignee()).getNameCn();
                    message.setDealUser(String.format("%s  %s", name, mCurTask.getAssignee()));
                });
                return new VerifyInfo().pass("已驳回接口人审核");
            }
            compFailDaoService.commitAnalysis(content, analysisParam);
            extracted(analysisParam, variableMap);
            taskService.setVariables(taskId, variableMap);
            taskService.complete(taskId);
            buildMessage(content.getProcessInstance(), analysisParam.getAssessId());
            return new VerifyInfo().pass("提交成功, 风险评估中");
        }
    
    
        /**
         * extracted
         * 
         * @param analysisParam analysisParam
         * @param variableMap variableMap
         */
        private void extracted(CompFailAnalysisParam analysisParam, Map<String, Object> variableMap) {
            variableMap.put(COMP_FAIL_GATEWAY_ANALYSIS_NORMAL_ADVANCE, Boolean.TRUE.toString());
            variableMap.put(COMP_FAIL_TASK_RISK_ASSIGNEE, analysisParam.getAssessId());
            if (!StringUtils.isBlank(analysisParam.getProjectOwner())) {
                variableMap.put(COMP_FAIL_TASK_PM_REVIEW_ASSIGNEE, analysisParam.getProjectOwner());
            }
            if (!StringUtils.isBlank(analysisParam.getMlTeamLeader())) {
                variableMap.put(COMP_FAIL_TASK_ML_REVIEW_ASSIGNEE, analysisParam.getMlTeamLeader());
            }
            if (!StringUtils.isBlank(analysisParam.getQuestionAnswer())) {
                variableMap.put(COMP_FAIL_TASK_CLOSE_REVIEW_ASSIGNEE, analysisParam.getQuestionAnswer());
            }
        }
    
    
        /**
         * draftAnalysis
         * 
         * @param analysisParam analysisParam
         * @return VerifyInfo
         */
        @Override
        public VerifyInfo draftAnalysis(CompFailAnalysisParam analysisParam) {
            CompFailProcessContent content = getProcessContent(analysisParam.getFaId());
            TaskInfo curTask = judgeAnalysis(analysisParam, content);
            if (content == null || curTask == null) {
                return new VerifyInfo().notPassed("处理失败, 流程所处状态错误");
            }
            UserVo user = userService.getUser();
            if (user == null) {
                return new VerifyInfo().notPassed("获取用户信息失败");
            }
    
            Map<String, String> variableMap = new HashMap<>();
            // 前端已固定分析人意见
            variableMap.put(COMP_FAIL_TASK_ANALYSIS_OPINION, "");
            compFailDaoService.draftAnalysis(content, analysisParam);
            taskService.setVariables(curTask.getId(), variableMap);
            return new VerifyInfo().pass("保存草稿成功");
        }
    
    
        /**
         * getAnalysis
         * 
         * @param faId faId
         * @return CompFailAnalysisParam
         */
        @Override
        public CompFailAnalysisParam getAnalysis(String faId) {
            CompFailAnalysisParam result = compFailDaoService.getAnalysis(faId);
            Map<String, Object> variables = processCommonDaoService.getVariables(
                processCommonDaoService.getProcessInstanceByBusinessId(COMP_FAIL_FA_ID, faId).getId());
            result.setReviewPass(CompProcessReview.PASSED);
            result.setItemCode((String) variables.get(COMP_FAIL_COMP_CODE));
            // 若被驳回
            result.setAssessId((String) variables.get(COMP_FAIL_TASK_RISK_ASSIGNEE));
            result.setHandlerSuggestion((String) variables.get(COMP_FAIL_TASK_RISK_OPINION));
            return result;
        }
    
    
        /**
         * submitRisk
         * 
         * @param riskParam riskParam
         * @return VerifyInfo
         */
        @Override
        public VerifyInfo submitRisk(CompFailRiskParam riskParam) {
            VerifyInfo result = new VerifyInfo();
            String faId = riskParam.getFaId();
            CompFailProcessContent content = getProcessContent(faId);
            if (content == null) {
                return result.notPassed("流程单号未找到~");
            }
            TaskInfo curTask = content.getCurTask();
            if (curTask == null || !StringUtils.equals(curTask.getTaskDefinitionKey(),
                CompFailProcessTask.COMP_FAIL_TASK_RISK.getDefinitionKey())) {
                return result.notPassed("处理失败, 流程所处状态错误~");
            }
    
            String procInstId = content.getProcessInstance().getId();
            Map<String, Object> variables = processCommonDaoService.getVariables(procInstId);
            String assignee = (String) variables.get(COMP_FAIL_TASK_RISK_ASSIGNEE);
            UserVo user = userService.getUser();
            if (!user.getAccount().equals(assignee)) {
                return result.notPassed("处理失败, 无权限处理该流程~");
            }
    
            CompProcessReview review = new CompProcessReview(riskParam.getReviewPass());
            if (review.isTransferred()) {
                String latestAssignee = riskParam.getPmId();
                taskService.setAssignee(curTask.getId(), latestAssignee);
                taskService.setVariable(curTask.getId(), COMP_FAIL_TASK_RISK_ASSIGNEE, latestAssignee);
                buildMessage(content.getProcessInstance(), latestAssignee);
                return result.pass("转单成功，您已不是当前流程的处理人~");
            }
    
            Map<String, Object> variableMap = new HashMap<>();
            // 前端已固定风险评估人意见
            variableMap.put(COMP_FAIL_TASK_RISK_OPINION, "");
            if (review.isNotPass()) {
                compFailDaoService.rejectAnalysis(faId);
                variableMap.put(COMP_FAIL_GATEWAY_RISK_NORMAL_ADVANCE, Boolean.FALSE.toString());
                taskService.setVariables(curTask.getId(), variableMap);
                taskService.complete(curTask.getId());
                buildMessage(content.getProcessInstance(), message -> {
                    TaskInfo mCurTask = Objects.requireNonNull(getProcessContent(faId)).getCurTask();
                    String name = userAdapter.getUserInfo(mCurTask.getAssignee()).getNameCn();
                    message.setDealUser(String.format("%s  %s", name, mCurTask.getAssignee()));
                });
                return result.pass("已驳回分析");
            }
    
            compFailDaoService.commitRisk(content, riskParam);
            variableMap.put(COMP_FAIL_GATEWAY_RISK_NORMAL_ADVANCE, Boolean.TRUE.toString());
            // 设置下一流程处理人
            variableMap.put(COMP_FAIL_TASK_PM_REVIEW_ASSIGNEE, riskParam.getPmId());
            taskService.setVariables(curTask.getId(), variableMap);
            taskService.complete(curTask.getId());
    
            buildMessage(content.getProcessInstance(), riskParam.getPmId());
            return result.pass("提交成功, 项目经理审核中");
        }
    
    
        /**
         * draftRisk
         * 
         * @param riskParam riskParam
         * @return VerifyInfo
         */
        @Override
        public VerifyInfo draftRisk(CompFailRiskParam riskParam) {
            VerifyInfo result = new VerifyInfo();
            String faId = riskParam.getFaId();
            CompFailProcessContent content = getProcessContent(faId);
            if (content == null) {
                return result.notPassed("流程单号未找到");
            }
            TaskInfo curTask = content.getCurTask();
            if (curTask == null || !StringUtils.equals(curTask.getTaskDefinitionKey(),
                CompFailProcessTask.COMP_FAIL_TASK_RISK.getDefinitionKey())) {
                return result.notPassed("处理失败, 流程所处状态错误");
            }
    
            Map<String, String> variableMap = new HashMap<>();
            // 前端已固定风险评估人意见
            variableMap.put(COMP_FAIL_TASK_RISK_OPINION, "");
            compFailDaoService.draftRisk(content, riskParam);
            taskService.setVariables(curTask.getId(), variableMap);
            return result.pass("保存草稿成功");
        }
    
    
        /**
         * getRisk
         * 
         * @param faId faId
         * @return CompFailRiskParam
         */
        @Override
        public CompFailRiskParam getRisk(String faId) {
            CompFailRiskParam result = compFailDaoService.getRisk(faId);
            Map<String, Object> variables = processCommonDaoService.getVariables(
                processCommonDaoService.getProcessInstanceByBusinessId(COMP_FAIL_FA_ID, faId).getId());
            result.setReviewPass(CompProcessReview.PASSED);
            // 若被驳回
            result.setPmId((String) variables.get(COMP_FAIL_TASK_PM_REVIEW_ASSIGNEE));
            result.setHandlerSuggestion((String) variables.get(COMP_FAIL_TASK_PM_REVIEW_OPINION));
            return result;
        }
    
    
        /**
         * submitPmReview
         * 
         * @param pmReviewParam pmReviewParam
         * @return VerifyInfo
         */
        @Override
        public VerifyInfo submitPmReview(CompFailPmReviewParam pmReviewParam) {
            VerifyInfo result = new VerifyInfo();
            String faId = pmReviewParam.getFaId();
            CompFailProcessContent content = getProcessContent(faId);
            if (content == null) {
                return result.notPassed("流程单号未找到");
            }
            TaskInfo curTask = content.getCurTask();
            if (curTask == null || !StringUtils.equals(curTask.getTaskDefinitionKey(),
                CompFailProcessTask.COMP_FAIL_TASK_PM_REVIEW.getDefinitionKey())) {
                return result.notPassed("处理失败, 流程所处状态错误");
            }
    
            String procInstId = content.getProcessInstance().getId();
            Map<String, Object> variables = processCommonDaoService.getVariables(procInstId);
            String assignee = (String) variables.get(COMP_FAIL_TASK_PM_REVIEW_ASSIGNEE);
            UserVo user = userService.getUser();
            if (!user.getAccount().equals(assignee)) {
                return result.notPassed("处理失败, 无权限处理该流程");
            }
    
            String taskId = curTask.getId();
            CompProcessReview review = new CompProcessReview(pmReviewParam.getReviewPass());
            if (review.isTransferred()) {
                String latestAssignee = pmReviewParam.getMlReviewId();
                taskService.setAssignee(curTask.getId(), latestAssignee);
                taskService.setVariable(curTask.getId(), COMP_FAIL_TASK_PM_REVIEW_ASSIGNEE, latestAssignee);
    
                buildMessage(content.getProcessInstance(), latestAssignee);
                return result.pass("转单成功，您已不是当前流程的处理人");
            }
    
            Map<String, Object> variableMap = new HashMap<>();
            // pm审核意见
            variableMap.put(COMP_FAIL_TASK_PM_REVIEW_OPINION, pmReviewParam.getDeReviewOpinion());
            if (review.isNotPass()) {
                compFailDaoService.rejectRisk(faId);
                variableMap.put(COMP_FAIL_GATEWAY_PM_REVIEW_NORMAL_ADVANCE, Boolean.FALSE.toString());
                taskService.setVariables(taskId, variableMap);
                taskService.complete(taskId);
    
                buildMessage(content.getProcessInstance(), message -> {
                    TaskInfo mCurTask = Objects.requireNonNull(getProcessContent(faId)).getCurTask();
                    String name = userAdapter.getUserInfo(mCurTask.getAssignee()).getNameCn();
                    message.setDealUser(String.format("%s  %s", name, mCurTask.getAssignee()));
                });
                return result.pass("已驳回评估");
            }
    
            variableMap.put(COMP_FAIL_GATEWAY_PM_REVIEW_NORMAL_ADVANCE, Boolean.TRUE.toString());
            // 设置下一流程处理人
            variableMap.put(COMP_FAIL_TASK_ML_REVIEW_ASSIGNEE, pmReviewParam.getMlReviewId());
            variableMap.put(COMP_FAIL_TASK_PM_REVIEW_SHARE, pmReviewParam.getIsSubmitKSLibrary());
            taskService.setVariables(taskId, variableMap);
            taskService.complete(taskId);
    
            buildMessage(content.getProcessInstance(), pmReviewParam.getMlReviewId());
            return result.pass("提交成功, 专家组审核中");
        }
    
    
        /**
         * getPmReview
         * 
         * @param faId faId
         * @return CompFailPmReviewParam
         */
        @Override
        public CompFailPmReviewParam getPmReview(String faId) {
            CompFailPmReviewParam result = new CompFailPmReviewParam();
            Map<String, Object> variables = processCommonDaoService.getVariables(
                processCommonDaoService.getProcessInstanceByBusinessId(COMP_FAIL_FA_ID, faId).getId());
            result.setReviewPass(CompProcessReview.PASSED);
            result.setDeReviewOpinion((String) variables.get(COMP_FAIL_TASK_PM_REVIEW_OPINION));
            result.setIsSubmitKSLibrary((String) variables.get(COMP_FAIL_TASK_PM_REVIEW_SHARE));
            result.setMlReviewId((String) variables.get(COMP_FAIL_TASK_PM_REVIEW_ASSIGNEE));
            // 若被驳回，
            result.setMlReviewId((String) variables.get(COMP_FAIL_TASK_ML_REVIEW_ASSIGNEE));
            result.setHandlerSuggestion((String) variables.get(COMP_FAIL_TASK_ML_REVIEW_OPINION));
            return result;
        }
    
    
        /**
         * submitMlReview
         * 
         * @param mlReviewParam mlReviewParam
         * @return VerifyInfo
         */
        @Override
        public VerifyInfo submitMlReview(CompFailMlReviewParam mlReviewParam) {
            VerifyInfo result = new VerifyInfo();
            String faId = mlReviewParam.getFaId();
            CompFailProcessContent content = getProcessContent(faId);
            if (content == null) {
                return result.notPassed("流程单号未找到");
            }
            TaskInfo curTask = content.getCurTask();
            if (curTask == null || !StringUtils.equals(curTask.getTaskDefinitionKey(),
                CompFailProcessTask.COMP_FAIL_TASK_ML_REVIEW.getDefinitionKey())) {
                return result.notPassed("处理失败, 流程所处状态错误");
            }
            String procInstId = content.getProcessInstance().getId();
            Map<String, Object> variables = processCommonDaoService.getVariables(procInstId);
            String assignee = (String) variables.get(COMP_FAIL_TASK_ML_REVIEW_ASSIGNEE);
            UserVo user = userService.getUser();
            if (!user.getAccount().equals(assignee)) {
                return result.notPassed("处理失败, 无权限处理该流程");
            }
    
            String taskId = curTask.getId();
            CompProcessReview review = new CompProcessReview(mlReviewParam.getReviewPass());
            if (review.isTransferred()) {
                String latestAssignee = mlReviewParam.getPlReviewId();
                taskService.setAssignee(curTask.getId(), latestAssignee);
                taskService.setVariable(curTask.getId(), COMP_FAIL_TASK_ML_REVIEW_ASSIGNEE, latestAssignee);
    
                buildMessage(content.getProcessInstance(), latestAssignee);
                return result.pass("转单成功，您已不是当前流程的处理人");
            }
    
            Map<String, Object> variableMap = new HashMap<>();
            // 审核意见
            variableMap.put(COMP_FAIL_TASK_ML_REVIEW_OPINION, mlReviewParam.getMlReviewOpinion());
            if (review.isNotPass()) {
                variableMap.put(COMP_FAIL_GATEWAY_ML_REVIEW_NORMAL_ADVANCE, Boolean.FALSE.toString());
                taskService.setVariables(taskId, variableMap);
                taskService.complete(taskId);
    
                buildMessage(content.getProcessInstance(), message -> {
                    TaskInfo mCurTask = Objects.requireNonNull(getProcessContent(faId)).getCurTask();
                    String name = userAdapter.getUserInfo(mCurTask.getAssignee()).getNameCn();
                    message.setDealUser(String.format("%s  %s", name, mCurTask.getAssignee()));
                });
                return result.pass("已驳回项目经理审核");
            }
    
            variableMap.put(COMP_FAIL_GATEWAY_ML_REVIEW_NORMAL_ADVANCE, Boolean.TRUE.toString());
            // 设置下一流程处理人
            variableMap.put(COMP_FAIL_TASK_CLOSE_REVIEW_ASSIGNEE, mlReviewParam.getPlReviewId());
            taskService.setVariables(taskId, variableMap);
            taskService.complete(taskId);
    
            buildMessage(content.getProcessInstance(), mlReviewParam.getPlReviewId());
            return result.pass("提交成功, 专家组审核中");
        }
    
    
        /**
         * getMlReview
         * 
         * @param faId faId
         * @return CompFailMlReviewParam
         */
        @Override
        public CompFailMlReviewParam getMlReview(String faId) {
            CompFailMlReviewParam result = new CompFailMlReviewParam();
            Map<String, Object> variables = processCommonDaoService.getVariables(
                processCommonDaoService.getProcessInstanceByBusinessId(COMP_FAIL_FA_ID, faId).getId());
            result.setReviewPass(CompProcessReview.PASSED);
            result.setMlReviewOpinion((String) variables.get(COMP_FAIL_TASK_ML_REVIEW_OPINION));
            result.setPlReviewId((String) variables.get(COMP_FAIL_TASK_ML_REVIEW_ASSIGNEE));
            // 若被驳回，
            result.setPlReviewId((String) variables.get(COMP_FAIL_TASK_CLOSE_REVIEW_ASSIGNEE));
            result.setHandlerSuggestion((String) variables.get(COMP_FAIL_TASK_CLOSE_REVIEW_OPINION));
            return result;
        }
    
    
        /**
         * submitCloseReview
         * 
         * @param closeReviewParam closeReviewParam
         * @return VerifyInfo
         */
        @Override
        public VerifyInfo submitCloseReview(CompFailCloseReviewParam closeReviewParam) {
            VerifyInfo result = new VerifyInfo();
            String faId = closeReviewParam.getFaId();
            CompFailProcessContent content = getProcessContent(faId);
            if (content == null) {
                return result.notPassed("流程单号未找到");
            }
            TaskInfo curTask = content.getCurTask();
            if (curTask == null || !StringUtils.equals(curTask.getTaskDefinitionKey(),
                CompFailProcessTask.COMP_FAIL_TASK_CLOSE_REVIEW.getDefinitionKey())) {
                return result.notPassed("处理失败, 流程所处状态错误");
            }
            String procInstId = content.getProcessInstance().getId();
            Map<String, Object> variables = processCommonDaoService.getVariables(procInstId);
            String assignee = (String) variables.get(COMP_FAIL_TASK_CLOSE_REVIEW_ASSIGNEE);
            UserVo user = userService.getUser();
            if (!user.getAccount().equals(assignee)) {
                return result.notPassed("处理失败, 无权限处理该流程");
            }
    
            String taskId = curTask.getId();
            CompProcessReview review = new CompProcessReview(closeReviewParam.getReviewPass());
            if (review.isTransferred()) {
                return result.notPassed("处理失败, 此流程不可以进行转单");
            }
    
            Map<String, Object> variableMap = new HashMap<>();
            // 关闭人审核意见
            variableMap.put(COMP_FAIL_TASK_CLOSE_REVIEW_OPINION, closeReviewParam.getPlReviewOpinion());
            if (review.isNotPass()) {
                variableMap.put(COMP_FAIL_GATEWAY_CLOSE_REVIEW_NORMAL_ADVANCE, Boolean.FALSE.toString());
                taskService.setVariables(taskId, variableMap);
                taskService.complete(taskId);
    
                buildMessage(content.getProcessInstance(), message -> {
                    TaskInfo mCurTask = Objects.requireNonNull(getProcessContent(faId)).getCurTask();
                    String name = userAdapter.getUserInfo(mCurTask.getAssignee()).getNameCn();
                    message.setDealUser(String.format("%s  %s", name, mCurTask.getAssignee()));
                });
                return result.pass("已驳回专家组审核");
            }
    
            variableMap.put(COMP_FAIL_GATEWAY_CLOSE_REVIEW_NORMAL_ADVANCE, Boolean.TRUE.toString());
            taskService.setVariables(taskId, variableMap);
            taskService.complete(taskId);
    
            buildMessage(content.getProcessInstance(), message -> {
                TaskInfo mCurTask = Objects.requireNonNull(getProcessContent(faId)).getCurTask();
                String name = userAdapter.getUserInfo(mCurTask.getAssignee()).getNameCn();
                message.setDealUser(String.format("%s  %s", name, mCurTask.getAssignee()));
            });
            return result.pass("提交成功, 专家组审核中");
        }
    
    
        /**
         * getCloseReview
         * 
         * @param faId faId
         * @return CompFailCloseReviewParam
         */
        @Override
        public CompFailCloseReviewParam getCloseReview(String faId) {
            CompFailCloseReviewParam result = new CompFailCloseReviewParam();
            Map<String, Object> variables = processCommonDaoService.getVariables(
                processCommonDaoService.getProcessInstanceByBusinessId(COMP_FAIL_FA_ID, faId).getId());
            result.setReviewPass(CompProcessReview.PASSED);
            result.setPlReviewOpinion((String) variables.get(COMP_FAIL_TASK_CLOSE_REVIEW_OPINION));
            // result.setHandlerSuggestion(); 意见反馈流程不能驳回，且处理人固定为申请人
            return result;
        }
    
    
        /**
         * submitFeedback
         * 
         * @param feedbackParam feedbackParam
         * @return VerifyInfo
         */
        @Override
        public VerifyInfo submitFeedback(CompFailFeedbackParam feedbackParam) {
            VerifyInfo result = new VerifyInfo();
            String faId = feedbackParam.getFaId();
            CompFailProcessContent content = getProcessContent(faId);
            if (content == null) {
                return result.notPassed("流程单号未找到");
            }
            TaskInfo curTask = content.getCurTask();
            if (curTask == null || !StringUtils.equals(curTask.getTaskDefinitionKey(),
                CompFailProcessTask.COMP_FAIL_TASK_FEEDBACK.getDefinitionKey())) {
                return result.notPassed("处理失败, 流程所处状态错误");
            }
    
            String taskId = curTask.getId();
            Map<String, Object> variableMap = new HashMap<>();
            // 接口人意见
            variableMap.put(COMP_FAIL_TASK_FEEDBACK_SATISFACTION, feedbackParam.getSatisfaction());
            variableMap.put(COMP_FAIL_TASK_FEEDBACK_ADVISE, feedbackParam.getAdvise());
            variableMap.put(COMP_FAIL_TASK_FEEDBACK_EVALUATION, feedbackParam.getEvaluation());
            taskService.setVariables(taskId, variableMap);
            taskService.complete(taskId);
    
            deleteMessage(faId);
            return result.pass("反馈意见完成, 流程结束");
        }
    
    
        /**
         * getFeedback
         * 
         * @param faId faId
         * @return CompFailFeedbackParam
         */
        @Override
        public CompFailFeedbackParam getFeedback(String faId) {
            CompFailFeedbackParam result = new CompFailFeedbackParam();
            Map<String, Object> variables = processCommonDaoService.getVariables(
                processCommonDaoService.getProcessInstanceByBusinessId(COMP_FAIL_FA_ID, faId).getId());
            result.setReviewPass(CompProcessReview.PASSED);
            result.setSatisfaction((String) variables.get(COMP_FAIL_TASK_FEEDBACK_SATISFACTION));
            result.setAdvise((String) variables.get(COMP_FAIL_TASK_FEEDBACK_ADVISE));
            result.setEvaluation((String) variables.get(COMP_FAIL_TASK_FEEDBACK_EVALUATION));
            // result.setHandlerSuggestion(); 流程已结束，无下一流程驳回意见
            return result;
        }
    
    
        /**
         * getProcessList
         * 
         * @return List<CompFailOverview>
         */
        public List<CompFailOverview> getProcessList() {
            List<CompFailOverview> result = new ArrayList<>();
            List<HistoricProcessInstance> list = getHistoricProcessInstance();
            Map<String, Task> runnableTaskMap = processCommonDaoService.getRunnableTaskMap();
            Map<String, Map<String, Object>> varMap = getVarMap(list);
            for (HistoricProcessInstance historicProcessInstance : list) {
                String procInstId = historicProcessInstance.getId();
                Map<String, Object> variables = varMap.get(procInstId);
                CompFailOverview oneResult = createRelCertOverview(historicProcessInstance, variables,
                    readCurState(runnableTaskMap.get(procInstId)));
                oneResult.setCreateUser(variables.get("COMP_FAIL_TASK_APPLICATION_ASSIGNEE").toString());
                if (runnableTaskMap.get(procInstId) == null) {
                    continue;
                }
                oneResult.setDealUser(runnableTaskMap.get(procInstId).getAssignee());
                result.add(oneResult);
            }
            return result;
        }
    
    
        /**
         * createRelCertOverview
         * 
         * @param historicProcessInstance historicProcessInstance
         * @param variables variables
         * @param curState curState
         * @return CompFailOverview
         */
        private CompFailOverview createRelCertOverview(HistoricProcessInstance historicProcessInstance,
            Map<String, Object> variables, String curState) {
            CompFailOverview oneResult = new CompFailOverview();
            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            oneResult.setCreateDate(dateFormat.format(historicProcessInstance.getStartTime()));
    
            oneResult.setCompCode((String) variables.get(COMP_FAIL_COMP_CODE));
            oneResult.setFaId((String) variables.get(COMP_FAIL_FA_ID));
            oneResult.setCurState(curState);
            return oneResult;
        }
    
    
        /**
         * getWaitingProcessList
         * 
         * @param pageNo pageNo
         * @param pageSize pageSize
         * @param componentCode componentCode
         * @return ResponseVo
         */
        @Override
        public ResponseVo getWaitingProcessList(Integer pageNo, Integer pageSize, String componentCode) {
            List<CompFailOverview> result = getWaitingProcessList();
            result = filterProcessByCompCode(result, componentCode);
            List<CompFailOverview> pageResult = page(pageNo, pageSize, result);
            return ResponseUtils.successPageResponse(pageResult, result.size());
        }
    
    
        /**
         * getDoingProcessList
         * 
         * @param pageNo pageNo
         * @param pageSize pageSize
         * @param componentCode componentCode
         * @return ResponseVo
         */
        @Override
        public ResponseVo getDoingProcessList(Integer pageNo, Integer pageSize, String componentCode) {
            List<CompFailOverview> result = getDoingProcessList();
            result = filterProcessByCompCode(result, componentCode);
            List<CompFailOverview> pageResult = page(pageNo, pageSize, result);
            return ResponseUtils.successPageResponse(pageResult, result.size());
        }
    
    
        /**
         * getHistoryProcessList
         * 
         * @param pageNo pageNo
         * @param pageSize pageSize
         * @param componentCode componentCode
         * @return ResponseVo
         */
        @Override
        public ResponseVo getHistoryProcessList(Integer pageNo, Integer pageSize, String componentCode) {
            List<CompFailOverview> result = getHistoryProcessList();
            result = filterProcessByCompCode(result, componentCode);
            List<CompFailOverview> pageResult = page(pageNo, pageSize, result);
            return ResponseUtils.successPageResponse(pageResult, result.size());
        }
    
    
        /**
         * getCheckHistoryProcessList
         * 
         * @param pageNo pageNo
         * @param pageSize pageSize
         * @param componentCode componentCode
         * @return ResponseVo
         */
        @Override
        public ResponseVo getCheckHistoryProcessList(Integer pageNo, Integer pageSize, String componentCode) {
            List<CompFailOverview> result = getCheckHistoryProcessList();
            result = filterProcessByCompCode(result, componentCode);
            List<CompFailOverview> pageResult = page(pageNo, pageSize, result);
            return ResponseUtils.successPageResponse(pageResult, result.size());
        }
    
    
        /**
         * getShareProcessList
         * 
         * @param pageNo pageNo
         * @param pageSize pageSize
         * @param componentCode componentCode
         * @return ResponseVo
         */
        @Override
        public ResponseVo getShareProcessList(Integer pageNo, Integer pageSize, String componentCode) {
            UserVo user = userService.getUser();
            if (user == null || !isTargetDept(user)) {
                return ResponseUtils.successPageResponse(new ArrayList<>(), 0);
            }
            List<CompFailOverview> result = getShareProcessList();
            result = filterProcessByCompCode(result, componentCode);
            List<CompFailOverview> pageResult = page(pageNo, pageSize, result);
            return ResponseUtils.successPageResponse(pageResult, result.size());
        }
    
    
        /**
         * isTargetDept
         * 
         * @param userVo userVo
         * @return boolean
         */
        private boolean isTargetDept(UserVo userVo) {
            String dept = "电源工程部";
            return dept.equals(userVo.getDeptNameLevel3()) || dept.equals(userVo.getDeptNameLevel4()) || dept.equals(
                userVo.getDeptNameLevel5()) || dept.equals(userVo.getDeptNameLevelMin());
        }
    
    
        /**
         * updateCreateVar
         * 
         * @param businessId businessId
         * @param user user
         * @param failureAnalysisCreateParam failureAnalysisCreateParam
         * @return Map<String,Object>
         */
        private Map<String, Object> updateCreateVar(String businessId, UserVo user,
            CompFailCreateParam failureAnalysisCreateParam) {
            Map<String, Object> result = new HashMap<>();
            result.put(COMP_FAIL_FA_ID, businessId);
            result.put(COMP_FAIL_TASK_APPLICATION_ASSIGNEE, user.getAccount()); // 设置申请流程处理人
            result.put(COMP_FAIL_TASK_RISK_ASSIGNEE, user.getAccount());   // 设置风险评估处理人
            result.put(COMP_FAIL_TASK_FEEDBACK_ASSIGNEE, user.getAccount());   // 设置反馈流程处理人
    
            result.put(COMP_FAIL_COMP_CODE, failureAnalysisCreateParam.getCompCode());
            return result;
        }
    
    
        /**
         * getProcessContent
         * 
         * @param faId faId
         * @return CompFailProcessContent
         */
        private CompFailProcessContent getProcessContent(String faId) {
            CompFailProcessContent result = new CompFailProcessContent();
            result.setId(faId);
            result.setVarName(CompFailConstants.COMP_FAIL_FA_ID);
            HistoricProcessInstance instance = processCommonDaoService.getProcessInstanceByBusinessId(
                CompFailConstants.COMP_FAIL_FA_ID, faId);
            if (instance == null) {
                return null;
            }
            result.setProcessInstance(instance);
            Task curTask = processCommonDaoService.getCurTaskIdByProcInsId(instance.getId());
            if (curTask != null) {
                result.setPreTask(processCommonDaoService.getPreTaskByProcInstId(instance.getId()));
            }
            result.setCurTask(curTask);
            result.setCurState(curTask == null
                ? CompFailState.CLOSED
                : CompFailProcessTask.valueOf(curTask.getTaskDefinitionKey()).getState());
            return result;
        }
    
    
        /**
         * isShareProcess
         * 
         * @param procInstId procInstId
         * @param varMap varMap
         * @return boolean
         */
        private boolean isShareProcess(String procInstId, Map<String, Object> varMap) {
            if (varMap == null || varMap.isEmpty()) {
                varMap = processCommonDaoService.getVariables(procInstId);
            }
            return "true".equals(varMap.get(COMP_FAIL_TASK_PM_REVIEW_SHARE));
        }
    
    
        /**
         * readCurState
         * 
         * @param curTask curTask
         * @return String
         */
        private String readCurState(TaskInfo curTask) {
            if (curTask != null) {
                return CompFailProcessTask.valueOf(curTask.getTaskDefinitionKey()).getState().getStateName();
            }
            return CompFailState.CLOSED.getStateName();
        }
    
    
        /**
         * getCurTaskInfo
         * 
         * @param curTask curTask
         * @param preTask preTask
         * @return CompRelCertTaskInfo
         */
        private CompRelCertTaskInfo getCurTaskInfo(TaskInfo curTask, TaskInfo preTask) {
            CompRelCertTaskInfo result = new CompRelCertTaskInfo();
            result.setName(curTask.getTaskDefinitionKey());
            // 如果上一个任务次序高于当前任务，表名当前任务处于“被驳回状态”
            result.setState(compareTask(curTask, preTask) ? State.OPEN.toString() : State.REJECTED.toString());
            return result;
        }
    
    
        /**
         * compareTask
         * 
         * @param curTask curTask
         * @param preTask preTask
         * @return boolean
         */
        private boolean compareTask(TaskInfo curTask, TaskInfo preTask) {
            if (preTask == null) {
                return true;
            }
            return CompFailProcessTask.valueOf(curTask.getTaskDefinitionKey()).getOrder() >= CompFailProcessTask.valueOf(
                preTask.getTaskDefinitionKey()).getOrder();
        }
    
    
        /**
         * getVarMap
         * 
         * @param historicProcessInstanceList historicProcessInstanceList
         * @return Map<String,Map<String,Object>>
         */
        private Map<String, Map<String, Object>> getVarMap(List<HistoricProcessInstance> historicProcessInstanceList) {
            List<String> processInstanceIdList = historicProcessInstanceList.stream()
                .map(HistoricProcessInstance::getId)
                .collect(Collectors.toList());
            return processCommonDaoService.getVariables(processInstanceIdList);
        }
    
    
        /**
         * page
         * 
         * @param pageNo pageNo
         * @param pageSize pageSize
         * @param result result
         * @return List<CompFailOverview>
         */
        private List<CompFailOverview> page(Integer pageNo, Integer pageSize, List<CompFailOverview> result) {
            return result.stream()
                .sorted(Comparator.comparing(CompFailOverview::getFaId)
                    .thenComparing(CompFailOverview::getCreateDate)
                    .reversed())
                .skip((long) (pageNo - 1) * pageSize)
                .limit(pageSize)
                .collect(Collectors.toList());
        }
    
    
        /**
         * createCompFailOverview
         * 
         * @param historicProcessInstance historicProcessInstance
         * @param variables variables
         * @param curState curState
         * @return CompFailOverview
         */
        private CompFailOverview createCompFailOverview(HistoricProcessInstance historicProcessInstance,
            Map<String, Object> variables, String curState) {
            CompFailOverview oneResult = new CompFailOverview();
            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
            oneResult.setCreateDate(dateFormat.format(historicProcessInstance.getStartTime()));
            oneResult.setCompCode((String) variables.get(COMP_FAIL_COMP_CODE));
            oneResult.setFaId((String) variables.get(COMP_FAIL_FA_ID));
            oneResult.setCurState(curState);
            return oneResult;
        }
    
    
        /**
         * getWaitingProcessList
         * 
         * @return List<CompFailOverview>
         */
        private List<CompFailOverview> getWaitingProcessList() {
            List<CompFailOverview> result = new ArrayList<>();
            List<HistoricProcessInstance> list = getHistoricProcessInstance();
            Map<String, Task> runnableTaskMap = processCommonDaoService.getRunnableTaskMap();
            Map<String, Map<String, Object>> varMap = getVarMap(list);
            UserVo user = userService.getUser();
            for (HistoricProcessInstance historicProcessInstance : list) {
                String procInstId = historicProcessInstance.getId();
                Map<String, Object> variables = varMap.get(procInstId);
                String curState = readCurState(runnableTaskMap.get(procInstId));
                if (!"已关闭".equals(curState) && user.getAccount().equals(runnableTaskMap.get(procInstId).getAssignee())) {
                    CompFailOverview oneResult = createCompFailOverview(historicProcessInstance, variables, curState);
                    result.add(oneResult);
                }
            }
            return result;
        }
    
    
        /**
         * getDoingProcessList
         * 
         * @return List<CompFailOverview>
         */
        private List<CompFailOverview> getDoingProcessList() {
            List<CompFailOverview> result = new ArrayList<>();
            List<HistoricProcessInstance> list = getHistoricProcessInstance();
            Map<String, Task> runnableTaskMap = processCommonDaoService.getRunnableTaskMap();
            Map<String, Map<String, Object>> varMap = getVarMap(list);
            UserVo user = userService.getUser();
            for (HistoricProcessInstance historicProcessInstance : list) {
                String procInstId = historicProcessInstance.getId();
                Map<String, Object> variables = varMap.get(procInstId);
                String curState = readCurState(runnableTaskMap.get(procInstId));
                if (!"已关闭".equals(curState) && user.getAccount()
                    .equals(variables.get(COMP_FAIL_TASK_APPLICATION_ASSIGNEE))) {
                    CompFailOverview oneResult = createCompFailOverview(historicProcessInstance, variables, curState);
                    result.add(oneResult);
                }
            }
            return result;
        }
    
    
        /**
         * getHistoryProcessList
         * 
         * @return List<CompFailOverview>
         */
        private List<CompFailOverview> getHistoryProcessList() {
            List<CompFailOverview> result = new ArrayList<>();
            List<HistoricProcessInstance> list = getHistoricProcessInstance();
            Map<String, Task> runnableTaskMap = processCommonDaoService.getRunnableTaskMap();
            Map<String, Map<String, Object>> varMap = getVarMap(list);
            UserVo user = userService.getUser();
            for (HistoricProcessInstance historicProcessInstance : list) {
                String procInstId = historicProcessInstance.getId();
                Map<String, Object> variables = varMap.get(procInstId);
                String curState = readCurState(runnableTaskMap.get(procInstId));
                // 不包含用户主动关闭的
                if ("已关闭".equals(curState) && user.getAccount().equals(variables.get(COMP_FAIL_TASK_APPLICATION_ASSIGNEE))
                    // 通过了关闭审核的网关，则一定是正常关闭的流程
                    && "true".equals(variables.get(COMP_FAIL_GATEWAY_CLOSE_REVIEW_NORMAL_ADVANCE))) {
                    CompFailOverview oneResult = createCompFailOverview(historicProcessInstance, variables, curState);
                    result.add(oneResult);
                }
            }
            return result;
        }
    
    
        /**
         * getCheckHistoryProcessList
         * 
         * @return List<CompFailOverview>
         */
        private List<CompFailOverview> getCheckHistoryProcessList() {
            List<CompFailOverview> result = new ArrayList<>();
            List<HistoricProcessInstance> list = getHistoricProcessInstance();
            Map<String, Task> runnableTaskMap = processCommonDaoService.getRunnableTaskMap();
            Map<String, Map<String, Object>> varMap = getVarMap(list);
            UserVo user = userService.getUser();
            for (HistoricProcessInstance historicProcessInstance : list) {
                String procInstId = historicProcessInstance.getId();
                Map<String, Object> variables = varMap.get(procInstId);
                Task task = runnableTaskMap.get(procInstId);
                String curState = readCurState(task);
                // 除去申请（开头）、反馈（结尾）、以及用户正在处理的阶段，只要处理过中间的流程，即为审批历史
                variables.remove(COMP_FAIL_TASK_APPLICATION_ASSIGNEE);
                variables.remove(COMP_FAIL_TASK_FEEDBACK_ASSIGNEE);
                if (task != null) {
                    // 移除当前流程中的处理人
                    variables.remove(CompFailProcessTask.valueOf(task.getTaskDefinitionKey()).getAssigneeDefKey());
                }
                if (variables.containsValue(user.getAccount())) {
                    CompFailOverview oneResult = createCompFailOverview(historicProcessInstance, variables, curState);
                    result.add(oneResult);
                }
            }
            return result;
        }
    
    
        /**
         * getShareProcessList
         * 
         * @return List<CompFailOverview>
         */
        private List<CompFailOverview> getShareProcessList() {
            List<CompFailOverview> result = new ArrayList<>();
            List<HistoricProcessInstance> list = getHistoricProcessInstance();
            Map<String, Task> runnableTaskMap = processCommonDaoService.getRunnableTaskMap();
            Map<String, Map<String, Object>> varMap = getVarMap(list);
            for (HistoricProcessInstance historicProcessInstance : list) {
                String procInstId = historicProcessInstance.getId();
                String curState = readCurState(runnableTaskMap.get(procInstId));
                Map<String, Object> variables = varMap.get(procInstId);
                if (isShareProcess(procInstId, variables)) {
                    // 除去用户主动关闭的, 只要通过了关闭审核任务的网关，则一定是正常关闭的
                    if ("已关闭".equals(curState) && !"true".equals(
                        variables.get(COMP_FAIL_GATEWAY_CLOSE_REVIEW_NORMAL_ADVANCE))) {
                        continue;
                    }
                    CompFailOverview oneResult = createCompFailOverview(historicProcessInstance, variables, curState);
                    result.add(oneResult);
                }
            }
            return result;
        }
    
    
        /**
         * filterProcessByCompCode
         * 
         * @param result result
         * @param componentCode componentCode
         * @return List<CompFailOverview>
         */
        private List<CompFailOverview> filterProcessByCompCode(List<CompFailOverview> result, String componentCode) {
            if (StringUtils.isBlank(componentCode)) {
                return result;
            }
            Set<String> compSet = new HashSet<>(MyStringUtils.stringToListWithCommaStr(componentCode));
            return result.stream()
                .filter(compFailOverview -> compSet.contains(compFailOverview.getCompCode()))
                .collect(Collectors.toList());
        }
    
    
        /**
         * getComponentCode
         * 
         * @param key key
         * @param type type
         * @return Collection<String>
         */
        @Override
        public Collection<String> getComponentCode(String key, String type) {
            CompTableType typeEnum = CompTableType.valueOf(type);
            List<CompFailOverview> result = getProcessList(typeEnum);
    
            return result.stream()
                .map(CompFailOverview::getCompCode)
                .filter(compCode -> !StringUtils.isBlank(compCode) && (StringUtils.isBlank(key) || compCode.contains(key)))
                .sorted(Comparator.naturalOrder())
                .limit(20)
                .collect(Collectors.toSet());
        }
    
    
        /**
         * getProcessState
         * 
         * @param businessId businessId
         * @return String
         */
        @Override
        public String getProcessState(String businessId) {
            CompFailProcessContent processContent = getProcessContent(businessId);
            if (processContent == null) {
                return "流程不存在";
            }
            return readCurState(processContent.getCurTask());
        }
    
    
        /**
         * getProcessList
         * 
         * @param typeEnum typeEnum
         * @return List<CompFailOverview>
         */
        private List<CompFailOverview> getProcessList(CompTableType typeEnum) {
            switch (typeEnum) {
                case WAITING:
                    return getWaitingProcessList();
                case DOING:
                    return getDoingProcessList();
                case HISTORY:
                    return getHistoryProcessList();
                case CHECK_HISTORY:
                    return getCheckHistoryProcessList();
                case SHARE:
                    return getShareProcessList();
                default:
                    return new ArrayList<>();
            }
        }
    
    
        /**
         * getHistoricProcessInstance
         * 
         * @return List<HistoricProcessInstance>
         */
        private List<HistoricProcessInstance> getHistoricProcessInstance() {
            return historyService.createHistoricProcessInstanceQuery()
                .processDefinitionKey(COMP_FAIL_PROCESS_DEF_KEY)
                .list();
        }
    }

### service 层 通用流程服务操作接口 ###

package com.service.dao;
    
    import com.domain.entity.process.ProcessContent;
    import com.exception.NumberOutOfRangeException;
    import org.activiti.engine.history.HistoricProcessInstance;
    import org.activiti.engine.history.HistoricTaskInstance;
    import org.activiti.engine.repository.ProcessDefinition;
    import org.activiti.engine.task.Task;
    
    import java.util.List;
    import java.util.Map;
    
    /**
     * ProcessCommonDaoService
     *
     */
    public interface ProcessCommonDaoService {
    
        /**
         * getVariables
         * 
         * @param procInstId procInstId
         * @return Map<String,Object>
         */
        Map<String, Object> getVariables(String procInstId);
    
    
        /**
         * getVariables
         * 
         * @param procInstId procInstId
         * @param vars vars
         * @return Map<String,Object>
         */
        Map<String, Object> getVariables(String procInstId, List<String> vars);
    
    
        /**
         * getVariables
         * 
         * @param procInstId procInstId
         * @param vars vars
         * @param running running
         * @return Map<String,Object>
         */
        Map<String, Object> getVariables(String procInstId, List<String> vars, boolean running);
    
    
        /**
         * getProcInstId
         * 
         * @param content content
         * @return String
         */
        String getProcInstId(ProcessContent content);
    
    
        /**
         * setVariables
         * 
         * @param procInstId procInstId
         * @param variables variables
         */
        void setVariables(String procInstId, Map<String, Object> variables);
    
        /**
         * 获取流程变量
         *
         * @param procInstIdList 流程id集合
         * @return Map<String:procInstId, Map<String, Object>:params>
         */
        Map<String, Map<String, Object>> getVariables(List<String> procInstIdList);
    
        /**
         * 获取流程实例
         *
         * @param businessIdVarName 流程实例业务id变量名
         * @param businessIdValue 变量值
         * @return 流程实例
         */
        HistoricProcessInstance getProcessInstanceByBusinessId(String businessIdVarName, String businessIdValue);
    
        /**
         * getProcessInstanceByBusinessId
         *
         * @param businessId businessId
         * @return HistoricProcessInstance
         */
        HistoricProcessInstance getProcessInstanceByBusinessId(String businessId);
    
        /**
         * 获取任务节点id
         *
         * @param procInsId 流程实例Id
         * @return 该流程所处任务节点的id
         */
        Task getCurTaskIdByProcInsId(String procInsId);
    
        /**
         * 获取前一个任务节点id
         *
         * @param procInstId 流程实例id
         * @return 该流程前一个任务节点
         */
        HistoricTaskInstance getPreTaskByProcInstId(String procInstId);
    
        /**
         * 获取正在运行的流程任务
         *
         * @return <流程id, 当前任务实例>
         */
        Map<String, Task> getRunnableTaskMap();
    
    
        /**
         * getRunnableTaskMap
         * 
         * @param processDefinitionKey processDefinitionKey
         * @return Map<String,Task>
         */
        Map<String, Task> getRunnableTaskMap(String processDefinitionKey);
    
    
        /**
         * getRunnableTaskMap
         * 
         * @param instIdList instIdList
         * @return Map<String,Task>
         */
        Map<String, Task> getRunnableTaskMap(List<String> instIdList);
    
    
        /**
         * getProcessDefinition
         * 
         * @param processDefinitionKey processDefinitionKey
         * @return ProcessDefinition
         */
        ProcessDefinition getProcessDefinition(String processDefinitionKey);
    
        /**
         * 创建流程实例业务ID
         *
         * @param customFlag customFlag
         * @return String
         * @throws NumberOutOfRangeException NumberOutOfRangeException
         */
        String createProcessInstBusinessId(String customFlag) throws NumberOutOfRangeException;
    
    
        /**
         * deleteProcess
         * 
         * @param processId processId
         * @param deleteReason deleteReason
         */
        void deleteProcess(String processId, String deleteReason);
    }

### service 层 通用流程服务操作接口实现类 ###

package com.service.impl.dao;
    
    import com.domain.entity.process.ProcessContent;
    import com.exception.NumberOutOfRangeException;
    import com.service.dao.ProcessCommonDaoService;
    import com.service.dao.mapper.process.ProcessInstHistoricMapper;
    import com.utils.ProcessUtils;
    import org.activiti.engine.HistoryService;
    import org.activiti.engine.ManagementService;
    import org.activiti.engine.RepositoryService;
    import org.activiti.engine.RuntimeService;
    import org.activiti.engine.TaskService;
    import org.activiti.engine.history.HistoricProcessInstance;
    import org.activiti.engine.history.HistoricTaskInstance;
    import org.activiti.engine.history.HistoricVariableInstance;
    import org.activiti.engine.repository.ProcessDefinition;
    import org.activiti.engine.task.Task;
    import org.activiti.engine.task.TaskQuery;
    import org.apache.commons.lang3.StringUtils;
    import org.springframework.stereotype.Service;
    
    import javax.annotation.Resource;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Locale;
    import java.util.Map;
    import java.util.stream.Collectors;
    
    /**
     * ProcessCommonDaoServiceImpl
     *
     */
    @Service
    public class ProcessCommonDaoServiceImpl implements ProcessCommonDaoService {
    
        @Resource
        TaskService taskService;
    
        @Resource
        RuntimeService runtimeService;
    
        @Resource
        HistoryService historyService;
    
        @Resource
        ManagementService managementService;
    
        @Resource
        RepositoryService repositoryService;
    
        @Resource
        private ProcessInstHistoricMapper processHistoricMapper;
    
    
        /**
         * getVariables
         * 
         * @param procInstId procInstId
         * @return Map<String,Object>
         */
        @Override
        public Map<String, Object> getVariables(String procInstId) {
            Map<String, Object> varMap = new HashMap<>();
            List<HistoricVariableInstance> list = historyService.createNativeHistoricVariableInstanceQuery()
                .sql(String.format(Locale.ROOT, "select * from \n"
                        + "(select *, row_number() over(partition by NAME_ order by create_TIME_ desc) as row_num from %s "
                        + "where PROC_INST_ID_ = '%s' order by CREATE_TIME_ desc) X\n" + "where X.row_num = 1",
                    managementService.getTableName(HistoricVariableInstance.class), procInstId))
                .list();
            list.forEach(var -> varMap.put(var.getVariableName(), var.getValue()));
            return varMap;
        }
    
    
        /**
         * getVariables
         * 
         * @param procInstId procInstId
         * @param vars vars
         * @return Map<String,Object>
         */
        @Override
        public Map<String, Object> getVariables(String procInstId, List<String> vars) {
            return getVariables(procInstId, vars, false);
        }
    
    
        /**
         * getVariables
         * 
         * @param procInstId procInstId
         * @param vars vars
         * @param running running
         * @return Map<String,Object>
         */
        @Override
        public Map<String, Object> getVariables(String procInstId, List<String> vars, boolean running) {
            if (running) {
                return runtimeService.getVariables(procInstId, vars);
            }
            return getVariablesFromHistory(procInstId, vars);
        }
    
    
        /**
         * getProcInstId
         * 
         * @param content content
         * @return String
         */
        @Override
        public String getProcInstId(ProcessContent content) {
            if (content == null || content.getProcessInstance() == null) {
                return "";
            }
            return content.getProcessInstance().getId();
        }
    
    
        /**
         * setVariables
         * 
         * @param procInstId procInstId
         * @param variables variables
         */
        @Override
        public void setVariables(String procInstId, Map<String, Object> variables) {
            Task task = getCurTaskIdByProcInsId(procInstId);
            if (task != null) {
                taskService.setVariables(task.getId(), variables);
            }
        }
    
        /**
         * 获取流程变量
         *
         * @param procInstIdList 流程id集合
         * @return Map<String:procInstId, Map < String, Object>:params>
         */
        @Override
        public Map<String, Map<String, Object>> getVariables(List<String> procInstIdList) {
            if (procInstIdList.isEmpty()) {
                return new HashMap<>();
            }
    
            StringBuilder stringBuilder = new StringBuilder("(");
            for (String proc : procInstIdList) {
                stringBuilder.append("'").append(proc).append("'").append(",");
            }
            stringBuilder.delete(stringBuilder.length() - 1, stringBuilder.length());
            stringBuilder.append(")");
            List<HistoricVariableInstance> list = historyService.createNativeHistoricVariableInstanceQuery()
                .sql(String.format(Locale.ROOT, "select * from \n"
                        + "(select *, row_number() over(partition by PROC_INST_ID_, NAME_ order by create_TIME_ desc) as row_num from %s "
                        + "where PROC_INST_ID_ in %s) X\n" + "where X.row_num = 1",
                    managementService.getTableName(HistoricVariableInstance.class), stringBuilder))
                .list();
    
            Map<String, Map<String, Object>> varMap = new HashMap<>();
            list.forEach(var -> {
                String procInstIs = var.getProcessInstanceId();
                Map<String, Object> map = varMap.computeIfAbsent(procInstIs, key -> new HashMap<>());
                map.put(var.getVariableName(), var.getValue());
            });
            return varMap;
        }
    
    
        /**
         * getVariablesFromHistory
         * 
         * @param procInstId procInstId
         * @param vars vars
         * @return Map<String,Object>
         */
        private Map<String, Object> getVariablesFromHistory(String procInstId, List<String> vars) {
            Map<String, Object> varMap = getVariables(procInstId);
            Map<String, Object> result = new HashMap<>();
            vars.forEach(e -> result.put(e, varMap.get(e)));
            return result;
        }
    
    
        /**
         * getProcessInstanceByBusinessId
         * 
         * @param businessIdVarName businessIdVarName
         * @param businessIdValue businessIdValue
         * @return HistoricProcessInstance
         */
        @Override
        public HistoricProcessInstance getProcessInstanceByBusinessId(String businessIdVarName, String businessIdValue) {
            return historyService.createHistoricProcessInstanceQuery()
                .variableValueEquals(businessIdVarName, businessIdValue)
                .singleResult();
        }
    
        /**
         * getProcessInstanceByBusinessId
         *
         * @param businessId businessId
         * @return HistoricProcessInstance
         */
        @Override
        public HistoricProcessInstance getProcessInstanceByBusinessId(String businessId) {
            return historyService.createHistoricProcessInstanceQuery()
                .processInstanceBusinessKey(businessId)
                .singleResult();
        }
    
    
        /**
         * getCurTaskIdByProcInsId
         * 
         * @param procInsId procInsId
         * @return Task
         */
        @Override
        public Task getCurTaskIdByProcInsId(String procInsId) {
            return taskService.createTaskQuery().processInstanceId(procInsId).active().singleResult();
        }
    
    
        /**
         * getPreTaskByProcInstId
         * 
         * @param procInstId procInstId
         * @return HistoricTaskInstance
         */
        @Override
        public HistoricTaskInstance getPreTaskByProcInstId(String procInstId) {
            return historyService.createNativeHistoricTaskInstanceQuery()
                .sql("select * from " + managementService.getTableName(HistoricTaskInstance.class)
                    + " T where T.PROC_INST_ID_ = '" + procInstId + "' order by START_TIME_ desc limit " + "1,1")
                .singleResult();
        }
    
    
        /**
         * getRunnableTaskMap
         * 
         * @return Map<String,Task>
         */
        @Override
        public Map<String, Task> getRunnableTaskMap() {
            return getRunnableTaskMap("");
        }
    
    
        /**
         * getRunnableTaskMap
         * 
         * @param processDefinitionKey processDefinitionKey
         * @return Map<String,Task>
         */
        @Override
        public Map<String, Task> getRunnableTaskMap(String processDefinitionKey) {
            return getCurRunnableTasks(processDefinitionKey, null);
        }
    
    
        /**
         * getRunnableTaskMap
         * 
         * @param instIdList instIdList
         * @return Map<String,Task>
         */
        @Override
        public Map<String, Task> getRunnableTaskMap(List<String> instIdList) {
            return getCurRunnableTasks(null, instIdList);
        }
    
    
        /**
         * getCurRunnableTasks
         * 
         * @param processDefinitionKey processDefinitionKey
         * @param instIdList instIdList
         * @return Map<String,Task>
         */
        private Map<String, Task> getCurRunnableTasks(String processDefinitionKey, List<String> instIdList) {
            TaskQuery taskQuery = taskService.createTaskQuery();
            if (!StringUtils.isBlank(processDefinitionKey)) {
                taskQuery.processDefinitionKey(processDefinitionKey);
            }
            if (instIdList != null && instIdList.isEmpty()) {
                taskQuery.processInstanceIdIn(instIdList);
            }
            List<Task> tasks = taskQuery.active().list();
    
            return tasks == null
                ? new HashMap<>()
                : tasks.stream().collect(Collectors.toMap(Task::getProcessInstanceId, e -> e));
        }
    
    
        /**
         * getProcessDefinition
         * 
         * @param processDefinitionKey processDefinitionKey
         * @return ProcessDefinition
         */
        @Override
        public ProcessDefinition getProcessDefinition(String processDefinitionKey) {
            return repositoryService.createProcessDefinitionQuery()
                .processDefinitionKey(processDefinitionKey)
                .latestVersion()
                .singleResult();
        }
    
        /**
         * 创建流程实例业务ID
         *
         * @param customFlag 自定义标识
         * @return String
         * @throws NumberOutOfRangeException NumberOutOfRangeException
         */
        @Override
        public String createProcessInstBusinessId(String customFlag) throws NumberOutOfRangeException {
            int maxNum = processHistoricMapper.getTodayProcInsMaxNum();
            return ProcessUtils.formatBusinessId(customFlag, maxNum);
        }
    
    
        /**
         * deleteProcess
         * 
         * @param processId processId
         * @param deleteReason deleteReason
         */
        @Override
        public void deleteProcess(String processId, String deleteReason) {
            HistoricProcessInstance processInstance = historyService.createHistoricProcessInstanceQuery()
                .processInstanceId(processId)
                .singleResult();
            if (processInstance == null) {
                return;
            }
            if (processInstance.getEndTime() == null) {
                runtimeService.deleteProcessInstance(processInstance.getId(), deleteReason);
            }
            historyService.deleteHistoricProcessInstance(processInstance.getId());
        }
    }

###  ###

### dao层 mapper接口 ###

package com.service.dao.mapper.process;
    
    import com.domain.dto.process.ProcessInstHistoryDto;
    import org.apache.ibatis.annotations.Mapper;
    import org.apache.ibatis.annotations.Select;
    
    import java.util.List;
    
    /**
     * ProcessInstHistoricMapper
     *
     */
    @Mapper
    public interface ProcessInstHistoricMapper {
    
    
        /**
         * getTodayProcInsMaxNum
         * 
         * @return int
         */
        @Select("select count(*) from act_hi_procinst where TO_DAYS(START_TIME_) = TO_DAYS(NOW())  ")
        int getTodayProcInsMaxNum();
    
    
        /**
         * selectProcessInstByBusinessId
         * 
         * @param businessIdList businessIdList
         * @return List<ProcessInstHistoryDto>
         */
        List<ProcessInstHistoryDto> selectProcessInstByBusinessId(List<String> businessIdList);
    }

###  ###

### dao层 xml映射 ###

<?xml version="1.0" encoding="UTF-8"?>
    
    
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.service.dao.mapper.process.ProcessInstHistoricMapper">
    
        <select id="selectProcessInstByBusinessId" resultType="com.domain.dto.process.ProcessInstHistoryDto">
            SELECT
                PROC_INST_ID_ AS instId,
                BUSINESS_KEY_ AS businessId,
                SUPER_PROCESS_INSTANCE_ID_ AS superInstId
            FROM
                act_hi_procinst
            WHERE
                BUSINESS_KEY_ IN
                <foreach collection="list" item="item" separator="," open="(" close=")">
                    #{item}
                </foreach>
        </select>
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    </mapper>

--------------------

### service层 失效分析服务接口 ###

package com.service.dao;
    
    import com.qualitybigdata.model.CompFailAnalysisParam;
    import com.qualitybigdata.model.CompFailApplicationParam;
    import com.qualitybigdata.model.CompFailRiskParam;
    import com.domain.entity.process.CompFailProcessContent;
    
    /**
     * CompFailDaoService
     * 
     */
    public interface CompFailDaoService {
    
        /**
         * commitApplication
         * 
         * @param content content
         * @param compFailApplicationParam compFailApplicationParam
         */
        void commitApplication(CompFailProcessContent content, CompFailApplicationParam compFailApplicationParam);
    
    
        /**
         * draftApplication
         * 
         * @param content content
         * @param compFailApplicationParam compFailApplicationParam
         */
        void draftApplication(CompFailProcessContent content, CompFailApplicationParam compFailApplicationParam);
    
    
        /**
         * getApplication
         * 
         * @param faId faId
         * @return CompFailApplicationParam
         */
        CompFailApplicationParam getApplication(String faId);
    
        // 修改业务表状态
    
        /**
         * rejectApplication
         * 
         * @param faId faId
         */
        void rejectApplication(String faId);
    
    
        /**
         * commitAnalysis
         * 
         * @param content content
         * @param analysisParam analysisParam
         */
        void commitAnalysis(CompFailProcessContent content, CompFailAnalysisParam analysisParam);
    
    
        /**
         * draftAnalysis
         * 
         * @param content content
         * @param analysisParam analysisParam
         */
        void draftAnalysis(CompFailProcessContent content, CompFailAnalysisParam analysisParam);
    
    
        /**
         * getAnalysis
         * 
         * @param faId faId
         * @return CompFailAnalysisParam
         */
        CompFailAnalysisParam getAnalysis(String faId);
    
        // 修改业务表状态
    
        /**
         * rejectAnalysis
         * 
         * @param faId faId
         */
        void rejectAnalysis(String faId);
    
    
        /**
         * commitRisk
         * 
         * @param content content
         * @param riskParam riskParam
         */
        void commitRisk(CompFailProcessContent content, CompFailRiskParam riskParam);
    
    
        /**
         * draftRisk
         * 
         * @param content content
         * @param riskParam riskParam
         */
        void draftRisk(CompFailProcessContent content, CompFailRiskParam riskParam);
    
    
        /**
         * getRisk
         * 
         * @param faId faId
         * @return CompFailRiskParam
         */
        CompFailRiskParam getRisk(String faId);
    
        // 修改业务表状态
    
        /**
         * rejectRisk
         * 
         * @param faId faId
         */
        void rejectRisk(String faId);
    }

###  ###

### service层 失效分析服务接口实现类 ###

下篇待续...