[Feature] 工单增加 挂起、激活、终止 操作 V1.1

approve-core-service/src/main/java/com/dragonsoft/dcuc/approve/business/impl/ApproveBusinessImpl.java

@@ -11,17 +11,20 @@ import com.dragoninfo.dcuc.common.utils.ResponseUtil;
 import com.dragonsoft.approve.common.ErrorCode;
 import com.dragonsoft.dcuc.approve.business.IApproveBaseBusiness;
 import com.dragonsoft.dcuc.approve.business.IApproveBusiness;
-import com.dragonsoft.dcuc.approve.business.external.IDcucAuthBusiness;
 import com.dragonsoft.dcuc.approve.business.IWorkFlowBusiness;
+import com.dragonsoft.dcuc.approve.business.external.IDcucAuthBusiness;
 import com.dragonsoft.dcuc.approve.constants.ApproveConstants;
-import com.dragonsoft.dcuc.approve.model.dto.ApprovalInfoDTO;
-import com.dragonsoft.dcuc.approve.model.dto.ContentRespDTO;
-import com.dragonsoft.dcuc.approve.model.dto.ResourceInfoDTO;
 import com.dragonsoft.dcuc.approve.enumresources.ApproveWorkFlowOperationEnum;
 import com.dragonsoft.dcuc.approve.enumresources.CandidateTypeEnum;
 import com.dragonsoft.dcuc.approve.enumresources.FlowTypeEnum;
 import com.dragonsoft.dcuc.approve.enumresources.PageTypeEnum;
-import com.dragonsoft.dcuc.approve.model.*;
+import com.dragonsoft.dcuc.approve.model.ApproveActHiTask;
+import com.dragonsoft.dcuc.approve.model.ApproveActRunIdentityLink;
+import com.dragonsoft.dcuc.approve.model.ApproveActRunTask;
+import com.dragonsoft.dcuc.approve.model.ApproveRecordInfo;
+import com.dragonsoft.dcuc.approve.model.dto.ApprovalInfoDTO;
+import com.dragonsoft.dcuc.approve.model.dto.ContentRespDTO;
+import com.dragonsoft.dcuc.approve.model.dto.ResourceInfoDTO;
 import com.dragonsoft.dcuc.approve.model.req.AppFunctionResourceNameReqVO;
 import com.dragonsoft.dcuc.approve.model.req.AppFunctionResourceReqVO;
 import com.dragonsoft.dcuc.approve.model.req.ResourceInfoReqVO;
@@ -40,7 +43,11 @@ import com.dragonsoft.duceap.base.enums.BooleanEnum;
 import com.dragonsoft.duceap.base.exception.ApplicationException;
 import com.dragonsoft.duceap.commons.util.date.DateConst;
 import com.dragonsoft.duceap.commons.util.date.DateUtils;
-import com.dragonsoft.duceap.duwf.api.model.*;
+import com.dragonsoft.duceap.duwf.api.model.CandidateVo;
+import com.dragonsoft.duceap.duwf.api.model.ProcessInstanceVO;
+import com.dragonsoft.duceap.duwf.api.model.TaskHistoryDetailVo;
+import com.dragonsoft.duceap.duwf.api.model.WorkflowProcessVo;
+import com.dragonsoft.duceap.duwf.api.model.WorkflowProcesstypeVo;
 import com.dragonsoft.duceap.workflow.client.WorkflowClientFactory;
 import com.dragonsoft.duceap.workflow.enums.WorkFlowOprationEnum;
 import com.fasterxml.jackson.core.JsonProcessingException;
@@ -51,7 +58,15 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 import javax.validation.constraints.NotBlank;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
 import java.util.stream.Collectors;
 
 /**
@@ -84,7 +99,6 @@ public class ApproveBusinessImpl implements IApproveBusiness {
 
     private IApproveBaseBusiness approveBaseBusiness;
 
-
     @Autowired
     public void setApproveBaseBusiness(IApproveBaseBusiness approveBaseBusiness) {
         this.approveBaseBusiness = approveBaseBusiness;
@@ -147,13 +161,13 @@ public class ApproveBusinessImpl implements IApproveBusiness {
         log.info("====获取到的待办任务为:{}====", approveActRunTask == null ? "null" : JSONObject.toJSONString(approveActRunTask));
         if (approveActRunTask != null) {
             log.info("====step1: 在待办表中删除当前结点的待办信息====");
-            //step1: 删除当前结点
+            // step1: 删除当前结点
             approveActRunTask.setDeleted(BooleanEnum.TRUE.getValue());
             approveActRunTask.setOperateType(workFlowOperationEnum.getValue());
             // 使用@TableLogic需要使用Delete才能删除
             String approveActRunTaskId = approveActRunTask.getId();
             approveActRunTaskService.deleteById(approveActRunTaskId);
-            //step2: 把当前代办写入已办
+            // step2: 把当前代办写入已办
             log.info("====step2: 把当前代办写入已办====");
             ApproveActHiTask actHiTask = new ApproveActHiTask();
             BeanUtil.copyProperties(approveActRunTask, actHiTask);
@@ -163,7 +177,7 @@ public class ApproveBusinessImpl implements IApproveBusiness {
             actHiTask.setOperateUserName(operateUserName);
             approveActHiTaskService.save(actHiTask);
             log.info("====step2: 生成新的待办====");
-            //step3: 生成新的待办
+            // step3: 生成新的待办
             if (CollectionUtils.isNotEmpty(taskRunDetailVos)) {
                 for (TaskHistoryDetailVo todoTask : taskRunDetailVos) {
                     ApproveActRunTask newApproveActRunTask = new ApproveActRunTask();
@@ -174,7 +188,11 @@ public class ApproveBusinessImpl implements IApproveBusiness {
                     newApproveActRunTask.setTaskCode(todoTask.getTaskCode());
                     newApproveActRunTask.setId(null);
                     approveActRunTaskService.save(newApproveActRunTask);
-                    //待办人员列表
+                    // 待办人员列表
+                    if (ApproveWorkFlowOperationEnum.SUSPEND.getValue().equals(newApproveActRunTask.getOperateType()) ||
+                            ApproveWorkFlowOperationEnum.ACTIVATE.getValue().equals(newApproveActRunTask.getOperateType())) {
+                        continue;
+                    }
                     List<ApproveActRunIdentityLink> links = this.buildActIdentityLink(todoTask);
                     for (ApproveActRunIdentityLink approveActRunIdentityLink : links) {
                         approveActRunIdentityLinkService.save(approveActRunIdentityLink);
@@ -238,20 +256,19 @@ public class ApproveBusinessImpl implements IApproveBusiness {
         }
     }
 
-
     /**
      * 流程开启生成待办，已办
      * 第一个节点提交的时候没有对应的已办事项
      *
      * @param processInstanceVO 实例信息
-     * @param approvalInfoDTO      审批信息
+     * @param approvalInfoDTO   审批信息
      */
     @Override
     public void createTodoAfterProcessStart(ProcessInstanceVO processInstanceVO, ApprovalInfoDTO approvalInfoDTO) {
         Date now = new Date();
         List<TaskHistoryDetailVo> taskRunDetailVos = processInstanceVO.getTaskRunDetailVos();
         for (TaskHistoryDetailVo taskHistoryDetailVo : taskRunDetailVos) {
-            //待办
+            // 待办
             ApproveActRunTask approveActRunTask = new ApproveActRunTask();
             approveActRunTask.setTaskId(taskHistoryDetailVo.getId());
             approveActRunTask.setApplyRecordId(approvalInfoDTO.getId());
@@ -265,7 +282,7 @@ public class ApproveBusinessImpl implements IApproveBusiness {
             approveActRunTask.setTaskName(taskHistoryDetailVo.getName());
             approveActRunTask.setProcessTitle(approvalInfoDTO.getProcessTitle());
             approveActRunTaskService.save(approveActRunTask);
-            //联系人
+            // 联系人
             List<ApproveActRunIdentityLink> links = this.buildActIdentityLink(taskHistoryDetailVo);
             for (ApproveActRunIdentityLink approveActRunIdentityLink : links) {
                 approveActRunIdentityLinkService.save(approveActRunIdentityLink);
@@ -366,7 +383,6 @@ public class ApproveBusinessImpl implements IApproveBusiness {
         return ResponseStatus.success();
     }
 
-
     @Override
     public List<BatchTaskOperateRespVO> batchTaskOperate(List<String> approveNoList, PageTypeEnum pageTypeEnum) {
         List<BatchTaskOperateRespVO> taskOperateRespVOList = new ArrayList<>(approveNoList.size());
@@ -531,7 +547,7 @@ public class ApproveBusinessImpl implements IApproveBusiness {
 
     @Override
     public String getUnOperateUsers(String currentTaskId) {
-        //设置当前任务ID
+        // 设置当前任务ID
         StringBuilder unOperator = new StringBuilder();
         if (StringUtils.isNotEmpty(currentTaskId) && !ApproveConstants.END_STR.equalsIgnoreCase(currentTaskId)) {
             String[] tasks = currentTaskId.split(StrUtil.COMMA);
@@ -564,10 +580,9 @@ public class ApproveBusinessImpl implements IApproveBusiness {
         return string;
     }
 
-
     @Override
     public Boolean isKxPeople(String idCard) {
-        //默认非科信人员
+        // 默认非科信人员
         boolean kxPeople = false;
         String kxList = approveProperties.getKxPeopleList();
         log.info("config kxList is :{}", kxList);
@@ -576,7 +591,7 @@ public class ApproveBusinessImpl implements IApproveBusiness {
         }
         String[] users = kxList.split(StrUtil.COMMA);
         for (String user : users) {
-            //判断当前身份证号是否为科信人员
+            // 判断当前身份证号是否为科信人员
             if (idCard.equalsIgnoreCase(user)) {
                 kxPeople = true;
                 break;
@@ -585,7 +600,6 @@ public class ApproveBusinessImpl implements IApproveBusiness {
         return kxPeople;
     }
 
-
     /**
      * 设置流程信息
      *
@@ -595,10 +609,10 @@ public class ApproveBusinessImpl implements IApproveBusiness {
     public void setProcessInfo(ApprovalInfoDTO approvalInfoDTO) {
         // 处理结束时间
         approvalInfoDTO.setEndTime(approveBaseBusiness.parseEndTime(approvalInfoDTO.getEndTime()));
-        //获取流程类型详情
+        // 获取流程类型详情
         WorkflowProcesstypeVo workflowProcesstypeVo;
         try {
-            //调用工作流获取流程类型详情
+            // 调用工作流获取流程类型详情
             workflowProcesstypeVo = workFlowBusiness.queryProcessType(approvalInfoDTO.getProcessType());
         } catch (ApplicationException e) {
             log.info("流程类型标识码-Exception：【{}】", approvalInfoDTO.getProcessType());
@@ -609,7 +623,7 @@ public class ApproveBusinessImpl implements IApproveBusiness {
             throw new ApplicationException(ErrorCode.WORKFLOW_TYPE_NOT_EXIST.getCode(), ErrorCode.WORKFLOW_TYPE_NOT_EXIST.getMsg());
         }
         approvalInfoDTO.setProcessTypeName(workflowProcesstypeVo.getName());
-        //获取流程信息
+        // 获取流程信息
         @NotBlank String businessCode = approvalInfoDTO.getBusinessCode();
         WorkflowProcessVo workflowProcessVo = workFlowBusiness.queryWorkflowProcessByBusinessCode(businessCode);
         if (null == workflowProcessVo) {
@@ -621,7 +635,7 @@ public class ApproveBusinessImpl implements IApproveBusiness {
         String processTitle = approvalInfoDTO.getProcessTitle();
         // 判断是否有流程标题，否则生成新的标题
         if (StrUtil.isBlank(processTitle)) {
-            //流程标题
+            // 流程标题
             processTitle = approvalInfoDTO.getProcessName() + "-" + approvalInfoDTO.getApplicantName() +
                     "-" + DateUtils.getTimeStr(approvalInfoDTO.getCreateTime(), DateConst.HYPHEN_DISPLAY_DATE);
             approvalInfoDTO.setProcessTitle(processTitle);
@@ -645,7 +659,7 @@ public class ApproveBusinessImpl implements IApproveBusiness {
             if (ApproveConstants.END_STR.equalsIgnoreCase(taskId)) {
                 return approvalInfoRespVo;
             }
-            //查询当前任务详情
+            // 查询当前任务详情
             TaskHistoryDetailVo taskDetailVo = workflowClientFactory.getWorkflowTaskClient().queryTaskDetail(taskId);
             if (taskDetailVo == null) {
                 return approvalInfoRespVo;
@@ -660,7 +674,6 @@ public class ApproveBusinessImpl implements IApproveBusiness {
         return approvalInfoRespVo;
     }
 
-
     /**
      * 根据未操作人map获取字符串
      *
@@ -674,15 +687,15 @@ public class ApproveBusinessImpl implements IApproveBusiness {
         if (candidateVo.getCandidateUsers() != null) {
             result.putAll(candidateVo.getCandidateUsers());
         }
-        //处理人为机构
+        // 处理人为机构
         if (candidateVo.getCandidateGroupsOrg() != null) {
             result.putAll(candidateVo.getCandidateGroupsOrg());
         }
-        //处理人为角色
+        // 处理人为角色
         if (candidateVo.getCandidateGroups() != null) {
             result.putAll(candidateVo.getCandidateGroups());
         }
-        //处理人为具体人员
+        // 处理人为具体人员
         if (candidateVo.getAssignee() != null) {
             result.putAll(candidateVo.getAssignee());
         }
@@ -740,7 +753,6 @@ public class ApproveBusinessImpl implements IApproveBusiness {
         approvalInfoDTO.setUpdateUser(ProofsUtil.getIdcard());
     }
 
-
     @Override
     public void setResourceInfoData(ApproveRecordInfo approveRecordInfo, ResourceInfoDTO resourceInfoDTO) {
         Map<String, String> accessResources = new HashMap<>(1);

approve-core-service/src/main/java/com/dragonsoft/dcuc/approve/business/impl/ApproveCommonBusinessImpl.java

@@ -11,23 +11,50 @@ import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
 import com.baomidou.mybatisplus.core.toolkit.StringUtils;
 import com.dragoninfo.dcuc.common.utils.ResponseUtil;
 import com.dragoninfo.dcuc.duceap.enums.ManageDisposeTypeEnum;
-import com.dragonsoft.dcuc.approve.business.*;
+import com.dragonsoft.dcuc.approve.business.IApproveBaseBusiness;
+import com.dragonsoft.dcuc.approve.business.IApproveBusiness;
+import com.dragonsoft.dcuc.approve.business.IApproveCommonBusiness;
+import com.dragonsoft.dcuc.approve.business.IApproveLogBusiness;
+import com.dragonsoft.dcuc.approve.business.IWorkFlowBusiness;
 import com.dragonsoft.dcuc.approve.business.external.IDcucAuthBusiness;
 import com.dragonsoft.dcuc.approve.constants.ApproveConstants;
-import com.dragonsoft.dcuc.approve.enumresources.*;
+import com.dragonsoft.dcuc.approve.enumresources.ApproveResultEnum;
+import com.dragonsoft.dcuc.approve.enumresources.ApproveWorkFlowOperationEnum;
+import com.dragonsoft.dcuc.approve.enumresources.ApproveWorkFlowTaskStateEnum;
+import com.dragonsoft.dcuc.approve.enumresources.CommitTypeEnum;
+import com.dragonsoft.dcuc.approve.enumresources.FlowTypeEnum;
+import com.dragonsoft.dcuc.approve.enumresources.OperateOptionEnum;
+import com.dragonsoft.dcuc.approve.enumresources.PermissionValidTypeEnum;
 import com.dragonsoft.dcuc.approve.event.ApproveEventPublish;
 import com.dragonsoft.dcuc.approve.model.ApproveCirculationInfo;
 import com.dragonsoft.dcuc.approve.model.ApproveRecordInfo;
 import com.dragonsoft.dcuc.approve.model.TaskAssignRecord;
-import com.dragonsoft.dcuc.approve.model.dto.*;
+import com.dragonsoft.dcuc.approve.model.dto.ApprovalInfoDTO;
+import com.dragonsoft.dcuc.approve.model.dto.ApproveMessageInfoDTO;
+import com.dragonsoft.dcuc.approve.model.dto.BaseOperateReqDTO;
+import com.dragonsoft.dcuc.approve.model.dto.ContentRespDTO;
+import com.dragonsoft.dcuc.approve.model.dto.LogDto;
+import com.dragonsoft.dcuc.approve.model.dto.OperateReqDTO;
+import com.dragonsoft.dcuc.approve.model.dto.ResourceInfoDTO;
+import com.dragonsoft.dcuc.approve.model.dto.TaskRequestUserInfoDTO;
 import com.dragonsoft.dcuc.approve.model.req.AgentReqVO;
 import com.dragonsoft.dcuc.approve.model.req.ApprovalInfoReqVO;
 import com.dragonsoft.dcuc.approve.model.req.ApprovalInfoUpdateReqVO;
 import com.dragonsoft.dcuc.approve.model.req.ResourceInfoReqVO;
-import com.dragonsoft.dcuc.approve.model.resp.*;
+import com.dragonsoft.dcuc.approve.model.resp.ApprovalInfoRespVO;
+import com.dragonsoft.dcuc.approve.model.resp.ApproveCommentVo;
+import com.dragonsoft.dcuc.approve.model.resp.OperateRespVO;
+import com.dragonsoft.dcuc.approve.model.resp.ProcessStatusDetailVo;
+import com.dragonsoft.dcuc.approve.model.resp.ProcessStatusVo;
+import com.dragonsoft.dcuc.approve.model.resp.TaskOutgoingVo;
+import com.dragonsoft.dcuc.approve.model.resp.TaskVo;
 import com.dragonsoft.dcuc.approve.model.vo.ApproveTaskRequestVo;
 import com.dragonsoft.dcuc.approve.properties.ApproveProperties;
-import com.dragonsoft.dcuc.approve.service.*;
+import com.dragonsoft.dcuc.approve.service.IApproveActHiTaskService;
+import com.dragonsoft.dcuc.approve.service.IApproveActRunTaskService;
+import com.dragonsoft.dcuc.approve.service.IApproveCirculationService;
+import com.dragonsoft.dcuc.approve.service.IApproveRecordService;
+import com.dragonsoft.dcuc.approve.service.ITaskAssignRecordService;
 import com.dragonsoft.dcuc.approve.utils.ProofsUtil;
 import com.dragonsoft.duceap.base.entity.http.ResponseDTO;
 import com.dragonsoft.duceap.base.entity.http.ResponseStatus;
@@ -41,7 +68,13 @@ import com.dragonsoft.duceap.commons.util.enums.EnumUtils;
 import com.dragonsoft.duceap.commons.util.json.JsonUtils;
 import com.dragonsoft.duceap.core.search.Searchable;
 import com.dragonsoft.duceap.core.search.enums.SearchOperator;
-import com.dragonsoft.duceap.duwf.api.model.*;
+import com.dragonsoft.duceap.duwf.api.model.ActivitiHolder;
+import com.dragonsoft.duceap.duwf.api.model.ApproveMessage;
+import com.dragonsoft.duceap.duwf.api.model.ProcessInstanceVO;
+import com.dragonsoft.duceap.duwf.api.model.TaskHistoryDetailVo;
+import com.dragonsoft.duceap.duwf.api.model.TaskRequest;
+import com.dragonsoft.duceap.duwf.api.model.TransMessage;
+import com.dragonsoft.duceap.duwf.api.model.WorkflowRequestData;
 import com.dragonsoft.duceap.workflow.client.WorkflowClientFactory;
 import com.dragonsoft.duceap.workflow.enums.WorkFlowOprationEnum;
 import org.slf4j.Logger;
@@ -55,9 +88,19 @@ import org.springframework.transaction.annotation.Transactional;
 import javax.validation.Valid;
 import javax.validation.constraints.NotBlank;
 import javax.validation.constraints.NotNull;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Date;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
 import java.util.stream.Collectors;
 
+import static com.dragonsoft.dcuc.approve.constants.ApproveConstants.END_STR;
+
 /**
  * 代码千万行,注释第一行,编码不规范,同事两行泪
  *
@@ -170,15 +213,15 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
 
     @Override
     public Page<TaskVo> queryApproveList(Searchable searchable) {
-        //获取当前查询条件的状态值
+        // 获取当前查询条件的状态值
         String state = searchable.getSearchFilterByKey("state_eq").getValue().toString();
         searchable.removeSearchFilter("state", SearchOperator.eq);
         ApproveWorkFlowTaskStateEnum approveWorkFlowTaskStateEnum = EnumUtils.enumOf(ApproveWorkFlowTaskStateEnum.class, state);
         if (ApproveWorkFlowTaskStateEnum.FINISH.equals(approveWorkFlowTaskStateEnum)) {
-            //已办列表
+            // 已办列表
             return approveActHiTaskService.buildApproveActHiTask(searchable);
         } else {
-            //待办列表
+            // 待办列表
             return approveActRunTaskService.buildApproveActRunTask(searchable);
         }
     }
@@ -202,7 +245,7 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
         try {
             logger.info("====开始处理表单提交,data:{}====", JSONObject.toJSONString(approvalInfoReqVO));
 
-            //构建ApprovalInfo对象
+            // 构建ApprovalInfo对象
             approvalInfoDTO = buildApprovalInfo(approvalInfoReqVO);
             // 设置流程相关信息
             approveBusiness.setProcessInfo(approvalInfoDTO);
@@ -218,7 +261,7 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
                 ContentRespDTO contentRespDTO = approveBusiness.generalContentRespVO(flowTypeEnum, resourceInfoDTO);
                 approvalInfoDTO.setApplyContent(JSON.toJSONString(contentRespDTO));
             }
-            //构建ApprovalResourceInfo资源对象
+            // 构建ApprovalResourceInfo资源对象
             // 生成审批单号
             String approveNo = approvalInfoReqVO.getApproveTaskId();
             if (StrUtil.isBlank(approveNo)) {
@@ -227,23 +270,23 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
                 approveNo = approveBaseBusiness.buildApproveNo(appCode, applicantOrgCode);
             }
 
-            //判断是否需要提交，创建流程
+            // 判断是否需要提交，创建流程
             String operateType = approvalInfoReqVO.getOperateType();
             CommitTypeEnum commitTypeEnum = EnumUtils.enumOf(CommitTypeEnum.class, operateType);
             if (CommitTypeEnum.APPLY_COMMIT.equals(commitTypeEnum)) {
-                //创建流程
+                // 创建流程
                 logger.info("===开始提交=====");
-                //构建ApproveTaskRequestVo，用于工作流给待办中心发送消息，需设置业务类型和业务id，因工作流对接多方应用且都需要给待办发消息
+                // 构建ApproveTaskRequestVo，用于工作流给待办中心发送消息，需设置业务类型和业务id，因工作流对接多方应用且都需要给待办发消息
                 ApproveTaskRequestVo approveTaskRequestVo = this.buildTaskRequestVo(approvalInfoDTO);
                 String flowType = approvalInfoReqVO.getFlowType();
                 approveTaskRequestVo.setFlowType(flowType);
-                //构建工作流申请的taskRequest对象
+                // 构建工作流申请的taskRequest对象
                 TaskRequest<ApproveTaskRequestVo> taskRequest = new TaskRequest<>();
-                //设置自定义对象ApproveTaskRequestVo
+                // 设置自定义对象ApproveTaskRequestVo
                 taskRequest.setData(approveTaskRequestVo);
                 String userId = approvalInfoDTO.getApplicantIdcard();
                 logger.info("===提交的用户是:{}===", userId);
-                //调用工作流创建流程
+                // 调用工作流创建流程
                 processInstanceVO = workflowClientFactory.getWorkflowTaskClient().startTaskByCode(approvalInfoReqVO.getBusinessCode(),
                         "", taskRequest, userId);
                 String processInstanceId = processInstanceVO.getProcessInstanceId();
@@ -251,7 +294,7 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
 
                 approvalInfoDTO.setProcessInstanceId(processInstanceId);
 
-                //流程开启后生成待办(刚开启的节点没有已办事宜)
+                // 流程开启后生成待办(刚开启的节点没有已办事宜)
                 approveBusiness.createTodoAfterProcessStart(processInstanceVO, approvalInfoDTO);
 
                 TaskRequestUserInfoDTO taskRequestUserInfoDTO = new TaskRequestUserInfoDTO();
@@ -263,9 +306,9 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
                 ResourceInfoDTO resourceInfoDTO = ResourceInfoDTO.parseResourceInfoReqVO(resourceInfoReqVO);
                 OperateRespVO operateRespVO = dcucAuthBusiness.checkHitRedList(applicantIdcard, flowTypeEnum, resourceInfoDTO);
 
-                //构建流转的taskRequest
+                // 构建流转的taskRequest
                 TaskRequest<ApproveTaskRequestVo> commitTaskRequest = new TaskRequest<>();
-                //再次构建taskRequest
+                // 再次构建taskRequest
                 this.buildTaskRequest(commitTaskRequest, approvalInfoDTO, taskRequestUserInfoDTO, approvalInfoReqVO.getActivitiHolderList(),
                         processInstanceVO.getTaskRunDetailVos().get(0).getId(), operateRespVO.getHitRedList());
 
@@ -286,13 +329,13 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
                                 .hitRedList(operateRespVO.getHitRedList())
                                 .build();
 
-                        //调用工作流提交节点,审批时使用申请人的身份证号码
+                        // 调用工作流提交节点,审批时使用申请人的身份证号码
                         processInstanceVO = baseApproveOperate(baseOperateReqDTO);
                         if (CollectionUtils.isNotEmpty(taskRunDetailVos)) {
                             sendMessageFlag = false;
                         }
                         logger.info("工作流申请流程：【{}】,taskId:【{}】", JSON.toJSONString(processInstanceVO), taskDetailVo.getId());
-                        //生成待办，更新已办数据
+                        // 生成待办，更新已办数据
                         logger.info("====开始执行提交后续动作====");
                         List<TaskHistoryDetailVo> afterTaskRunDetailVos = processInstanceVO.getTaskRunDetailVos();
                         approveBusiness.afterTaskCommitTask(taskDetailVo.getId(), ApproveWorkFlowOperationEnum.COMPLETE_AGREE,
@@ -301,27 +344,27 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
                     logger.info("===发送消息标志:{}====", sendMessageFlag);
                     if (sendMessageFlag) {
                         ApproveMessageInfoDTO approveMessageInfoDTO = ApproveMessageInfoDTO.newInstance(approvalInfoDTO, ApproveWorkFlowOperationEnum.COMPLETE_AGREE, "");
-                        //发送消息
+                        // 发送消息
                         approveEventPublish.publishApproveFinalResultEvent(approveMessageInfoDTO);
                         approveResult = ApproveResultEnum.SUCCESS;
                     }
                 }
                 approvalInfoDTO.setApproveResult(approveResult.value);
-                //构建任务id、任务标识码、任务名称字段，多个均以,相隔
-                //需使用最新的processInstanceVO
+                // 构建任务id、任务标识码、任务名称字段，多个均以,相隔
+                // 需使用最新的processInstanceVO
                 approveBusiness.buildTaskInfoByProcessInstanceId(approvalInfoDTO, processInstanceVO.getTaskRunDetailVos());
                 logger.info("===保存表单信息====");
-                //将原本的旧表对象构建成模式3的新表对象
+                // 将原本的旧表对象构建成模式3的新表对象
             } else {
                 logger.info("===保存表单信息====");
                 approvalInfoDTO.setUpdateTime(new Date());
                 approvalInfoDTO.setUpdateUser(ProofsUtil.getIdcard());
             }
 
-            //将原本的旧表对象构建成模式3的新表对象
+            // 将原本的旧表对象构建成模式3的新表对象
             approveRecordInfo = approveRecordService.buildApproveRecordInfo(approvalInfoDTO, approveNo);
             approveRecordInfo.setCreateTime(oldCreateTime);
-            //保存数据
+            // 保存数据
             approveRecordService.save(approveRecordInfo);
         } catch (Exception e) {
             approveResultEnum = ApproveResultEnum.FAIL;
@@ -350,29 +393,29 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
         ProcessInstanceVO processInstanceVO = null;
         ApproveResultEnum approveResultEnum = ApproveResultEnum.SUCCESS;
         String failMsg = "";
-        //是否需要保存修改日志（若是调用了保存接口则无需。）
+        // 是否需要保存修改日志（若是调用了保存接口则无需。）
         boolean needSaveUpdateLog = true;
-        //是否需要保存操作日志（已创建了流程，此次只是修改表单但是不提交）
+        // 是否需要保存操作日志（已创建了流程，此次只是修改表单但是不提交）
         boolean needSaveOperateLog = false;
 
-        //是否发送消息给权限中心，默认发送
+        // 是否发送消息给权限中心，默认发送
         boolean sendMessageFlag = true;
         try {
             logger.info("=======" + JSONObject.toJSONString(approvalInfoUpdateReqVO) + "========");
-            //实例id
+            // 实例id
             String instanceId = approvalInfoUpdateReqVO.getProcessInstanceId();
-            //判断实例id是否存在，不存在的话，原本为草稿状态
+            // 判断实例id是否存在，不存在的话，原本为草稿状态
             if (StringUtils.isEmpty(instanceId)) {
                 ApprovalInfoReqVO approvalInfoReqVO = new ApprovalInfoReqVO();
                 BeanUtils.copyProperties(approvalInfoUpdateReqVO, approvalInfoReqVO);
 
                 if (StringUtils.isNotEmpty(approvalId)) {
                     logger.info("====删除草稿信息====");
-                    //草稿状态下，先删除原本表单
+                    // 草稿状态下，先删除原本表单
                     approveRecordService.deleteById(approvalId);
                 }
                 needSaveUpdateLog = false;
-                //调用保存接口
+                // 调用保存接口
                 ApproveRecordInfo result = approveService.saveBase(approvalInfoReqVO, ManageDisposeTypeEnum.UPDATE, approvalInfoDTO.getCreateTime());
                 return ResponseUtil.newInstance(result.getProcessInstanceId());
             } else {
@@ -391,15 +434,15 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
                 ResourceInfoDTO resourceInfoDTO = ResourceInfoDTO.parseResourceInfoReqVO(resourceInfoReqVO);
                 approvalInfoDTO.setResourceInfoVo(resourceInfoDTO);
                 BeanUtils.copyProperties(approvalInfoUpdateReqVO, approvalInfoDTO);
-                //判断有效期类型
+                // 判断有效期类型
                 String permissionValidType = approvalInfoUpdateReqVO.getPermissionValidType();
                 PermissionValidTypeEnum permissionValidTypeEnum = EnumUtils.enumOf(PermissionValidTypeEnum.class, permissionValidType);
                 if (permissionValidTypeEnum.equals(PermissionValidTypeEnum.CUSTOM)) {
-                    //自定义类型，需设置开始、结束时间
+                    // 自定义类型，需设置开始、结束时间
                     approvalInfoDTO.setStartTime(approvalInfoUpdateReqVO.getStartTime());
                     approvalInfoDTO.setEndTime(approveBaseBusiness.parseEndTime(approvalInfoUpdateReqVO.getEndTime()));
                 } else {
-                    //长期类型，开始、结束时间设置为空
+                    // 长期类型，开始、结束时间设置为空
                     approvalInfoDTO.setStartTime(null);
                     approvalInfoDTO.setEndTime(null);
                 }
@@ -410,18 +453,18 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
                 @Valid @NotNull ResourceInfoDTO resourceInfoRespVO = approvalInfoDTO.getResourceInfoVo();
                 ContentRespDTO contentRespDTO = approveBusiness.generalContentRespVO(flowTypeEnum, resourceInfoRespVO);
                 approvalInfoDTO.setApplyContent(JSON.toJSONString(contentRespDTO));
-                //构建模式3新表单表对象
+                // 构建模式3新表单表对象
                 approveRecordInfo = approveRecordService.buildApproveRecordInfo(approvalInfoDTO, approvalInfoDTO.getApproveNo());
                 approveRecordInfo.setAlreadyRedListApprove(BooleanEnum.FALSE.value);
-                //修改模式3新表单表
+                // 修改模式3新表单表
                 approveRecordService.updateById(approveRecordInfo);
 
-                //判断实例id是否存在，存在的话，原本为非草稿状态
-                //原本为非草稿状态，点击保存并提交，需要
+                // 判断实例id是否存在，存在的话，原本为非草稿状态
+                // 原本为非草稿状态，点击保存并提交，需要
                 @NotBlank String operateType = approvalInfoUpdateReqVO.getOperateType();
                 CommitTypeEnum commitTypeEnum = EnumUtils.enumOf(CommitTypeEnum.class, operateType);
                 if (CommitTypeEnum.APPLY_COMMIT.equals(commitTypeEnum)) {
-                    //根据实例id获取流程当前待办数组
+                    // 根据实例id获取流程当前待办数组
                     List<TaskHistoryDetailVo> list = workflowClientFactory.getWorkflowProcessClient()
                             .queryTaskDetailByProcessInstanceId(approvalInfoDTO.getProcessInstanceId());
                     TaskRequest<ApproveTaskRequestVo> taskRequest = new TaskRequest<>();
@@ -434,7 +477,7 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
 
                     OperateRespVO operateRespVO = dcucAuthBusiness.checkHitRedList(applicantIdcard, flowTypeEnum, resourceInfoRespVO);
 
-                    //构建工作流请求体
+                    // 构建工作流请求体
                     this.buildTaskRequest(taskRequest, approvalInfoDTO, taskRequestUserInfoDTO, approvalInfoUpdateReqVO.getActivitiHolderList(), null, operateRespVO.getHitRedList());
 
                     for (TaskHistoryDetailVo taskDetailVo : list) {
@@ -452,34 +495,34 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
                                 .hitRedList(operateRespVO.getHitRedList())
                                 .build();
 
-                        //循环提交当前待办任务
+                        // 循环提交当前待办任务
                         processInstanceVO = baseApproveOperate(baseOperateReqDTO);
                         List<TaskHistoryDetailVo> taskRunDetailVos = processInstanceVO.getTaskRunDetailVos();
                         if (CollectionUtils.isNotEmpty(taskRunDetailVos)) {
-                            //若存在待办任务，说明流程未结束，无需发送消息给权限中心
+                            // 若存在待办任务，说明流程未结束，无需发送消息给权限中心
                             sendMessageFlag = false;
                         }
                         logger.info("工作流申请流程：【{}】,taskId:【{}】", JSON.toJSONString(processInstanceVO), taskDetailVoId);
-                        //构建任务id、任务标识码、任务名称字段，多个均以,相隔
+                        // 构建任务id、任务标识码、任务名称字段，多个均以,相隔
                         approveBusiness.buildTaskInfoByProcessInstanceId(approvalInfoDTO, taskRunDetailVos);
 
-                        //生成待办&已办
+                        // 生成待办&已办
                         logger.info("=====节点提交后开始生成待办和已办=====");
 
                         approveBusiness.afterTaskCommitTask(taskDetailVoId, ApproveWorkFlowOperationEnum.COMPLETE_AGREE, taskRequestUserInfoDTO.getIdCard(), taskRequestUserInfoDTO.getUserName(), taskRunDetailVos);
                     }
                     logger.info("====发送结果标志:{}", sendMessageFlag);
                     if (sendMessageFlag) {
-                        //构建消息体并发送到kafka
+                        // 构建消息体并发送到kafka
                         ApproveMessageInfoDTO approveMessageInfoDTO = ApproveMessageInfoDTO.newInstance(approvalInfoDTO, ApproveWorkFlowOperationEnum.COMPLETE_AGREE, "");
 
                         approveEventPublish.publishApproveFinalResultEvent(approveMessageInfoDTO);
                         approveRecordInfo.setFinalApprovalResult(ApproveResultEnum.SUCCESS.getValue());
                     }
                     logger.info("===保存表单信息====");
-                    //构建任务id、任务标识码、任务名称字段，多个均以,相隔
+                    // 构建任务id、任务标识码、任务名称字段，多个均以,相隔
                     buildUpdateInfo(approveRecordInfo, approvalInfoDTO);
-                    //修改
+                    // 修改
                     approveRecordService.updateById(approveRecordInfo);
                     needSaveOperateLog = true;
                 }
@@ -529,13 +572,13 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
         if (taskRequest == null) {
             taskRequest = new TaskRequest<>();
         }
-        //设置自定义对象
+        // 设置自定义对象
         ApproveTaskRequestVo approveTaskRequestVo = new ApproveTaskRequestVo();
         //，指定是否为科信人员
         approveTaskRequestVo.setKxPeople(kxPeople);
         // 判断是否需要红名单审批
         approveTaskRequestVo.setRedList(needRedListApprove);
-        //设置业务表单信息
+        // 设置业务表单信息
         approveTaskRequestVo.setBusinessKey(approvalInfoDTO.getId());
         approveTaskRequestVo.setApplyTitle(approvalInfoDTO.getProcessTitle());
         approveTaskRequestVo.setApplyContent(approvalInfoDTO.getApplyContent());
@@ -546,11 +589,11 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
         approveTaskRequestVo.setHandleUser(userInfo == null ? taskRequestUserInfoDTO.getIdCard() : userInfo.getIdcard());
         approveTaskRequestVo.setHandleUserName(userInfo == null ? taskRequestUserInfoDTO.getUserName() : userInfo.getUserName());
         taskRequest.setData(approveTaskRequestVo);
-        //判断下一任务处理人是否为空
+        // 判断下一任务处理人是否为空
         if (CollectionUtils.isNotEmpty(activitiHolderList)) {
             TransMessage transMessage = new TransMessage();
             if (StringUtils.isNotEmpty(taskId)) {
-                //通过任务id获取任务分支
+                // 通过任务id获取任务分支
                 List<TaskOutgoingVo> list = workFlowBusiness.buildTaskOutgoingVoList(taskId);
                 if (CollectionUtils.isNotEmpty(list)) {
                     for (ActivitiHolder activitiHolder : activitiHolderList) {
@@ -581,15 +624,15 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
         ProcessInstanceVO processInstanceVO = null;
         ApproveResultEnum approveResultEnum = ApproveResultEnum.SUCCESS;
         String failMsg = "";
-        //是否发送消息到kafka，默认发
+        // 是否发送消息到kafka，默认发
         boolean sendMessageFlag = true;
 
         boolean needSendRedListRisk = false;
         OperateRespVO operateRespVO = null;
         try {
-            //根据实例id或任务id获取申请表单并构建成旧ApprovalInfo对象
-            ApproveRecordInfo approveRecordInfo = approveRecordService.findByProcessInstanceId(processInstanceId);  //获取表单数据
-            approvalInfoDTO = approveRecordInfo.toApprovalInfo();       //构建为旧表单数据 建成旧ApprovalInfo对象
+            // 根据实例id或任务id获取申请表单并构建成旧ApprovalInfo对象
+            ApproveRecordInfo approveRecordInfo = approveRecordService.findByProcessInstanceId(processInstanceId);  // 获取表单数据
+            approvalInfoDTO = approveRecordInfo.toApprovalInfo();       // 构建为旧表单数据 建成旧ApprovalInfo对象
             if (approvalInfoDTO == null) {
                 approveResultEnum = ApproveResultEnum.FAIL;
                 failMsg = "审批单不存在";
@@ -600,24 +643,24 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
             ResourceInfoDTO resourceInfoVo = updateResourceInfo(operateReqDTO, approvalInfoDTO.getResourceInfoVo());
             approvalInfoDTO.setResourceInfoVo(resourceInfoVo);
 
-            String flowType = approvalInfoDTO.getFlowType();    //权限申请类型   重要？      应用功能授权  数据授权  任务等
+            String flowType = approvalInfoDTO.getFlowType();    // 权限申请类型   重要？      应用功能授权  数据授权  任务等
             FlowTypeEnum flowTypeEnum = EnumUtils.enumOf(FlowTypeEnum.class, flowType);
-            ContentRespDTO contentRespDTO = approveBusiness.generalContentRespVO(flowTypeEnum, resourceInfoVo);//响应的界面显示信息
-            approvalInfoDTO.setApplyContent(JSON.toJSONString(contentRespDTO));      //申请内容记录
+            ContentRespDTO contentRespDTO = approveBusiness.generalContentRespVO(flowTypeEnum, resourceInfoVo);// 响应的界面显示信息
+            approvalInfoDTO.setApplyContent(JSON.toJSONString(contentRespDTO));      // 申请内容记录
 
             String alreadyRedListApprove = approvalInfoDTO.getAlreadyRedListApprove();
-            TaskHistoryDetailVo taskHistoryDetailVo = workflowClientFactory.getWorkflowTaskClient().queryTaskDetail(taskId);    //历史审批信息
+            TaskHistoryDetailVo taskHistoryDetailVo = workflowClientFactory.getWorkflowTaskClient().queryTaskDetail(taskId);    // 历史审批信息
             String taskHistoryDetailVoName = taskHistoryDetailVo.getName();
             String taskCode = taskHistoryDetailVo.getTaskCode();
 
             String approvalInfoTaskId = approvalInfoDTO.getTaskId();
             String approvalInfoId = approvalInfoDTO.getId();
             String approveNo = approvalInfoDTO.getApproveNo();
-            String businessCode = approvalInfoDTO.getBusinessCode();    //流程编号
+            String businessCode = approvalInfoDTO.getBusinessCode();    // 流程编号
             String applicantIdcard = approvalInfoDTO.getApplicantIdcard();
 
-            //判断操作类型是否支持
-            //如果是  回退  或者 撤回，需要先看下  当前审批流程实例 是否支持
+            // 判断操作类型是否支持
+            // 如果是  回退  或者 撤回，需要先看下  当前审批流程实例 是否支持
             if (approveWorkFlowOperationEnum.equals(ApproveWorkFlowOperationEnum.RECALL)
                     || approveWorkFlowOperationEnum.equals(ApproveWorkFlowOperationEnum.BACK)) {
                 boolean enableOperate = isEnableOperateRecallBack(operateReqDTO, approvalInfoTaskId, taskCode);
@@ -629,11 +672,11 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
                 }
             }
 
-            //TODO 增加 挂起（Suspend），激活（Activate），终止（Redo）  哪种情况的支持操作
-            //TODO add wanghao
+            // TODO 增加 挂起（Suspend），激活（Activate），终止（Redo）  哪种情况的支持操作
+            // TODO add wanghao
             if (approveWorkFlowOperationEnum.equals(ApproveWorkFlowOperationEnum.SUSPEND)
                     || approveWorkFlowOperationEnum.equals(ApproveWorkFlowOperationEnum.ACTIVATE)
-                    || approveWorkFlowOperationEnum.equals(ApproveWorkFlowOperationEnum.REDO) ) {
+                    || approveWorkFlowOperationEnum.equals(ApproveWorkFlowOperationEnum.REDO)) {
                 boolean enableOperate = isEnableOperateSuspendActivateRedo(operateReqDTO, approvalInfoTaskId, taskCode);
                 if (!enableOperate) {
                     return ResponseUtil.dtoFail("该节点不支持此项操作");
@@ -643,7 +686,6 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
                 }
             }
 
-
             operateRespVO = dcucAuthBusiness.checkHitRedList(applicantIdcard, flowTypeEnum, resourceInfoVo);
             String redListTip = operateRespVO.getRedListTip();
             Boolean hitRedList = operateRespVO.getHitRedList();
@@ -651,7 +693,7 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
             // 判断是否红名单审批
             boolean alreadyRedListApproveBoolean = EnumUtils.enumOf(BooleanEnum.class, alreadyRedListApprove).booleanValue;
 
-            //开始执行操作内容--同意
+            // 开始执行操作内容--同意
             if (approveWorkFlowOperationEnum.equals(ApproveWorkFlowOperationEnum.COMPLETE_AGREE)) {
                 // 需要检查红名单且还未进行红名单审批
                 if (needCheckRedList && (!alreadyRedListApproveBoolean)) {
@@ -669,9 +711,9 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
                 needSendRedListRisk = (!needCheckRedList) && (!alreadyRedListApproveBoolean) && (!taskName.contains(ApproveConstants.RED_LIST));
             }
 
-            //构建工作流请求体
+            // 构建工作流请求体
             this.buildTaskRequest(taskRequest, approvalInfoDTO, taskRequestUserInfoDTO, activitiHolderList, null, operateRespVO.getHitRedList());
-            //节点构建
+            // 节点构建
             BaseOperateReqDTO baseOperateReqDTO = BaseOperateReqDTO.builder()
                     .operateIdcard(ProofsUtil.getIdcard())
                     .taskId(taskId)
@@ -685,13 +727,13 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
                     .hitRedList(operateRespVO.getHitRedList())
                     .build();
 
-            //节点信息提交
-            processInstanceVO = baseApproveOperate(baseOperateReqDTO);  //执行审批操作           //TODO 主要改这里
+            // 节点信息提交
+            processInstanceVO = baseApproveOperate(baseOperateReqDTO);  // 执行审批操作           //TODO 主要改这里
 
             List<TaskHistoryDetailVo> afterTaskRunDetailVos = processInstanceVO.getTaskRunDetailVos();
 
             if (CollectionUtils.isNotEmpty(afterTaskRunDetailVos)) {
-                //若有待办，说明流程未结束，则不发
+                // 若有待办，说明流程未结束，则不发
                 sendMessageFlag = false;
             }
 
@@ -702,24 +744,25 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
                 approvalInfoDTO.setAlreadyRedListApprove(BooleanEnum.TRUE.value);
             }
 
-            //生成待办&已办
+            // 生成待办&已办
             logger.info("=====节点提交后开始生成待办和已办=====");
 
-            //删除代办---新增已办，  用的两张表记录的，不是状态位？
+            // 删除代办---新增已办，  用的两张表记录的，不是状态位？
             approveBusiness.afterTaskCommitTask(taskId, approveWorkFlowOperationEnum, taskRequestUserInfoDTO.getIdCard(), taskRequestUserInfoDTO.getUserName(), afterTaskRunDetailVos);
 
             logger.info("====是否发送消息标志位:{}====", sendMessageFlag);
-            if (sendMessageFlag) {      //往kafka 推送消息  给下一步审批人？
+            if (sendMessageFlag) {      // 往kafka 推送消息  给下一步审批人？
                 ApproveMessage approveMessage = taskRequest.getApproveMessage();
                 String message = approveMessage.getMessage();
-                //构建消息体并发送
+                // 构建消息体并发送
                 sendMessage(approveWorkFlowOperationEnum, approvalInfoDTO, message);
-                //设置流程状态结果
+                // 设置流程状态结果
                 switch (approveWorkFlowOperationEnum) {
                     case COMPLETE_AGREE:
                         approvalInfoDTO.setApproveResult(ApproveResultEnum.SUCCESS.getValue());
                         break;
                     case COMPLETE_DISAGREE:
+                    case REDO:
                         approvalInfoDTO.setApproveResult(ApproveResultEnum.FAIL.getValue());
                         break;
                     default:
@@ -728,14 +771,14 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
                 approveRecordInfo.setFinalApprovalResult(approvalInfoDTO.getApproveResult());
             }
 
-            //更新任务信息
-            //构建任务id、任务标识码、任务名称字段，多个均以,相隔
+            // 更新任务信息
+            // 构建任务id、任务标识码、任务名称字段，多个均以,相隔
             approveBusiness.buildTaskInfoByProcessInstanceId(approvalInfoDTO, afterTaskRunDetailVos);
             logger.info("====当前任务详情:{}====", JSONObject.toJSON(afterTaskRunDetailVos));
             logger.info("====开始更新审批单信息====");
-            //设置表单信息
+            // 设置表单信息
             buildUpdateInfo(approveRecordInfo, approvalInfoDTO);
-            //修改表单
+            // 修改表单
             approveRecordService.updateById(approveRecordInfo);
         } catch (Exception e) {
             logger.error("operate error", e);
@@ -795,7 +838,7 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
         boolean hitRedList = baseOperateReqDTO.getHitRedList();
 
         taskRequest = buildTaskRequest(taskRequest, approvalInfoDTO, taskRequestUserInfoDTO, null, null, hitRedList);
-        //判断是否有审批信息，若无，默认设置
+        // 判断是否有审批信息，若无，默认设置
         if (null == taskRequest.getApproveMessage()) {
             ApproveMessage approveMessage = new ApproveMessage();
             approveMessage.setApproveState(approveWorkFlowOperationEnum.getValue());
@@ -811,12 +854,12 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
         switch (approveWorkFlowOperationEnum) {     // TODO 增加调用  挂起等判断
             case COMPLETE_AGREE:
                 vo = workflowClientFactory.getWorkflowTaskClient().commitTask(taskId, taskRequest, WorkFlowOprationEnum.COMPLETE_AGREE, operateIdcard);
-                //保存任务指派人记录信息
+                // 保存任务指派人记录信息
                 insertTaskAssignRecord(vo, approveWorkFlowOperationEnum, operateIdcard, taskRequest, approveRecordId);
                 break;
             case COMPLETE_DISAGREE:
                 vo = workflowClientFactory.getWorkflowTaskClient().commitTask(taskId, taskRequest, WorkFlowOprationEnum.COMPLETE_DISAGREE, operateIdcard);
-                //保存任务指派人记录信息
+                // 保存任务指派人记录信息
                 insertTaskAssignRecord(vo, approveWorkFlowOperationEnum, operateIdcard, taskRequest, approveRecordId);
                 break;
             case BACK:
@@ -826,7 +869,7 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
                 vo = workflowClientFactory.getWorkflowTaskClient().recallTask(taskId, taskRequest, operateIdcard);
                 break;
 
-            //TODO add wanghao
+            // TODO add wanghao
             case SUSPEND:
                 vo = workflowClientFactory.getWorkflowTaskClient().handleTaskForSuspend(taskId, operateIdcard);
                 break;
@@ -834,15 +877,25 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
                 vo = workflowClientFactory.getWorkflowTaskClient().handleTaskForActivate(taskId, operateIdcard);
                 break;
             case REDO:
-                vo = workflowClientFactory.getWorkflowTaskClient().handleTaskForRedo(taskId, operateIdcard);
+                // vo = workflowClientFactory.getWorkflowTaskClient().handleTaskForRedo(taskId, operateIdcard);
+                TaskHistoryDetailVo historyVo = workflowClientFactory.getWorkflowTaskClient().queryTaskDetail(taskId);
+                vo = new ProcessInstanceVO();
+                TaskHistoryDetailVo historyDetailVo = new TaskHistoryDetailVo();
+                historyDetailVo.setName(historyVo.getName());
+                historyDetailVo.setTaskCode(END_STR);
+                historyDetailVo.setStartTime(historyVo.getStartTime());
+                historyDetailVo.setEndTime(new Date());
+                historyDetailVo.setTaskDefinitionKey(historyVo.getTaskDefinitionKey());
+                vo.setTaskHistoryDetailVo(historyDetailVo);
+                vo.setPocessDefinitionId(historyVo.getProcessDefinitionId());
+                vo.setProcessInstanceId(historyVo.getProcessInstanceId());
                 break;
-
             default:
                 break;
         }
-        //构建审批记录表
+        // 构建审批记录表
         System.err.println(JSONObject.toJSONString(vo));
-        buildApproveCirculationInfoAndSave(approveRecordId, vo, approveWorkFlowOperationEnum.getValue(), taskRequestUserInfoDTO, taskRequest.getApproveMessage().getMessage(), approveNo, processNo);
+        buildApproveCirculationInfoAndSave(approveRecordId, vo, approveWorkFlowOperationEnum, taskRequestUserInfoDTO, taskRequest.getApproveMessage().getMessage(), approveNo, processNo);
         return vo;
     }
 
@@ -857,35 +910,37 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
      * @param approveNo              审批编号
      * @param processNo              流程编号
      */
-    private void buildApproveCirculationInfoAndSave(String approveRecordId, ProcessInstanceVO vo, String operateType, TaskRequestUserInfoDTO taskRequestUserInfoDTO, String msg, String approveNo, String processNo) {
+    private void buildApproveCirculationInfoAndSave(
+            String approveRecordId, ProcessInstanceVO vo, ApproveWorkFlowOperationEnum operateType,
+            TaskRequestUserInfoDTO taskRequestUserInfoDTO, String msg, String approveNo, String processNo) {
 
         ApproveCirculationInfo approveCirculationInfo = new ApproveCirculationInfo();
         approveCirculationInfo.setApproveRecordId(approveRecordId);
         approveCirculationInfo.setApproveNo(approveNo);
         approveCirculationInfo.setProcessNo(processNo);
-        approveCirculationInfo.setNodeName(vo.getTaskHistoryDetailVo().getName());
-        approveCirculationInfo.setNodeNo(vo.getTaskHistoryDetailVo().getTaskCode());
-        approveCirculationInfo.setTaskKey(vo.getTaskHistoryDetailVo().getTaskDefinitionKey());
-        approveCirculationInfo.setOperateType(operateType);
-        approveCirculationInfo.setOperateTime(DateUtils.getTimeStr(vo.getTaskHistoryDetailVo().getEndTime(), DateConst.HYPHEN_DISPLAY_TIME));
+        approveCirculationInfo.setOperateType(operateType.getValue());
         approveCirculationInfo.setOperateUserName(taskRequestUserInfoDTO.getUserName());
         approveCirculationInfo.setOperateUserId(taskRequestUserInfoDTO.getIdCard());
         approveCirculationInfo.setOperateUserOrg(taskRequestUserInfoDTO.getOrgName());
         approveCirculationInfo.setOperateUserOrgId(taskRequestUserInfoDTO.getOrgCode());
         approveCirculationInfo.setApproveOpinion(msg);
 
-        //TODO add wanghao  解决 挂起 无endtime 问题
-        Date tmpDate = new Date();
-        if(vo.getTaskHistoryDetailVo().getEndTime() != null){
-            tmpDate =  vo.getTaskHistoryDetailVo().getEndTime();
-        }
-
-        approveCirculationInfo.setOperateTimeConsuming(String.valueOf(DateUtil.between(tmpDate, vo.getTaskHistoryDetailVo().getStartTime(), DateUnit.SECOND)));
-        //TODO 电子签名内容待定，先设置个null
+        // TODO 电子签名内容待定，先设置个null
         approveCirculationInfo.setElectronicSignature(null);
         approveCirculationInfo.setIsDeleted(BooleanEnum.FALSE.getValue());
         approveCirculationInfo.setCreateUser(taskRequestUserInfoDTO.getIdCard());
         approveCirculationInfo.setCreateTime(new Date());
+
+        approveCirculationInfo.setNodeName(vo.getTaskHistoryDetailVo().getName());
+        approveCirculationInfo.setNodeNo(vo.getTaskHistoryDetailVo().getTaskCode());
+        approveCirculationInfo.setTaskKey(vo.getTaskHistoryDetailVo().getTaskDefinitionKey());
+        approveCirculationInfo.setOperateTime(DateUtils.getTimeStr(vo.getTaskHistoryDetailVo().getEndTime(), DateConst.HYPHEN_DISPLAY_TIME));
+        // TODO add wanghao  解决 挂起 无endtime 问题
+        Date tmpDate = new Date();
+        if (vo.getTaskHistoryDetailVo().getEndTime() != null) {
+            tmpDate = vo.getTaskHistoryDetailVo().getEndTime();
+        }
+        approveCirculationInfo.setOperateTimeConsuming(String.valueOf(DateUtil.between(tmpDate, vo.getTaskHistoryDetailVo().getStartTime(), DateUnit.SECOND)));
         approveCirculationInfoService.save(approveCirculationInfo);
     }
 
@@ -923,7 +978,7 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
         WorkflowRequestData workflowRequestData = new WorkflowRequestData();
         ApproveMessage approveMessage = new ApproveMessage();
         workflowRequestData.setApproveMessage(approveMessage);
-        //转办接口
+        // 转办接口
         workflowClientFactory.getWorkflowTaskClient().taskOperationAssign(agentReqVO.getTaskId(), agentReqVO.getAssigneeUser(),
                 ProofsUtil.getIdcard(), workflowRequestData);
     }
@@ -934,23 +989,22 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
             return ResponseUtil.newInstance(Collections.emptyList());
         }
 
-        //step1 审批历史记录
+        // step1 审批历史记录
         List<ApproveCirculationInfo> hisTaskMapNew = this.getProcessPathNew(processInstanceId);
 
         return approveCirculationInfoService.buildApproveCommentVo(hisTaskMapNew);
     }
 
-
     @Override
     public Integer queryApproveQty(Searchable searchable) {
-        //获取已办列表
+        // 获取已办列表
         Page<TaskVo> page = queryApproveList(searchable);
         return (int) page.getTotalElements();
     }
 
     @Override
     public Integer queryMyRequestQty() {
-        //获取表单列表
+        // 获取表单列表
         String currentUserId = ProofsUtil.getIdcard();
         return approveRecordService.getUserRequestCount(currentUserId);
 
@@ -963,7 +1017,7 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
         ApproveResultEnum approveResultEnum = ApproveResultEnum.SUCCESS;
         String failMsg = "";
         try {
-            //获取表单信息
+            // 获取表单信息
             approvalInfoDTO = getApproveRecord(id);
             if (approvalInfoDTO == null) {
                 approveResultEnum = ApproveResultEnum.FAIL;
@@ -972,7 +1026,7 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
             }
 
             if (StringUtils.isNotEmpty(approvalInfoDTO.getTaskId())) {
-                if (approvalInfoDTO.getTaskId().equalsIgnoreCase(ApproveConstants.END_STR)) {
+                if (approvalInfoDTO.getTaskId().equalsIgnoreCase(END_STR)) {
                     approveResultEnum = ApproveResultEnum.FAIL;
                     failMsg = "流程已结束，不允许删除";
                     return ResponseDTO.fail("流程已结束，不允许删除");
@@ -980,11 +1034,11 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
             }
 
             boolean callBackEnableFlag = false;
-            //判断是否是草稿状态
+            // 判断是否是草稿状态
             if (StringUtils.isNotEmpty(approvalInfoDTO.getProcessInstanceId())) {
-                //1. 获取当前结点可以操作的类型
-                //2. 判断是否可以执行撤销操作，若可以执行撤销，否则返回错误信息
-                //3. 将流程实例信息(审批端)的删除标志置1
+                // 1. 获取当前结点可以操作的类型
+                // 2. 判断是否可以执行撤销操作，若可以执行撤销，否则返回错误信息
+                // 3. 将流程实例信息(审批端)的删除标志置1
 
                 String taskIds = approvalInfoDTO.getTaskId();
                 String taskCodes = approvalInfoDTO.getApproveTaskIdentifier();
@@ -998,10 +1052,10 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
                         break;
                     }
                 }
-                //判断并执行撤销操作
+                // 判断并执行撤销操作
                 if (callBackEnableFlag) {
                     for (String taskId : arrTaskId) {
-                        //执行流程撤销操作，撤销会删除流程
+                        // 执行流程撤销操作，撤销会删除流程
                         workflowClientFactory.getWorkflowTaskClient().handleTaskForRedo(taskId, ProofsUtil.getIdcard());
                     }
                 } else {
@@ -1010,15 +1064,15 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
                     return ResponseDTO.fail("当前节点不允许删除操作");
                 }
             }
-            //执行表单表逻辑删除
+            // 执行表单表逻辑删除
             approveRecordService.deleteById(id);
             ApproveMessageInfoDTO approveMessageInfoDTO = ApproveMessageInfoDTO.newInstance(approvalInfoDTO, ApproveWorkFlowOperationEnum.RECALL, "");
             approveEventPublish.publishApproveFinalResultEvent(approveMessageInfoDTO);
 
-            //删除所有已办
+            // 删除所有已办
             approveActHiTaskService.deleteByApplyRecordId(id);
 
-            //删除所有待办
+            // 删除所有待办
             approveActRunTaskService.deleteByApplyRecordId(id);
         } catch (Exception e) {
             approveResultEnum = ApproveResultEnum.FAIL;
@@ -1034,7 +1088,7 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
 
     @Override
     public ResponseDTO<ApprovalInfoRespVO> queryApproveDetail(String id) {
-        //获取表单信息
+        // 获取表单信息
         ApprovalInfoDTO approvalInfoDTO = getApproveRecord(id);
         if (approvalInfoDTO == null) {
             return ResponseUtil.dtoFail("申请表单不存在");
@@ -1043,10 +1097,9 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
         return ResponseUtil.newInstance(approvalInfoRespVO);
     }
 
-
     @Override
     public ResponseDTO<List<ProcessStatusVo>> approveStatus(String processInstanceId) {
-        //获取表单信息
+        // 获取表单信息
         ApproveRecordInfo approveRecordInfo = approveRecordService.findByProcessInstanceId(processInstanceId);
         ApprovalInfoDTO approvalInfoDTO = approveRecordInfo.toApprovalInfo();
         if (approvalInfoDTO == null) {
@@ -1056,16 +1109,15 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
         return approveStatusByBusinessId(approvalInfoId);
     }
 
-
     @Override
     public ResponseDTO<List<ProcessStatusVo>> approveStatusByBusinessId(String approveRecordId) {
-        //通过审批记录
+        // 通过审批记录
         List<ApproveCirculationInfo> processPathNew = approveCirculationInfoService.getListByApproveRecordId(approveRecordId);
-        //根据任务定义key去重
+        // 根据任务定义key去重
         List<ApproveCirculationInfo> processPath = processPathNew.stream()
                 .collect(Collectors.collectingAndThen(Collectors.toCollection(() ->
                         new TreeSet<>(Comparator.comparing(ApproveCirculationInfo::getTaskKey))), ArrayList::new));
-        //根据创建时间排序
+        // 根据创建时间排序
         List<ApproveCirculationInfo> sortList = processPath.stream()
                 .sorted(Comparator.comparing(ApproveCirculationInfo::getCreateTime))
                 .collect(Collectors.toList());
@@ -1077,7 +1129,7 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
             processStatusVo.setNodeName(approveCirculationInfo.getNodeName());
             String taskKey = approveCirculationInfo.getTaskKey();
 
-            //通过审批记录（分组）
+            // 通过审批记录（分组）
             List<ApproveCirculationInfo> childList = approveCirculationInfoService.getListByApproveRecordIdAndTaskKey(approveRecordId, taskKey);
             Set<ProcessStatusDetailVo> taskVos = new HashSet<>();
             if (CollectionUtils.isNotEmpty(childList)) {
@@ -1112,7 +1164,6 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
         return ResponseUtil.newInstance(collect);
     }
 
-
     /**
      * 根据流程实例完成的节点
      *
@@ -1120,13 +1171,13 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
      * @return 审批意见
      */
     private List<ApproveCirculationInfo> getProcessPathNew(String processInstanceId) {
-        //获取表单信息
+        // 获取表单信息
         ApproveRecordInfo approveRecordInfo = approveRecordService.findByProcessInstanceId(processInstanceId);
         if (approveRecordInfo == null) {
             throw new IllegalArgumentException(String.format("processInstanceId:%s can't find ApprovalInfo", processInstanceId));
         }
         String approvalInfoId = approveRecordInfo.getId();
-        //通过表单id查询审批记录
+        // 通过表单id查询审批记录
         return approveCirculationInfoService.getListByApproveRecordId(approvalInfoId);
     }
 
@@ -1152,7 +1203,6 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
         return taskRequestVo;
     }
 
-
     /**
      * 通过表单id查询并构建旧表单对象
      *
@@ -1160,7 +1210,7 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
      * @return 审批信息
      */
     public ApprovalInfoDTO getApproveRecord(String id) {
-        //表单查询
+        // 表单查询
         ApproveRecordInfo approveRecordInfo = approveRecordService.selectOne(id);
         if (approveRecordInfo != null) {
             return approveRecordInfo.toApprovalInfo();
@@ -1196,7 +1246,6 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
         return approvalInfoDTO;
     }
 
-
     /**
      * 是否支持撤回、退回操作
      *
@@ -1216,14 +1265,14 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
 
         boolean isEnable;
         if (approveWorkFlowOperationEnum.equals(ApproveWorkFlowOperationEnum.RECALL)) {
-            //查询当前任务是否支持撤回操作（工作流节点是否有配置撤回操作）
+            // 查询当前任务是否支持撤回操作（工作流节点是否有配置撤回操作）
             isEnable = workFlowBusiness.checkOperateOptionOfCurrentStep(taskId, processInstanceId, taskCode, OperateOptionEnum._BTN_WITH_DRAW_COMMIT);
         } else {
-            //查询当前任务是否支持退回操作（工作流节点是否有配置退回操作）
+            // 查询当前任务是否支持退回操作（工作流节点是否有配置退回操作）
             isEnable = workFlowBusiness.checkOperateOptionOfCurrentStep(taskId, processInstanceId, taskCode, OperateOptionEnum._BTN_BACK_COMMIT);
         }
         logger.info("=====节点的{}操作权限判断结果为:{}======", approveWorkFlowOperationEnum, isEnable);
-        return isEnable && !approvalInfoTaskId.equalsIgnoreCase(ApproveConstants.END_STR);
+        return isEnable && !approvalInfoTaskId.equalsIgnoreCase(END_STR);
     }
 
     /**
@@ -1233,7 +1282,7 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
      * @param approvalInfoDTO              审批信息
      */
     protected void sendMessage(ApproveWorkFlowOperationEnum approveWorkFlowOperationEnum, ApprovalInfoDTO approvalInfoDTO, String approveMessage) {
-        //构建消息体并发送
+        // 构建消息体并发送
         ApproveMessageInfoDTO approveMessageInfoDTO = ApproveMessageInfoDTO.newInstance(approvalInfoDTO, approveWorkFlowOperationEnum, approveMessage);
         approveEventPublish.publishApproveFinalResultEvent(approveMessageInfoDTO);
     }
@@ -1260,11 +1309,9 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
         return resourceInfoDTO;
     }
 
+    // TODO 增加 挂起（Suspend），激活（Activate），终止（Redo）  哪种情况的支持操作
+    // TODO add wanghao
 
-
-
-    //TODO 增加 挂起（Suspend），激活（Activate），终止（Redo）  哪种情况的支持操作
-    //TODO add wanghao
     /**
      * 是否支持挂起、激活、终止操作
      *
@@ -1284,17 +1331,17 @@ public class ApproveCommonBusinessImpl implements IApproveCommonBusiness {
 
         boolean isEnable = false;
         if (approveWorkFlowOperationEnum.equals(ApproveWorkFlowOperationEnum.SUSPEND)) {
-            //查询当前任务是否支持挂起操作（工作流节点是否有配置 挂起 操作） 以及业务逻辑是否支持
+            // 查询当前任务是否支持挂起操作（工作流节点是否有配置 挂起 操作） 以及业务逻辑是否支持
             isEnable = workFlowBusiness.checkOperateOptionOfCurrentStep(taskId, processInstanceId, taskCode, OperateOptionEnum._BTN_SUSPEND_COMMIT);
-        } else if(approveWorkFlowOperationEnum.equals(ApproveWorkFlowOperationEnum.ACTIVATE)){
-            //查询当前任务是否支持挂起操作（工作流节点是否有配置 激活 操作） 以及业务逻辑是否支持
+        } else if (approveWorkFlowOperationEnum.equals(ApproveWorkFlowOperationEnum.ACTIVATE)) {
+            // 查询当前任务是否支持挂起操作（工作流节点是否有配置 激活 操作） 以及业务逻辑是否支持
             isEnable = workFlowBusiness.checkOperateOptionOfCurrentStep(taskId, processInstanceId, taskCode, OperateOptionEnum._BTN_RECOVER);
-        } else if(approveWorkFlowOperationEnum.equals(ApproveWorkFlowOperationEnum.REDO)){
-            //查询当前任务是否支持挂起操作（工作流节点是否有配置 终止 操作） 以及业务逻辑是否支持
+        } else if (approveWorkFlowOperationEnum.equals(ApproveWorkFlowOperationEnum.REDO)) {
+            // 查询当前任务是否支持挂起操作（工作流节点是否有配置 终止 操作） 以及业务逻辑是否支持
             isEnable = workFlowBusiness.checkOperateOptionOfCurrentStep(taskId, processInstanceId, taskCode, OperateOptionEnum._BTN_REDO_COMMIT);
         }
 
         logger.info("=====节点的{}操作权限判断结果为:{}======", approveWorkFlowOperationEnum, isEnable);
-        return isEnable && !approvalInfoTaskId.equalsIgnoreCase(ApproveConstants.END_STR);
+        return isEnable && !approvalInfoTaskId.equalsIgnoreCase(END_STR);
     }
 }

approve-core-service/src/main/java/com/dragonsoft/dcuc/approve/business/impl/ApproveLogBusinessImpl.java

@@ -167,11 +167,32 @@ public class ApproveLogBusinessImpl implements IApproveLogBusiness {
      */
     @Override
     public void buildOperateLog(LogDto logDto, ApproveWorkFlowOperationEnum workFlowOperationEnum, Boolean flowFinish) {
+
+        // TODO add wanghao   20241105 修改
+        String flowNodeCode = "" ;
+        String flowNodeName = "" ;
+        String taskKey = "" ;
+        String flowKey = "" ;
+        String processInstanceId = "" ;
+
+
+        if(logDto.getProcessInstanceVO() != null){
+            flowNodeCode = logDto.getProcessInstanceVO().getTaskHistoryDetailVo() == null ? "" : logDto.getProcessInstanceVO().getTaskHistoryDetailVo().getTaskCode();
+            flowNodeName = logDto.getProcessInstanceVO().getTaskHistoryDetailVo() == null ? "" : logDto.getProcessInstanceVO().getTaskHistoryDetailVo().getName();
+            taskKey = logDto.getProcessInstanceVO().getTaskHistoryDetailVo() == null ? "" : logDto.getProcessInstanceVO().getTaskHistoryDetailVo().getTaskDefinitionKey();
+            flowKey = logDto.getProcessInstanceVO().getPocessDefinitionId() == null ? "" : logDto.getProcessInstanceVO().getPocessDefinitionId();
+            processInstanceId = logDto.getProcessInstanceVO().getProcessInstanceId() == null ? "" : logDto.getProcessInstanceVO().getProcessInstanceId();
+        }
+
+
+        /*  TODO add wanghao     原内容
+
         String flowNodeCode = logDto.getProcessInstanceVO() == null ? "" : logDto.getProcessInstanceVO().getTaskHistoryDetailVo().getTaskCode();
         String flowNodeName = logDto.getProcessInstanceVO() == null ? "" : logDto.getProcessInstanceVO().getTaskHistoryDetailVo().getName();
         String taskKey = logDto.getProcessInstanceVO() == null ? "" : logDto.getProcessInstanceVO().getTaskHistoryDetailVo().getTaskDefinitionKey();
         String flowKey = logDto.getProcessInstanceVO() == null ? "" : logDto.getProcessInstanceVO().getPocessDefinitionId();
         String processInstanceId = logDto.getProcessInstanceVO() == null ? "" : logDto.getProcessInstanceVO().getProcessInstanceId();
+        */
 
         ProcessInstanceVO processInstanceVO = logDto.getProcessInstanceVO();
         ProcessInstanceInfoDTO processInstanceInfoDTO = ProcessInstanceInfoDTO.parseProcessInstanceVO(processInstanceVO);