diff --git a/src/main/java/neatlogic/module/process/api/process/ProcessSaveApi.java b/src/main/java/neatlogic/module/process/api/process/ProcessSaveApi.java index 1def29194fd1ef3e8e9bc11c9e91f08d0aa8f30f..eab38f76dcc7a7de4c46e997305077b28d10f6c6 100644 --- a/src/main/java/neatlogic/module/process/api/process/ProcessSaveApi.java +++ b/src/main/java/neatlogic/module/process/api/process/ProcessSaveApi.java @@ -59,6 +59,7 @@ public class ProcessSaveApi extends PrivateApiComponentBase { @Param(name = "uuid", type = ApiParamType.STRING, desc = "流程uuid") }) @Description(desc = "保存流程") + @ResubmitInterval(value = 2) public Object myDoService(JSONObject jsonObj) throws Exception { ProcessVo processVo = JSON.toJavaObject(jsonObj, ProcessVo.class); ProcessMessageManager.setOperationType(OperationTypeEnum.UPDATE); diff --git a/src/main/java/neatlogic/module/process/api/processtask/ProcessTaskAuditListApi.java b/src/main/java/neatlogic/module/process/api/processtask/ProcessTaskAuditListApi.java index a37b8616d3247cd94c8d3653ea5b9752e61c2d5d..ec9d4ee6d2c7f0ed7b9ecdff56ad337c416925f1 100644 --- a/src/main/java/neatlogic/module/process/api/processtask/ProcessTaskAuditListApi.java +++ b/src/main/java/neatlogic/module/process/api/processtask/ProcessTaskAuditListApi.java @@ -12,12 +12,10 @@ import neatlogic.framework.process.audithandler.core.IProcessTaskStepAuditDetail import neatlogic.framework.process.audithandler.core.ProcessTaskAuditDetailTypeFactory; import neatlogic.framework.process.audithandler.core.ProcessTaskStepAuditDetailHandlerFactory; import neatlogic.framework.process.auth.PROCESS_BASE; +import neatlogic.framework.process.dto.*; import neatlogic.framework.process.operationauth.core.IOperationType; import neatlogic.framework.process.constvalue.ProcessTaskOperationType; import neatlogic.framework.process.constvalue.ProcessTaskStepOperationType; -import neatlogic.framework.process.dto.ProcessTaskStepAuditDetailVo; -import neatlogic.framework.process.dto.ProcessTaskStepAuditVo; -import neatlogic.framework.process.dto.ProcessTaskStepVo; import neatlogic.framework.process.operationauth.core.ProcessAuthManager; import neatlogic.framework.restful.annotation.*; import neatlogic.framework.restful.constvalue.OperationTypeEnum; @@ -65,9 +63,14 @@ public class ProcessTaskAuditListApi extends PrivateApiComponentBase { return null; } + @Override + public boolean disableReturnCircularReferenceDetect() { + return true; + } + @Input({ @Param(name = "processTaskId", type = ApiParamType.LONG, isRequired = true, desc = "工单id"), - @Param(name = "processTaskStepIdList", type = ApiParamType.JSONARRAY, desc = "工单步骤id列表") + @Param(name = "processTaskStepIdList", type = ApiParamType.JSONARRAY, desc = "工单步骤id列表"), }) @Output({ @Param(name = "Return", explode = ProcessTaskStepAuditVo[].class, desc = "工单活动列表"), @@ -101,6 +104,60 @@ public class ProcessTaskAuditListApi extends PrivateApiComponentBase { if (!operateMap.computeIfAbsent(processTaskId, k -> new HashSet<>()).contains(ProcessTaskOperationType.PROCESSTASK_VIEW)) { return resultList; } + Map hash2ConfigMap = new HashMap<>(); + List configHashList = processTaskStepList.stream().map(ProcessTaskStepVo::getConfigHash).filter(Objects::nonNull).collect(Collectors.toList()); + if (CollectionUtils.isNotEmpty(configHashList)) { + List configList = selectContentByHashMapper.getProcessTaskStepConfigListByHashList(configHashList); + for (ProcessTaskStepConfigVo processTaskStepConfigVo : configList) { + hash2ConfigMap.put(processTaskStepConfigVo.getHash(), processTaskStepConfigVo.getConfig()); + } + } + for (ProcessTaskStepVo processTaskStepVo : processTaskStepList) { + String stepConfig = hash2ConfigMap.get(processTaskStepVo.getConfigHash()); + if (StringUtils.isNotBlank(stepConfig)) { + JSONObject configObj = JSONObject.parseObject(stepConfig); + String formSceneUuid = configObj.getString("formSceneUuid"); + processTaskStepVo.setFormSceneUuid(formSceneUuid); + } + } + Set contentHashSet = new HashSet<>(); + Set userUuidSet = new HashSet<>(); + for (ProcessTaskStepAuditVo processTaskStepAudit : processTaskStepAuditList) { + if (StringUtils.isNotBlank(processTaskStepAudit.getDescriptionHash())) { + contentHashSet.add(processTaskStepAudit.getDescriptionHash()); + } + if (!Objects.equals(processTaskStepAudit.getUserUuid(), SystemUser.SYSTEM.getUserUuid())) { + userUuidSet.add(processTaskStepAudit.getUserUuid()); + } + if (!Objects.equals(processTaskStepAudit.getOriginalUser(), SystemUser.SYSTEM.getUserUuid())) { + userUuidSet.add(processTaskStepAudit.getOriginalUser()); + } + List processTaskStepAuditDetailList = processTaskStepAudit.getAuditDetailList(); + for (ProcessTaskStepAuditDetailVo processTaskStepAuditDetailVo : processTaskStepAuditDetailList) { + if (ProcessTaskAuditDetailTypeFactory.getNeedCompression(processTaskStepAuditDetailVo.getType())) { + String oldContent = processTaskStepAuditDetailVo.getOldContent(); + if (StringUtils.isNotBlank(oldContent)) { + contentHashSet.add(oldContent); + } + String newContent = processTaskStepAuditDetailVo.getNewContent(); + if (StringUtils.isNotBlank(newContent)) { + contentHashSet.add(newContent); + } + } + } + } + Map userMap = new HashMap<>(); + Map hashToContentMap = new HashMap<>(); + List userUuidList = userUuidSet.stream().filter(Objects::nonNull).collect(Collectors.toList()); + if (CollectionUtils.isNotEmpty(userUuidList)) { + List userList = userMapper.getUserByUserUuidList(userUuidList); + userMap = userList.stream().collect(Collectors.toMap(UserVo::getUuid, e -> e)); + } + List contentHashList = contentHashSet.stream().filter(Objects::nonNull).collect(Collectors.toList()); + if (CollectionUtils.isNotEmpty(contentHashList)) { + List processTaskContentList = selectContentByHashMapper.getProcessTaskContentListByHashList(new ArrayList<>(contentHashSet)); + hashToContentMap = processTaskContentList.stream().collect(Collectors.toMap(ProcessTaskContentVo::getHash, ProcessTaskContentVo::getContent)); + } for (ProcessTaskStepAuditVo processTaskStepAudit : processTaskStepAuditList) { if (processTaskStepAudit.getProcessTaskStepId() != null) { @@ -113,26 +170,24 @@ public class ProcessTaskAuditListApi extends PrivateApiComponentBase { processTaskStepAudit.setFormSceneUuid(processTaskStepVo.getFormSceneUuid()); } } - - if(StringUtils.isNotBlank(processTaskStepAudit.getDescriptionHash())){ - String description = selectContentByHashMapper.getProcessTaskContentStringByHash(processTaskStepAudit.getDescriptionHash()); + if (StringUtils.isNotBlank(processTaskStepAudit.getDescriptionHash())) { + String description = hashToContentMap.get(processTaskStepAudit.getDescriptionHash()); processTaskStepAudit.setDescription(description); } - if(SystemUser.SYSTEM.getUserUuid().equals(processTaskStepAudit.getUserUuid())){ + if (SystemUser.SYSTEM.getUserUuid().equals(processTaskStepAudit.getUserUuid())) { processTaskStepAudit.setUserVo(new WorkAssignmentUnitVo(SystemUser.SYSTEM.getUserVo())); - }else { - UserVo userVo = userMapper.getUserBaseInfoByUuid(processTaskStepAudit.getUserUuid()); - if(userVo == null){ + } else { + UserVo userVo = userMap.get(processTaskStepAudit.getUserUuid()); + if (userVo == null) { userVo = new UserVo(processTaskStepAudit.getUserUuid()); } processTaskStepAudit.setUserVo(new WorkAssignmentUnitVo(userVo)); } - - if(SystemUser.SYSTEM.getUserUuid().equals(processTaskStepAudit.getOriginalUser())){ + if (SystemUser.SYSTEM.getUserUuid().equals(processTaskStepAudit.getOriginalUser())) { processTaskStepAudit.setOriginalUserVo(new WorkAssignmentUnitVo(SystemUser.SYSTEM.getUserVo())); - }else if(StringUtils.isNotBlank(processTaskStepAudit.getOriginalUser())) { - UserVo userVo = userMapper.getUserBaseInfoByUuid(processTaskStepAudit.getOriginalUser()); - if(userVo == null){ + } else if (StringUtils.isNotBlank(processTaskStepAudit.getOriginalUser())) { + UserVo userVo = userMap.get(processTaskStepAudit.getOriginalUser()); + if (userVo == null) { userVo = new UserVo(processTaskStepAudit.getOriginalUser()); } processTaskStepAudit.setOriginalUserVo(new WorkAssignmentUnitVo(userVo)); @@ -142,14 +197,14 @@ public class ProcessTaskAuditListApi extends PrivateApiComponentBase { Iterator iterator = processTaskStepAuditDetailList.iterator(); while (iterator.hasNext()) { ProcessTaskStepAuditDetailVo processTaskStepAuditDetailVo = iterator.next(); - if(ProcessTaskAuditDetailTypeFactory.getNeedCompression(processTaskStepAuditDetailVo.getType())){ + if (ProcessTaskAuditDetailTypeFactory.getNeedCompression(processTaskStepAuditDetailVo.getType())) { String oldContent = processTaskStepAuditDetailVo.getOldContent(); - if(StringUtils.isNotBlank(oldContent)) { - processTaskStepAuditDetailVo.setOldContent(selectContentByHashMapper.getProcessTaskContentStringByHash(oldContent)); + if (StringUtils.isNotBlank(oldContent)) { + processTaskStepAuditDetailVo.setOldContent(hashToContentMap.get(oldContent)); } String newContent = processTaskStepAuditDetailVo.getNewContent(); - if(StringUtils.isNotBlank(newContent)) { - processTaskStepAuditDetailVo.setNewContent(selectContentByHashMapper.getProcessTaskContentStringByHash(newContent)); + if (StringUtils.isNotBlank(newContent)) { + processTaskStepAuditDetailVo.setNewContent(hashToContentMap.get(newContent)); } } IProcessTaskStepAuditDetailHandler auditDetailHandler = ProcessTaskStepAuditDetailHandlerFactory.getHandler(processTaskStepAuditDetailVo.getType()); @@ -166,6 +221,71 @@ public class ProcessTaskAuditListApi extends PrivateApiComponentBase { resultList.sort((e1, e2) -> e2.getId().compareTo(e1.getId())); } return resultList; + +// for (ProcessTaskStepAuditVo processTaskStepAudit : processTaskStepAuditList) { +// if (processTaskStepAudit.getProcessTaskStepId() != null) { +// // 判断当前用户是否有权限查看该节点信息 +// if (!operateMap.computeIfAbsent(processTaskStepAudit.getProcessTaskStepId(), k -> new HashSet<>()).contains(ProcessTaskStepOperationType.STEP_VIEW)) { +// continue; +// } +// ProcessTaskStepVo processTaskStepVo = processTaskStepMap.get(processTaskStepAudit.getProcessTaskStepId()); +// if (processTaskStepVo != null) { +// processTaskStepAudit.setFormSceneUuid(processTaskStepVo.getFormSceneUuid()); +// } +// } +// +// if(StringUtils.isNotBlank(processTaskStepAudit.getDescriptionHash())){ +// String description = selectContentByHashMapper.getProcessTaskContentStringByHash(processTaskStepAudit.getDescriptionHash()); +// processTaskStepAudit.setDescription(description); +// } +// if(SystemUser.SYSTEM.getUserUuid().equals(processTaskStepAudit.getUserUuid())){ +// processTaskStepAudit.setUserVo(new WorkAssignmentUnitVo(SystemUser.SYSTEM.getUserVo())); +// }else { +// UserVo userVo = userMapper.getUserBaseInfoByUuid(processTaskStepAudit.getUserUuid()); +// if(userVo == null){ +// userVo = new UserVo(processTaskStepAudit.getUserUuid()); +// } +// processTaskStepAudit.setUserVo(new WorkAssignmentUnitVo(userVo)); +// } +// +// if(SystemUser.SYSTEM.getUserUuid().equals(processTaskStepAudit.getOriginalUser())){ +// processTaskStepAudit.setOriginalUserVo(new WorkAssignmentUnitVo(SystemUser.SYSTEM.getUserVo())); +// }else if(StringUtils.isNotBlank(processTaskStepAudit.getOriginalUser())) { +// UserVo userVo = userMapper.getUserBaseInfoByUuid(processTaskStepAudit.getOriginalUser()); +// if(userVo == null){ +// userVo = new UserVo(processTaskStepAudit.getOriginalUser()); +// } +// processTaskStepAudit.setOriginalUserVo(new WorkAssignmentUnitVo(userVo)); +// } +// List processTaskStepAuditDetailList = processTaskStepAudit.getAuditDetailList(); +// processTaskStepAuditDetailList.sort(ProcessTaskStepAuditDetailVo::compareTo); +// Iterator iterator = processTaskStepAuditDetailList.iterator(); +// while (iterator.hasNext()) { +// ProcessTaskStepAuditDetailVo processTaskStepAuditDetailVo = iterator.next(); +// if(ProcessTaskAuditDetailTypeFactory.getNeedCompression(processTaskStepAuditDetailVo.getType())){ +// String oldContent = processTaskStepAuditDetailVo.getOldContent(); +// if(StringUtils.isNotBlank(oldContent)) { +// processTaskStepAuditDetailVo.setOldContent(selectContentByHashMapper.getProcessTaskContentStringByHash(oldContent)); +// } +// String newContent = processTaskStepAuditDetailVo.getNewContent(); +// if(StringUtils.isNotBlank(newContent)) { +// processTaskStepAuditDetailVo.setNewContent(selectContentByHashMapper.getProcessTaskContentStringByHash(newContent)); +// } +// } +// IProcessTaskStepAuditDetailHandler auditDetailHandler = ProcessTaskStepAuditDetailHandlerFactory.getHandler(processTaskStepAuditDetailVo.getType()); +// if (auditDetailHandler != null) { +// int isShow = auditDetailHandler.handle(processTaskStepAuditDetailVo); +// if (isShow == 0) { +// iterator.remove(); +// } +// } +// } +// resultList.add(processTaskStepAudit); +// } +// if(CollectionUtils.isNotEmpty(resultList)){ +// resultList.sort((e1, e2) -> e2.getId().compareTo(e1.getId())); +// } +// return resultList; } } diff --git a/src/main/java/neatlogic/module/process/api/processtask/ProcessTaskFlowChartApi.java b/src/main/java/neatlogic/module/process/api/processtask/ProcessTaskFlowChartApi.java index ebb122c0ee5ccdff06d355eda3fe163630fc906d..9e504f388cc2ad65bd5a4f1975cf2b255e4d476e 100644 --- a/src/main/java/neatlogic/module/process/api/processtask/ProcessTaskFlowChartApi.java +++ b/src/main/java/neatlogic/module/process/api/processtask/ProcessTaskFlowChartApi.java @@ -1,18 +1,24 @@ package neatlogic.module.process.api.processtask; +import com.alibaba.fastjson.JSON; +import com.alibaba.fastjson.JSONArray; +import com.alibaba.fastjson.JSONObject; import neatlogic.framework.asynchronization.threadlocal.UserContext; import neatlogic.framework.auth.core.AuthAction; import neatlogic.framework.common.constvalue.ApiParamType; +import neatlogic.framework.common.constvalue.GroupSearch; +import neatlogic.framework.dao.mapper.RoleMapper; +import neatlogic.framework.dao.mapper.TeamMapper; +import neatlogic.framework.dao.mapper.UserMapper; +import neatlogic.framework.dto.RoleVo; +import neatlogic.framework.dto.TeamVo; +import neatlogic.framework.dto.UserVo; +import neatlogic.framework.dto.WorkAssignmentUnitVo; import neatlogic.framework.exception.type.ParamNotExistsException; import neatlogic.framework.process.auth.PROCESS_BASE; import neatlogic.framework.process.constvalue.ProcessTaskStepStatus; import neatlogic.framework.process.constvalue.ProcessTaskStepUserStatus; import neatlogic.framework.process.constvalue.ProcessUserType; -import neatlogic.module.process.dao.mapper.catalog.ChannelMapper; -import neatlogic.module.process.dao.mapper.processtask.ProcessTaskMapper; -import neatlogic.module.process.dao.mapper.processtask.ProcessTaskStepTaskMapper; -import neatlogic.module.process.dao.mapper.SelectContentByHashMapper; -import neatlogic.module.process.dao.mapper.task.TaskMapper; import neatlogic.framework.process.dto.*; import neatlogic.framework.process.exception.channel.ChannelNotFoundException; import neatlogic.framework.process.exception.process.ProcessNotFoundException; @@ -21,11 +27,13 @@ import neatlogic.framework.process.stephandler.core.ProcessStepHandlerFactory; import neatlogic.framework.restful.annotation.*; import neatlogic.framework.restful.constvalue.OperationTypeEnum; import neatlogic.framework.restful.core.privateapi.PrivateApiComponentBase; +import neatlogic.module.process.dao.mapper.SelectContentByHashMapper; +import neatlogic.module.process.dao.mapper.catalog.ChannelMapper; import neatlogic.module.process.dao.mapper.process.ProcessMapper; +import neatlogic.module.process.dao.mapper.processtask.ProcessTaskMapper; +import neatlogic.module.process.dao.mapper.processtask.ProcessTaskStepTaskMapper; +import neatlogic.module.process.dao.mapper.task.TaskMapper; import neatlogic.module.process.service.ProcessTaskService; -import com.alibaba.fastjson.JSONArray; -import com.alibaba.fastjson.JSONObject; -import com.alibaba.fastjson.JSONPath; import org.apache.commons.collections4.CollectionUtils; import org.apache.commons.collections4.MapUtils; import org.apache.commons.lang3.StringUtils; @@ -61,6 +69,15 @@ public class ProcessTaskFlowChartApi extends PrivateApiComponentBase { @Resource private ProcessTaskStepTaskMapper processTaskStepTaskMapper; + @Resource + private UserMapper userMapper; + + @Resource + private TeamMapper teamMapper; + + @Resource + private RoleMapper roleMapper; + @Override public String getToken() { return "processtask/flowchart"; @@ -76,6 +93,11 @@ public class ProcessTaskFlowChartApi extends PrivateApiComponentBase { return null; } + @Override + public boolean disableReturnCircularReferenceDetect() { + return true; + } + @Input({ @Param(name = "processTaskId", type = ApiParamType.LONG, desc = "工单id"), @Param(name = "channelUuid", type = ApiParamType.STRING, desc = "工单id") @@ -105,8 +127,86 @@ public class ProcessTaskFlowChartApi extends PrivateApiComponentBase { } List processTaskStepList = processTaskMapper.getProcessTaskStepListByProcessTaskId(processTaskId); if (CollectionUtils.isNotEmpty(processTaskStepList)) { + Set userUuidSet = new HashSet<>(); + Set teamUuidSet = new HashSet<>(); + Set roleUuidSet = new HashSet<>(); + ProcessTaskStepUserVo searchStepUserVo = new ProcessTaskStepUserVo(); + searchStepUserVo.setProcessTaskId(processTaskId); + List processTaskStepUserList = processTaskMapper.getProcessTaskStepUserList(searchStepUserVo); + for (ProcessTaskStepUserVo stepUserVo : processTaskStepUserList) { + userUuidSet.add(stepUserVo.getUserUuid()); + } + List processTaskStepWorkerList = processTaskMapper.getProcessTaskStepWorkerByProcessTaskIdAndProcessTaskStepId(processTaskId, null); + for (ProcessTaskStepWorkerVo workerVo : processTaskStepWorkerList) { + if (workerVo.getType().equals(GroupSearch.USER.getValue())) { + userUuidSet.add(workerVo.getUuid()); + } else if (workerVo.getType().equals(GroupSearch.TEAM.getValue())) { + teamUuidSet.add(workerVo.getUuid()); + } else if (workerVo.getType().equals(GroupSearch.ROLE.getValue())) { + roleUuidSet.add(workerVo.getUuid()); + } + } + Map userMap = new HashMap<>(); + Map teamMap = new HashMap<>(); + Map roleMap = new HashMap<>(); + List userUuidList = userUuidSet.stream().filter(Objects::nonNull).collect(Collectors.toList()); + if (CollectionUtils.isNotEmpty(userUuidList)) { + List userList = userMapper.getUserByUserUuidList(userUuidList); + userMap = userList.stream().collect(Collectors.toMap(UserVo::getUuid, e -> e)); + } + List teamUuidList = teamUuidSet.stream().filter(Objects::nonNull).collect(Collectors.toList()); + if (CollectionUtils.isNotEmpty(teamUuidList)) { + List teamList = teamMapper.getTeamListContainsDeletedByUuidList(teamUuidList); + teamMap = teamList.stream().collect(Collectors.toMap(TeamVo::getUuid, e -> e)); + } + List roleUuidList = roleUuidSet.stream().filter(Objects::nonNull).collect(Collectors.toList()); + if (CollectionUtils.isNotEmpty(roleUuidList)) { + List roleList = roleMapper.getRoleListContainsDeletedByUuidList(roleUuidList); + roleMap = roleList.stream().collect(Collectors.toMap(RoleVo::getUuid, e -> e)); + } + for (ProcessTaskStepUserVo stepUserVo : processTaskStepUserList) { + UserVo userVo = userMap.get(stepUserVo.getUserUuid()); + if (userVo != null) { + stepUserVo.setUserName(userVo.getUserName()); + } + } + for (ProcessTaskStepWorkerVo workerVo : processTaskStepWorkerList) { + if (workerVo.getType().equals(GroupSearch.USER.getValue())) { + UserVo userVo = userMap.get(workerVo.getUuid()); + if (userVo != null) { + workerVo.setWorker(new WorkAssignmentUnitVo(userVo)); + workerVo.setName(userVo.getUserName()); + } + } else if (workerVo.getType().equals(GroupSearch.TEAM.getValue())) { + TeamVo teamVo = teamMap.get(workerVo.getUuid()); + if (teamVo != null) { + workerVo.setWorker(new WorkAssignmentUnitVo(teamVo)); + workerVo.setName(teamVo.getName()); + } + } else if (workerVo.getType().equals(GroupSearch.ROLE.getValue())) { + RoleVo roleVo = roleMap.get(workerVo.getUuid()); + if (roleVo != null) { + workerVo.setWorker(new WorkAssignmentUnitVo(roleVo)); + workerVo.setName(roleVo.getName()); + } + } + } + Map hash2ConfigMap = new HashMap<>(); + List configHashList = processTaskStepList.stream().map(ProcessTaskStepVo::getConfigHash).filter(Objects::nonNull).collect(Collectors.toList()); + if (CollectionUtils.isNotEmpty(configHashList)) { + List configList = selectContentByHashMapper.getProcessTaskStepConfigListByHashList(configHashList); + for (ProcessTaskStepConfigVo processTaskStepConfigVo : configList) { + hash2ConfigMap.put(processTaskStepConfigVo.getHash(), processTaskStepConfigVo.getConfig()); + } + } for (ProcessTaskStepVo processTaskStepVo : processTaskStepList) { - processTaskService.setProcessTaskStepUser(processTaskStepVo); + String stepConfig = hash2ConfigMap.get(processTaskStepVo.getConfigHash()); + if (StringUtils.isNotBlank(stepConfig)) { + processTaskStepVo.setConfig(JSON.parseObject(stepConfig)); + } else { + processTaskStepVo.setConfig(new JSONObject()); + } + processTaskService.setProcessTaskStepUser(processTaskStepVo, processTaskStepUserList, processTaskStepWorkerList); List minorUserList = processTaskStepVo.getMinorUserList(); if (CollectionUtils.isNotEmpty(minorUserList)) { setMinorUserTaskType(processTaskStepVo, minorUserList); @@ -125,6 +225,7 @@ public class ProcessTaskFlowChartApi extends PrivateApiComponentBase { processTaskStepVo.setSlaTimeList(null); processTaskStepVo.setUserList(null); processTaskStepVo.setWorkerPolicyList(null); + processTaskStepVo.setConfig(null); } } List processTaskStepRelVoList = processTaskMapper.getProcessTaskStepRelByProcessTaskId(processTaskId); @@ -199,8 +300,17 @@ public class ProcessTaskFlowChartApi extends PrivateApiComponentBase { */ private void setMinorUserTaskType(ProcessTaskStepVo processTaskStepVo, List minorUserList) { Map> userUuidTaskConfigNameMap = new HashMap<>(); - String stepConfigStr = selectContentByHashMapper.getProcessTaskStepConfigByHash(processTaskStepVo.getConfigHash()); - JSONObject taskConfig = (JSONObject) JSONPath.read(stepConfigStr, "taskConfig"); + JSONObject stepConfigObj = processTaskStepVo.getConfig(); + if (stepConfigObj == null) { + String config = selectContentByHashMapper.getProcessTaskStepConfigByHash(processTaskStepVo.getConfigHash()); + if (StringUtils.isNotBlank(config)) { + stepConfigObj = JSONObject.parseObject(config); + } else { + stepConfigObj = new JSONObject(); + } + processTaskStepVo.setConfig(stepConfigObj); + } + JSONObject taskConfig = stepConfigObj.getJSONObject("taskConfig"); if (MapUtils.isNotEmpty(taskConfig)) { JSONArray idArray = taskConfig.getJSONArray("idList"); if (CollectionUtils.isNotEmpty(idArray)) { diff --git a/src/main/java/neatlogic/module/process/api/processtask/ProcessTaskStepListApi.java b/src/main/java/neatlogic/module/process/api/processtask/ProcessTaskStepListApi.java index d335e79fbd07ebc5a603d0654c9f0319ae6899d2..0929b550f02a52b4d398b1e636341c8464ecde82 100644 --- a/src/main/java/neatlogic/module/process/api/processtask/ProcessTaskStepListApi.java +++ b/src/main/java/neatlogic/module/process/api/processtask/ProcessTaskStepListApi.java @@ -50,7 +50,7 @@ public class ProcessTaskStepListApi extends PrivateApiComponentBase { @Override public String getToken() { - return "processtask/step/list"; + return "processtask/step/list/old"; } @Override @@ -149,7 +149,7 @@ public class ProcessTaskStepListApi extends PrivateApiComponentBase { startProcessTaskStepVo.setCommentList( processTaskService.getProcessTaskStepReplyListByProcessTaskStepId(startProcessTaskStepVo.getId(), typeList)); //任务列表 - processTaskStepTaskService.getProcessTaskStepTask(startProcessTaskStepVo); +// processTaskStepTaskService.getProcessTaskStepTask(startProcessTaskStepVo); startProcessTaskStepVo.setIsView(1); return startProcessTaskStepVo; } diff --git a/src/main/java/neatlogic/module/process/api/processtask/ProcessTaskStepStatusListApi.java b/src/main/java/neatlogic/module/process/api/processtask/ProcessTaskStepStatusListApi.java index 7e6862ae6c25973f0bf7236db01e58846bc9318f..1a159214a086d1409389ddf0142cdfca2d2a7757 100644 --- a/src/main/java/neatlogic/module/process/api/processtask/ProcessTaskStepStatusListApi.java +++ b/src/main/java/neatlogic/module/process/api/processtask/ProcessTaskStepStatusListApi.java @@ -18,6 +18,7 @@ import java.util.List; @Service @AuthAction(action = PROCESS_BASE.class) @OperationType(type = OperationTypeEnum.SEARCH) +@Deprecated public class ProcessTaskStepStatusListApi extends PrivateApiComponentBase { @Autowired diff --git a/src/main/java/neatlogic/module/process/api/processtask/SearchProcessTaskStepListApi.java b/src/main/java/neatlogic/module/process/api/processtask/SearchProcessTaskStepListApi.java new file mode 100644 index 0000000000000000000000000000000000000000..90b03dc94e9b4ae129aa72cb6a6fe7ea0d650013 --- /dev/null +++ b/src/main/java/neatlogic/module/process/api/processtask/SearchProcessTaskStepListApi.java @@ -0,0 +1,810 @@ +package neatlogic.module.process.api.processtask; + +import com.alibaba.fastjson.JSON; +import com.alibaba.fastjson.JSONArray; +import com.alibaba.fastjson.JSONObject; +import neatlogic.framework.asynchronization.threadlocal.UserContext; +import neatlogic.framework.auth.core.AuthAction; +import neatlogic.framework.common.constvalue.ApiParamType; +import neatlogic.framework.common.constvalue.GroupSearch; +import neatlogic.framework.common.constvalue.systemuser.SystemUser; +import neatlogic.framework.dao.mapper.RoleMapper; +import neatlogic.framework.dao.mapper.TeamMapper; +import neatlogic.framework.dao.mapper.UserMapper; +import neatlogic.framework.dto.RoleVo; +import neatlogic.framework.dto.TeamVo; +import neatlogic.framework.dto.UserVo; +import neatlogic.framework.dto.WorkAssignmentUnitVo; +import neatlogic.framework.exception.type.PermissionDeniedException; +import neatlogic.framework.file.dao.mapper.FileMapper; +import neatlogic.framework.file.dto.FileVo; +import neatlogic.framework.integration.dao.mapper.IntegrationMapper; +import neatlogic.framework.integration.dto.IntegrationVo; +import neatlogic.framework.notify.core.NotifyTriggerTypeFactory; +import neatlogic.framework.process.auth.PROCESS_BASE; +import neatlogic.framework.process.constvalue.*; +import neatlogic.framework.process.dto.*; +import neatlogic.framework.process.exception.operationauth.ProcessTaskPermissionDeniedException; +import neatlogic.framework.process.operationauth.core.IOperationType; +import neatlogic.framework.process.operationauth.core.ProcessAuthManager; +import neatlogic.framework.process.stephandler.core.IProcessStepInternalHandler; +import neatlogic.framework.process.stephandler.core.ProcessStepInternalHandlerFactory; +import neatlogic.framework.restful.annotation.*; +import neatlogic.framework.restful.constvalue.OperationTypeEnum; +import neatlogic.framework.restful.core.privateapi.PrivateApiComponentBase; +import neatlogic.module.process.dao.mapper.SelectContentByHashMapper; +import neatlogic.module.process.dao.mapper.processtask.*; +import neatlogic.module.process.dao.mapper.task.TaskMapper; +import neatlogic.module.process.service.ProcessTaskService; +import neatlogic.module.process.service.ProcessTaskStepTaskService; +import org.apache.commons.collections4.CollectionUtils; +import org.apache.commons.collections4.MapUtils; +import org.apache.commons.lang3.StringUtils; +import org.springframework.beans.BeanUtils; +import org.springframework.stereotype.Service; + +import javax.annotation.Resource; +import java.util.*; +import java.util.stream.Collectors; + +@Service +@AuthAction(action = PROCESS_BASE.class) +@OperationType(type = OperationTypeEnum.SEARCH) +public class SearchProcessTaskStepListApi extends PrivateApiComponentBase { + + @Resource + private ProcessTaskMapper processTaskMapper; + + @Resource + private ProcessTaskService processTaskService; + + @Resource + ProcessTaskStepDataMapper processTaskStepDataMapper; + + @Resource + private ProcessTaskStepTaskService processTaskStepTaskService; + + @Resource + private SelectContentByHashMapper selectContentByHashMapper; + + @Resource + private UserMapper userMapper; + + @Resource + private TeamMapper teamMapper; + + @Resource + private RoleMapper roleMapper; + + @Resource + private FileMapper fileMapper; + + @Resource + private ProcessTaskActionMapper processTaskActionMapper; + @Resource + private IntegrationMapper integrationMapper; + @Resource + ProcessTaskStepTaskMapper processTaskStepTaskMapper; + @Resource + TaskMapper taskMapper; + + @Resource + private ProcessTaskSlaMapper processTaskSlaMapper; + + @Override + public String getToken() { + return "processtask/step/list"; + } + + @Override + public String getName() { + return "工单步骤列表接口"; + } + + @Override + public String getConfig() { + return null; + } + + @Override + public boolean disableReturnCircularReferenceDetect() { + return true; + } + + @Input({ + @Param(name = "processTaskId", type = ApiParamType.LONG, isRequired = true, desc = "term.itsm.processtaskid") + }) + @Output({ + @Param(name = "Return", explode = ProcessTaskStepVo[].class, desc = "common.tbodylist") + }) + @Description(desc = "工单步骤列表接口") + @Override + public Object myDoService(JSONObject jsonObj) throws Exception { + Long processTaskId = jsonObj.getLong("processTaskId"); + ProcessTaskVo processTaskVo = processTaskService.checkProcessTaskParamsIsLegal(processTaskId); + List processTaskStepIdList = new ArrayList<>(); + List resultList = new ArrayList<>(); + List processTaskStepList = processTaskMapper.getProcessTaskStepListByProcessTaskId(processTaskId); + for (ProcessTaskStepVo processTaskStepVo : processTaskStepList) { + if (Objects.equals(processTaskStepVo.getType(), ProcessStepType.START.getValue())) { + resultList.add(processTaskStepVo); + processTaskStepIdList.add(processTaskStepVo.getId()); + } else if (Objects.equals(processTaskStepVo.getType(), ProcessStepType.PROCESS.getValue())) { + if (processTaskStepVo.getActiveTime() != null) { + resultList.add(processTaskStepVo); + processTaskStepIdList.add(processTaskStepVo.getId()); + } + } + } + ProcessAuthManager build = new ProcessAuthManager.Builder() + .addProcessTaskId(processTaskId) + .addOperationType(ProcessTaskOperationType.PROCESSTASK_VIEW) + .addProcessTaskStepId(processTaskStepIdList) + .addOperationType(ProcessTaskStepOperationType.STEP_VIEW) + .build(); + Map> operateMap = build.getOperateMap(); + Set operationTypeList = operateMap.get(processTaskId); + if (CollectionUtils.isEmpty(operationTypeList) || !operationTypeList.contains(ProcessTaskOperationType.PROCESSTASK_VIEW)) { + ProcessTaskPermissionDeniedException processTaskPermissionDeniedException = build.getProcessTaskPermissionDeniedException(processTaskId, ProcessTaskOperationType.PROCESSTASK_VIEW); + if (processTaskPermissionDeniedException != null) { + throw new PermissionDeniedException(processTaskPermissionDeniedException.getMessage()); + } + } + + // 其他处理步骤 + if (CollectionUtils.isNotEmpty(resultList)) { + for (ProcessTaskStepVo processTaskStepVo : resultList) { + // 判断当前用户是否有权限查看该节点信息 + Set processTaskStepOperateSet = operateMap.get(processTaskStepVo.getId()); + if (CollectionUtils.isNotEmpty(processTaskStepOperateSet) + && processTaskStepOperateSet.contains(ProcessTaskStepOperationType.STEP_VIEW)) { + processTaskStepVo.setIsView(1); + } else if (Objects.equals(processTaskStepVo.getType(), ProcessStepType.START.getValue())) { + processTaskStepVo.setIsView(1); + } else { + processTaskStepVo.setIsView(0); + } + } + getProcessTaskStepDetailList(processTaskVo, resultList); + for (ProcessTaskStepVo processTaskStepVo : resultList) { + processTaskStepVo.setIsInTheCurrentStepTab(0); + if (Objects.equals(processTaskStepVo.getIsActive(), 1)) { + if (Objects.equals(processTaskStepVo.getStatus(), ProcessTaskStepStatus.PENDING.getValue()) + || Objects.equals(processTaskStepVo.getStatus(), ProcessTaskStepStatus.RUNNING.getValue()) + || Objects.equals(processTaskStepVo.getStatus(), ProcessTaskStepStatus.HANG.getValue())) { + processTaskStepVo.setIsInTheCurrentStepTab(1); + } + } + } + resultList.sort((o1, o2) -> { + if (o1.getActiveTime() != null && o2.getActiveTime() != null) { + int i = o1.getActiveTime().compareTo(o2.getActiveTime()); + if (i == 0) { + return o1.getId().compareTo(o2.getId()); + } else { + return i; + } + } else { + return -1; + } + }); + } + return resultList; + } + + private void getProcessTaskStepDetailList(ProcessTaskVo processTaskVo, List processTaskStepList) { + Long processTaskId = processTaskVo.getId(); + List processTaskStepIdList = processTaskStepList.stream().map(ProcessTaskStepVo::getId).collect(Collectors.toList()); + ProcessTaskStepUserVo searchStepUserVo = new ProcessTaskStepUserVo(); + searchStepUserVo.setProcessTaskId(processTaskId); + List processTaskStepUserList = processTaskMapper.getProcessTaskStepUserList(searchStepUserVo); + List processTaskStepWorkerList = processTaskMapper.getProcessTaskStepWorkerByProcessTaskIdAndProcessTaskStepId(processTaskId, null); + { + Set userUuidSet = new HashSet<>(); + Set teamUuidSet = new HashSet<>(); + Set roleUuidSet = new HashSet<>(); + for (ProcessTaskStepUserVo stepUserVo : processTaskStepUserList) { + userUuidSet.add(stepUserVo.getUserUuid()); + } + for (ProcessTaskStepWorkerVo workerVo : processTaskStepWorkerList) { + if (workerVo.getType().equals(GroupSearch.USER.getValue())) { + userUuidSet.add(workerVo.getUuid()); + } else if (workerVo.getType().equals(GroupSearch.TEAM.getValue())) { + teamUuidSet.add(workerVo.getUuid()); + } else if (workerVo.getType().equals(GroupSearch.ROLE.getValue())) { + roleUuidSet.add(workerVo.getUuid()); + } + } + Map userMap = new HashMap<>(); + Map teamMap = new HashMap<>(); + Map roleMap = new HashMap<>(); + List userUuidList = userUuidSet.stream().filter(Objects::nonNull).collect(Collectors.toList()); + if (CollectionUtils.isNotEmpty(userUuidList)) { + List userList = userMapper.getUserByUserUuidList(userUuidList); + userMap = userList.stream().collect(Collectors.toMap(UserVo::getUuid, e -> e)); + } + List teamUuidList = teamUuidSet.stream().filter(Objects::nonNull).collect(Collectors.toList()); + if (CollectionUtils.isNotEmpty(teamUuidList)) { + List teamList = teamMapper.getTeamListContainsDeletedByUuidList(teamUuidList); + teamMap = teamList.stream().collect(Collectors.toMap(TeamVo::getUuid, e -> e)); + } + List roleUuidList = roleUuidSet.stream().filter(Objects::nonNull).collect(Collectors.toList()); + if (CollectionUtils.isNotEmpty(roleUuidList)) { + List roleList = roleMapper.getRoleListContainsDeletedByUuidList(roleUuidList); + roleMap = roleList.stream().collect(Collectors.toMap(RoleVo::getUuid, e -> e)); + } + for (ProcessTaskStepUserVo stepUserVo : processTaskStepUserList) { + UserVo userVo = userMap.get(stepUserVo.getUserUuid()); + if (userVo != null) { + stepUserVo.setUserName(userVo.getUserName()); + } + } + for (ProcessTaskStepWorkerVo workerVo : processTaskStepWorkerList) { + if (workerVo.getType().equals(GroupSearch.USER.getValue())) { + UserVo userVo = userMap.get(workerVo.getUuid()); + if (userVo != null) { + workerVo.setWorker(new WorkAssignmentUnitVo(userVo)); + workerVo.setName(userVo.getUserName()); + } + } else if (workerVo.getType().equals(GroupSearch.TEAM.getValue())) { + TeamVo teamVo = teamMap.get(workerVo.getUuid()); + if (teamVo != null) { + workerVo.setWorker(new WorkAssignmentUnitVo(teamVo)); + workerVo.setName(teamVo.getName()); + } + } else if (workerVo.getType().equals(GroupSearch.ROLE.getValue())) { + RoleVo roleVo = roleMap.get(workerVo.getUuid()); + if (roleVo != null) { + workerVo.setWorker(new WorkAssignmentUnitVo(roleVo)); + workerVo.setName(roleVo.getName()); + } + } + } + } + ProcessTaskStepDataVo searchStepDataVo = new ProcessTaskStepDataVo(); + searchStepDataVo.setProcessTaskId(processTaskId); + List processTaskStepDataList = processTaskStepDataMapper.searchProcessTaskStepData(searchStepDataVo); + List focusUserList = processTaskMapper.getFocusUserListByTaskId(processTaskId); + { + Map hash2ConfigMap = new HashMap<>(); + List configHashList = processTaskStepList.stream().map(ProcessTaskStepVo::getConfigHash).filter(Objects::nonNull).collect(Collectors.toList()); + if (CollectionUtils.isNotEmpty(configHashList)) { + List configList = selectContentByHashMapper.getProcessTaskStepConfigListByHashList(configHashList); + for (ProcessTaskStepConfigVo processTaskStepConfigVo : configList) { + hash2ConfigMap.put(processTaskStepConfigVo.getHash(), processTaskStepConfigVo.getConfig()); + } + } + for (ProcessTaskStepVo processTaskStepVo : processTaskStepList) { + String stepConfig = hash2ConfigMap.get(processTaskStepVo.getConfigHash()); + if (StringUtils.isNotBlank(stepConfig)) { + processTaskStepVo.setConfig(JSON.parseObject(stepConfig)); + } else { + processTaskStepVo.setConfig(new JSONObject()); + } + } + } + List processTaskStepReplyList = getProcessTaskStepReplyListByProcessTaskId(processTaskVo, processTaskStepList, processTaskStepUserList, processTaskStepWorkerList, focusUserList); + List processTaskActionList = getProcessTaskActionListByProcessTaskId(processTaskVo.getId()); + Map> processTaskStepId2SlaIdListMap = new HashMap<>(); + Set slaIdSet = new HashSet<>(); + List> processTaskStepSlaList = processTaskSlaMapper.getProcessTaskStepSlaListByProcessTaskStepIdList(processTaskStepIdList); + for (Map processTaskStepSlaMap : processTaskStepSlaList) { + Long processTaskStepId = processTaskStepSlaMap.get("processTaskStepId"); + Long slaId = processTaskStepSlaMap.get("slaId"); + processTaskStepId2SlaIdListMap.computeIfAbsent(processTaskStepId, key -> new ArrayList<>()).add(slaId); + slaIdSet.add(slaId); + } + List processTaskSlaTimeList = processTaskService.getSlaTimeListBySlaIdList(new ArrayList<>(slaIdSet)); + List processTaskStepTaskList = getProcessTaskStepTaskListByProcessTaskId(processTaskVo, processTaskStepList); + List allTaskConfigList = getAllTaskConfigList(processTaskStepList); + for (ProcessTaskStepVo processTaskStepVo : processTaskStepList) { + if (Objects.equals(processTaskStepVo.getIsView(), 1)) { + // 处理人列表 + processTaskService.setProcessTaskStepUser(processTaskStepVo, processTaskStepUserList, processTaskStepWorkerList); + // 当前步骤特有步骤信息 + IProcessStepInternalHandler processStepUtilHandler = ProcessStepInternalHandlerFactory.getHandler(processTaskStepVo.getHandler()); + if (processStepUtilHandler != null) { + if (Objects.equals(processTaskStepVo.getType(), ProcessStepType.START.getValue())) { + processTaskStepVo.setHandlerStepInfo(processStepUtilHandler.getStartStepInfo(processTaskStepVo)); + } else { + processTaskStepVo.setHandlerStepInfo(processStepUtilHandler.getNonStartStepInfo(processTaskStepVo)); + } + } + // 步骤评论列表 + List commentList = new ArrayList<>(); + for (ProcessTaskStepReplyVo processTaskStepReplyVo : processTaskStepReplyList) { + if (Objects.equals(processTaskStepReplyVo.getProcessTaskStepId(), processTaskStepVo.getId())) { + commentList.add(processTaskStepReplyVo); + } + } + commentList.sort((o1, o2) -> o2.getId().compareTo(o1.getId())); + processTaskStepVo.setCommentList(commentList); + if (Objects.equals(processTaskStepVo.getType(), ProcessStepType.START.getValue())) { + for (ProcessTaskStepReplyVo comment : commentList) { + if (ProcessTaskOperationType.PROCESSTASK_START.getValue().equals(comment.getType())) { + processTaskStepVo.setComment(comment); + break; + } + } + } + // 动作列表 + List actionList = new ArrayList<>(); + for (ProcessTaskActionVo processTaskActionVo : processTaskActionList) { + if (Objects.equals(processTaskActionVo.getProcessTaskStepId(), processTaskStepVo.getId())) { + actionList.add(processTaskActionVo); + } + } + processTaskStepVo.setActionList(actionList); + //任务列表 + List taskConfigList = getTaskConfigList(processTaskStepVo, processTaskStepTaskList, allTaskConfigList); + processTaskStepVo.setTaskConfigList(taskConfigList); + // 时效列表 + List slaTimeList = new ArrayList<>(); + List slaIdList = processTaskStepId2SlaIdListMap.get(processTaskStepVo.getId()); + if (CollectionUtils.isNotEmpty(slaIdList)) { + for (ProcessTaskSlaTimeVo processTaskSlaTimeVo : processTaskSlaTimeList) { + if (slaIdList.contains(processTaskSlaTimeVo.getSlaId())) { + slaTimeList.add(processTaskSlaTimeVo); + } + } + } + processTaskStepVo.setSlaTimeList(slaTimeList); + // automatic processtaskStepData + ProcessTaskStepDataVo stepDataVo = null; + for (ProcessTaskStepDataVo processTaskStepDataVo : processTaskStepDataList) { + if (Objects.equals(processTaskStepDataVo.getProcessTaskStepId(), processTaskStepVo.getId()) + && Objects.equals(processTaskStepDataVo.getType(), processTaskStepVo.getHandler()) + && processTaskStepDataVo.getFcu() != null && Objects.equals(processTaskStepDataVo.getFcu().toLowerCase(), SystemUser.SYSTEM.getUserUuid()) + ) { + stepDataVo = processTaskStepDataVo; + break; + } + } + if (stepDataVo != null) { + JSONObject stepDataJson = stepDataVo.getData(); + boolean isStepUser = false; + for (ProcessTaskStepUserVo processTaskStepUserVo : processTaskStepUserList) { + if (Objects.equals(processTaskStepUserVo.getProcessTaskStepId(), processTaskStepVo.getId()) + && Objects.equals(processTaskStepUserVo.getUserUuid(), UserContext.get().getUserUuid()) + ) { + isStepUser = true; + } + } + stepDataJson.put("isStepUser", isStepUser ? 1 : 0); + processTaskStepVo.setProcessTaskStepData(stepDataJson); + } + processTaskStepVo.setReplaceableTextList(processTaskService.getReplaceableTextList(processTaskStepVo)); + processTaskStepVo.setCustomStatusList(processTaskService.getCustomStatusList(processTaskStepVo)); + processTaskStepVo.setCustomButtonList(processTaskService.getCustomButtonList(processTaskStepVo)); + } + processTaskStepVo.setConfig(null); + } + } + + + private List getProcessTaskStepReplyListByProcessTaskId( + ProcessTaskVo processTaskVo, + List processTaskStepList, + List processTaskStepUserList, + List processTaskStepWorkerList, + List focusUserList + ) { + List typeList = new ArrayList<>(); + typeList.add(ProcessTaskStepOperationType.STEP_COMMENT.getValue()); + typeList.add(ProcessTaskStepOperationType.STEP_COMPLETE.getValue()); + typeList.add(ProcessTaskStepOperationType.STEP_BACK.getValue()); + typeList.add(ProcessTaskOperationType.PROCESSTASK_RETREAT.getValue()); + typeList.add(ProcessTaskOperationType.PROCESSTASK_TRANSFER.getValue()); + typeList.add(ProcessTaskStepOperationType.STEP_REAPPROVAL.getValue()); + typeList.add(ProcessTaskOperationType.PROCESSTASK_START.getValue()); + typeList.add(ProcessTaskStepOperationType.STEP_TRANSFER.getValue()); + List processTaskStepReplyList = new ArrayList<>(); + { + List stepContentIdList = new ArrayList<>(); + Set contentHashSet = new HashSet<>(); + List processTaskStepContentList = processTaskMapper.getProcessTaskStepContentByProcessTaskId(processTaskVo.getId()); + for (ProcessTaskStepContentVo processTaskStepContentVo : processTaskStepContentList) { + stepContentIdList.add(processTaskStepContentVo.getId()); + if (processTaskStepContentVo.getContentHash() != null) { + contentHashSet.add(processTaskStepContentVo.getContentHash()); + } + } + Map fileMap = new HashMap<>(); + List processTaskStepFileList = processTaskMapper.getProcessTaskStepFileListByTaskId(processTaskVo.getId()); + Set fileIdSet = processTaskStepFileList.stream().map(ProcessTaskStepFileVo::getFileId).collect(Collectors.toSet()); + if (CollectionUtils.isNotEmpty(fileIdSet)) { + List fileList = fileMapper.getFileListByIdList(new ArrayList<>(fileIdSet)); + fileMap = fileList.stream().collect(Collectors.toMap(FileVo::getId, e -> e)); + } + List processTaskStepContentTargetList = new ArrayList<>(); + if (CollectionUtils.isNotEmpty(stepContentIdList)) { + processTaskStepContentTargetList = processTaskMapper.getTargetListByContentIdList(stepContentIdList); + } + Map hash2ContentMap = new HashMap<>(); + if (CollectionUtils.isNotEmpty(contentHashSet)) { + List processTaskContentList = selectContentByHashMapper.getProcessTaskContentListByHashList(new ArrayList<>(contentHashSet)); + hash2ContentMap = processTaskContentList.stream().collect(Collectors.toMap(ProcessTaskContentVo::getHash, ProcessTaskContentVo::getContent)); + } + for (ProcessTaskStepContentVo processTaskStepContentVo : processTaskStepContentList) { + if (typeList.contains(processTaskStepContentVo.getType())) { + ProcessTaskStepReplyVo processTaskStepReplyVo = new ProcessTaskStepReplyVo(processTaskStepContentVo); + if (processTaskStepReplyVo.getContentHash() != null) { + processTaskStepReplyVo.setContent(hash2ContentMap.get(processTaskStepReplyVo.getContentHash())); + } + List fileIdList = processTaskStepFileList.stream().filter(processTaskStepFileVo -> Objects.equals(processTaskStepFileVo.getContentId(), processTaskStepReplyVo.getId())).map(ProcessTaskStepFileVo::getFileId).collect(Collectors.toList()); + if (CollectionUtils.isNotEmpty(fileIdList)) { + List fileList = new ArrayList<>(); + for (Long fileId : fileIdList) { + FileVo fileVo = fileMap.get(fileId); + if (fileVo != null) { + fileList.add(fileVo); + } + } + if (CollectionUtils.isNotEmpty(fileList)) { + processTaskStepReplyVo.setFileList(fileList); + processTaskStepReplyVo.setFileIdList(fileList.stream().map(FileVo::getId).collect(Collectors.toList())); + } + } + List targetList = new ArrayList<>(); + for (ProcessTaskStepContentTargetVo processTaskStepContentTargetVo : processTaskStepContentTargetList) { + if (Objects.equals(processTaskStepContentTargetVo.getContentId(), processTaskStepReplyVo.getId())) { + WorkAssignmentUnitVo workAssignmentUnitVo = new WorkAssignmentUnitVo(); + workAssignmentUnitVo.setInitType(processTaskStepContentTargetVo.getType()); + workAssignmentUnitVo.setUuid(processTaskStepContentTargetVo.getUuid()); + targetList.add(workAssignmentUnitVo); + } + } + processTaskStepReplyVo.setTargetList(targetList); + processTaskStepReplyList.add(processTaskStepReplyVo); + } + } + } + List processUserTypeList = new ArrayList<>(); + processUserTypeList.add(ProcessUserType.OWNER); + processUserTypeList.add(ProcessUserType.REPORTER); + processUserTypeList.add(ProcessUserType.MAJOR); + processUserTypeList.add(ProcessUserType.MINOR); + processUserTypeList.add(ProcessUserType.FOCUS_USER); + for (ProcessTaskStepVo processTaskStepVo : processTaskStepList) { + Map> processUserTypeListMap = getProcessTaskStepProcessUserTypeData(processTaskVo, processTaskStepVo, processTaskStepUserList, processTaskStepWorkerList, focusUserList, processUserTypeList); + for (ProcessTaskStepReplyVo processTaskStepReplyVo : processTaskStepReplyList) { + if (Objects.equals(processTaskStepReplyVo.getProcessTaskStepId(), processTaskStepVo.getId())) { + if (Objects.equals(processTaskStepVo.getStatus(), ProcessTaskStepStatus.RUNNING.getValue()) + && Objects.equals(UserContext.get().getUserUuid(), processTaskStepReplyVo.getFcu())) { + processTaskStepReplyVo.setIsEditable(1); + processTaskStepReplyVo.setIsDeletable(1); + } else { + processTaskStepReplyVo.setIsEditable(0); + processTaskStepReplyVo.setIsDeletable(0); + } + List operatorProcessUserTypeList = new ArrayList<>(); + for (Map.Entry> entry : processUserTypeListMap.entrySet()) { + List uuidList = entry.getValue(); + if (CollectionUtils.isEmpty(uuidList)) { + continue; + } + for (String uuid : uuidList) { + if (processTaskStepReplyVo.getLcu() != null && uuid.contains(processTaskStepReplyVo.getLcu())) { + operatorProcessUserTypeList.add(entry.getKey()); + break; + } + } + } + List operatorProcessUserTypeTextList = new ArrayList<>(operatorProcessUserTypeList.size()); + for (ProcessUserType processUserType : operatorProcessUserTypeList) { + operatorProcessUserTypeTextList.add(processUserType.getText()); + } + processTaskStepReplyVo.setOperatorRole(String.join("、", operatorProcessUserTypeTextList)); + } + } + } + return processTaskStepReplyList; + } + + + private Map> getProcessTaskStepProcessUserTypeData( + ProcessTaskVo processTaskVo, + ProcessTaskStepVo processTaskStepVo, + List processTaskStepUserList, + List processTaskStepWorkerList, + List focusUserList, + List processUserTypeList + ) { + Map> resultMap = new LinkedHashMap<>(); + if (processTaskVo != null) { + /* 上报人 **/ + if (StringUtils.isNotBlank(processTaskVo.getOwner()) && processUserTypeList.contains(ProcessUserType.OWNER)) { + resultMap.computeIfAbsent(ProcessUserType.OWNER, k -> new ArrayList<>()) + .add(GroupSearch.USER.addPrefix(processTaskVo.getOwner())); + } + /* 代报人 **/ + if (StringUtils.isNotBlank(processTaskVo.getReporter()) && processUserTypeList.contains(ProcessUserType.REPORTER)) { + resultMap.computeIfAbsent(ProcessUserType.REPORTER, k -> new ArrayList<>()) + .add(GroupSearch.USER.addPrefix(processTaskVo.getReporter())); + } + } + if (processUserTypeList.contains(ProcessUserType.MAJOR)) { + /* 主处理人 **/ + List majorUserList = new ArrayList<>(); + for (ProcessTaskStepUserVo processTaskStepUserVo : processTaskStepUserList) { + if (Objects.equals(processTaskStepUserVo.getProcessTaskStepId(), processTaskStepVo.getId()) + && Objects.equals(processTaskStepUserVo.getUserType(), ProcessUserType.MAJOR.getValue())) { + majorUserList.add(processTaskStepUserVo); + } + } + for (ProcessTaskStepUserVo processTaskStepUserVo : majorUserList) { + resultMap.computeIfAbsent(ProcessUserType.MAJOR, k -> new ArrayList<>()) + .add(GroupSearch.USER.addPrefix(processTaskStepUserVo.getUserUuid())); + } + } + if (processUserTypeList.contains(ProcessUserType.MINOR)) { + /* 所有任务处理人 **/ + List minorUserList = new ArrayList<>(); + for (ProcessTaskStepUserVo processTaskStepUserVo : processTaskStepUserList) { + if (Objects.equals(processTaskStepUserVo.getProcessTaskStepId(), processTaskStepVo.getId()) + && Objects.equals(processTaskStepUserVo.getUserType(), ProcessUserType.MINOR.getValue())) { + minorUserList.add(processTaskStepUserVo); + } + } + for (ProcessTaskStepUserVo processTaskStepUserVo : minorUserList) { + resultMap.computeIfAbsent(ProcessUserType.MINOR, k -> new ArrayList<>()) + .add(GroupSearch.USER.addPrefix(processTaskStepUserVo.getUserUuid())); + } + } + if (processUserTypeList.contains(ProcessUserType.WORKER)) { + /* 待处理人 **/ + for (ProcessTaskStepWorkerVo processTaskStepWorkerVo : processTaskStepWorkerList) { + if (Objects.equals(processTaskStepWorkerVo.getProcessTaskStepId(), processTaskStepVo.getId())) { + resultMap.computeIfAbsent(ProcessUserType.WORKER, k -> new ArrayList<>()).add(processTaskStepWorkerVo.getType() + "#" + processTaskStepWorkerVo.getUuid()); + } + } + } + if (processUserTypeList.contains(ProcessUserType.FOCUS_USER)) { + /* 工单关注人 */ + for (String focusUser : focusUserList) { + resultMap.computeIfAbsent(ProcessUserType.FOCUS_USER, k -> new ArrayList<>()) + .add(focusUser); + } + } + if (processUserTypeList.contains(ProcessUserType.DEFAULT_WORKER)) { + JSONObject config = processTaskStepVo.getConfig(); + /* 异常处理人 **/ + String defaultWorker = config.getString("workerPolicyConfig.defaultWorker"); + if (StringUtils.isNotBlank(defaultWorker)) { + resultMap.computeIfAbsent(ProcessUserType.DEFAULT_WORKER, k -> new ArrayList<>()) + .add(defaultWorker); + } + } + return resultMap; + } + + private List getProcessTaskActionListByProcessTaskId(Long processTaskId) { + List processTaskActionList = processTaskActionMapper.getProcessTaskActionListByProcessTaskId(processTaskId); + if (CollectionUtils.isNotEmpty(processTaskActionList)) { + List integrationUuidList = processTaskActionList.stream().map(ProcessTaskActionVo::getIntegrationUuid).collect(Collectors.toList()); + List integrationList = integrationMapper.getIntegrationListByUuidList(integrationUuidList); + Map uuid2NameMap = integrationList.stream().collect(Collectors.toMap(IntegrationVo::getUuid, IntegrationVo::getName)); + for (ProcessTaskActionVo processTaskActionVo : processTaskActionList) { + String integrationName = uuid2NameMap.get(processTaskActionVo.getIntegrationUuid()); + if (StringUtils.isNotBlank(integrationName)) { + processTaskActionVo.setIntegrationName(integrationName); + } else { + JSONObject config = processTaskActionVo.getConfig(); + if (MapUtils.isNotEmpty(config)) { + integrationName = config.getString("integrationName"); + if (StringUtils.isNotBlank(integrationName)) { + processTaskActionVo.setIntegrationName(integrationName); + } + } + } + if (Objects.equals(processTaskActionVo.getStatus(), "succeed")) { + processTaskActionVo.setStatusText("已成功"); + } else { + processTaskActionVo.setStatusText("已失败"); + } + String triggerText = NotifyTriggerTypeFactory.getText(processTaskActionVo.getTrigger()); + if(StringUtils.isNotBlank(triggerText)) { + processTaskActionVo.setTriggerText(triggerText); + } + } + } + return processTaskActionList; + } + + private List getAllTaskConfigList(List processTaskStepList) { + JSONArray idList = new JSONArray(); + for (ProcessTaskStepVo processTaskStepVo : processTaskStepList) { + JSONObject config = processTaskStepVo.getConfig(); + JSONObject taskConfig = config.getJSONObject("taskConfig"); + if (MapUtils.isNotEmpty(taskConfig)) { + JSONArray idArray = taskConfig.getJSONArray("idList"); + if (CollectionUtils.isNotEmpty(idArray)) { + for (int i = 0; i < idArray.size(); i++) { + Long id = idArray.getLong(i); + if (id != null && !idList.contains(id)) { + idList.add(id); + } + } + } + } + } + if (CollectionUtils.isNotEmpty(idList)) { + return taskMapper.getTaskConfigByIdList(idList); + } + return new ArrayList<>(); + } + /** + * 解析&校验 任务配置 + * + * @param processTaskStepVo 步骤 + * @return 任务配置 + */ + public JSONObject getTaskConfig(ProcessTaskStepVo processTaskStepVo) { + JSONObject config = processTaskStepVo.getConfig(); + if (MapUtils.isNotEmpty(config)) { + JSONObject taskConfig = config.getJSONObject("taskConfig"); + if (MapUtils.isNotEmpty(taskConfig)) { + return taskConfig; + } + } + return null; + } + + /** + * 获取步骤的任务策略列表及其任务列表 + * + * @param processTaskStepVo 步骤信息 + */ + + public List getTaskConfigList(ProcessTaskStepVo processTaskStepVo, List processTaskStepTaskList, List allTaskConfigList) { + JSONObject taskConfig = getTaskConfig(processTaskStepVo); + if (MapUtils.isEmpty(taskConfig)) { + return null; + } + JSONArray idArray = taskConfig.getJSONArray("idList"); + if (CollectionUtils.isEmpty(idArray)) { + return null; + } + List rangeList = null; + JSONArray rangeArray = taskConfig.getJSONArray("rangeList"); + if (CollectionUtils.isNotEmpty(rangeArray)) { + rangeList = rangeArray.toJavaList(String.class); + } + List taskConfigList = new ArrayList<>(); + List idList = idArray.toJavaList(Long.class); + for (Long id : idList) { + for (TaskConfigVo taskConfigVo : allTaskConfigList) { + if (Objects.equals(taskConfigVo.getId(), id)) { + TaskConfigVo newTaskConfigVo = new TaskConfigVo(); + newTaskConfigVo.setId(taskConfigVo.getId()); + newTaskConfigVo.setName(taskConfigVo.getName()); + newTaskConfigVo.setNum(taskConfigVo.getNum()); + newTaskConfigVo.setPolicy(taskConfigVo.getPolicy()); + newTaskConfigVo.setIsActive(taskConfigVo.getIsActive()); + newTaskConfigVo.setConfig(taskConfigVo.getConfig()); + newTaskConfigVo.setFcd(taskConfigVo.getFcd()); + newTaskConfigVo.setFcu(taskConfigVo.getFcu()); + newTaskConfigVo.setLcd(taskConfigVo.getLcd()); + newTaskConfigVo.setLcu(taskConfigVo.getLcu()); + newTaskConfigVo.setRangeList(rangeList); + List stepTaskList = new ArrayList<>(); + for (ProcessTaskStepTaskVo processTaskStepTaskVo : processTaskStepTaskList) { + if (Objects.equals(processTaskStepTaskVo.getProcessTaskStepId(), processTaskStepVo.getId()) + && Objects.equals(processTaskStepTaskVo.getTaskConfigId(), id) + ) { + stepTaskList.add(processTaskStepTaskVo); + } + } + if (CollectionUtils.isNotEmpty(stepTaskList)) { + newTaskConfigVo.setProcessTaskStepTaskList(stepTaskList); + } + taskConfigList.add(newTaskConfigVo); + break; + } + } + } + if (CollectionUtils.isNotEmpty(taskConfigList)) { + return taskConfigList; + } + return null; + } + + private List getProcessTaskStepTaskListByProcessTaskId( + ProcessTaskVo processTaskVo, + List processTaskStepList + ) { + List processTaskStepTaskList = processTaskStepTaskMapper.getStepTaskByProcessTaskId(processTaskVo.getId()); + if (CollectionUtils.isEmpty(processTaskStepTaskList)) { + return processTaskStepTaskList; + } + Map processTaskStepMap = processTaskStepList.stream().collect(Collectors.toMap(ProcessTaskStepVo::getId, e -> e)); + Map> stepTaskUserMap = new HashMap<>(); + List stepTaskIdList = new ArrayList<>(); + Map stepTaskId2StepIdMap = new HashMap<>(); + for (ProcessTaskStepTaskVo processTaskStepTaskVo : processTaskStepTaskList) { + stepTaskId2StepIdMap.put(processTaskStepTaskVo.getId(), processTaskStepTaskVo.getProcessTaskStepId()); + stepTaskIdList.add(processTaskStepTaskVo.getId()); + } + List stepTaskUserList = processTaskStepTaskMapper.getStepTaskUserByStepTaskIdList(stepTaskIdList); + if (CollectionUtils.isNotEmpty(stepTaskUserList)) { + List stepTaskUserIdList = stepTaskUserList.stream().map(ProcessTaskStepTaskUserVo::getId).collect(Collectors.toList()); + List stepTaskUserAgentList = processTaskStepTaskMapper.getProcessTaskStepTaskUserAgentListByStepTaskUserIdList(stepTaskUserIdList); + Map stepTaskUserAgentMap = stepTaskUserAgentList.stream().collect(Collectors.toMap(ProcessTaskStepTaskUserAgentVo::getProcessTaskStepTaskUserId, ProcessTaskStepTaskUserAgentVo::getUserUuid)); + Map userMap = new HashMap<>(); + List userUuidList = new ArrayList<>(stepTaskUserAgentMap.values()); + if (CollectionUtils.isNotEmpty(userUuidList)) { + List userList = userMapper.getUserByUserUuidList(userUuidList); + userMap = userList.stream().collect(Collectors.toMap(UserVo::getUuid, e -> e)); + } + List stepTaskUserContentList = processTaskStepTaskMapper.getStepTaskUserContentByStepTaskUserIdList(stepTaskUserIdList); + Map stepTaskUserContentMap = new HashMap<>(); + for (ProcessTaskStepTaskUserContentVo stepTaskUserContentVo : stepTaskUserContentList) { + if (stepTaskUserContentMap.containsKey(stepTaskUserContentVo.getProcessTaskStepTaskUserId())) { + continue; + } + stepTaskUserContentMap.put(stepTaskUserContentVo.getProcessTaskStepTaskUserId(), stepTaskUserContentVo); + } + Map fileMap = new HashMap<>(); + Set fileIdSet = new HashSet<>(); + Map> stepTaskUserFileIdListMap = new HashMap<>(); + List processTaskStepTaskUserFileList = processTaskStepTaskMapper.getStepTaskUserFileListByStepTaskUserIdList(stepTaskUserIdList); + for (ProcessTaskStepTaskUserFileVo stepTaskUserFileVo : processTaskStepTaskUserFileList) { + fileIdSet.add(stepTaskUserFileVo.getFileId()); + stepTaskUserFileIdListMap.computeIfAbsent(stepTaskUserFileVo.getProcessTaskStepTaskUserId(), key -> new ArrayList<>()).add(stepTaskUserFileVo.getFileId()); + } + List allFileIdList = fileIdSet.stream().filter(Objects::nonNull).collect(Collectors.toList()); + if (CollectionUtils.isNotEmpty(allFileIdList)) { + List allFileList = fileMapper.getFileListByIdList(allFileIdList); + fileMap = allFileList.stream().collect(Collectors.toMap(FileVo::getId, e -> e)); + } + for (ProcessTaskStepTaskUserVo stepTaskUserVo : stepTaskUserList) { + if (stepTaskUserVo.getEndTime() == null && stepTaskUserVo.getIsDelete() == 1) { + continue; + } + int isReplyable = 0; + try { + Long processTaskStepId = stepTaskId2StepIdMap.get(stepTaskUserVo.getProcessTaskStepTaskId()); + ProcessTaskStepVo processTaskStepVo = processTaskStepMap.get(processTaskStepId); + isReplyable = processTaskStepTaskService.checkIsReplyable(processTaskVo, processTaskStepVo, stepTaskUserVo.getUserUuid(), stepTaskUserVo.getId()); + } catch (ProcessTaskPermissionDeniedException processTaskPermissionDeniedException) { + isReplyable = 0; + } + stepTaskUserVo.setIsReplyable(isReplyable); + String originalUserUuid = stepTaskUserAgentMap.get(stepTaskUserVo.getId()); + if (StringUtils.isNotBlank(originalUserUuid)) { + stepTaskUserVo.setOriginalUserUuid(originalUserUuid); + UserVo userVo = userMap.get(originalUserUuid); + if (userVo != null) { + UserVo originalUserVo = new UserVo(); + BeanUtils.copyProperties(userVo, originalUserVo); + stepTaskUserVo.setOriginalUserVo(originalUserVo); + } + } + ProcessTaskStepTaskUserContentVo stepTaskUserContentVo = stepTaskUserContentMap.get(stepTaskUserVo.getId()); + if (stepTaskUserContentVo != null) { + stepTaskUserVo.setContent(stepTaskUserContentVo.getContent()); + stepTaskUserVo.setProcessTaskStepTaskUserContentId(stepTaskUserContentVo.getId()); + } + stepTaskUserMap.computeIfAbsent(stepTaskUserVo.getProcessTaskStepTaskId(), key -> new ArrayList<>()).add(stepTaskUserVo); + + List fileIdList = stepTaskUserFileIdListMap.get(stepTaskUserVo.getId()); + if (CollectionUtils.isNotEmpty(fileIdList)) { + stepTaskUserVo.setFileIdList(fileIdList); + List fileList = new ArrayList<>(); + for (Long fileId : fileIdList) { + FileVo fileVo = fileMap.get(fileId); + if (fileVo != null) { + fileList.add(fileVo); + } + } + stepTaskUserVo.setFileList(fileList); + } + } + } + for (ProcessTaskStepTaskVo stepTaskVo : processTaskStepTaskList) { + List processTaskStepTaskUserList = stepTaskUserMap.get(stepTaskVo.getId()); + stepTaskVo.setStepTaskUserVoList(processTaskStepTaskUserList); + } + return processTaskStepTaskList; + } +} diff --git a/src/main/java/neatlogic/module/process/api/processtask/task/ProcessTaskStepTaskGetApi.java b/src/main/java/neatlogic/module/process/api/processtask/task/ProcessTaskStepTaskGetApi.java index 930d1487f9424fead950d86b6dfe6b4609dbe395..d5b1364f20ddf0b2f314028846e20f950f43b87e 100644 --- a/src/main/java/neatlogic/module/process/api/processtask/task/ProcessTaskStepTaskGetApi.java +++ b/src/main/java/neatlogic/module/process/api/processtask/task/ProcessTaskStepTaskGetApi.java @@ -15,19 +15,15 @@ along with this program. If not, see .*/ package neatlogic.module.process.api.processtask.task; +import com.alibaba.fastjson.JSONObject; import neatlogic.framework.auth.core.AuthAction; import neatlogic.framework.common.constvalue.ApiParamType; import neatlogic.framework.process.auth.PROCESS_BASE; -import neatlogic.framework.process.constvalue.ProcessTaskStepStatus; -import neatlogic.module.process.dao.mapper.processtask.ProcessTaskMapper; -import neatlogic.framework.process.dto.ProcessTaskStepVo; -import neatlogic.framework.process.exception.processtask.ProcessTaskStepNotFoundException; import neatlogic.framework.restful.annotation.*; import neatlogic.framework.restful.constvalue.OperationTypeEnum; import neatlogic.framework.restful.core.privateapi.PrivateApiComponentBase; +import neatlogic.module.process.dao.mapper.processtask.ProcessTaskMapper; import neatlogic.module.process.service.ProcessTaskStepTaskService; -import com.alibaba.fastjson.JSONObject; -import org.springframework.stereotype.Service; import javax.annotation.Resource; @@ -35,7 +31,7 @@ import javax.annotation.Resource; * @author lvzk * @since 2021/8/31 11:03 **/ -@Service +//@Service @OperationType(type = OperationTypeEnum.OPERATE) @AuthAction(action = PROCESS_BASE.class) @Deprecated @@ -68,14 +64,15 @@ public class ProcessTaskStepTaskGetApi extends PrivateApiComponentBase { @Description(desc = "获取工单步骤任务接口") @Override public Object myDoService(JSONObject jsonObj) throws Exception { - Long processTaskStepId = jsonObj.getLong("id"); - ProcessTaskStepVo processTaskStepVo = processTaskMapper.getProcessTaskStepBaseInfoById(processTaskStepId); - if(processTaskStepVo == null){ - throw new ProcessTaskStepNotFoundException(processTaskStepId.toString()); - } - if (processTaskStepVo.getIsActive() == 1 && ProcessTaskStepStatus.RUNNING.getValue().equals(processTaskStepVo.getStatus())) { - processTaskStepTaskService.getProcessTaskStepTask(processTaskStepVo); - } - return processTaskStepVo.getProcessTaskStepTask(); +// Long processTaskStepId = jsonObj.getLong("id"); +// ProcessTaskStepVo processTaskStepVo = processTaskMapper.getProcessTaskStepBaseInfoById(processTaskStepId); +// if(processTaskStepVo == null){ +// throw new ProcessTaskStepNotFoundException(processTaskStepId.toString()); +// } +// if (processTaskStepVo.getIsActive() == 1 && ProcessTaskStepStatus.RUNNING.getValue().equals(processTaskStepVo.getStatus())) { +// processTaskStepTaskService.getProcessTaskStepTask(processTaskStepVo); +// } +// return processTaskStepVo.getProcessTaskStepTask(); + return null; } } diff --git a/src/main/java/neatlogic/module/process/audithandler/handler/FormAuditHandler.java b/src/main/java/neatlogic/module/process/audithandler/handler/FormAuditHandler.java index 7271dc78d31e7c62652db7eba8a3b8e7b31ead20..a95526fa180329cd4d51fda29cf9e8aa6d344b5e 100644 --- a/src/main/java/neatlogic/module/process/audithandler/handler/FormAuditHandler.java +++ b/src/main/java/neatlogic/module/process/audithandler/handler/FormAuditHandler.java @@ -1,5 +1,8 @@ package neatlogic.module.process.audithandler.handler; +import com.alibaba.fastjson.JSON; +import com.alibaba.fastjson.JSONArray; +import com.alibaba.fastjson.JSONObject; import neatlogic.framework.form.attribute.core.FormAttributeDataConversionHandlerFactory; import neatlogic.framework.form.attribute.core.FormAttributeHandlerFactory; import neatlogic.framework.form.attribute.core.IFormAttributeDataConversionHandler; @@ -8,23 +11,19 @@ import neatlogic.framework.form.dto.FormAttributeVo; import neatlogic.framework.form.dto.FormVersionVo; import neatlogic.framework.process.audithandler.core.IProcessTaskStepAuditDetailHandler; import neatlogic.framework.process.constvalue.ProcessTaskAuditDetailType; -import neatlogic.module.process.dao.mapper.processtask.ProcessTaskMapper; -import neatlogic.module.process.dao.mapper.SelectContentByHashMapper; import neatlogic.framework.process.dto.ProcessTaskAuditFormAttributeDataVo; import neatlogic.framework.process.dto.ProcessTaskFormAttributeDataVo; import neatlogic.framework.process.dto.ProcessTaskFormVo; import neatlogic.framework.process.dto.ProcessTaskStepAuditDetailVo; -import com.alibaba.fastjson.JSON; -import com.alibaba.fastjson.JSONArray; -import com.alibaba.fastjson.JSONObject; import neatlogic.framework.util.FormUtil; +import neatlogic.module.process.dao.mapper.processtask.ProcessTaskStaticDataMapper; import org.apache.commons.collections4.CollectionUtils; import org.apache.commons.lang3.StringUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; +import javax.annotation.Resource; import java.util.*; import java.util.stream.Collectors; @@ -33,10 +32,8 @@ public class FormAuditHandler implements IProcessTaskStepAuditDetailHandler { private final static Logger logger = LoggerFactory.getLogger(FormAuditHandler.class); - @Autowired - private ProcessTaskMapper processTaskMapper; - @Autowired - private SelectContentByHashMapper selectContentByHashMapper; + @Resource + private ProcessTaskStaticDataMapper processTaskStaticDataMapper; @Override public String getType() { @@ -79,7 +76,7 @@ public class FormAuditHandler implements IProcessTaskStepAuditDetailHandler { return 0; } Long processTaskId = processTaskFormAttributeDataList.get(0).getProcessTaskId(); - ProcessTaskFormVo processTaskForm = processTaskMapper.getProcessTaskFormByProcessTaskId(processTaskId); + ProcessTaskFormVo processTaskForm = processTaskStaticDataMapper.getProcessTaskFormByProcessTaskId(processTaskId); if (processTaskForm == null || StringUtils.isBlank(processTaskForm.getFormContent())) { return 0; } diff --git a/src/main/java/neatlogic/module/process/audithandler/handler/WorkerAuditHandler.java b/src/main/java/neatlogic/module/process/audithandler/handler/WorkerAuditHandler.java index b057dde86c06b0659b6fb5f90e925aa2f60fdb1b..5d137b2fd401b9963ed3cb2c5a1529a40b2b5891 100755 --- a/src/main/java/neatlogic/module/process/audithandler/handler/WorkerAuditHandler.java +++ b/src/main/java/neatlogic/module/process/audithandler/handler/WorkerAuditHandler.java @@ -1,18 +1,6 @@ package neatlogic.module.process.audithandler.handler; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -import neatlogic.framework.process.audithandler.core.IProcessTaskStepAuditDetailHandler; -import org.apache.commons.collections4.CollectionUtils; -import org.apache.commons.lang3.StringUtils; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.stereotype.Service; - import com.alibaba.fastjson.JSON; - import neatlogic.framework.common.constvalue.GroupSearch; import neatlogic.framework.dao.mapper.RoleMapper; import neatlogic.framework.dao.mapper.TeamMapper; @@ -20,8 +8,18 @@ import neatlogic.framework.dao.mapper.UserMapper; import neatlogic.framework.dto.RoleVo; import neatlogic.framework.dto.TeamVo; import neatlogic.framework.dto.UserVo; +import neatlogic.framework.process.audithandler.core.IProcessTaskStepAuditDetailHandler; import neatlogic.framework.process.constvalue.ProcessTaskAuditDetailType; import neatlogic.framework.process.dto.ProcessTaskStepAuditDetailVo; +import org.apache.commons.collections4.CollectionUtils; +import org.apache.commons.lang3.StringUtils; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; @Service public class WorkerAuditHandler implements IProcessTaskStepAuditDetailHandler { @@ -43,7 +41,21 @@ public class WorkerAuditHandler implements IProcessTaskStepAuditDetailHandler { List> resultList = new ArrayList<>(); List workerList = new ArrayList<>(); if(content.startsWith("[") && content.endsWith("]")) { - workerList = JSON.parseArray(content, String.class); + if (content.length() > 2) { + if(content.startsWith("[\"") && content.endsWith("\"]")) { + workerList = JSON.parseArray(content, String.class); + } else { + String subStr = content.substring(1, content.length() - 1); + if (subStr.contains(",")) { + String[] split = subStr.split(","); + for (String str : split) { + workerList.add(str.trim()); + } + } else { + workerList.add(subStr.trim()); + } + } + } }else { workerList.add(content); } diff --git a/src/main/java/neatlogic/module/process/dao/mapper/SelectContentByHashMapper.java b/src/main/java/neatlogic/module/process/dao/mapper/SelectContentByHashMapper.java index a272b1027dadee482bc7fb8b0147362df1408d2c..32d4b0e30ec7aeb69ea268d7ddc13d3b31deefdf 100644 --- a/src/main/java/neatlogic/module/process/dao/mapper/SelectContentByHashMapper.java +++ b/src/main/java/neatlogic/module/process/dao/mapper/SelectContentByHashMapper.java @@ -20,6 +20,7 @@ package neatlogic.module.process.dao.mapper; import neatlogic.framework.process.crossover.ISelectContentByHashCrossoverMapper; import neatlogic.framework.process.dto.ProcessTaskConfigVo; import neatlogic.framework.process.dto.ProcessTaskContentVo; +import neatlogic.framework.process.dto.ProcessTaskStepConfigVo; import java.util.List; @@ -27,6 +28,8 @@ public interface SelectContentByHashMapper extends ISelectContentByHashCrossover String getProcessTaskStepConfigByHash(String hash); + List getProcessTaskStepConfigListByHashList(List hashList); + ProcessTaskContentVo getProcessTaskContentByHash(String hash); List getProcessTaskContentListByHashList(List contentHashList); diff --git a/src/main/java/neatlogic/module/process/dao/mapper/SelectContentByHashMapper.xml b/src/main/java/neatlogic/module/process/dao/mapper/SelectContentByHashMapper.xml index 70675caf123aa29f5f381afbf7580409a0a71205..42f2f37be5ebbc3e4a0f304ae9f5e4ce25f24bb1 100644 --- a/src/main/java/neatlogic/module/process/dao/mapper/SelectContentByHashMapper.xml +++ b/src/main/java/neatlogic/module/process/dao/mapper/SelectContentByHashMapper.xml @@ -18,7 +18,7 @@ - + + + SELECT `handler`, diff --git a/src/main/java/neatlogic/module/process/dao/mapper/processtask/ProcessTaskActionMapper.java b/src/main/java/neatlogic/module/process/dao/mapper/processtask/ProcessTaskActionMapper.java index fce452434ef3b9218544783f31f352a2ff5d0561..9bf3c4f5d41748b542002d1df3d17a47b783004f 100644 --- a/src/main/java/neatlogic/module/process/dao/mapper/processtask/ProcessTaskActionMapper.java +++ b/src/main/java/neatlogic/module/process/dao/mapper/processtask/ProcessTaskActionMapper.java @@ -25,5 +25,7 @@ public interface ProcessTaskActionMapper { List getProcessTaskActionListByProcessTaskStepId(Long processTaskStepId); + List getProcessTaskActionListByProcessTaskId(Long processTaskId); + int insertProcessTaskAction(ProcessTaskActionVo processTaskActionVo); } diff --git a/src/main/java/neatlogic/module/process/dao/mapper/processtask/ProcessTaskActionMapper.xml b/src/main/java/neatlogic/module/process/dao/mapper/processtask/ProcessTaskActionMapper.xml index 8f4d46038da768e6db96562e08ce537cec177ee9..9d0a49fb27be9dfc6a3ade7f8b61e6d1beb8c60c 100644 --- a/src/main/java/neatlogic/module/process/dao/mapper/processtask/ProcessTaskActionMapper.xml +++ b/src/main/java/neatlogic/module/process/dao/mapper/processtask/ProcessTaskActionMapper.xml @@ -34,6 +34,21 @@ WHERE `processtask_step_id` = #{value} + + INSERT INTO `processtask_action` ( `id`, diff --git a/src/main/java/neatlogic/module/process/dao/mapper/processtask/ProcessTaskMapper.java b/src/main/java/neatlogic/module/process/dao/mapper/processtask/ProcessTaskMapper.java index c7cc4092ef9065d04cfb207a09a74d4d2a0a0804..b3aa6a2be7f2da2f0b99c90064101b38cbdd12c3 100644 --- a/src/main/java/neatlogic/module/process/dao/mapper/processtask/ProcessTaskMapper.java +++ b/src/main/java/neatlogic/module/process/dao/mapper/processtask/ProcessTaskMapper.java @@ -201,6 +201,8 @@ public interface ProcessTaskMapper extends IProcessTaskCrossoverMapper { List getTargetListByContentId(Long contentId); + List getTargetListByContentIdList(List contentIdList); + ProcessTaskStepContentVo getProcessTaskStepContentById(Long id); List getProcessTaskStepUserList(ProcessTaskStepUserVo processTaskStepUserVo); diff --git a/src/main/java/neatlogic/module/process/dao/mapper/processtask/ProcessTaskMapper.xml b/src/main/java/neatlogic/module/process/dao/mapper/processtask/ProcessTaskMapper.xml index 50cfc834aef635397eaf0a363cf1326cc659ddcc..0517d703f175e9df768aa3253f7b711d31a6096c 100644 --- a/src/main/java/neatlogic/module/process/dao/mapper/processtask/ProcessTaskMapper.xml +++ b/src/main/java/neatlogic/module/process/dao/mapper/processtask/ProcessTaskMapper.xml @@ -1013,6 +1013,7 @@ + @@ -1054,6 +1055,7 @@ `active_time`, `start_time`, `end_time`, + `error`, `expire_time`, `config_hash` FROM `processtask_step` @@ -1341,6 +1343,18 @@ WHERE `content_id` = #{value} + + + + diff --git a/src/main/java/neatlogic/module/process/dao/mapper/processtask/ProcessTaskStaticDataMapper.java b/src/main/java/neatlogic/module/process/dao/mapper/processtask/ProcessTaskStaticDataMapper.java new file mode 100644 index 0000000000000000000000000000000000000000..480a78667d4d6ae58800055d13635341d33f1d2c --- /dev/null +++ b/src/main/java/neatlogic/module/process/dao/mapper/processtask/ProcessTaskStaticDataMapper.java @@ -0,0 +1,24 @@ +/* + * Copyright (C) 2025 深圳极向量科技有限公司 All Rights Reserved. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +package neatlogic.module.process.dao.mapper.processtask; + +import neatlogic.framework.process.dto.ProcessTaskFormVo; + +public interface ProcessTaskStaticDataMapper { + ProcessTaskFormVo getProcessTaskFormByProcessTaskId(Long processTaskId); +} diff --git a/src/main/java/neatlogic/module/process/dao/mapper/processtask/ProcessTaskStaticDataMapper.xml b/src/main/java/neatlogic/module/process/dao/mapper/processtask/ProcessTaskStaticDataMapper.xml new file mode 100644 index 0000000000000000000000000000000000000000..bab47f82e62809a01ffb2793430a587df4339e6d --- /dev/null +++ b/src/main/java/neatlogic/module/process/dao/mapper/processtask/ProcessTaskStaticDataMapper.xml @@ -0,0 +1,35 @@ + + + + + + + + + + \ No newline at end of file diff --git a/src/main/java/neatlogic/module/process/dao/mapper/processtask/ProcessTaskStepTaskMapper.java b/src/main/java/neatlogic/module/process/dao/mapper/processtask/ProcessTaskStepTaskMapper.java index 364d495c2097a59f43068eb1e71f3518624c3434..d911e4a77e790ed91dfc1ff94a3a3354f079780b 100644 --- a/src/main/java/neatlogic/module/process/dao/mapper/processtask/ProcessTaskStepTaskMapper.java +++ b/src/main/java/neatlogic/module/process/dao/mapper/processtask/ProcessTaskStepTaskMapper.java @@ -41,6 +41,8 @@ public interface ProcessTaskStepTaskMapper extends IProcessTaskStepTaskCrossover ProcessTaskStepTaskUserVo getStepTaskUserById(Long id); + List getStepTaskByProcessTaskId(Long processTaskId); + List getStepTaskByProcessTaskStepId(Long processTaskStepId); List getStepTaskListByProcessTaskStepId(Long processTaskStepId); diff --git a/src/main/java/neatlogic/module/process/dao/mapper/processtask/ProcessTaskStepTaskMapper.xml b/src/main/java/neatlogic/module/process/dao/mapper/processtask/ProcessTaskStepTaskMapper.xml index 94109ff609ac447d469b101d89e5e109f9c2df13..dae89e13a39073c1c19f6c8e49ff4c50b7d0824f 100644 --- a/src/main/java/neatlogic/module/process/dao/mapper/processtask/ProcessTaskStepTaskMapper.xml +++ b/src/main/java/neatlogic/module/process/dao/mapper/processtask/ProcessTaskStepTaskMapper.xml @@ -136,6 +136,24 @@ where pst.`processtask_step_id` = #{value} + + SELECT pstu.`id`, pstu.`processtask_step_task_id` as processTaskStepTaskId, - pstu.`user_uuid` as userUuid, + u.id as userId, u.pinyin as pinyin, u.user_info as userInfo, u.vip_level as userLevel, u.user_name as userName, - u.user_id as userId, + u.user_id as UserUserId, + u.uuid as userUuid, pstu.`end_time` as endTime, pstu.`status`, pstu.`is_delete` as isDelete diff --git a/src/main/java/neatlogic/module/process/service/ProcessTaskService.java b/src/main/java/neatlogic/module/process/service/ProcessTaskService.java index 66f5d64babc3969bc217745d6a574247b69230a7..66c6b297c685e0092f5e53d5fce4bf0450986ea4 100644 --- a/src/main/java/neatlogic/module/process/service/ProcessTaskService.java +++ b/src/main/java/neatlogic/module/process/service/ProcessTaskService.java @@ -146,6 +146,12 @@ public interface ProcessTaskService { */ public void setProcessTaskStepUser(ProcessTaskStepVo processTaskStepVo); + /** + * @param processTaskStepVo + * @Description: 设置步骤处理人、协助处理人、待办人等 + */ + void setProcessTaskStepUser(ProcessTaskStepVo processTaskStepVo, List processTaskStepUserList, List processTaskStepWorkerList); + /** * @param jsonObj * @param processTaskStepReplyVo 旧的回复数据 diff --git a/src/main/java/neatlogic/module/process/service/ProcessTaskServiceImpl.java b/src/main/java/neatlogic/module/process/service/ProcessTaskServiceImpl.java index a654a7e58b8cb637e933be50e26cd37f8c212324..55a494bc0b9e03a8a2986280590825148e475538 100644 --- a/src/main/java/neatlogic/module/process/service/ProcessTaskServiceImpl.java +++ b/src/main/java/neatlogic/module/process/service/ProcessTaskServiceImpl.java @@ -627,7 +627,7 @@ public class ProcessTaskServiceImpl implements ProcessTaskService, IProcessTaskC continue; } for (String uuid : uuidList) { - if (uuid.contains(processTaskStepReplyVo.getLcu())) { + if (processTaskStepReplyVo.getLcu() != null && uuid.contains(processTaskStepReplyVo.getLcu())) { operatorProcessUserTypeList.add(entry.getKey()); break; } @@ -744,6 +744,9 @@ public class ProcessTaskServiceImpl implements ProcessTaskService, IProcessTaskC @Override public List getSlaTimeListBySlaIdList(List slaIdList) { + if (CollectionUtils.isEmpty(slaIdList)) { + return new ArrayList<>(); + } List processTaskSlaTimeList = processTaskSlaMapper.getProcessTaskSlaTimeListBySlaIdList(slaIdList); if (CollectionUtils.isEmpty(processTaskSlaTimeList)) { return processTaskSlaTimeList; @@ -970,6 +973,33 @@ public class ProcessTaskServiceImpl implements ProcessTaskService, IProcessTaskC processTaskStepVo.setMinorUserList(minorUserList); } + @Override + public void setProcessTaskStepUser(ProcessTaskStepVo processTaskStepVo, List processTaskStepUserList, List processTaskStepWorkerList) { + List majorUserList = new ArrayList<>(); + List minorUserList = new ArrayList<>(); + for (ProcessTaskStepUserVo stepUserVo : processTaskStepUserList) { + if (Objects.equals(stepUserVo.getProcessTaskStepId(), processTaskStepVo.getId())) { + if (stepUserVo.getUserType().equals(ProcessUserType.MAJOR.getValue())) { + majorUserList.add(stepUserVo); + } else if (stepUserVo.getUserType().equals(ProcessUserType.MINOR.getValue())) { + minorUserList.add(stepUserVo); + } + } + } + if (CollectionUtils.isNotEmpty(majorUserList)) { + processTaskStepVo.setMajorUser(majorUserList.get(0)); + } else { + List workerList = new ArrayList<>(); + for (ProcessTaskStepWorkerVo workerVo : processTaskStepWorkerList) { + if (Objects.equals(workerVo.getProcessTaskStepId(), processTaskStepVo.getId())) { + workerList.add(workerVo); + } + } + processTaskStepVo.setWorkerList(workerList); + } + processTaskStepVo.setMinorUserList(minorUserList); + } + @Override public boolean saveProcessTaskStepReply(JSONObject jsonObj, ProcessTaskStepReplyVo oldReplyVo) { if (oldReplyVo == null) { @@ -1825,9 +1855,18 @@ public class ProcessTaskServiceImpl implements ProcessTaskService, IProcessTaskC @Override public JSONArray getReplaceableTextList(ProcessTaskStepVo processTaskStepVo) { - String config = selectContentByHashMapper.getProcessTaskStepConfigByHash(processTaskStepVo.getConfigHash()); + JSONObject stepConfigObj = processTaskStepVo.getConfig(); + if (stepConfigObj == null) { + String config = selectContentByHashMapper.getProcessTaskStepConfigByHash(processTaskStepVo.getConfigHash()); + if (StringUtils.isNotBlank(config)) { + stepConfigObj = JSONObject.parseObject(config); + } else { + stepConfigObj = new JSONObject(); + } + processTaskStepVo.setConfig(stepConfigObj); + } boolean stepLevelTakesEffect = false; - JSONArray replaceableTextList = (JSONArray) JSONPath.read(config, "replaceableTextList"); + JSONArray replaceableTextList = stepConfigObj.getJSONArray("replaceableTextList"); if (CollectionUtils.isNotEmpty(replaceableTextList)) { for (int i = 0; i < replaceableTextList.size(); i++) { JSONObject replaceableText = replaceableTextList.getJSONObject(i); @@ -1864,9 +1903,18 @@ public class ProcessTaskServiceImpl implements ProcessTaskService, IProcessTaskC @Override public JSONArray getCustomButtonList(ProcessTaskStepVo processTaskStepVo) { - String config = selectContentByHashMapper.getProcessTaskStepConfigByHash(processTaskStepVo.getConfigHash()); + JSONObject stepConfigObj = processTaskStepVo.getConfig(); + if (stepConfigObj == null) { + String config = selectContentByHashMapper.getProcessTaskStepConfigByHash(processTaskStepVo.getConfigHash()); + if (StringUtils.isNotBlank(config)) { + stepConfigObj = JSONObject.parseObject(config); + } else { + stepConfigObj = new JSONObject(); + } + processTaskStepVo.setConfig(stepConfigObj); + } boolean stepLevelTakesEffect = false; - JSONArray customButtonList = (JSONArray) JSONPath.read(config, "customButtonList"); + JSONArray customButtonList = stepConfigObj.getJSONArray("customButtonList"); if (CollectionUtils.isNotEmpty(customButtonList)) { for (int i = 0; i < customButtonList.size(); i++) { JSONObject customButton = customButtonList.getJSONObject(i); @@ -1893,9 +1941,18 @@ public class ProcessTaskServiceImpl implements ProcessTaskService, IProcessTaskC @Override public JSONArray getCustomStatusList(ProcessTaskStepVo processTaskStepVo) { - String config = selectContentByHashMapper.getProcessTaskStepConfigByHash(processTaskStepVo.getConfigHash()); + JSONObject stepConfigObj = processTaskStepVo.getConfig(); + if (stepConfigObj == null) { + String config = selectContentByHashMapper.getProcessTaskStepConfigByHash(processTaskStepVo.getConfigHash()); + if (StringUtils.isNotBlank(config)) { + stepConfigObj = JSONObject.parseObject(config); + } else { + stepConfigObj = new JSONObject(); + } + processTaskStepVo.setConfig(stepConfigObj); + } boolean stepLevelTakesEffect = false; - JSONArray customStatusList = (JSONArray) JSONPath.read(config, "customStatusList"); + JSONArray customStatusList = stepConfigObj.getJSONArray("customStatusList"); if (CollectionUtils.isNotEmpty(customStatusList)) { for (int i = 0; i < customStatusList.size(); i++) { JSONObject customStatus = customStatusList.getJSONObject(i); @@ -2012,7 +2069,7 @@ public class ProcessTaskServiceImpl implements ProcessTaskService, IProcessTaskC //任务列表 if (processTaskStepVo.getIsActive() == 1 && ProcessTaskStepStatus.RUNNING.getValue().equals(processTaskStepVo.getStatus())) { - processTaskStepTaskService.getProcessTaskStepTask(processTaskStepVo); +// processTaskStepTaskService.getProcessTaskStepTask(processTaskStepVo); List taskConfigList = processTaskStepTaskService.getTaskConfigList(processTaskStepVo); processTaskStepVo.setTaskConfigList(taskConfigList); } @@ -2109,7 +2166,7 @@ public class ProcessTaskServiceImpl implements ProcessTaskService, IProcessTaskC @Override public Map> getProcessTaskStepProcessUserTypeData(ProcessTaskStepVo processTaskStepVo, List processUserTypeList) { - Map> resultMap = new HashMap<>(); + Map> resultMap = new LinkedHashMap<>(); ProcessTaskVo processTaskVo = processTaskMapper.getProcessTaskBaseInfoByIdIncludeIsDeleted(processTaskStepVo.getProcessTaskId()); if (processTaskVo != null) { /* 上报人 **/ @@ -3389,7 +3446,7 @@ public class ProcessTaskServiceImpl implements ProcessTaskService, IProcessTaskC getProcessTaskStepReplyListByProcessTaskStepId(processTaskStepVo.getId(), typeList)); processTaskStepVo.setActionList(getProcessTaskActionListByProcessTaskStepId(processTaskStepVo.getId())); //任务列表 - processTaskStepTaskService.getProcessTaskStepTask(processTaskStepVo); +// processTaskStepTaskService.getProcessTaskStepTask(processTaskStepVo); List taskConfigList = processTaskStepTaskService.getTaskConfigList(processTaskStepVo); processTaskStepVo.setTaskConfigList(taskConfigList); // 时效列表 diff --git a/src/main/java/neatlogic/module/process/service/ProcessTaskStepTaskService.java b/src/main/java/neatlogic/module/process/service/ProcessTaskStepTaskService.java index db18db7aa63ec76d3719cbb3db35f1cafdae7f67..cd940f5953bf149cca3773393f9a689a07d4b718 100644 --- a/src/main/java/neatlogic/module/process/service/ProcessTaskStepTaskService.java +++ b/src/main/java/neatlogic/module/process/service/ProcessTaskStepTaskService.java @@ -63,6 +63,7 @@ public interface ProcessTaskStepTaskService { * 获取工单任务信息 * @param processTaskStepVo 步骤vo */ + @Deprecated void getProcessTaskStepTask(ProcessTaskStepVo processTaskStepVo); /** diff --git a/src/main/java/neatlogic/module/process/service/ProcessTaskStepTaskServiceImpl.java b/src/main/java/neatlogic/module/process/service/ProcessTaskStepTaskServiceImpl.java index 6e975cae97c1803a5501be4787054b9998492982..ae5b5215e33decc6b23170f4c1bbb631bc7bcbaa 100644 --- a/src/main/java/neatlogic/module/process/service/ProcessTaskStepTaskServiceImpl.java +++ b/src/main/java/neatlogic/module/process/service/ProcessTaskStepTaskServiceImpl.java @@ -255,10 +255,12 @@ public class ProcessTaskStepTaskServiceImpl implements ProcessTaskStepTaskServic for (ProcessTaskStepTaskUserVo processTaskStepTaskUserVo : processTaskStepTaskUserList) { workerList.add(GroupSearch.USER.getValuePlugin() + processTaskStepTaskUserVo.getUserUuid()); } + JSONArray workerArray = new JSONArray(); + workerArray.addAll(workerList); JSONObject paramObj = new JSONObject(); paramObj.put("replaceable_task", taskConfigVo.getName()); paramObj.put(ProcessTaskAuditDetailType.CONTENT.getParamName(), processTaskStepTaskVo.getContent()); - paramObj.put(ProcessTaskAuditDetailType.WORKERLIST.getParamName(), JSONObject.toJSONString(workerList)); + paramObj.put(ProcessTaskAuditDetailType.WORKERLIST.getParamName(), workerArray.toJSONString()); paramObj.put("source", source); processTaskStepVo.getParamObj().putAll(paramObj); processStepHandlerUtil.audit(processTaskStepVo, auditType); @@ -664,6 +666,7 @@ public class ProcessTaskStepTaskServiceImpl implements ProcessTaskStepTaskServic * @param processTaskStepVo 步骤vo */ @Override + @Deprecated public void getProcessTaskStepTask(ProcessTaskStepVo processTaskStepVo) { //任务列表 Map> stepTaskVoMap = new HashMap<>();