fix(标准解读流程): 基础性调整

laws-modules/src/main/java/com/jero/modules/activiti/enums/ProcessTypeEnum.java

@@ -11,28 +11,8 @@ import lombok.Getter;
 @AllArgsConstructor
 public enum ProcessTypeEnum {
     DEMO("测试流程", 0, "com.jero.modules.activiti.process.demo.service.ProcessDemoService", "/workCenter/StandardEntryOrChangeProcess", "/workCenter/StandardEntryOrChangeProcess"),
-    FB_ENTRY_CHANGE("标准法规入库/变更流程", 1, "com.jero.modules.activiti.process.fb.service.impl.ProcessFbEntryChangeServiceImpl", "/workCenter/StandardEntryOrChangeProcess", "/workCenter/StandardEntryOrChangeProcess"),
-    FB_STANDARD_CONSULTATION("标准征求意见流程", 2, "com.jero.modules.activiti.process.fb.service.impl.ProcessFbStandardConsultationServiceImpl", "/workCenter/StandardConsultationProcess", "/workCenter/StandardConsultationProcess"),
-    PROJECT_ASSESS("项目合规评估流程", 3, "com.jero.modules.activiti.process.projectassess.service.ProcessProjectAssessService", "/workCenter/ProjectComplianceEvaluationProcess", "/workCenter/ProjectComplianceEvaluationProcess"),
-    STANDARD_COMPLIANCE_CHECK("法规符合性排查流程", 4, "com.jero.modules.activiti.process.standardComplianceCheck.service.ProcessStandardComplianceCheckService", "/workCenter/StandardComplianceCheckProcess", "/workCenter/StandardComplianceCheckProcess"),
-    PROJECT_STANDARD("法规合规评估流程", 5, "com.jero.modules.activiti.process.projectstandard.service.ProcessProjectStandardService", "/workCenter/StandardComplianceProcess", "/workCenter/StandardComplianceProcess"),
-    FB_STANDARD_PURCHASE("法规采购流程", 6, "com.jero.modules.activiti.process.fb.service.impl.ProcessFbStandardPurchaseServiceImpl", "/workCenter/StandardProcurementProcess", "/workCenter/StandardProcurementProcess"),
-    ES_INIT_CHANGE("企标立项/变更计划", 7, "com.jero.modules.activiti.process.esInitChange.service.impl.ProcessEsInitChangeServiceImpl", "/workCenter/enterpriseStandardInitChange/planApprovalChangeFlow", "/workCenter/enterpriseStandardInitChange"),
-    ES_ANNUAL_REPORT("年度制修订计划审批流程(各部门主动上报)", 8, "com.jero.modules.activiti.process.esAbolish.service.impl.ProcessEsAbolishServiceImpl", "/workCenter/annualRevisionPlanActivelyReport/revisionPlanActivelyReportFlow", "/workCenter/annualRevisionPlanActivelyReport"),
-    ES_ANNUAL_INIT("年度制修订计划审批流程(标准化发起)", 9, "com.jero.modules.activiti.process.esAnnualReport.service.impl.ProcessEsAnnualReportServiceImpl", "/workCenter/annualRevisionPlanStandardizationInit/revisionPlanStandardizationInitFlow", "/workCenter/annualRevisionPlanStandardizationInit"),
-    ES_REVISION("企标制修订流程(草案编写/征求意见/报批)", 10, "com.jero.modules.activiti.process.esRevision.service.impl.EsRevisionServiceImpl", "/workCenter/enterpriseStandardRevision/enterpriseStandardRevisionFlow", "/workCenter/enterpriseStandardRevision"),
-    ES_CHANGE("企标更改流程", 11, "com.jero.modules.activiti.process.esChange.service.impl.ProcessEsChangeServiceImpl", "/workCenter/enterpriseStandardChange/enterpriseStandardChangeFlow", "/workCenter/enterpriseStandardChange/enterpriseStandardChangeFlow"),
-    ES_RECHECK("企标复审流程", 12, "com.jero.modules.activiti.process.esRecheck.service.impl.ProcessEsRecheckServiceImpl", "/workCenter/enterpriseStandardRecheck/enterpriseStandardRecheckFlow", "/workCenter/enterpriseStandardRecheck"),
-    ES_ABOLISH("企标废止流程", 13, "com.jero.modules.activiti.process.esAbolish.service.impl.ProcessEsAbolishServiceImpl", "/workCenter/enterpriseStandardAnnul/enterpriseStandardAnnulFlow", "/workCenter/enterpriseStandardAnnul"),
-    ES_ARCHIVE("企标封存流程", 14, "com.jero.modules.activiti.process.esArchive.service.impl.ProcessEsArchiveServiceImpl", "/workCenter/enterpriseStandardSealSave/enterpriseStandardSealSaveFlow", "/workCenter/enterpriseStandardSealSave"),
-    ES_ENABLE("已封存企标启用流程", 15, "com.jero.modules.activiti.process.esEnable.service.impl.ProcessEsEnableServiceImpl", "/workCenter/enterpriseStandardStartUse/enterpriseStandardStartUseFlow", "/workCenter/enterpriseStandardStartUse"),
-    ES_INSPECT_PLAN("企标稽查计划", 16, "com.jero.modules.activiti.process.esinspectplan.service.impl.EsInspectPlanFlow", "/workCenter/EnterpriseStandardInspectionPlan", "/workCenter/EnterpriseStandardInspectionPlan"),
-    ES_INSPECT("企标稽查流程", 17, "com.jero.modules.activiti.process.esinspect.service.impl.EsInspectFlow", "/workCenter/EnterpriseStandardInspectionProcess", "/workCenter/EnterpriseStandardInspectionProcess"),
-    ES_INSPECT_DELAY_APPLY("稽查延期申请流程", 18, "com.jero.modules.activiti.process.esinspectdelayapply.service.impl.EsInspectDelayApplyFlow", "/workCenter/InspectionExtensionRequestProcess", "/workCenter/InspectionExtensionRequestProcess"),
-    ES_INSPECT_REPORT("企标稽查整改", 19, "com.jero.modules.activiti.process.esinspectrectify.service.impl.EsInspectRectifyFlow", "/workCenter/EnterpriseStandardInspectionRectification", "/workCenter/EnterpriseStandardInspectionRectification"),
-    PERMISSION_APPLY_PROCESS("权限申请流程", 20, "com.jero.modules.activiti.process.espermissionapply.service.impl.EsPermissionApplyFlow", "/workCenter/PermissionApplicationProcess", "/workCenter/PermissionApplicationProcess"),
-    STANDARD_DECLARE("标准宣贯流程", 21, "com.jero.modules.activiti.process.esdeclare.service.impl.EsDeclareFlow", "/workCenter/StandardPromotionProcess", "/noMobile"),
-    MEETING_MANAGE("会后管理流程", 22, "com.jero.modules.activiti.process.meetingmanage.service.impl.MeetingManageFlow", "/workCenter/PostMeetingManageProcess", "/noMobile");
+    STANDARD_INTERPRET("标准解读流程", 2, "com.jero.modules.activiti.process.standardinterpret.service.impl.StandardInterpretFlow", "", ""),
+    ;
 
     private final String name;
     private final Integer value;

laws-modules/src/main/java/com/jero/modules/activiti/process/aspect/ProcessAspect.java

@@ -0,0 +1,373 @@
+package com.jero.modules.activiti.process.aspect;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
+import com.jero.common.constant.enums.LanguageEnum;
+import com.jero.common.exception.JeroBootException;
+import com.jero.common.system.vo.LoginUser;
+import com.jero.common.util.MessageUtils;
+import com.jero.common.util.SnowflakeUtils;
+import com.jero.modules.activiti.entity.ProcessAll;
+import com.jero.modules.activiti.entity.ProcessApprovalRecord;
+import com.jero.modules.activiti.entity.ProcessNode;
+import com.jero.modules.activiti.enums.CommitFlagEnum;
+import com.jero.modules.activiti.enums.FinishFlagEnum;
+import com.jero.modules.activiti.enums.VariableTypeEnum;
+import com.jero.modules.activiti.process.common.entity.ProcessDraft;
+import com.jero.modules.activiti.process.common.service.ProcessDraftService;
+import com.jero.modules.activiti.service.ProcessAllService;
+import com.jero.modules.activiti.service.ProcessApprovalRecordService;
+import com.jero.modules.activiti.service.ProcessNodeService;
+import com.jero.modules.activiti.util.SpringContextUtil;
+import lombok.extern.slf4j.Slf4j;
+import org.activiti.bpmn.model.Process;
+import org.activiti.bpmn.model.UserTask;
+import org.activiti.engine.HistoryService;
+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.task.Task;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.shiro.SecurityUtils;
+import org.aspectj.lang.JoinPoint;
+import org.aspectj.lang.annotation.AfterReturning;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Before;
+import org.aspectj.lang.annotation.Pointcut;
+import org.springframework.beans.BeanUtils;
+import org.springframework.core.annotation.Order;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import javax.annotation.Resource;
+import java.util.*;
+
+/**
+ * @ClassName: 流程aop
+ * @Description:
+ * @Author: yjz
+ * @Date: 2023-12-07 15:45
+ * @Version: 1.0
+ **/
+@Aspect
+@Component
+@Slf4j
+@Transactional(rollbackFor = RuntimeException.class)
+public class ProcessAspect {
+    @Resource
+    private TaskService taskService;
+    @Resource
+    private HistoryService historyService;
+    @Resource
+    private RepositoryService repositoryService;
+    @Resource
+    private ProcessApprovalRecordService processApprovalRecordService;
+    @Resource
+    private ProcessDraftService processDraftService;
+    @Resource
+    private RuntimeService runtimeService;
+    @Resource
+    private ProcessAllService processAllService;
+    @Resource
+    private ProcessNodeService processNodeService;
+    private static final String PROCESS_ALL = "processAll";
+    private static final String SAVE_BY_DRAFT = "2";
+    /**
+     * 强制撤回
+     */
+    private static final String REVOCATION = "3";
+
+
+    // 流程发起
+    @Pointcut("execution(public * com.jero.modules.activiti.process..*Controller.flowStart(..))")
+    public void processServiceFlowStart() {
+    }
+
+    // 流程保存
+    @Pointcut("execution(public * com.jero.modules.activiti.process..*Controller.flowSave(..))")
+    public void processServiceFlowSave() {
+    }
+
+    // 流程审批
+    @Pointcut("execution(public * com.jero.modules.activiti.process..*Controller.flowApproval(..))")
+    public void processServiceFlowApproval() {
+    }
+
+    // 流程转办
+    @Pointcut("execution(public * com.jero.modules.activiti.process..*Controller.flowTransfer(..))")
+    public void processServiceFlowTransfer() {
+    }
+
+    // 流程驳回
+    @Pointcut("execution(public * com.jero.modules.activiti.process..*Controller.flowReject(..))")
+    public void processServiceFlowReject() {
+    }
+
+    @Before("processServiceFlowApproval() || processServiceFlowReject()")
+    public void doBefore(JoinPoint jp) {
+        log.info("==========流程合法性校验前置方法开始==========");
+        if (!Objects.isNull(jp.getArgs())) {
+            Map<String, Objects> map = JSON.parseObject(JSON.toJSONString(jp.getArgs()[0]), Map.class);
+            Object object = map.get(PROCESS_ALL);
+            ProcessAll processAll = JSON.parseObject(JSON.toJSONString(object), ProcessAll.class);
+            if (checkTaskExistence(processAll.getTaskId())){
+                if (LanguageEnum.CN.getValue().equals(MessageUtils.getLanguage().getValue())){
+                    throw new JeroBootException("任务不存在!");
+                }else {
+                    throw new JeroBootException("The task does not exist!");
+                }
+            }
+
+            LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
+            if (!getTaskAssignee(processAll.getTaskId()).equals(loginUser.getId())){
+                if (LanguageEnum.CN.getValue().equals(MessageUtils.getLanguage().getValue())){
+                    throw new JeroBootException("非当前节点处理人!");
+                }else {
+                    throw new JeroBootException("Not the current node processor!");
+                }
+            }
+        }
+        log.info("==========流程合法性校验前置方法结束==========");
+    }
+
+    @Before("processServiceFlowReject()")
+    public void doBeforeCountersignReject(JoinPoint jp){
+        log.info("==========流程会签节点驳回一票否决前置方法开始==========");
+        if (!Objects.isNull(jp.getArgs())) {
+            Map<String, Objects> map = JSON.parseObject(JSON.toJSONString(jp.getArgs()[0]), Map.class);
+            Object object = map.get(PROCESS_ALL);
+            ProcessAll processAll = JSON.parseObject(JSON.toJSONString(object), ProcessAll.class);
+
+            Object objectMap = map.get("map");
+            Map<String, Object> stringObjectMap = JSON.parseObject(JSON.toJSONString(objectMap), Map.class);
+
+            if ((stringObjectMap.containsKey("pass") && !(boolean) stringObjectMap.get("pass")) && isMultiTask(processAll.getTaskId())){
+                // 所有会签人数
+                Integer all = (Integer) taskService.getVariable(processAll.getTaskId(), "nrOfInstances");
+                taskService.setVariable(processAll.getTaskId(), "nrOfCompletedInstances", all);
+                // 其他会签人员审批信息，更新状态为未处理
+                processApprovalRecordService.update(
+                        new LambdaUpdateWrapper<ProcessApprovalRecord>()
+                                .eq(ProcessApprovalRecord::getProcessInstanceId, processAll.getProcessInstanceId())
+                                .eq(ProcessApprovalRecord::getNodeId, processAll.getNodeId())
+                                .isNull(ProcessApprovalRecord::getEndTime)
+                                .ne(ProcessApprovalRecord::getTaskId, processAll.getTaskId())
+                                .set(ProcessApprovalRecord::getCommitText, CommitFlagEnum.UNDISPOSED.getName())
+                                .set(ProcessApprovalRecord::getFinishFlag, FinishFlagEnum.SUSPEND.getValue()));
+            }
+        }
+        log.info("==========流程会签节点驳回一票否决前置方法结束==========");
+    }
+
+    @AfterReturning("processServiceFlowReject()")
+    @Order(1)
+    public void doAfter(JoinPoint jp) {
+        log.info("==========流程驳回，若驳回到的节点之前经过转办，则驳回到转办人手里后置方法开始==========");
+        if (!Objects.isNull(jp.getArgs())) {
+            Map<String, Objects> map = JSON.parseObject(JSON.toJSONString(jp.getArgs()[0]), Map.class);
+            Object object = map.get(PROCESS_ALL);
+            ProcessAll processAll = JSON.parseObject(JSON.toJSONString(object), ProcessAll.class);
+
+            Object objectMap = map.get("map");
+            Map<String, Object> stringObjectMap = JSON.parseObject(JSON.toJSONString(objectMap), Map.class);
+            // 特殊节点排除
+            if ((stringObjectMap.containsKey("pass") && !(boolean) stringObjectMap.get("pass"))){
+                // 驳回的节点
+                List<ProcessApprovalRecord> processApprovalRecordList = processApprovalRecordService.list(
+                        new LambdaQueryWrapper<ProcessApprovalRecord>()
+                                .eq(ProcessApprovalRecord::getProcessInstanceId, processAll.getProcessInstanceId())
+                                .orderByDesc(ProcessApprovalRecord::getCreateTime));
+                if (!processApprovalRecordList.isEmpty()){
+                    ProcessApprovalRecord processApprovalRecord = processApprovalRecordList.get(0);
+                    processApprovalRecordList.remove(0);
+                    Optional<ProcessApprovalRecord> optional = processApprovalRecordList.stream().filter(v ->
+                                    v.getTaskName().equals(processApprovalRecord.getTaskName())
+                                            && v.getNodeId().equals(processApprovalRecord.getNodeId())).findFirst();
+                    optional.ifPresent(v -> {
+                        // 是否转办过
+                        if (StringUtils.isNotBlank(v.getTransferBy())){
+                            // 转办给转办人
+                            taskService.setAssignee(processApprovalRecord.getTaskId(), v.getUserId());
+                            // 更新流程审批记录表
+                            processApprovalRecordService.update(
+                                    new LambdaUpdateWrapper<ProcessApprovalRecord>()
+                                            .eq(ProcessApprovalRecord::getTaskId, processApprovalRecord.getTaskId())
+                                            .set(ProcessApprovalRecord::getUserId, v.getUserId())
+                                            .set(ProcessApprovalRecord::getOriginUserId, v.getUserId()));
+                        }
+                    });
+                }
+            }
+        }
+        log.info("==========流程驳回，若驳回到的节点之前经过转办，则驳回到转办人手里后置方法结束==========");
+    }
+
+    @AfterReturning("processServiceFlowSave() || processServiceFlowStart()")
+    public void doAfterFlowSave(JoinPoint jp) {
+        log.info("==========流程保存到草稿后置方法开始==========");
+        if (!Objects.isNull(jp.getArgs())) {
+            LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
+            Map<String, Objects> map = JSON.parseObject(JSON.toJSONString(jp.getArgs()[0]), Map.class);
+            Object processApprovalRecordObject = map.get("processApprovalRecord");
+            String infoJsonStr = String.valueOf(map.get("infoJsonStr"));
+            String saveSource = String.valueOf(map.get("saveSource"));
+            Object processAllObject = map.get(PROCESS_ALL);
+            if (!Objects.isNull(processApprovalRecordObject) && !Objects.isNull(processAllObject)){
+                ProcessApprovalRecord processApprovalRecord = JSON.parseObject(JSON.toJSONString(processApprovalRecordObject), ProcessApprovalRecord.class);
+                ProcessAll processAll = JSON.parseObject(JSON.toJSONString(processAllObject), ProcessAll.class);
+                if (StringUtils.isBlank(processAll.getNodeId()) || SAVE_BY_DRAFT.equals(saveSource)){
+                    ProcessDraft processDraft = new ProcessDraft();
+                    setProperty(loginUser, infoJsonStr, processApprovalRecord, processAll, processDraft);
+                    // 删除旧草稿
+                    processDraftService.remove(new LambdaQueryWrapper<ProcessDraft>()
+                            .eq(ProcessDraft::getProjectId, processAll.getProjectId())
+                            .eq(ProcessDraft::getUserId, loginUser.getId()));
+                    // 保存新草稿
+                    processDraftService.save(processDraft);
+
+                    // 保存新草稿(强制撤回用)
+                    processDraft.setId(String.valueOf(SnowflakeUtils.snowflake()));
+                    processDraft.setSaveSource(REVOCATION);
+                    processDraft.setInfoJsonStr(processDraft.getInfoJsonStr().replaceFirst("\\{", "{\"revocation\": true,"));
+                    processDraftService.save(processDraft);
+
+                    if (jp.getSignature().getName().equals("flowStart")){
+                        // 发起后删除草稿
+                        processDraftService.remove(new LambdaQueryWrapper<ProcessDraft>()
+                                .eq(ProcessDraft::getProjectId, processAll.getProjectId())
+                                .eq(ProcessDraft::getUserId, loginUser.getId())
+                                .and(qw -> qw.ne(ProcessDraft::getSaveSource, REVOCATION)
+                                        .or().isNull(ProcessDraft::getSaveSource)));
+                    }
+                }
+            }
+        }
+        log.info("==========流程保存到草稿后置方法结束==========");
+    }
+
+    @AfterReturning("processServiceFlowStart() || processServiceFlowApproval() || processServiceFlowReject()")
+    public void doAfterRemoveDraft(JoinPoint jp) {
+        log.info("==========流程发起、审批、驳回。删除草稿后置方法开始==========");
+        if (!Objects.isNull(jp.getArgs())) {
+            LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
+            Map<String, Objects> map = JSON.parseObject(JSON.toJSONString(jp.getArgs()[0]), Map.class);
+            Object object = map.get(PROCESS_ALL);
+            if (!Objects.isNull(object)){
+                // 发起、审批、驳回
+                ProcessAll processAll = JSON.parseObject(JSON.toJSONString(object), ProcessAll.class);
+                // 删除草稿
+                processDraftService.remove(new LambdaQueryWrapper<ProcessDraft>()
+                        .eq(ProcessDraft::getProjectId, processAll.getProjectId())
+                        .eq(ProcessDraft::getUserId, loginUser.getId())
+                        .and(qw -> qw.ne(ProcessDraft::getSaveSource, REVOCATION)
+                                .or().isNull(ProcessDraft::getSaveSource)));
+            }
+        }
+        log.info("==========流程发起、审批、驳回。删除草稿后置方法结束==========");
+    }
+
+
+    @AfterReturning("processServiceFlowTransfer()")
+    public void doAfterFlowTransfer(JoinPoint jp) {
+        log.info("==========流程转办后置方法开始==========");
+        if (!Objects.isNull(jp.getArgs())) {
+            String taskId = JSON.parseObject(JSON.toJSONString(jp.getArgs()[0]), String.class);
+            String toUserId = JSON.parseObject(JSON.toJSONString(jp.getArgs()[1]), String.class);
+            ProcessApprovalRecord processApprovalRecord = processApprovalRecordService.getToDoByTaskId(taskId);
+            String processInstanceId = processApprovalRecord.getProcessInstanceId();
+            ProcessAll processAll = processAllService.getByProcessInstanceId(processInstanceId);
+            TaskService taskService = SpringContextUtil.getBean(TaskService.class);
+            Task task = taskService.createTaskQuery().taskId(processApprovalRecord.getTaskId()).singleResult();
+            // 查询节点信息
+            ProcessNode processNode = processNodeService.getOne(
+                    new LambdaQueryWrapper<ProcessNode>()
+                            .eq(ProcessNode::getProcessDefinitionId, processAll.getProcessDefinitionId())
+                            .eq(ProcessNode::getXmlNodeId, processApprovalRecord.getNodeId()));
+            if (!Objects.isNull(processNode) && VariableTypeEnum.STRING.getName().equals(processNode.getVariableType())){
+                runtimeService.setVariable(task.getExecutionId(), processNode.getVariableName(), toUserId);
+            }
+            // 稽查延期申请流程 稽查联络人评估 节点特殊处理
+//            if (ProcessTypeEnum.ES_INSPECT_DELAY_APPLY.getValue().equals(processAll.getPrcType())
+//                    && EsInspectDelayApplyCommon.PROCESS_NODE_3.equals(processApprovalRecord.getNodeId())){
+//                LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
+//                IProcessEsInspectDelayApplyService processEsInspectDelayApplyService = SpringContextUtil.getBean(IProcessEsInspectDelayApplyService.class);
+//                processEsInspectDelayApplyService.update(
+//                        new LambdaUpdateWrapper<ProcessEsInspectDelayApply>()
+//                                .eq(ProcessEsInspectDelayApply::getProjectId, processAll.getProjectId())
+//                                .eq(ProcessEsInspectDelayApply::getLiaisons, loginUser.getId())
+//                                .set(ProcessEsInspectDelayApply::getLiaisons, toUserId));
+//            }
+        }
+        log.info("==========流程转办后置方法结束==========");
+    }
+
+    private static void setProperty(LoginUser loginUser, String infoJsonStr, ProcessApprovalRecord processApprovalRecord, ProcessAll processAll, ProcessDraft processDraft) {
+        // 属性拷贝
+        BeanUtils.copyProperties(processAll, processDraft);
+        processDraft.setCreateBy("");
+        processDraft.setId("");
+        processDraft.setUpdateBy("");
+        Date date = new Date();
+        if (Objects.isNull(processAll.getCreateTime())){
+            processDraft.setCreateTime(date);
+        }else {
+            processDraft.setCreateTime(processAll.getCreateTime());
+        }
+        processDraft.setUpdateBy("");
+        processDraft.setUpdateTime(date);
+        // 保存草稿表
+        if (com.baomidou.mybatisplus.core.toolkit.StringUtils.isNotBlank(processApprovalRecord.getCommitFile())){
+            processDraft.setHandleFile(processApprovalRecord.getCommitFile());
+        }
+        if (com.baomidou.mybatisplus.core.toolkit.StringUtils.isNotBlank(processApprovalRecord.getCommitText())){
+            processDraft.setHandleText(processApprovalRecord.getCommitText());
+        }
+        if (!Objects.isNull(processAll.getDueTime())){
+            processDraft.setProcessDueDate(processAll.getDueTime());
+        }
+        if (com.baomidou.mybatisplus.core.toolkit.StringUtils.isNotBlank(processAll.getPrcMes())){
+            processDraft.setProcessDescription(processAll.getPrcMes());
+        }
+        if (com.baomidou.mybatisplus.core.toolkit.StringUtils.isNotBlank(infoJsonStr)){
+            processDraft.setInfoJsonStr(infoJsonStr);
+        }
+        processDraft.setUserId(loginUser.getId());
+    }
+
+    /**
+     * 是否会签节点
+     * @param taskId
+     * @return
+     */
+    public boolean isMultiTask(String taskId){
+        // 根据流程实例id查询
+        Task task = taskService.createTaskQuery()
+                .taskId(taskId)
+                .singleResult();
+        // 获取流程实例对象
+        HistoricProcessInstance historicProcessInstance = historyService.createHistoricProcessInstanceQuery()
+                .processInstanceId(task.getProcessInstanceId())
+                .singleResult();
+        // 获取流程定义对象，主要用于判断流程任务结点是否为会签结点
+        Process process = repositoryService.getBpmnModel(historicProcessInstance.getProcessDefinitionId())
+                .getProcessById(historicProcessInstance.getProcessDefinitionKey());
+        // 获取当前任务结点
+        Optional<UserTask> userTask = process.getFlowElements().stream()
+                .filter(flowElement -> task.getTaskDefinitionKey().equals(flowElement.getId()))
+                .map(UserTask.class::cast)
+                .findAny();
+        return userTask.isPresent() && !Objects.isNull(userTask.get().getLoopCharacteristics());
+    }
+
+    public boolean checkTaskExistence(String taskId) {
+        Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
+        return Objects.isNull(task);
+    }
+
+    public String getTaskAssignee(String taskId) {
+        Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
+        return task.getAssignee();
+    }
+}

laws-modules/src/main/java/com/jero/modules/activiti/process/common/utility/FlowUtility.java

@@ -1,22 +1,29 @@
 package com.jero.modules.activiti.process.common.utility;
 
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.baomidou.mybatisplus.core.toolkit.StringUtils;
 import com.jero.common.exception.JeroBootException;
 import com.jero.common.system.vo.LoginUser;
+import com.jero.common.util.SnowflakeUtils;
 import com.jero.modules.activiti.entity.ProcessAll;
 import com.jero.modules.activiti.entity.ProcessApprovalRecord;
 import com.jero.modules.activiti.enums.FinishFlagEnum;
+import com.jero.modules.activiti.process.common.entity.ProcessDraft;
+import com.jero.modules.activiti.process.common.service.ProcessDraftService;
+import com.jero.modules.activiti.process.standardinterpret.vo.FlowApproveInfo;
 import com.jero.modules.activiti.service.ProcessAllService;
 import com.jero.modules.activiti.service.ProcessApprovalRecordService;
 import lombok.RequiredArgsConstructor;
 import org.apache.shiro.SecurityUtils;
+import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.util.Date;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.stream.Collectors;
 
 /**
@@ -33,6 +40,7 @@ public class FlowUtility {
 
     private final ProcessAllService processAllService;
     private final ProcessApprovalRecordService processApprovalRecordService;
+    private final ProcessDraftService processDraftService;
 
     public void flowApprovalUpdate(ProcessAll processAll, ProcessApprovalRecord processApprovalRecord){
         LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
@@ -51,6 +59,74 @@ public class FlowUtility {
                         .set(ProcessApprovalRecord::getEndTime, new Date()));
     }
 
+    public void flowSaveUpdate(ProcessAll processAll, ProcessApprovalRecord processApprovalRecord){
+        // 更新流程信息
+        processAllService.update(new LambdaUpdateWrapper<ProcessAll>()
+                .eq(ProcessAll::getId, processAll.getId())
+                .set(ProcessAll::getPrcName, processAll.getPrcName())
+                .set(ProcessAll::getPrcMes, processAll.getPrcMes())
+                .set(ProcessAll::getDueTime, processAll.getDueTime()));
+        // 更新流程审批信息
+        processApprovalRecordService.update(new LambdaUpdateWrapper<ProcessApprovalRecord>()
+                .eq(ProcessApprovalRecord::getTaskId, processAll.getTaskId())
+                .set(ProcessApprovalRecord::getCommitText, processApprovalRecord.getCommitText())
+                .set(ProcessApprovalRecord::getCommitFile, processApprovalRecord.getCommitFile()));
+    }
+
+    public FlowApproveInfo queryFlowApproveInfo(String projectId, String taskId){
+        FlowApproveInfo flowApproveInfo = new FlowApproveInfo();
+        LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
+        ProcessAll processAll = processAllService.getOne(new LambdaQueryWrapper<ProcessAll>()
+                .eq(ProcessAll::getProjectId, projectId)
+                .orderByDesc(ProcessAll::getCreateTime), false);
+        ProcessApprovalRecord processApprovalRecord = new ProcessApprovalRecord();
+        // 是否存在草稿
+        List<ProcessDraft> processDraftList = processDraftService.list(new LambdaQueryWrapper<ProcessDraft>()
+                .eq(ProcessDraft::getProjectId, projectId)
+                .eq(ProcessDraft::getUserId, loginUser.getId())
+                .and(qw -> qw.ne(ProcessDraft::getSaveSource, "3")
+                        .or().isNull(ProcessDraft::getSaveSource)));
+        if (!processDraftList.isEmpty()){
+            String id = "";
+            if(Objects.isNull(processAll)){
+                processAll = new ProcessAll();
+                id = String.valueOf(SnowflakeUtils.snowflake());
+            }else {
+                id = processAll.getId();
+            }
+            // 存在草稿
+            ProcessDraft processDraft = processDraftList.get(0);
+            // 属性拷贝
+            BeanUtils.copyProperties(processDraft, processAll);
+            processAll.setId(id);
+            if (StringUtils.isNotBlank(processDraft.getHandleFile())){
+                processApprovalRecord.setCommitFile(processDraft.getHandleFile());
+            }
+            if (StringUtils.isNotBlank(processDraft.getHandleText())){
+                processApprovalRecord.setCommitText(processDraft.getHandleText());
+            }
+            if (!Objects.isNull(processDraft.getProcessDueDate())){
+                processAll.setDueTime(processDraft.getProcessDueDate());
+            }
+            if (StringUtils.isNotBlank(processDraft.getProcessDescription())){
+                processAll.setPrcMes(processDraft.getProcessDescription());
+            }
+            if (StringUtils.isNotBlank(processDraft.getInfoJsonStr())){
+                flowApproveInfo.setInfoJsonStr(processDraft.getInfoJsonStr());
+            }
+        }else {
+            // 不存在草稿
+            processApprovalRecord = processApprovalRecordService.getOne(new LambdaQueryWrapper<ProcessApprovalRecord>()
+                            .eq(ProcessApprovalRecord::getUserId, loginUser.getId())
+                            .eq(ProcessApprovalRecord::getTaskId, taskId)
+                    , false);
+        }
+
+        flowApproveInfo.setProcessAll(processAll);
+        flowApproveInfo.setProcessApprovalRecord(processApprovalRecord);
+        return flowApproveInfo;
+    }
+
     /**
      * 将Map中值为List类型的元素转换为以逗号分隔的字符串。
      * 这样做的目的是为了简化Map的表示，尤其是当List中包含多个元素时。

laws-modules/src/main/java/com/jero/modules/activiti/process/standardinterpret/controller/StandardInterpretFlowController.java

@@ -62,6 +62,19 @@ public class StandardInterpretFlowController {
         return Result.OK(MessageUtils.getMessage(ResultCommon.OK));
     }
 
+    /**
+     * 标准解读流程-流程保存
+     * @param standardInterpretFlowDTO 标准解读流程对象
+     * @return 结果对象
+     */
+    @AutoLog(value = "标准解读流程-流程保存")
+    @ApiOperation(value="标准解读流程-流程保存", notes="标准解读流程-流程保存")
+    @PostMapping(value = "/flowSave")
+    public Result<T> flowSave(@RequestBody StandardInterpretFlowDTO standardInterpretFlowDTO) {
+        standardInterpretFlowService.flowSave(standardInterpretFlowDTO);
+        return Result.OK(MessageUtils.getMessage(ResultCommon.OK));
+    }
+
     /**
      * 标准解读流程-流程审批
      * @param standardInterpretFlowDTO 标准解读流程对象
@@ -89,6 +102,31 @@ public class StandardInterpretFlowController {
         return Result.OK(standardInterpretFlowService.queryDetail(projectId, taskId));
     }
 
+    /**
+     * 标准解读流程-驳回
+     * @param standardInterpretFlowDTO 标准解读流程对象
+     * @return 结果对象
+     */
+    @AutoLog(value = "标准解读流程-驳回")
+    @ApiOperation(value="标准解读流程-驳回", notes="标准解读流程-驳回")
+    @PostMapping(value = "/flowReject")
+    public Result<T> flowReject(@RequestBody StandardInterpretFlowDTO standardInterpretFlowDTO) {
+        standardInterpretFlowService.flowApproval(standardInterpretFlowDTO);
+        return Result.OK(MessageUtils.getMessage(ResultCommon.OK));
+    }
+
+    /**
+     * 标准解读流程-流程转办
+     * @return 结果对象
+     */
+    @AutoLog(value = "标准解读流程-流程转办")
+    @ApiOperation(value="标准解读流程-流程转办", notes="标准解读流程-流程转办")
+    @GetMapping(value = "/flowTransfer")
+    public Result<T> flowTransfer(@ApiParam("任务id") String taskId, @ApiParam("用户id") String userId) {
+        standardInterpretFlowService.flowTransfer(taskId, userId);
+        return Result.OK(MessageUtils.getMessage(ResultCommon.OK));
+    }
+
     /**
      * 标准解读流程-生成项目id
      * @return 项目id

laws-modules/src/main/java/com/jero/modules/activiti/process/standardinterpret/entity/ProcessStandardInterpretClauseSublist.java

@@ -50,9 +50,12 @@ public class ProcessStandardInterpretClauseSublist extends BaseEntity {
     /**法规注释*/
     @ApiModelProperty(value = "法规注释")
     private String regulatoryNotes;
-    /**关键词*/
-    @ApiModelProperty(value = "关键词")
+    /**涉及系统/部件）*/
+    @ApiModelProperty(value = "涉及系统/部件）")
     private String keywords;
+    /**涉及系统/部件）*/
+    @ApiModelProperty(value = "关键控制器）")
+    private String keyController;
     /**适用零部件*/
     @ApiModelProperty(value = "适用零部件")
     private String applicableComponents;

laws-modules/src/main/java/com/jero/modules/activiti/process/standardinterpret/service/StandardInterpretFlowService.java

@@ -40,6 +40,20 @@ public interface StandardInterpretFlowService {
      */
     void flowApproval(StandardInterpretFlowDTO standardInterpretFlowDTO);
 
+
+    /**
+     * 流程保存
+     * @param standardInterpretFlowDTO
+     */
+    void flowSave(StandardInterpretFlowDTO standardInterpretFlowDTO);
+
+    /**
+     * 流程转办
+     * @param taskId
+     * @param userId
+     */
+    void flowTransfer(String taskId, String userId);
+
     /**
      * 流程监听
      * @param delegateTask

laws-modules/src/main/java/com/jero/modules/activiti/process/standardinterpret/service/impl/StandardInterpretFlow.java

@@ -0,0 +1,47 @@
+package com.jero.modules.activiti.process.standardinterpret.service.impl;
+
+import com.jero.common.exception.JeroBootException;
+import com.jero.modules.activiti.entity.ProcessAll;
+import com.jero.modules.activiti.entity.ProcessApprovalRecord;
+import com.jero.modules.activiti.service.ProcessAllService;
+import com.jero.modules.activiti.service.WorkCenterService;
+import com.jero.modules.activiti.util.SpringContextUtil;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * @ClassName: EsInspectPlanFlowService
+ * @Description:
+ * @Author: yjz
+ * @Date: 2024-01-11 21:19
+ * @Version: 1.0
+ **/
+@Slf4j
+@Transactional(rollbackFor = {Exception.class, JeroBootException.class})
+@Service
+public class StandardInterpretFlow implements WorkCenterService {
+    /**
+     * 强制撤回
+     * @param processAll 流程总表
+     */
+    @Override
+    public void changeToDraft(ProcessAll processAll) {
+        // 删除业务表数据
+        ProcessAllService processAllService = SpringContextUtil.getBean(ProcessAllService.class);
+        processAllService.physicalDeleteByProjectId("process_standard_interpret", processAll.getProjectId());
+    }
+
+    /**
+     * 转办
+     * @param processAll
+     * @param processApprovalRecord
+     * @param toUserId
+     * @param userId
+     */
+    @Override
+    public void handleTransfer(ProcessAll processAll, ProcessApprovalRecord processApprovalRecord, String toUserId, String userId) {
+        ProcessAllService processAllService = SpringContextUtil.getBean(ProcessAllService.class);
+        processAllService.specialTransfer(processAll, processApprovalRecord, toUserId, userId);
+    }
+}

laws-modules/src/main/java/com/jero/modules/activiti/process/standardinterpret/service/impl/StandardInterpretFlowServiceImpl.java

@@ -16,6 +16,7 @@ import com.jero.modules.activiti.enums.FinishFlagEnum;
 import com.jero.modules.activiti.enums.ProcessStatusEnum;
 import com.jero.modules.activiti.process.common.enums.ProcessType;
 import com.jero.modules.activiti.process.common.utility.FlowUtility;
+import com.jero.modules.activiti.process.fb.service.IProcessHandleService;
 import com.jero.modules.activiti.process.standardinterpret.common.StandardInterpretCommon;
 import com.jero.modules.activiti.process.standardinterpret.controller.ProcessStandardInterpretClauseSublistController;
 import com.jero.modules.activiti.process.standardinterpret.dto.StandardInterpretDTO;
@@ -27,6 +28,7 @@ import com.jero.modules.activiti.process.standardinterpret.service.ProcessStanda
 import com.jero.modules.activiti.process.standardinterpret.service.ProcessStandardInterpretClauseSublistService;
 import com.jero.modules.activiti.process.standardinterpret.service.ProcessStandardInterpretService;
 import com.jero.modules.activiti.process.standardinterpret.service.StandardInterpretFlowService;
+import com.jero.modules.activiti.process.standardinterpret.vo.FlowApproveInfo;
 import com.jero.modules.activiti.process.standardinterpret.vo.StandardInterpretFlowVO;
 import com.jero.modules.activiti.service.ProcessAllService;
 import com.jero.modules.activiti.service.ProcessApprovalRecordService;
@@ -73,6 +75,7 @@ public class StandardInterpretFlowServiceImpl implements StandardInterpretFlowSe
     private final ProcessStandardInterpretClauseSublistService processStandardInterpretClauseSublistService;
     private final ILawsDomesticStandardService lawsDomesticStandardService;
     private final ProcessStandardInterpretClauseSublistController processStandardInterpretClauseSublist;
+    private final IProcessHandleService processHandleService;
 
     @Override
     public void flowStart(StandardInterpretFlowDTO standardInterpretFlowDTO) {
@@ -229,32 +232,150 @@ public class StandardInterpretFlowServiceImpl implements StandardInterpretFlowSe
             log.info("发起 标准解读流程（子解读人流程）");
         }else if (StandardInterpretCommon.MASTER_INTERPRET_SUMMARY.equals(taskDefinitionKey)){
             // 标准主解读汇总 合并条款
-
+            ProcessStandardInterpret processStandardInterpret = processStandardInterpretService.getOne(
+                    new LambdaQueryWrapper<ProcessStandardInterpret>()
+                            .eq(ProcessStandardInterpret::getProjectId, processAlls.getProjectId()));
+            if (!Objects.isNull(processStandardInterpret)) {
+                String id = processStandardInterpret.getId();
+                List<ProcessStandardInterpretClause> processStandardInterpretClauseList =
+                        processStandardInterpretClauseService.list(
+                                new LambdaQueryWrapper<ProcessStandardInterpretClause>()
+                                        .eq(ProcessStandardInterpretClause::getStandardInterpretId, id));
+                if (!processStandardInterpretClauseList.isEmpty()) {
+                    List<String> standardInterpretClauseIdList = processStandardInterpretClauseList.stream()
+                            .map(ProcessStandardInterpretClause::getId).collect(Collectors.toList());
+                    List<ProcessStandardInterpretClauseSublist> processStandardInterpretClauseSublistList =
+                            processStandardInterpretClauseSublistService.list(
+                                new LambdaQueryWrapper<ProcessStandardInterpretClauseSublist>()
+                                        .in(ProcessStandardInterpretClauseSublist::getStandardInterpretClauseId
+                                                , standardInterpretClauseIdList));
+                    // 根据条款分组
+                    Map<String, List<ProcessStandardInterpretClauseSublist>> listMap =
+                            processStandardInterpretClauseSublistList.stream()
+                                .collect(Collectors.groupingBy(ProcessStandardInterpretClauseSublist::getClauseId));
+                    listMap.forEach((k, v) -> {
+                        ProcessStandardInterpretClauseSublist first = v.get(0);
+                        v.remove(0);
+                        for (ProcessStandardInterpretClauseSublist standardInterpretClauseSublist : v) {
+                            // 合并
+                            first.setInterpretPersonId(first.getInterpretPersonId()
+                                    + "," + standardInterpretClauseSublist.getInterpretPersonId());
+                            first.setTranslation(first.getTranslation()
+                                    + "," + standardInterpretClauseSublist.getTranslation());
+                            first.setIsSameAsPrevVersion(first.getIsSameAsPrevVersion()
+                                    + "," + standardInterpretClauseSublist.getIsSameAsPrevVersion());
+                            first.setChangeDescription(first.getChangeDescription()
+                                    + "," + standardInterpretClauseSublist.getChangeDescription());
+                            first.setRegulatoryNotes(first.getRegulatoryNotes()
+                                    + "," + standardInterpretClauseSublist.getRegulatoryNotes());
+                            first.setKeywords(first.getKeywords()
+                                    + "," + standardInterpretClauseSublist.getKeywords());
+                            first.setKeyController(first.getKeyController()
+                                    + "," + standardInterpretClauseSublist.getKeyController());
+                            first.setApplicableComponents(first.getApplicableComponents()
+                                    + "," + standardInterpretClauseSublist.getApplicableComponents());
+                            first.setRelatedDepartment(first.getRelatedDepartment()
+                                    + "," + standardInterpretClauseSublist.getRelatedDepartment());
+                            first.setResponsibleModule(first.getResponsibleModule()
+                                    + "," + standardInterpretClauseSublist.getResponsibleModule());
+                            first.setRelatedModule(first.getRelatedModule()
+                                    + "," + standardInterpretClauseSublist.getRelatedModule());
+                            first.setApplications(first.getApplications()
+                                    + "," + standardInterpretClauseSublist.getApplications());
+                            first.setPowerType(first.getPowerType()
+                                    + "," + standardInterpretClauseSublist.getPowerType());
+                            first.setDomainArea(first.getDomainArea()
+                                    + "," + standardInterpretClauseSublist.getDomainArea());
+                            first.setConfigurationRequirements(first.getConfigurationRequirements()
+                                    + "," + standardInterpretClauseSublist.getConfigurationRequirements());
+                            first.setNewCerImplementDate(first.getNewCerImplementDate()
+                                    + "," + standardInterpretClauseSublist.getNewCerImplementDate());
+                            first.setNewCerImplementDate(first.getNewCerImplementDate()
+                                    + "," + standardInterpretClauseSublist.getNewCerImplementDate());
+                            first.setEnterpriseStandard(first.getEnterpriseStandard()
+                                    + "," + standardInterpretClauseSublist.getEnterpriseStandard());
+                            first.setTechnicalSpecificationDesignGuide(first.getTechnicalSpecificationDesignGuide()
+                                    + "," + standardInterpretClauseSublist.getTechnicalSpecificationDesignGuide());
+                            first.setDrawingTemplate(first.getDrawingTemplate()
+                                    + "," + standardInterpretClauseSublist.getDrawingTemplate());
+                            first.setTechnicalAgreementTemplate(first.getTechnicalAgreementTemplate()
+                                    + "," + standardInterpretClauseSublist.getTechnicalAgreementTemplate());
+                            first.setVerificationReportTemplateChecklist(first.getVerificationReportTemplateChecklist()
+                                    + "," + standardInterpretClauseSublist.getVerificationReportTemplateChecklist());
+                            first.setDvpTemplate(first.getDvpTemplate()
+                                    + "," + standardInterpretClauseSublist.getDvpTemplate());
+                            first.setDfema(first.getDfema()
+                                    + "," + standardInterpretClauseSublist.getDfema());
+                            first.setKeyTechnologyDecompositionTable(first.getKeyTechnologyDecompositionTable()
+                                    + "," + standardInterpretClauseSublist.getKeyTechnologyDecompositionTable());
+                            first.setOtherDocumentsTemplates(first.getOtherDocumentsTemplates()
+                                    + "," + standardInterpretClauseSublist.getOtherDocumentsTemplates());
+                            first.setP3(first.getP3()
+                                    + "," + standardInterpretClauseSublist.getP3());
+                            first.setP5(first.getP5()
+                                    + "," + standardInterpretClauseSublist.getP5());
+                            first.setRemarks(first.getRemarks()
+                                    + "," + standardInterpretClauseSublist.getRemarks());
+                            processStandardInterpretClauseSublistService
+                                    .removeById(standardInterpretClauseSublist.getId());
+                        }
+                        // 去重
+                        distinct(first);
+                    });
+                }
+            }
         }
         log.info("标准解读流程-流程监听器 结束");
     }
 
+    private void distinct(ProcessStandardInterpretClauseSublist data) {
+        data.setKeywords(toDistinct(data.getKeywords()));
+        data.setKeyController(toDistinct(data.getKeyController()));
+        data.setIsSameAsPrevVersion(toDistinct(data.getIsSameAsPrevVersion()));
+        data.setResponsibleDepartment(toDistinct(data.getResponsibleDepartment()));
+        data.setResponsibleModule(toDistinct(data.getResponsibleModule()));
+        data.setRelatedDepartment(toDistinct(data.getResponsibleDepartment()));
+        data.setRelatedModule(toDistinct(data.getRelatedModule()));
+        data.setApplications(toDistinct(data.getApplications()));
+        data.setPowerType(toDistinct(data.getPowerType()));
+        data.setDomainArea(toDistinct(data.getDomainArea()));
+        data.setConfigurationRequirements(toDistinct(data.getConfigurationRequirements()));
+        data.setNewCerImplementDate(toDistinct(data.getNewCerImplementDate()));
+        data.setNewProductionImplementation(toDistinct(data.getNewProductionImplementation()));
+        data.setEnterpriseStandard(toDistinct(data.getEnterpriseStandard()));
+        data.setTechnicalSpecificationDesignGuide(toDistinct(data.getTechnicalSpecificationDesignGuide()));
+        data.setDrawingTemplate(toDistinct(data.getDrawingTemplate()));
+        data.setTechnicalAgreementTemplate(toDistinct(data.getTechnicalAgreementTemplate()));
+        data.setVerificationReportTemplateChecklist(toDistinct(data.getVerificationReportTemplateChecklist()));
+        data.setDvpTemplate(toDistinct(data.getDvpTemplate()));
+        data.setDfema(toDistinct(data.getDfema()));
+        data.setKeyTechnologyDecompositionTable(toDistinct(data.getKeyTechnologyDecompositionTable()));
+        data.setOtherDocumentsTemplates(toDistinct(data.getOtherDocumentsTemplates()));
+        data.setP3(toDistinct(data.getP3()));
+        data.setP5(toDistinct(data.getP5()));
+    }
+
+    private static String toDistinct(String str) {
+        if (StringUtils.isNotBlank(str)){
+            List<String> list = Arrays.asList(str.split(","));
+            return list.stream().distinct().collect(Collectors.joining(","));
+        }
+        return "";
+    }
+
     @Override
     public StandardInterpretFlowVO queryDetail(String projectId, String taskId) {
         StandardInterpretFlowVO standardInterpretFlowVO = new StandardInterpretFlowVO();
-        LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
 
         // 查询流程信息
-        ProcessAll processAll = processAllService.getOne(
-                new LambdaQueryWrapper<ProcessAll>()
-                    .eq(ProcessAll::getProjectId, projectId)
-                    .orderByDesc(ProcessAll::getCreateTime), false);
-        standardInterpretFlowVO.setProcessAll(processAll);
-
-        // 查询流程审批信息
-        ProcessApprovalRecord processApprovalRecord = processApprovalRecordService.getOne(
-                new LambdaQueryWrapper<ProcessApprovalRecord>()
-                    .eq(ProcessApprovalRecord::getUserId, loginUser.getId())
-                    .eq(ProcessApprovalRecord::getTaskId, taskId), false);
-        standardInterpretFlowVO.setProcessApprovalRecord(processApprovalRecord);
+        FlowApproveInfo flowApproveInfo = flowUtility.queryFlowApproveInfo(projectId, taskId);
+        standardInterpretFlowVO.setProcessAll(flowApproveInfo.getProcessAll());
+        standardInterpretFlowVO.setProcessApprovalRecord(flowApproveInfo.getProcessApprovalRecord());
 
         // 查询业务信息
-        standardInterpretFlowVO.setData(queryBusinessData(processAll, processApprovalRecord));
+        StandardInterpretDTO data = queryBusinessData(flowApproveInfo.getProcessAll(),
+                flowApproveInfo.getProcessApprovalRecord());
+        standardInterpretFlowVO.setData(data);
         return standardInterpretFlowVO;
     }
 
@@ -323,6 +444,20 @@ public class StandardInterpretFlowServiceImpl implements StandardInterpretFlowSe
                 .list();
     }
 
+    @Override
+    public void flowSave(StandardInterpretFlowDTO standardInterpretFlowDTO) {
+        // 处理业务数据
+        handleBusinessData(standardInterpretFlowDTO);
+        // 保存流程信息
+        flowUtility.flowSaveUpdate(standardInterpretFlowDTO.getProcessAll(),
+                standardInterpretFlowDTO.getProcessApprovalRecord());
+    }
+
+    @Override
+    public void flowTransfer(String taskId, String userId) {
+        processHandleService.transfer(taskId, userId);
+    }
+
     private void handleBusinessData(StandardInterpretFlowDTO standardInterpretFlowDTO) {
         // map（参数）
         Map<String, Object> map = standardInterpretFlowDTO.getMap();
@@ -403,7 +538,7 @@ public class StandardInterpretFlowServiceImpl implements StandardInterpretFlowSe
                     // 设置未分配数量
                     map.put(StandardInterpretCommon.UNALLOCATED_QUANTITY, unallocatedQuantity);
                     // 设置子解读人
-                    map.put(StandardInterpretCommon.INTERPRETING_PEOPLE, interpretPersonIdList);
+                    map.put(StandardInterpretCommon.INTERPRETING_PEOPLE, new ArrayList<>(interpretPersonIdList));
                     processStandardInterpretClauseSublistService.saveBatch(processStandardInterpretClauseSublists);
                 }else {
                     // 不分发

laws-modules/src/main/java/com/jero/modules/activiti/process/standardinterpret/vo/FlowApproveInfo.java

@@ -0,0 +1,28 @@
+package com.jero.modules.activiti.process.standardinterpret.vo;
+
+import com.jero.modules.activiti.entity.ProcessAll;
+import com.jero.modules.activiti.entity.ProcessApprovalRecord;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+/**
+ * @ClassName: FlowApproveInfo
+ * @Description:
+ * @Author: yjz
+ * @Date: 2024-07-05 11:02
+ * @Version: 1.0
+ **/
+@Data
+public class FlowApproveInfo {
+    /**流程信息*/
+    @ApiModelProperty(value = "流程信息")
+    private ProcessAll processAll;
+
+    /**流程审批信息*/
+    @ApiModelProperty(value = "流程审批信息")
+    private ProcessApprovalRecord processApprovalRecord;
+
+    /**草稿信息json字符串*/
+    @ApiModelProperty(value = "草稿信息json字符串")
+    private String infoJsonStr;
+}