From 7c777b6f9f47ca57193b9e4196fa14fa184abe6c Mon Sep 17 00:00:00 2001
From: xiangpei <xiangpei@timesnew.cn>
Date: 星期二, 11 二月 2025 14:01:19 +0800
Subject: [PATCH] 任务处理人bug
---
business/src/main/java/com/ycl/service/impl/ProjectProcessServiceImpl.java | 759 +++++++++++++++++++++++++++++++++++++++++++++++----------
1 files changed, 621 insertions(+), 138 deletions(-)
diff --git a/business/src/main/java/com/ycl/service/impl/ProjectProcessServiceImpl.java b/business/src/main/java/com/ycl/service/impl/ProjectProcessServiceImpl.java
index f00ba94..16549dc 100644
--- a/business/src/main/java/com/ycl/service/impl/ProjectProcessServiceImpl.java
+++ b/business/src/main/java/com/ycl/service/impl/ProjectProcessServiceImpl.java
@@ -1,10 +1,12 @@
package com.ycl.service.impl;
+import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.conditions.update.LambdaUpdateChainWrapper;
import com.ycl.common.constant.ProcessConstants;
+import com.ycl.common.constant.ProcessOverTimeConstants;
import com.ycl.common.core.domain.entity.SysDept;
import com.ycl.common.core.domain.entity.SysRole;
import com.ycl.common.core.domain.entity.SysUser;
@@ -13,9 +15,12 @@
import com.ycl.common.enums.business.TaskStatusEnum;
import com.ycl.common.utils.SecurityUtils;
import com.ycl.constant.TaskTypeConstant;
+import com.ycl.domain.entity.ProcessCoding;
import com.ycl.domain.entity.ProjectInfo;
import com.ycl.domain.entity.ProjectProcess;
+import com.ycl.domain.entity.SysForm;
import com.ycl.domain.form.TaskDelegationForm;
+import com.ycl.domain.form.TaskJumpForm;
import com.ycl.domain.json.DelegateData;
import com.ycl.domain.vo.CustomerTaskVO;
import com.ycl.domain.vo.IndexCustomerTaskVO;
@@ -23,6 +28,9 @@
import com.ycl.event.event.TaskLogEvent;
import com.ycl.mapper.ProjectInfoMapper;
import com.ycl.mapper.ProjectProcessMapper;
+import com.ycl.service.IFlowTaskService;
+import com.ycl.service.ISysFormService;
+import com.ycl.service.ProcessCodingService;
import com.ycl.service.ProjectProcessService;
import com.ycl.common.base.Result;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
@@ -79,7 +87,11 @@
private final ISysRoleService sysRoleService;
private final ISysDeptService sysDeptService;
private final TaskCommonService taskCommonService;
+ private final IFlowTaskService flowTaskService;
+ private final ISysFormService formService;
+ private final ProcessCodingService processCodingService;
private final ApplicationEventPublisher publisher;
+ private final ISysDeptService deptService;
/**
* 鍒嗛〉鏌ヨ
@@ -129,11 +141,23 @@
}
}
}
- String processInsId = this.startPro(form.getProjectId(), form.getProcessDefId());
+ ProjectInfo project = new LambdaQueryChainWrapper<>(projectInfoMapper)
+ .select(ProjectInfo::getCreateBy)
+ .eq(ProjectInfo::getId, form.getProjectId())
+ .one();
+ if (Objects.isNull(project)) {
+ throw new RuntimeException("椤圭洰涓嶅瓨鍦�");
+ }
+ SysUser user = sysUserService.selectUserById(project.getCreateBy());
+ if (Objects.isNull(user)) {
+ throw new RuntimeException("椤圭洰涓氫富鍗曚綅涓嶅瓨鍦�");
+ }
+ String processInsId = this.startPro(form.getProjectId(), form.getProcessDefId(), user.getDeptId());
new LambdaUpdateChainWrapper<>(baseMapper)
.eq(ProjectProcess::getProjectId, form.getProjectId())
.set(ProjectProcess::getProcessDefId, form.getProcessDefId())
.set(ProjectProcess::getProcessInsId, processInsId)
+ .set(ProjectProcess::getDataLaunch, project.getCreateBy())
.update();
return Result.ok("娴佺▼鍙樻洿鎴愬姛");
}
@@ -141,11 +165,23 @@
@Override
@Transactional(rollbackFor = Exception.class)
public Result startProcess(Long projectId, String processDefId) {
- String processInsId = this.startPro(projectId, processDefId);
+ ProjectInfo project = new LambdaQueryChainWrapper<>(projectInfoMapper)
+ .select(ProjectInfo::getCreateBy)
+ .eq(ProjectInfo::getId, projectId)
+ .one();
+ if (Objects.isNull(project)) {
+ throw new RuntimeException("椤圭洰涓嶅瓨鍦�");
+ }
+ SysUser user = sysUserService.selectUserById(project.getCreateBy());
+ if (Objects.isNull(user)) {
+ throw new RuntimeException("椤圭洰涓氫富鍗曚綅涓嶅瓨鍦�");
+ }
+ String processInsId = this.startPro(projectId, processDefId, user.getDeptId());
ProjectProcess entity = new ProjectProcess();
entity.setProjectId(projectId);
entity.setProcessDefId(processDefId);
entity.setProcessInsId(processInsId);
+ entity.setDataLaunch(project.getCreateBy());
baseMapper.insert(entity);
return Result.ok("娴佺▼鍚姩鎴愬姛");
@@ -158,15 +194,9 @@
* @param processDefId
* @return
*/
- private String startPro(Long projectId, String processDefId) {
+ private String startPro(Long projectId, String processDefId, Long createBy) {
- ProjectInfo project = new LambdaQueryChainWrapper<>(projectInfoMapper)
- .select(ProjectInfo::getCreateBy)
- .eq(ProjectInfo::getId, projectId)
- .one();
- if (Objects.isNull(project)) {
- throw new RuntimeException("椤圭洰涓嶅瓨鍦�");
- }
+
ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().processDefinitionId(processDefId)
.latestVersion().singleResult();
if (Objects.nonNull(processDefinition) && processDefinition.isSuspended()) {
@@ -179,7 +209,7 @@
variables.put(ProcessConstants.PROCESS_INITIATOR, sysUser.getUserId());
// 灏嗚椤圭洰鐨勭敵璇蜂汉锛堜笟涓绘柟锛変綔涓烘祦绋嬩腑鏌愪簺鐜妭鐨勫鐞嗕汉
- variables.put(ProcessConstants.DATA_LAUNCH, project.getCreateBy());
+ variables.put(ProcessConstants.DATA_LAUNCH, createBy);
ProcessInstance processInstance = runtimeService.startProcessInstanceById(processDefId, projectId + "", variables);
return processInstance.getId();
}
@@ -220,13 +250,16 @@
taskStatistics.setTotalTaskNum(this.getTotalTaskNum(processDefId));
taskStatistics.setTodoTaskNum(this.getTodoTaskNum(projectProcess.getProcessInsId()));
taskStatistics.setRemainingTaskNum(this.getRemainingTaskNum(processDefId, projectProcess.getProcessInsId(), taskStatistics.getTotalTaskNum()));
+ taskStatistics.setTimelyFinishedTaskNum(this.getTimelyTaskNum(projectProcess.getProcessInsId()));
+ taskStatistics.setOvertimeTaskNum(this.getOvertimeTaskNum(projectProcess.getProcessInsId()));
+ taskStatistics.setWillOvertimeTaskNum(this.getWillOvertimeTaskNum(projectProcess.getProcessInsId()));
// taskStatistics.setCurrentTask(this.getCurrentNodeTaskList(projectProcess.getProcessInstanceId()));
detail.setStatistics(taskStatistics);
Result result = Result.ok();
// 浠ｅ姙浠诲姟
- this.getTodoTaskList(projectProcess.getProcessInsId(), "", 5, 1, result);
+ this.getTodoTaskList(projectProcess.getProjectId(), projectProcess.getProcessInsId(), "", 5, 1, result);
return result.data(detail);
}
@@ -243,16 +276,25 @@
Result ok = Result.ok();
switch (query.getTaskType()) {
case TaskTypeConstant.ALL:
- this.getAllUserTask(query.getProcessDefId(), projectProcess.getProcessInsId(), query.getTaskName(), (int) query.getCurrentPage(), (int) query.getPageSize(), ok);
+ this.getAllUserTask(query.getProjectId(), query.getProcessDefId(), projectProcess.getProcessInsId(), query.getTaskName(), (int) query.getCurrentPage(), (int) query.getPageSize(), ok);
break;
case TaskTypeConstant.TODO:
- this.getTodoTaskList(projectProcess.getProcessInsId(), query.getTaskName(), (int) query.getPageSize(), (int) query.getCurrentPage(), ok);
+ this.getTodoTaskList(query.getProjectId(), projectProcess.getProcessInsId(), query.getTaskName(), (int) query.getPageSize(), (int) query.getCurrentPage(), ok);
ok.data(ok.get("taskList"));
break;
case TaskTypeConstant.CURRENT:
break;
case TaskTypeConstant.REMAINING:
- this.getRemainingTask(query.getProcessDefId(), projectProcess.getProcessInsId(), query.getTaskName(), (int) query.getCurrentPage(), (int) query.getPageSize(), ok);
+ this.getRemainingTask(query.getProjectId(), query.getProcessDefId(), projectProcess.getProcessInsId(), query.getTaskName(), (int) query.getCurrentPage(), (int) query.getPageSize(), ok);
+ break;
+ case TaskTypeConstant.TIMELY:
+ this.getTimelyTask(query.getProcessDefId(), projectProcess.getProcessInsId(), query.getTaskName(), (int) query.getCurrentPage(), (int) query.getPageSize(), ok);
+ break;
+ case TaskTypeConstant.OVERTIME:
+ this.getOvertimeTask(query.getProjectId(), query.getProcessDefId(), projectProcess.getProcessInsId(), query.getTaskName(), (int) query.getCurrentPage(), (int) query.getPageSize(), ok);
+ break;
+ case TaskTypeConstant.WILL_OVER_TIME:
+ this.getWillOvertimeTask(query.getProjectId(), query.getProcessDefId(), projectProcess.getProcessInsId(), query.getTaskName(), (int) query.getCurrentPage(), (int) query.getPageSize(), ok);
break;
default:
break;
@@ -317,6 +359,10 @@
List<String> handlerNames = new ArrayList<>(2);
List<Long> handlerUnitIds = new ArrayList<>(2);
List<String> handlerUnitNames = new ArrayList<>(2);
+ taskVO.setHandlerId(handlerIds);
+ taskVO.setHandlerName(handlerNames);
+ taskVO.setHandlerUnitId(handlerUnitIds);
+ taskVO.setHandlerUnitName(handlerUnitNames);
// 娴佺▼澶勭悊浜轰俊鎭�
List<IdentityLink> identityLinks = taskService.getIdentityLinksForTask(task.getId());
@@ -360,10 +406,8 @@
}
}
}
- taskVO.setHandlerId(handlerIds);
- taskVO.setHandlerName(handlerNames);
- taskVO.setHandlerUnitId(handlerUnitIds);
- taskVO.setHandlerUnitName(handlerUnitNames);
+
+ this.distinctVo(taskVO);
vos.add(taskVO);
}
if (vos.size() < pageSize) {
@@ -476,7 +520,7 @@
for (FlowElement flowElement : flowElements) {
if (flowElement instanceof UserTask && flowElement.getId().equals(task.getTaskDefinitionKey())) {
UserTask userTask = (UserTask) flowElement;
- needAuditing = taskCommonService.checkTaskNeedAuditing(userTask.getExtensionElements().get("properties"));
+ needAuditing = taskCommonService.checkHasExeProperty(userTask.getExtensionElements().get("properties"), ProcessConstants.EXTENSION_PROPERTY_NEED_AUDITING_TEXT);
break;
}
@@ -568,21 +612,45 @@
return Result.ok("杞姙鎴愬姛");
}
+ @Override
+ @Transactional(rollbackFor = Exception.class)
+ public Result taskJump(TaskJumpForm form) {
+ Task task = taskService.createTaskQuery().taskId(form.getTaskId()).processInstanceId(form.getProcessInsId()).singleResult();
+ if (Objects.nonNull(task)) {
+ // 娣诲姞璺宠繃鏃ュ織
+ publisher.publishEvent(new TaskLogEvent(this, form.getProjectId(), form.getProcessInsId(), form.getTaskId(), ProcessLogEventTypeEnum.JUMP, null));
+ // 鏌ュ嚭璇ヤ换鍔＄粦瀹氱殑琛ㄥ崟
+
+ Map<String, Object> data = new HashMap<>(1);
+ if (StringUtils.isNotBlank(task.getFormKey())) {
+ SysForm sysForm = formService.selectSysFormById(Long.parseLong(task.getFormKey()));
+ if (Objects.nonNull(sysForm)) {
+ data.put(ProcessConstants.TASK_FORM_KEY, JSONObject.parseObject(sysForm.getFormContent()));
+ }
+ }
+ // 瀹屾垚浠诲姟
+ flowTaskService.completeSubmitForm(form.getTaskId(), data);
+ }
+ return Result.ok("鎿嶄綔鎴愬姛");
+ }
+
/**
* 鏌ヨ寰呭姙浠诲姟
*
+ * @param projectId
* @param processInsId
* @param taskName
* @param pageSize
* @param pageNum
* @param result
*/
- public void getTodoTaskList(String processInsId, String taskName, int pageSize, int pageNum, Result result) {
+ public void getTodoTaskList(Long projectId, String processInsId, String taskName, int pageSize, int pageNum, Result result) {
TaskQuery taskQuery = taskService.createTaskQuery()
.active()
.processInstanceId(processInsId)
.includeProcessVariables()
- .orderByTaskCreateTime().desc();
+ .orderByTaskCreateTime()
+ .desc();
if (StringUtils.isNotBlank(taskName)) {
taskQuery.processDefinitionNameLike(taskName);
@@ -592,7 +660,7 @@
List<CustomerTaskVO> vos = new ArrayList<>();
for (Task task : taskList) {
CustomerTaskVO taskVO = new CustomerTaskVO();
- this.setRuntimeTaskInfo(task, taskVO);
+ this.setRuntimeTaskInfo(task, taskVO, projectId);
vos.add(taskVO);
}
result.put("taskList", vos);
@@ -601,6 +669,7 @@
/**
* 鑾峰彇鎵�鏈変换鍔�
*
+ * @param projectId 椤圭洰id
* @param processDefinitionId 娴佺▼杩愯id
* @param processInsId 娴佺▼瀹炰緥id
* @param pageNum
@@ -608,7 +677,7 @@
* @param result
* @return
*/
- private List<CustomerTaskVO> getAllUserTask(String processDefinitionId, String processInsId, String taskName, Integer pageNum, Integer pageSize, Result result) {
+ private List<CustomerTaskVO> getAllUserTask(Long projectId, String processDefinitionId, String processInsId, String taskName, Integer pageNum, Integer pageSize, Result result) {
int startNum = pageSize * (pageNum - 1);
int endNum = startNum + pageSize;
List<UserTask> allUserTaskElement = this.getAllUserTaskElement(processDefinitionId);
@@ -649,6 +718,10 @@
List<String> handlerNames = new ArrayList<>(2);
List<Long> handlerUnitIds = new ArrayList<>(2);
List<String> handlerUnitNames = new ArrayList<>(2);
+ vo.setHandlerId(handlerIds);
+ vo.setHandlerName(handlerNames);
+ vo.setHandlerUnitId(handlerUnitIds);
+ vo.setHandlerUnitName(handlerUnitNames);
if (Objects.isNull(task)) {
// 濡傛灉浠诲姟鍦ㄨ繍琛屾椂娌℃壘鍒帮紝閭ｄ箞鍙兘涓烘湭寮�濮嬫垨鑰呭凡瀹屾垚锛岄渶瑕佷粠鍘嗗彶浠诲姟涓啀鎵句竴涓�
@@ -667,7 +740,7 @@
vo.setHandlerType(HandlerTypeEnum.USER);
// 澶勭悊鍙橀噺琛ㄨ揪寮�
if (userTask.getAssignee().contains(ProcessConstants.DATA_LAUNCH)) {
- handlerNames.add(userTask.getAssignee());
+ this.varReview(vo, projectId, processInsId);
} else {
SysUser sysUser = sysUserService.selectUserById(Long.parseLong(userTask.getAssignee()));
if (Objects.nonNull(sysUser)) {
@@ -724,10 +797,6 @@
vo.setTaskDefinitionKey(historicTasks.get(0).getTaskDefinitionKey());
this.setPromoterAndHandler(vo, historicTasks.get(0).getIdentityLinks());
}
- vo.setHandlerId(handlerIds);
- vo.setHandlerName(handlerNames);
- vo.setHandlerUnitId(handlerUnitIds);
- vo.setHandlerUnitName(handlerUnitNames);
} else {
vo.setTaskStatus(TaskStatusEnum.TODO);
vo.setTaskId(task.getId());
@@ -736,9 +805,9 @@
vo.setTaskDefinitionKey(task.getTaskDefinitionKey());
this.setPromoterAndHandler(vo, null);
- this.setRuntimeTaskInfo(task, vo);
+ this.setRuntimeTaskInfo(task, vo, projectId);
}
-
+ this.distinctVo(vo);
return vo;
}).collect(Collectors.toList());
result.data(vos);
@@ -797,8 +866,9 @@
*
* @param task 浠诲姟
* @param taskVO 浠诲姟vo
+ * @param projectId 椤圭洰id
*/
- private void setRuntimeTaskInfo(Task task, CustomerTaskVO taskVO) {
+ private void setRuntimeTaskInfo(Task task, CustomerTaskVO taskVO, Long projectId) {
// 褰撳墠娴佺▼淇℃伅
taskVO.setTaskId(task.getId());
taskVO.setCreateTime(task.getCreateTime());
@@ -807,11 +877,19 @@
taskVO.setTaskName(task.getName());
taskVO.setTaskStatus(TaskStatusEnum.TODO);
// 娴佺▼瀹氫箟淇℃伅
- ProcessDefinition pd = repositoryService.createProcessDefinitionQuery()
- .processDefinitionId(task.getProcessDefinitionId())
- .singleResult();
- taskVO.setDeployId(pd.getDeploymentId());
- taskVO.setProcessName(pd.getName());
+ ProcessInstance process = runtimeService.createProcessInstanceQuery().processInstanceId(task.getProcessInstanceId()).singleResult();
+ String deployId = "";
+ String processName = "";
+ if (Objects.nonNull(process)) {
+ deployId = process.getDeploymentId();
+ processName = process.getProcessDefinitionName();
+ } else {
+ HistoricProcessInstance hisProcess = historyService.createHistoricProcessInstanceQuery().processInstanceId(task.getProcessInstanceId()).singleResult();
+ deployId = hisProcess.getDeploymentId();
+ processName = hisProcess.getProcessDefinitionName();
+ }
+ taskVO.setDeployId(deployId);
+ taskVO.setProcessName(processName);
taskVO.setProcessInsId(task.getProcessInstanceId());
taskVO.setTaskDefinitionKey(task.getTaskDefinitionKey());
@@ -823,6 +901,10 @@
List<String> handlerNames = new ArrayList<>(2);
List<Long> handlerUnitIds = new ArrayList<>(2);
List<String> handlerUnitNames = new ArrayList<>(2);
+ taskVO.setHandlerId(handlerIds);
+ taskVO.setHandlerName(handlerNames);
+ taskVO.setHandlerUnitId(handlerUnitIds);
+ taskVO.setHandlerUnitName(handlerUnitNames);
// 娴佺▼澶勭悊浜轰俊鎭�
List<IdentityLink> identityLinksForTask = taskService.getIdentityLinksForTask(task.getId());
@@ -832,14 +914,19 @@
// }
// 缁戝畾鐨勬槸鐢ㄦ埛锛屾煡鍑虹敤鎴峰鍚嶃�侀儴闂�
if (StringUtils.isNotBlank(identityLink.getUserId())) {
+ // 澶勭悊鍙橀噺琛ㄨ揪寮�
+ if (identityLink.getUserId().contains(ProcessConstants.DATA_LAUNCH)) {
+ this.varReview(taskVO, projectId, task.getProcessInstanceId());
+ continue;
+ }
taskVO.setHandlerType(HandlerTypeEnum.USER);
SysUser sysUser = sysUserService.selectUserById(Long.parseLong(identityLink.getUserId()));
if (Objects.nonNull(sysUser)) {
- handlerIds.add(sysUser.getUserId());
- handlerNames.add(sysUser.getNickName());
+ taskVO.getHandlerId().add(sysUser.getUserId());
+ taskVO.getHandlerName().add(sysUser.getNickName());
if (Objects.nonNull(sysUser.getDept())) {
- handlerUnitIds.add(sysUser.getDept().getDeptId());
- handlerUnitNames.add(sysUser.getDept().getDeptName());
+ taskVO.getHandlerUnitId().add(sysUser.getDept().getDeptId());
+ taskVO.getHandlerUnitName().add(sysUser.getDept().getDeptName());
}
}
// 缁戝畾鐨勬槸瑙掕壊鎴栬�呴儴闂�
@@ -851,29 +938,395 @@
// 閮ㄩ棬
SysDept dept = sysDeptService.selectDeptById(Long.parseLong(split[1]));
if (Objects.nonNull(dept)) {
- handlerUnitIds.add(dept.getDeptId());
- handlerUnitNames.add(dept.getDeptName());
+ taskVO.getHandlerUnitId().add(dept.getDeptId());
+ taskVO.getHandlerUnitName().add(dept.getDeptName());
}
}
} else {
taskVO.setHandlerType(HandlerTypeEnum.ROLE);
SysRole role = sysRoleService.selectRoleById(Long.parseLong(identityLink.getGroupId()));
if (Objects.nonNull(role)) {
- handlerUnitIds.add(Long.parseLong(identityLink.getGroupId()));
- handlerUnitNames.add(role.getRoleName());
+ taskVO.getHandlerUnitId().add(Long.parseLong(identityLink.getGroupId()));
+ taskVO.getHandlerUnitName().add(role.getRoleName());
}
}
}
- taskVO.setHandlerId(handlerIds);
- taskVO.setHandlerName(handlerNames);
- taskVO.setHandlerUnitId(handlerUnitIds);
- taskVO.setHandlerUnitName(handlerUnitNames);
+
+ this.distinctVo(taskVO);
}
+ }
+
+ /**
+ * 缁熻鎸夋椂瀹屾垚鐨勪换鍔�
+ *
+ * @param processInsId 娴佺▼瀹炰緥id
+ * @return
+ */
+ private Long getTimelyTaskNum(String processInsId) {
+ // 鏌ュ嚭宸插畬鎴愮殑浠诲姟key
+ List<HistoricTaskInstance> hisTaskList = historyService.createHistoricTaskInstanceQuery()
+ .processInstanceId(processInsId)
+ .finished()
+ .includeIdentityLinks()
+ .list();
+ if (CollectionUtils.isEmpty(hisTaskList)) {
+ return 0L;
+ }
+
+ List<String> hisTaskKeys = hisTaskList.stream().map(HistoricTaskInstance::getTaskDefinitionKey).distinct().collect(Collectors.toList());
+ Map<String, HistoricTaskInstance> hisTaskMap = hisTaskList.stream().collect(Collectors.toMap(HistoricTaskInstance::getTaskDefinitionKey, his -> his));
+ // 鏌ュ嚭鏃堕棿姝ｅ父鐨勪换鍔ey
+ List<ProcessCoding> taskList = new LambdaQueryChainWrapper<>(processCodingService.getBaseMapper())
+ .eq(ProcessCoding::getProcessInsId, processInsId)
+ .in(ProcessCoding::getTaskDefKey, hisTaskKeys)
+ .list();
+ Map<String, ProcessCoding> codingMap = taskList.stream().collect(Collectors.toMap(ProcessCoding::getTaskDefKey, pro -> pro));
+ List<HistoricTaskInstance> finishedTaskList = new ArrayList<>();
+ // 鍒ゆ柇
+ for (String key : hisTaskMap.keySet()) {
+ ProcessCoding processCoding = codingMap.get(key);
+ // 濡傛灉宸插畬鎴愮殑浠诲姟娌′粠鏁版嵁搴撴煡鎵惧嚭鏉ワ紝璇存槑璇ヤ换鍔℃病閰嶇疆璧嬬爜绛夋椂闂达紝鐩存帴璁剧疆涓烘寜鏃跺畬鎴�
+ if (Objects.isNull(processCoding)) {
+ finishedTaskList.add(hisTaskMap.get(key));
+ } else if (ProcessOverTimeConstants.NORMAL.equals(processCoding.getOvertimeStatus()) || StringUtils.isBlank(processCoding.getOvertimeStatus())) {
+ finishedTaskList.add(hisTaskMap.get(key));
+ }
+ }
+ return Long.valueOf(finishedTaskList.size());
+ }
+
+ /**
+ * 鏌ヨ鎸夋椂瀹屾垚鐨勪换鍔�
+ *
+ * @param processDefinitionId 娴佺▼瀹氫箟id
+ * @param processInsId 娴佺▼瀹炰緥id
+ * @param taskName 浠诲姟鍚嶇О--鎼滅储鏉′欢
+ * @param pageNum
+ * @param pageSize
+ * @param result
+ * @return
+ */
+ private List<CustomerTaskVO> getTimelyTask(String processDefinitionId, String processInsId, String taskName, Integer pageNum, Integer pageSize, Result result) {
+ int startNum = pageSize * (pageNum - 1);
+ int endNum = startNum + pageSize;
+
+ // 鏌ュ嚭宸插畬鎴愮殑浠诲姟key
+ List<HistoricTaskInstance> hisTaskList = historyService.createHistoricTaskInstanceQuery()
+ .processInstanceId(processInsId)
+ .finished()
+ .taskNameLike(taskName)
+ .includeIdentityLinks()
+ .orderByTaskCreateTime()
+ .desc()
+ .list();
+ if (CollectionUtils.isEmpty(hisTaskList)) {
+ result.total(0);
+ return new ArrayList<>();
+ }
+
+ List<String> hisTaskKeys = hisTaskList.stream().map(HistoricTaskInstance::getTaskDefinitionKey).distinct().collect(Collectors.toList());
+ Map<String, HistoricTaskInstance> hisTaskMap = hisTaskList.stream().collect(Collectors.toMap(HistoricTaskInstance::getTaskDefinitionKey, his -> his));
+ // 鏌ュ嚭鏃堕棿姝ｅ父鐨勪换鍔ey
+ List<ProcessCoding> taskList = new LambdaQueryChainWrapper<>(processCodingService.getBaseMapper())
+ .eq(ProcessCoding::getProcessInsId, processInsId)
+ .in(ProcessCoding::getTaskDefKey, hisTaskKeys)
+ .list();
+ Map<String, ProcessCoding> codingMap = taskList.stream().collect(Collectors.toMap(ProcessCoding::getTaskDefKey, pro -> pro));
+ List<HistoricTaskInstance> finishedTaskList = new ArrayList<>();
+ // 鍒ゆ柇
+ for (String key : hisTaskMap.keySet()) {
+ ProcessCoding processCoding = codingMap.get(key);
+ // 濡傛灉宸插畬鎴愮殑浠诲姟娌′粠鏁版嵁搴撴煡鎵惧嚭鏉ワ紝璇存槑璇ヤ换鍔℃病閰嶇疆璧嬬爜绛夋椂闂达紝鐩存帴璁剧疆涓烘寜鏃跺畬鎴�
+ if (Objects.isNull(processCoding)) {
+ finishedTaskList.add(hisTaskMap.get(key));
+ } else if (ProcessOverTimeConstants.NORMAL.equals(processCoding.getOvertimeStatus()) || StringUtils.isBlank(processCoding.getOvertimeStatus())) {
+ finishedTaskList.add(hisTaskMap.get(key));
+ }
+ }
+
+ if (startNum >= finishedTaskList.size()) {
+ // 濡傛灉璧峰绱㈠紩瓒呭嚭浜嗗垪琛ㄧ殑澶у皬锛岃繑鍥炰竴涓┖鍒楄〃
+ return new ArrayList<>();
+ }
+ result.total(finishedTaskList.size());
+ int end = Math.min(endNum, finishedTaskList.size());
+ List<HistoricTaskInstance> pageFinishedTaskList = finishedTaskList.subList(startNum, end);
+ List<String> taskDefs = pageFinishedTaskList.stream().map(HistoricTaskInstance::getTaskDefinitionKey).collect(Collectors.toList());
+ Map<String, HistoricTaskInstance> keyMap = pageFinishedTaskList.stream().collect(Collectors.toMap(HistoricTaskInstance::getTaskDefinitionKey, his -> his));
+
+ // 寰楀埌鐩爣浠诲姟瀵瑰簲鐨勫畾涔�
+ List<UserTask> finishedUserTaskElement = this.getAllUserTaskElement(processDefinitionId).stream().filter(el -> taskDefs.contains(el.getId())).collect(Collectors.toList());
+ // 鏌ュ嚭娴佺▼
+
+ ProcessInstance process = runtimeService.createProcessInstanceQuery().processInstanceId(processInsId).singleResult();
+ String deployId = "";
+ String processName = "";
+ if (Objects.nonNull(process)) {
+ deployId = process.getDeploymentId();
+ processName = process.getProcessDefinitionName();
+ } else {
+ HistoricProcessInstance hisProcess = historyService.createHistoricProcessInstanceQuery().processInstanceId(processInsId).singleResult();
+ deployId = hisProcess.getDeploymentId();
+ processName = hisProcess.getProcessDefinitionName();
+ }
+
+ String finalDeployId = deployId;
+ String finalProcessName = processName;
+ List<CustomerTaskVO> vos = finishedUserTaskElement.stream().map(userTask -> {
+ CustomerTaskVO vo = new CustomerTaskVO();
+ vo.setProcessInsId(processInsId);
+ vo.setProcessDefId(processDefinitionId);
+ vo.setDeployId(finalDeployId);
+ vo.setTaskName(userTask.getName());
+ vo.setProcessName(finalProcessName);
+
+ // 涓�涓换鍔″彲鑳芥湁澶氫釜鍊欓�変汉/缁勶紝鎵�浠ラ渶瑕佷娇鐢╨ist
+ List<Long> handlerIds = new ArrayList<>(2);
+ List<String> handlerNames = new ArrayList<>(2);
+ List<Long> handlerUnitIds = new ArrayList<>(2);
+ List<String> handlerUnitNames = new ArrayList<>(2);
+ vo.setHandlerId(handlerIds);
+ vo.setHandlerName(handlerNames);
+ vo.setHandlerUnitId(handlerUnitIds);
+ vo.setHandlerUnitName(handlerUnitNames);
+
+ HistoricTaskInstance hisTask = keyMap.get(userTask.getId());
+ if (Objects.nonNull(hisTask)) {
+ vo.setTaskStatus(TaskStatusEnum.FINISHED);
+ // 濡傛灉鏄凡瀹屾垚鐨勶紝淇℃伅闇�瑕佸崟鐙祴鍊�
+ vo.setTaskId(hisTask.getId());
+ vo.setExecutionId(hisTask.getExecutionId());
+ vo.setCreateTime(hisTask.getStartTime());
+
+ // 鏌ヨ瀹為檯澶勭悊浜�
+ long handlerUserId = Long.parseLong(hisTask.getAssignee());
+ SysUser handlerUser = sysUserService.selectUserById(handlerUserId);
+ if (Objects.nonNull(handlerUser)) {
+ vo.getHandlerId().add(handlerUserId);
+ vo.getHandlerName().add(handlerUser.getNickName());
+ vo.setActualHandlerUserId(hisTask.getAssignee());
+ vo.setActualHandlerUserName(handlerUser.getNickName());
+ }
+ vo.setTaskDefinitionKey(hisTask.getTaskDefinitionKey());
+ this.setPromoterAndHandler(vo, hisTask.getIdentityLinks());
+ }
+
+ this.distinctVo(vo);
+ return vo;
+ }).collect(Collectors.toList());
+ result.data(vos);
+ return vos;
+ }
+
+
+ /**
+ * 缁熻瓒呮椂鐨勪换鍔℃暟
+ *
+ * @param processInsId 娴佺▼瀹炰緥id
+ * @return
+ */
+ private Long getOvertimeTaskNum(String processInsId) {
+ // 鏌ュ嚭杩愯鍦ㄧ殑浠诲姟key
+ List<Task> taskList = taskService.createTaskQuery().processInstanceId(processInsId).list();
+
+ if (CollectionUtils.isEmpty(taskList)) {
+ return 0L;
+ }
+ List<String> taskKeys = taskList.stream().map(Task::getTaskDefinitionKey).distinct().collect(Collectors.toList());
+ Map<String, Task> taskMap = taskList.stream().collect(Collectors.toMap(Task::getTaskDefinitionKey, his -> his));
+ // 鏌ュ嚭鏁版嵁搴撶殑浠诲姟key
+ List<ProcessCoding> databaseTaskList = new LambdaQueryChainWrapper<>(processCodingService.getBaseMapper())
+ .eq(ProcessCoding::getProcessInsId, processInsId)
+ .in(ProcessCoding::getTaskDefKey, taskKeys)
+ .list();
+ Map<String, ProcessCoding> codingMap = databaseTaskList.stream().collect(Collectors.toMap(ProcessCoding::getTaskDefKey, pro -> pro));
+ List<Task> tList = new ArrayList<>();
+ // 鍒ゆ柇
+ for (String key : taskMap.keySet()) {
+ ProcessCoding processCoding = codingMap.get(key);
+ // 濡傛灉杩愯涓殑浠诲姟娌′粠鏁版嵁搴撴煡鎵惧嚭鏉ワ紝璇存槑璇ヤ换鍔℃病閰嶇疆璧嬬爜绛夋椂闂达紝涓嶇畻瓒呮椂
+ if (Objects.nonNull(processCoding) && ProcessOverTimeConstants.OVERTIME.equals(processCoding.getOvertimeStatus())) {
+ tList.add(taskMap.get(key));
+ }
+ }
+
+ return Long.valueOf(taskList.size());
+ }
+
+ /**
+ * 鏌ヨ瓒呮椂鐨勪换鍔�
+ *
+ * @param projectId 椤圭洰id
+ * @param processDefinitionId 娴佺▼瀹氫箟id
+ * @param processInsId 娴佺▼瀹炰緥id
+ * @param taskName 浠诲姟鍚嶇О--鎼滅储鏉′欢
+ * @param pageNum
+ * @param pageSize
+ * @param result
+ * @return
+ */
+ private List<CustomerTaskVO> getOvertimeTask(Long projectId, String processDefinitionId, String processInsId, String taskName, Integer pageNum, Integer pageSize, Result result) {
+ int startNum = pageSize * (pageNum - 1);
+ int endNum = startNum + pageSize;
+
+ // 鏌ュ嚭杩愯鍦ㄧ殑浠诲姟key
+ List<Task> taskList = new ArrayList<>(12);
+ if (StringUtils.isNotBlank(taskName)) {
+ taskList = taskService.createTaskQuery().processInstanceId(processInsId).taskNameLike(taskName).orderByTaskCreateTime().desc().list();
+ } else {
+ taskList = taskService.createTaskQuery().processInstanceId(processInsId).orderByTaskCreateTime().desc().list();
+ }
+ if (CollectionUtils.isEmpty(taskList)) {
+ result.total(0);
+ return new ArrayList<>();
+ }
+ List<String> taskKeys = taskList.stream().map(Task::getTaskDefinitionKey).distinct().collect(Collectors.toList());
+ Map<String, Task> taskMap = taskList.stream().collect(Collectors.toMap(Task::getTaskDefinitionKey, his -> his));
+ // 鏌ュ嚭鏁版嵁搴撶殑浠诲姟key
+ List<ProcessCoding> databaseTaskList = new LambdaQueryChainWrapper<>(processCodingService.getBaseMapper())
+ .eq(ProcessCoding::getProcessInsId, processInsId)
+ .in(ProcessCoding::getTaskDefKey, taskKeys)
+ .list();
+ Map<String, ProcessCoding> codingMap = databaseTaskList.stream().collect(Collectors.toMap(ProcessCoding::getTaskDefKey, pro -> pro));
+ List<Task> tList = new ArrayList<>();
+ // 鍒ゆ柇
+ for (String key : taskMap.keySet()) {
+ ProcessCoding processCoding = codingMap.get(key);
+ // 濡傛灉杩愯涓殑浠诲姟娌′粠鏁版嵁搴撴煡鎵惧嚭鏉ワ紝璇存槑璇ヤ换鍔℃病閰嶇疆璧嬬爜绛夋椂闂达紝涓嶇畻瓒呮椂
+ if (Objects.nonNull(processCoding) && ProcessOverTimeConstants.OVERTIME.equals(processCoding.getOvertimeStatus())) {
+ tList.add(taskMap.get(key));
+ }
+ }
+
+ if (startNum >= tList.size()) {
+ // 濡傛灉璧峰绱㈠紩瓒呭嚭浜嗗垪琛ㄧ殑澶у皬锛岃繑鍥炰竴涓┖鍒楄〃
+ return new ArrayList<>();
+ }
+ result.total(tList.size());
+ int end = Math.min(endNum, tList.size());
+ List<Task> pageTaskList = tList.subList(startNum, end);
+ List<String> taskDefs = pageTaskList.stream().map(Task::getTaskDefinitionKey).collect(Collectors.toList());
+ Map<String, Task> keyMap = pageTaskList.stream().collect(Collectors.toMap(Task::getTaskDefinitionKey, his -> his));
+
+ // 寰楀埌鐩爣浠诲姟瀵瑰簲鐨勫畾涔�
+ List<UserTask> finishedUserTaskElement = this.getAllUserTaskElement(processDefinitionId).stream().filter(el -> taskDefs.contains(el.getId())).collect(Collectors.toList());
+
+ // 鏌ヨ浠诲姟鐩稿叧淇℃伅
+ List<CustomerTaskVO> vos = finishedUserTaskElement.stream().map(userTask -> {
+ Task task = keyMap.get(userTask.getId());
+ CustomerTaskVO vo = new CustomerTaskVO();
+ this.setRuntimeTaskInfo(task, vo, projectId);
+ return vo;
+ }).collect(Collectors.toList());
+ result.data(vos);
+ return vos;
+ }
+
+ /**
+ * 缁熻鍗冲皢瓒呮椂鐨勪换鍔℃暟
+ *
+ * @param processInsId 娴佺▼瀹炰緥id
+ * @return
+ */
+ private Long getWillOvertimeTaskNum(String processInsId) {
+ // 鏌ュ嚭杩愯鍦ㄧ殑浠诲姟key
+ List<Task> taskList = taskService.createTaskQuery().processInstanceId(processInsId).list();
+ if (CollectionUtils.isEmpty(taskList)) {
+ return 0L;
+ }
+ List<String> taskKeys = taskList.stream().map(Task::getTaskDefinitionKey).distinct().collect(Collectors.toList());
+ Map<String, Task> taskMap = taskList.stream().collect(Collectors.toMap(Task::getTaskDefinitionKey, his -> his));
+ // 鏌ュ嚭鏁版嵁搴撶殑浠诲姟key
+ List<ProcessCoding> databaseTaskList = new LambdaQueryChainWrapper<>(processCodingService.getBaseMapper())
+ .eq(ProcessCoding::getProcessInsId, processInsId)
+ .in(ProcessCoding::getTaskDefKey, taskKeys)
+ .list();
+ Map<String, ProcessCoding> codingMap = databaseTaskList.stream().collect(Collectors.toMap(ProcessCoding::getTaskDefKey, pro -> pro));
+ List<Task> tList = new ArrayList<>();
+ // 鍒ゆ柇
+ for (String key : taskMap.keySet()) {
+ ProcessCoding processCoding = codingMap.get(key);
+ // 濡傛灉杩愯涓殑浠诲姟娌′粠鏁版嵁搴撴煡鎵惧嚭鏉ワ紝璇存槑璇ヤ换鍔℃病閰嶇疆璧嬬爜绛夋椂闂达紝涓嶇畻鍗冲皢瓒呮椂
+ if (Objects.nonNull(processCoding) && ProcessOverTimeConstants.WILLOVERTIME.equals(processCoding.getOvertimeStatus())) {
+ tList.add(taskMap.get(key));
+ }
+ }
+ return Long.valueOf(tList.size());
+ }
+
+ /**
+ * 鏌ヨ鍗冲皢瓒呮椂鐨勪换鍔�
+ *
+ * @param projectId 椤圭洰id
+ * @param processDefinitionId 娴佺▼瀹氫箟id
+ * @param processInsId 娴佺▼瀹炰緥id
+ * @param taskName 浠诲姟鍚嶇О--鎼滅储鏉′欢
+ * @param pageNum
+ * @param pageSize
+ * @param result
+ * @return
+ */
+ private List<CustomerTaskVO> getWillOvertimeTask(Long projectId, String processDefinitionId, String processInsId, String taskName, Integer pageNum, Integer pageSize, Result result) {
+ int startNum = pageSize * (pageNum - 1);
+ int endNum = startNum + pageSize;
+
+ // 鏌ュ嚭杩愯鍦ㄧ殑浠诲姟key
+ List<Task> taskList = new ArrayList<>(12);
+ if (StringUtils.isNotBlank(taskName)) {
+ taskList = taskService.createTaskQuery().processInstanceId(processInsId).taskNameLike(taskName).orderByTaskCreateTime().desc().list();
+ } else {
+ taskList = taskService.createTaskQuery().processInstanceId(processInsId).orderByTaskCreateTime().desc().list();
+ }
+ if (CollectionUtils.isEmpty(taskList)) {
+ result.total(0);
+ return new ArrayList<>();
+ }
+ List<String> taskKeys = taskList.stream().map(Task::getTaskDefinitionKey).distinct().collect(Collectors.toList());
+ Map<String, Task> taskMap = taskList.stream().collect(Collectors.toMap(Task::getTaskDefinitionKey, his -> his));
+ // 鏌ュ嚭鏁版嵁搴撶殑浠诲姟key
+ List<ProcessCoding> databaseTaskList = new LambdaQueryChainWrapper<>(processCodingService.getBaseMapper())
+ .eq(ProcessCoding::getProcessInsId, processInsId)
+ .in(ProcessCoding::getTaskDefKey, taskKeys)
+ .list();
+ Map<String, ProcessCoding> codingMap = databaseTaskList.stream().collect(Collectors.toMap(ProcessCoding::getTaskDefKey, pro -> pro));
+ List<Task> tList = new ArrayList<>();
+ // 鍒ゆ柇
+ for (String key : taskMap.keySet()) {
+ ProcessCoding processCoding = codingMap.get(key);
+ // 濡傛灉杩愯涓殑浠诲姟娌′粠鏁版嵁搴撴煡鎵惧嚭鏉ワ紝璇存槑璇ヤ换鍔℃病閰嶇疆璧嬬爜绛夋椂闂达紝涓嶇畻鍗冲皢瓒呮椂
+ if (Objects.nonNull(processCoding) && ProcessOverTimeConstants.WILLOVERTIME.equals(processCoding.getOvertimeStatus())) {
+ tList.add(taskMap.get(key));
+ }
+ }
+
+ if (startNum >= tList.size()) {
+ // 濡傛灉璧峰绱㈠紩瓒呭嚭浜嗗垪琛ㄧ殑澶у皬锛岃繑鍥炰竴涓┖鍒楄〃
+ return new ArrayList<>();
+ }
+ result.total(tList.size());
+ int end = Math.min(endNum, tList.size());
+ List<Task> pageTaskList = tList.subList(startNum, end);
+ List<String> taskDefs = pageTaskList.stream().map(Task::getTaskDefinitionKey).collect(Collectors.toList());
+ Map<String, Task> keyMap = pageTaskList.stream().collect(Collectors.toMap(Task::getTaskDefinitionKey, his -> his));
+
+ // 寰楀埌鐩爣浠诲姟瀵瑰簲鐨勫畾涔�
+ List<UserTask> finishedUserTaskElement = this.getAllUserTaskElement(processDefinitionId).stream().filter(el -> taskDefs.contains(el.getId())).collect(Collectors.toList());
+
+ // 鏌ヨ浠诲姟鐩稿叧淇℃伅
+ List<CustomerTaskVO> vos = finishedUserTaskElement.stream().map(userTask -> {
+ Task task = keyMap.get(userTask.getId());
+ CustomerTaskVO vo = new CustomerTaskVO();
+ this.setRuntimeTaskInfo(task, vo, projectId);
+ return vo;
+ }).collect(Collectors.toList());
+ result.data(vos);
+ return vos;
}
/**
* 鏌ヨ鍓╀綑浜嬮」锛堟湭寮�濮嬬殑浠诲姟锛�
*
+ * @param projectId 椤圭洰id
* @param processDefinitionId
* @param processInsId
* @param taskName
@@ -882,22 +1335,13 @@
* @param result
* @return
*/
- private List<CustomerTaskVO> getRemainingTask(String processDefinitionId, String processInsId, String taskName, Integer pageNum, Integer pageSize, Result result) {
- int startNum = pageSize * (pageNum - 1);
- int endNum = startNum + pageSize;
- List<UserTask> allUserTaskElement = this.getAllUserTaskElement(processDefinitionId);
-
- if (startNum >= allUserTaskElement.size()) {
- // 濡傛灉璧峰绱㈠紩瓒呭嚭浜嗗垪琛ㄧ殑澶у皬锛岃繑鍥炰竴涓┖鍒楄〃
- return new ArrayList<>();
- }
- if (StringUtils.isNotBlank(taskName)) {
- // 妯℃嫙妯＄硦鏌ヨ
- allUserTaskElement = allUserTaskElement.stream().filter(taskEl -> taskEl.getName().contains(taskName)).collect(Collectors.toList());
- }
- result.total(allUserTaskElement.size());
- int end = Math.min(endNum, allUserTaskElement.size());
- List<UserTask> userTasks = allUserTaskElement.subList(startNum, end);
+ private List<CustomerTaskVO> getRemainingTask(Long projectId,
+ String processDefinitionId,
+ String processInsId,
+ String taskName,
+ Integer pageNum,
+ Integer pageSize,
+ Result result) {
// 鏌ュ嚭娴佺▼
ProcessInstance process = runtimeService.createProcessInstanceQuery().processInstanceId(processInsId).singleResult();
if (Objects.isNull(process)) {
@@ -907,92 +1351,129 @@
return vos;
}
- // 涓�涓换鍔″彲鑳芥湁澶氫釜鍊欓�変汉/缁勶紝鎵�浠ラ渶瑕佷娇鐢╨ist
- List<Long> handlerIds = new ArrayList<>(2);
- List<String> handlerNames = new ArrayList<>(2);
- List<Long> handlerUnitIds = new ArrayList<>(2);
- List<String> handlerUnitNames = new ArrayList<>(2);
+ int startNum = pageSize * (pageNum - 1);
+ int endNum = startNum + pageSize;
+ List<UserTask> allUserTaskElement = this.getAllUserTaskElement(processDefinitionId);
+
+ // 鎺掗櫎杩涜涓殑浠诲姟鍜屽凡瀹屾垚鐨勪换鍔�
+ List<String> runTaskKeyList = taskService.createTaskQuery().processInstanceId(processInsId).list().stream().map(Task::getTaskDefinitionKey).collect(Collectors.toList());
+ List<String> finishedTaskKeyList = historyService.createHistoricTaskInstanceQuery().processInstanceId(processInsId).finished().list().stream().map(HistoricTaskInstance::getTaskDefinitionKey).distinct().collect(Collectors.toList());
+ allUserTaskElement = allUserTaskElement.stream().filter(el -> !runTaskKeyList.contains(el.getId()) && !finishedTaskKeyList.contains(el.getId())).collect(Collectors.toList());
+ // 妯℃嫙妯＄硦鏌ヨ
+ if (StringUtils.isNotBlank(taskName)) {
+ allUserTaskElement = allUserTaskElement.stream().filter(taskEl -> taskEl.getName().contains(taskName)).collect(Collectors.toList());
+ }
+ if (startNum >= allUserTaskElement.size()) {
+ // 濡傛灉璧峰绱㈠紩瓒呭嚭浜嗗垪琛ㄧ殑澶у皬锛岃繑鍥炰竴涓┖鍒楄〃
+ return new ArrayList<>();
+ }
+ result.total(allUserTaskElement.size());
+ int end = Math.min(endNum, allUserTaskElement.size());
+ List<UserTask> userTasks = allUserTaskElement.subList(startNum, end);
+
+
// 鍒ゆ柇浠诲姟鐘舵�侊紝鏋勫缓vo
List<CustomerTaskVO> vos = new ArrayList<>(48);
for (UserTask userTask : userTasks) {
CustomerTaskVO vo = new CustomerTaskVO();
+ // 涓�涓换鍔″彲鑳芥湁澶氫釜鍊欓�変汉/缁勶紝鎵�浠ラ渶瑕佷娇鐢╨ist
+ List<Long> handlerIds = new ArrayList<>(2);
+ List<String> handlerNames = new ArrayList<>(2);
+ List<Long> handlerUnitIds = new ArrayList<>(2);
+ List<String> handlerUnitNames = new ArrayList<>(2);
+ vo.setHandlerId(handlerIds);
+ vo.setHandlerName(handlerNames);
+ vo.setHandlerUnitId(handlerUnitIds);
+ vo.setHandlerUnitName(handlerUnitNames);
+
vo.setProcessInsId(process.getId());
vo.setProcessDefId(processDefinitionId);
vo.setDeployId(process.getDeploymentId());
vo.setTaskName(userTask.getName());
vo.setProcessName(process.getProcessDefinitionName());
- Task task = taskService.createTaskQuery()
- .processInstanceId(process.getId())
- .taskDefinitionKey(userTask.getId())
- .singleResult();
- if (Objects.isNull(task)) {
- // 濡傛灉浠诲姟鍦ㄨ繍琛屾椂娌℃壘鍒帮紝閭ｄ箞鍙兘涓烘湭寮�濮嬫垨鑰呭凡瀹屾垚锛屽彧鏌ヨ鏈紑濮嬬殑
- List<HistoricTaskInstance> historicTasks = historyService.createHistoricTaskInstanceQuery()
- .processInstanceId(process.getProcessInstanceId())
- .taskDefinitionKey(userTask.getId())
- .includeIdentityLinks()
- .orderByHistoricTaskInstanceStartTime()
- .desc()
- .list();
- if (CollectionUtils.isEmpty(historicTasks)) {
- // 鏈紑濮嬬殑浠诲姟锛屽叾鍏宠仈鐨勭敤鎴风粍杩欎簺閮藉彲浠ヤ粠UserTask涓嬁鍒帮紝鍥犱负鏈韩鏈紑濮嬬殑浠诲姟鏄病鏈塼ask鐨勶紝鎵�浠ヨ繖閲岀洿鎺ユ煡
- if (StringUtils.isNotBlank(userTask.getAssignee())) {
- vo.setHandlerType(HandlerTypeEnum.USER);
- // 澶勭悊鍙橀噺琛ㄨ揪寮�
- if (userTask.getAssignee().contains(ProcessConstants.DATA_LAUNCH)) {
- handlerNames.add(userTask.getAssignee());
- continue;
- }
- SysUser sysUser = sysUserService.selectUserById(Long.parseLong(userTask.getAssignee()));
- if (Objects.nonNull(sysUser)) {
- handlerIds.add(sysUser.getUserId());
- handlerNames.add(sysUser.getNickName());
- if (Objects.nonNull(sysUser.getDept())) {
- handlerUnitIds.add(sysUser.getDept().getDeptId());
- handlerUnitNames.add(sysUser.getDept().getDeptName());
- }
- }
- } else if (CollectionUtil.isNotEmpty(userTask.getCandidateGroups())) {
- List<String> groupIds = userTask.getCandidateGroups();
- for (String groupId : groupIds) {
- if (groupId.startsWith("dept")) { // 閮ㄩ棬鐨刬d鏄姞浜嗗墠缂�鐨勫锛歞ept:1
- vo.setHandlerType(HandlerTypeEnum.DEPT);
- String[] split = groupId.split(":");
- if (split.length > 1) {
- // 閮ㄩ棬
- SysDept dept = sysDeptService.selectDeptById(Long.parseLong(split[1]));
- if (Objects.nonNull(dept)) {
- handlerUnitIds.add(dept.getDeptId());
- handlerUnitNames.add(dept.getDeptName());
+ vo.setTaskStatus(TaskStatusEnum.NOT_START);
+ // 鏈紑濮嬬殑浠诲姟锛屽叾鍏宠仈鐨勭敤鎴风粍杩欎簺閮藉彲浠ヤ粠UserTask涓嬁鍒帮紝鍥犱负鏈韩鏈紑濮嬬殑浠诲姟鏄病鏈塼ask鐨勶紝鎵�浠ヨ繖閲岀洿鎺ユ煡
+ if (StringUtils.isNotBlank(userTask.getAssignee())) {
+ vo.setHandlerType(HandlerTypeEnum.USER);
- }
- }
- } else {
- vo.setHandlerType(HandlerTypeEnum.ROLE);
- SysRole role = sysRoleService.selectRoleById(Long.parseLong(groupId));
- if (Objects.nonNull(role)) {
- handlerUnitIds.add(role.getRoleId());
- handlerUnitNames.add(role.getRoleName());
- }
- }
- }
- }
- vo.setTaskStatus(TaskStatusEnum.NOT_START);
- vo.setHandlerId(handlerIds);
- vo.setHandlerName(handlerNames);
- vo.setHandlerUnitId(handlerUnitIds);
- vo.setHandlerUnitName(handlerUnitNames);
- } else {
+ // 澶勭悊鍙橀噺琛ㄨ揪寮�
+ if (userTask.getAssignee().contains(ProcessConstants.DATA_LAUNCH)) {
+ this.varReview(vo, projectId, processInsId);
+ vos.add(vo);
continue;
}
- } else {
- this.setRuntimeTaskInfo(task, vo);
+ SysUser sysUser = sysUserService.selectUserById(Long.parseLong(userTask.getAssignee()));
+ if (Objects.nonNull(sysUser)) {
+ vo.getHandlerId().add(sysUser.getUserId());
+ vo.getHandlerName().add(sysUser.getNickName());
+ if (Objects.nonNull(sysUser.getDept())) {
+ vo.getHandlerUnitId().add(sysUser.getDept().getDeptId());
+ vo.getHandlerUnitName().add(sysUser.getDept().getDeptName());
+ }
+ }
+ } else if (CollectionUtil.isNotEmpty(userTask.getCandidateGroups())) {
+ List<String> groupIds = userTask.getCandidateGroups();
+ for (String groupId : groupIds) {
+ if (groupId.startsWith("dept")) { // 閮ㄩ棬鐨刬d鏄姞浜嗗墠缂�鐨勫锛歞ept:1
+ vo.setHandlerType(HandlerTypeEnum.DEPT);
+ String[] split = groupId.split(":");
+ if (split.length > 1) {
+ // 閮ㄩ棬
+ SysDept dept = sysDeptService.selectDeptById(Long.parseLong(split[1]));
+ if (Objects.nonNull(dept)) {
+ vo.getHandlerUnitId().add(dept.getDeptId());
+ vo.getHandlerUnitName().add(dept.getDeptName());
+ }
+ }
+ } else {
+ vo.setHandlerType(HandlerTypeEnum.ROLE);
+ SysRole role = sysRoleService.selectRoleById(Long.parseLong(groupId));
+ if (Objects.nonNull(role)) {
+ vo.getHandlerUnitId().add(role.getRoleId());
+ vo.getHandlerUnitName().add(role.getRoleName());
+ }
+ }
+ }
}
+ this.distinctVo(vo);
vos.add(vo);
}
result.data(vos);
return vos;
+ }
+
+ /**
+ * 瀵逛换鍔′俊鎭腑澶勭悊浜虹殑鍘婚噸
+ *
+ * @param vo
+ */
+ private void distinctVo(CustomerTaskVO vo) {
+ vo.setHandlerId(vo.getHandlerId().stream().distinct().collect(Collectors.toList()));
+ vo.setHandlerName(vo.getHandlerName().stream().distinct().collect(Collectors.toList()));
+ vo.setHandlerUnitId(vo.getHandlerUnitId().stream().distinct().collect(Collectors.toList()));
+ vo.setHandlerUnitName(vo.getHandlerUnitName().stream().distinct().collect(Collectors.toList()));
+ }
+
+ /**
+ * 澶勭悊娴佺▼鍙橀噺鐨勫鐞嗕汉鍥炴樉
+ *
+ * @param vo
+ */
+ private void varReview(CustomerTaskVO vo, Long projectId, String processInsId) {
+ ProjectProcess projectProcess = new LambdaQueryChainWrapper<>(projectProcessMapper)
+ .eq(ProjectProcess::getProjectId, projectId)
+ .eq(ProjectProcess::getProcessInsId, processInsId)
+ .one();
+ if (Objects.isNull(projectProcess)) {
+ throw new RuntimeException("璇ユ祦绋嬫湭缁戝畾椤圭洰");
+ }
+ SysUser user = sysUserService.selectUserById(projectProcess.getDataLaunch());
+ if (Objects.nonNull(user) && Objects.nonNull(user.getDept())) {
+ vo.getHandlerName().add(user.getDept().getDeptName());
+ vo.getHandlerId().add(user.getDept().getDeptId());
+ }
+ this.distinctVo(vo);
}
/**
@@ -1015,7 +1496,7 @@
.processInstanceId(process.getProcessInstanceId())
.finished()
.list();
- long num = list.stream().map(HistoricTaskInstance::getTaskDefinitionId).distinct().count();
+ long num = list.stream().map(HistoricTaskInstance::getTaskDefinitionKey).distinct().count();
return totalNum - num;
}
@@ -1035,6 +1516,10 @@
List<String> handlerNames = new ArrayList<>(2);
List<Long> handlerUnitIds = new ArrayList<>(2);
List<String> handlerUnitNames = new ArrayList<>(2);
+ taskVO.setHandlerId(handlerIds);
+ taskVO.setHandlerName(handlerNames);
+ taskVO.setHandlerUnitId(handlerUnitIds);
+ taskVO.setHandlerUnitName(handlerUnitNames);
// 娴佺▼澶勭悊浜轰俊鎭�
if (TaskStatusEnum.TODO.equals(taskVO.getTaskStatus())) {
@@ -1116,10 +1601,8 @@
}
}
}
- taskVO.setHandlerId(handlerIds);
- taskVO.setHandlerName(handlerNames);
- taskVO.setHandlerUnitId(handlerUnitIds);
- taskVO.setHandlerUnitName(handlerUnitNames);
+
+ this.distinctVo(taskVO);
}
/**
--
Gitblit v1.8.0