huangge1199/vue-pro
1
0
Fork 0
mirror of https://gitee.com/huangge1199_admin/vue-pro.git synced 2024-11-22 23:31:52 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

!689 【工作流】--加签减签review

Browse Source 
Merge pull request !689 from Youkehai/feature/bpm-addSignAndSubSign
This commit is contained in:
芋道源码 2023-10-21 11:59:22 +00:00 committed by Gitee
commit cc67174f87
No known key found for this signature in database
GPG Key ID: 173E9B9CA92EEF8F
7 changed files with 163 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
yudao-framework/yudao-common/src/main/java/cn/iocoder/yudao/framework/common/util/collection/CollectionUtils.java
View File

@ -3,11 +3,13 @@ package cn.iocoder.yudao.framework.common.util.collection;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.ArrayUtil;
import cn.iocoder.yudao.framework.common.util.number.NumberUtils;
import com.google.common.collect.ImmutableMap;
import java.util.*;
import java.util.function.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import static java.util.Arrays.asList;
@ -267,4 +269,19 @@ public class CollectionUtils {
return deptId == null ? Collections.emptyList() : Collections.singleton(deptId);
}
public static <T, U> List<U> convertListByMultiAttr(Collection<T> from,
Function<T, ? extends Stream<? extends U>> func) {
if (CollUtil.isEmpty(from)) {
return new ArrayList<>();
}
return from.stream().flatMap(func).filter(Objects::nonNull).collect(Collectors.toList());
}
public static <T, U> Set<U> convertSetByMultiAttr(Collection<T> from,
Function<T, ? extends Stream<? extends U>> func) {
if (CollUtil.isEmpty(from)) {
return new HashSet<>();
}
return from.stream().flatMap(func).filter(Objects::nonNull).collect(Collectors.toSet());
}
}

6
yudao-module-bpm/yudao-module-bpm-api/src/main/java/cn/iocoder/yudao/module/bpm/enums/task/BpmCommentTypeEnum.java
View File

@ -23,15 +23,13 @@ public enum BpmCommentTypeEnum {
* 操作类型
*/
private final Integer type;
// TODO @海：desc 可以改成 name；相当于操作名；
/**
* 操作名字
*/
private final String desc;
// TODO @海：直接改成 comment 哈；简单一点；
private final String name;
/**
* 操作描述
*/
private final String templateComment;
private final String comment;
}

6
yudao-module-bpm/yudao-module-bpm-api/src/main/java/cn/iocoder/yudao/module/bpm/enums/task/BpmProcessInstanceResultEnum.java
View File

@ -30,13 +30,13 @@ public enum BpmProcessInstanceResultEnum {
* 相当于是 通过 APPROVE 的特殊状态
* 例如：A审批， A 后加签了 B，并且审批通过了任务，但是 B 还未审批，则当前任务状态为“待后加签任务完成”
*/
ADD_SIGN_AFTER(7, "待后加签任务完成"),
SIGN_AFTER(7, "待后加签任务完成"),
/**
* 【加签】源任务未审批，但是向前加签了，所以源任务状态变为“待前加签任务完成”
* 相当于是 处理中 PROCESS 的特殊状态
* 例如：A 审批， A 前加签了 B，B 还未审核
*/
ADD_SIGN_BEFORE(8, "待前加签任务完成"),
SIGN_BEFORE(8, "待前加签任务完成"),
/**
* 【加签】后加签任务被创建时的初始状态
* 相当于是 处理中 PROCESS 的特殊状态
@ -71,7 +71,7 @@ public enum BpmProcessInstanceResultEnum {
public static boolean isEndResult(Integer result) {
return ObjectUtils.equalsAny(result, APPROVE.getResult(), REJECT.getResult(),
CANCEL.getResult(), BACK.getResult(),
ADD_SIGN_AFTER.getResult());
SIGN_AFTER.getResult());
}
}

18
yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/task/BpmTaskController.java
View File

@ -74,8 +74,7 @@ public class BpmTaskController {
return success(true);
}
// TODO @海：/return-list，不用带 get；
@GetMapping("/get-return-list")
@GetMapping("/return-list")
@Operation(summary = "获取所有可回退的节点", description = "用于【流程详情】的【回退】按钮")
@Parameter(name = "taskId", description = "当前任务ID", required = true)
@PreAuthorize("@ss.hasPermission('bpm:task:update')")
@ -99,8 +98,7 @@ public class BpmTaskController {
return success(true);
}
// TODO @海：create-sign？创建加签任务；
@PutMapping("/add-sign")
@PutMapping("/create-sign")
@Operation(summary = "加签", description = "before 前加签，after 后加签")
@PreAuthorize("@ss.hasPermission('bpm:task:update')")
public CommonResult<Boolean> addSignTask(@Valid @RequestBody BpmTaskAddSignReqVO reqVO) {
@ -108,8 +106,7 @@ public class BpmTaskController {
return success(true);
}
// TODO @海：delete-sign？删除加签任务；然后 @DeleteMapping；这样感觉可以保持统一；
@PutMapping("/sub-sign")
@DeleteMapping("/delete-sign")
@Operation(summary = "减签")
@PreAuthorize("@ss.hasPermission('bpm:task:update')")
public CommonResult<Boolean> subSignTask(@Valid @RequestBody BpmTaskSubSignReqVO reqVO) {
@ -117,13 +114,12 @@ public class BpmTaskController {
return success(true);
}
// TODO @海：/children-list，不用带 task 和 get；
// TODO @海：taskId 是不是改成 parentId？另外，它的 swagger 注解也加下哈；
@GetMapping("/get-children-task-list")
@GetMapping("children-list")
@Operation(summary = "获取能被减签的任务")
@Parameter(name = "parentId", description = "父级任务ID", required = true)
@PreAuthorize("@ss.hasPermission('bpm:task:update')")
public CommonResult<List<BpmTaskSubSignRespVO>> getChildrenTaskList(@RequestParam("taskId") String taskId) {
return success(taskService.getChildrenTaskList(taskId));
public CommonResult<List<BpmTaskSubSignRespVO>> getChildrenTaskList(@RequestParam("parentId") String parentId) {
return success(taskService.getChildrenTaskList(parentId));
}
}

23
yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/convert/task/BpmTaskConvert.java
View File

@ -2,8 +2,10 @@ package cn.iocoder.yudao.module.bpm.convert.task;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.LocalDateTimeUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import cn.iocoder.yudao.framework.common.util.collection.CollectionUtils;
import cn.iocoder.yudao.framework.common.util.collection.MapUtils;
import cn.iocoder.yudao.framework.common.util.date.DateUtils;
import cn.iocoder.yudao.framework.common.util.number.NumberUtils;
import cn.iocoder.yudao.module.bpm.controller.admin.task.vo.task.*;
@ -168,20 +170,15 @@ public interface BpmTaskConvert {
Map<Long, AdminUserRespDTO> userMap,
Map<String, Task> idTaskMap){
return CollectionUtils.convertList(bpmTaskExtDOList, task -> {
// TODO @海：setId、name，可以链式调用
BpmTaskSubSignRespVO bpmTaskSubSignRespVO = new BpmTaskSubSignRespVO();
bpmTaskSubSignRespVO.setName(task.getName());
bpmTaskSubSignRespVO.setId(task.getTaskId());
Task sourceTask = idTaskMap.get(task.getTaskId());
// TODO @海：下面这行注释，应该放到 idTaskMap.get(task.getTaskId()) 上面；原因是，应该注释之后，下面的逻辑是个整体；
BpmTaskSubSignRespVO bpmTaskSubSignRespVO = new BpmTaskSubSignRespVO()
.setName(task.getName())
.setId(task.getTaskId());
// 后加签任务不会直接设置 assignee ,所以不存在 assignee 的情况，则去取 owner
// TODO @海：可以使用 ObjUtil.default 方法
String assignee = StrUtil.isNotEmpty(sourceTask.getAssignee()) ? sourceTask.getAssignee() : sourceTask.getOwner();
// TODO @海：这里可以使用 MapUtils.findAndThen 写起来更简单一点；
AdminUserRespDTO assignUser = userMap.get(NumberUtils.parseLong(assignee));
if (assignUser != null) {
bpmTaskSubSignRespVO.setAssigneeUser(convert3(assignUser));
}
Task sourceTask = idTaskMap.get(task.getTaskId());
String assignee = ObjectUtil.defaultIfBlank(sourceTask.getOwner(),sourceTask.getAssignee());
MapUtils.findAndThen(userMap,NumberUtils.parseLong(assignee),
assignUser-> bpmTaskSubSignRespVO.setAssigneeUser(convert3(assignUser)));
return bpmTaskSubSignRespVO;
});
}

4
yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/task/BpmTaskService.java
View File

@ -176,9 +176,9 @@ public interface BpmTaskService {
/**
* 获取指定任务的子任务和审批人信息
*
* @param taskId 指定任务ID
* @param parentId 指定任务ID
* @return 子任务列表
*/
List<BpmTaskSubSignRespVO> getChildrenTaskList(String taskId);
List<BpmTaskSubSignRespVO> getChildrenTaskList(String parentId);
}

227
yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/task/BpmTaskServiceImpl.java
View File

@ -53,7 +53,6 @@ import javax.annotation.Resource;
import javax.validation.Valid;
import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
@ -240,11 +239,11 @@ public class BpmTaskServiceImpl implements BpmTaskService {
handleParentTask(task);
}
// TODO @海：我们是不是加签统一认为是 SIGN，这样 SIGN_AFTER 就是后置；SIGN_BEFORE 就是前置；
/**
* 审批通过存在“后加签”的任务。
* <p>
* 注意：该任务不能马上完成，需要一个中间状态（ADD_SIGN_AFTER），并激活剩余所有子任务（PROCESS）为可审批处理
* 注意：该任务不能马上完成，需要一个中间状态（SIGN_AFTER），并激活剩余所有子任务（PROCESS）为可审批处理
*
* @param task 当前任务
* @param reqVO 前端请求参数
@ -252,7 +251,7 @@ public class BpmTaskServiceImpl implements BpmTaskService {
private void approveAfterSignTask(Task task, BpmTaskApproveReqVO reqVO) {
// 1. 有向后加签，则该任务状态临时设置为 ADD_SIGN_AFTER 状态
taskExtMapper.updateByTaskId(
new BpmTaskExtDO().setTaskId(task.getId()).setResult(BpmProcessInstanceResultEnum.ADD_SIGN_AFTER.getResult())
new BpmTaskExtDO().setTaskId(task.getId()).setResult(BpmProcessInstanceResultEnum.SIGN_AFTER.getResult())
.setReason(reqVO.getReason()).setEndTime(LocalDateTime.now()));
// 2. 激活子任务
@ -275,50 +274,50 @@ public class BpmTaskServiceImpl implements BpmTaskService {
if (StrUtil.isBlank(parentTaskId)) {
return;
}
// TODO @海洋：279 这个判断就不需要啦；括号层级少一级噢；
if (StrUtil.isNotBlank(parentTaskId)) {
// 1. 判断当前任务的父任务是否还有子任务
Long childrenTaskCount = getChildrenTaskCount(parentTaskId);
if (childrenTaskCount > 0) {
return;
}
// TODO @海：如果非向前、向后加签，就直接 return 掉；就是把 3. 那判断做次提前；万一有别的父子任务经过这个逻辑，其实我们是不处理的，对哇？
// 2. 获取父任务
Task parentTask = validateTaskExist(parentTaskId);
// 3.1 情况一：处理向前加签
String scopeType = parentTask.getScopeType();
if (BpmTaskAddSignTypeEnum.BEFORE.getType().equals(scopeType)) {
// 3.1.1 如果是向前加签的任务，则调用 resolveTask 指派父任务，将 owner 重新赋值给父任务的 assignee，这样它就可以被审批
taskService.resolveTask(parentTaskId);
// 3.1.2 更新任务拓展表为处理中
taskExtMapper.updateByTaskId(
new BpmTaskExtDO().setTaskId(parentTask.getId()).setResult(BpmProcessInstanceResultEnum.PROCESS.getResult()));
} else if (BpmTaskAddSignTypeEnum.AFTER.getType().equals(scopeType)) {
// 3.2 情况二：处理向后加签
handleAfterSign(parentTask);
}
// 4. 子任务已处理完成，清空 scopeType 字段，修改 parentTask 信息，方便后续可以继续向前后向后加签
// 再查询一次的原因是避免报错：Task was updated by another transaction concurrently
// 因为前面处理后可能会导致 parentTask rev 字段被修改，需要重新获取最新的
parentTask = getTask(parentTaskId);
if (parentTask == null) {
// 为空的情况是：已经通过 handleAfterSign 方法将任务完成了，所以 ru_task 表会查不到数据
return;
}
clearTaskScopeTypeAndSave(parentTask);
// 1. 判断当前任务的父任务是否还有子任务
Long childrenTaskCount = getChildrenTaskCount(parentTaskId);
if (childrenTaskCount > 0) {
return;
}
// 2. 获取父任务
Task parentTask = validateTaskExist(parentTaskId);
// 3. 处理加签情况
String scopeType = parentTask.getScopeType();
if(!validateSignType(scopeType)){
return;
}
// 3.1 情况一：处理向前加签
if (BpmTaskAddSignTypeEnum.BEFORE.getType().equals(scopeType)) {
// 3.1.1 如果是向前加签的任务，则调用 resolveTask 指派父任务，将 owner 重新赋值给父任务的 assignee，这样它就可以被审批
taskService.resolveTask(parentTaskId);
// 3.1.2 更新任务拓展表为处理中
taskExtMapper.updateByTaskId(
new BpmTaskExtDO().setTaskId(parentTask.getId()).setResult(BpmProcessInstanceResultEnum.PROCESS.getResult()));
} else if (BpmTaskAddSignTypeEnum.AFTER.getType().equals(scopeType)) {
// 3.2 情况二：处理向后加签
handleParentTaskForAfterSign(parentTask);
}
// 4. 子任务已处理完成，清空 scopeType 字段，修改 parentTask 信息，方便后续可以继续向前后向后加签
// 再查询一次的原因是避免报错：Task was updated by another transaction concurrently
// 因为前面处理后可能会导致 parentTask rev 字段被修改，需要重新获取最新的
parentTask = getTask(parentTaskId);
if (parentTask == null) {
// 为空的情况是：已经通过 handleAfterSign 方法将任务完成了，所以 ru_task 表会查不到数据
return;
}
clearTaskScopeTypeAndSave(parentTask);
}
// TODO @海：可以把这个方法名，改成 handleParentTaskForAfterSign。= = 虽然这个名字也有点丑，但是目的是体现出它是 handleParentTask 的一种衍生
/**
* 处理后加签任务
*
* @param parentTask 当前审批任务的父任务
*/
// TODO @海：这个逻辑，怎么感觉可以是 parentTask 的 parent，再去调用 handleParentTask 方法；可以微信聊下；
private void handleAfterSign(Task parentTask) {
private void handleParentTaskForAfterSign(Task parentTask) {
String parentTaskId = parentTask.getId();
// 1. 更新 parentTask 的任务拓展表为通过，并调用 complete 完成自己
BpmTaskExtDO currentTaskExt = taskExtMapper.selectByTaskId(parentTask.getId());
@ -363,7 +362,7 @@ public class BpmTaskServiceImpl implements BpmTaskService {
continue;
}
// 3.2 没有子任务，判断当前任务状态是否为 ADD_SIGN_BEFORE 待前加签任务完成
if (BpmProcessInstanceResultEnum.ADD_SIGN_BEFORE.getResult().equals(parentTaskExt.getResult())) {
if (BpmProcessInstanceResultEnum.SIGN_BEFORE.getResult().equals(parentTaskExt.getResult())) {
// 3.3 需要修改该任务状态为处理中
taskService.resolveTask(parentTaskExt.getTaskId());
parentTaskExt.setResult(BpmProcessInstanceResultEnum.PROCESS.getResult());
@ -731,7 +730,7 @@ public class BpmTaskServiceImpl implements BpmTaskService {
// 2.3 更新扩展表状态
taskExtMapper.updateByTaskId(
new BpmTaskExtDO().setTaskId(taskEntity.getId())
.setResult(BpmProcessInstanceResultEnum.ADD_SIGN_BEFORE.getResult())
.setResult(BpmProcessInstanceResultEnum.SIGN_BEFORE.getResult())
.setReason(reqVO.getReason()));
}
// 2.4 记录加签方式，完成任务时需要用到判断
@ -740,11 +739,11 @@ public class BpmTaskServiceImpl implements BpmTaskService {
taskService.saveTask(taskEntity);
// 3. 创建加签任务
createAddSignChildrenTasks(convertList(reqVO.getUserIdList(), String::valueOf), taskEntity);
createSignTask(convertList(reqVO.getUserIdList(), String::valueOf), taskEntity);
// 4. 记录加签 comment，拼接结果为： [当前用户]向前加签/向后加签给了[多个用户]，理由为：reason
AdminUserRespDTO currentUser = adminUserApi.getUser(userId);
String comment = StrUtil.format(BpmCommentTypeEnum.ADD_SIGN.getTemplateComment(), currentUser.getNickname(),
String comment = StrUtil.format(BpmCommentTypeEnum.ADD_SIGN.getComment(), currentUser.getNickname(),
BpmTaskAddSignTypeEnum.formatDesc(reqVO.getType()), String.join(",", convertList(userList, AdminUserRespDTO::getNickname)), reqVO.getReason());
taskService.addComment(reqVO.getId(), taskEntity.getProcessInstanceId(),
BpmCommentTypeEnum.ADD_SIGN.getType().toString(), comment);
@ -783,14 +782,13 @@ public class BpmTaskServiceImpl implements BpmTaskService {
return taskEntity;
}
// TODO @海：方法名，要不改成 createSignTask；
/**
* 创建加签子任务
*
* @param addSingUserIdList 被加签的用户 ID
* @param taskEntity 被加签的任务
*/
private void createAddSignChildrenTasks(List<String> addSingUserIdList, TaskEntityImpl taskEntity) {
private void createSignTask(List<String> addSingUserIdList, TaskEntityImpl taskEntity) {
if (CollUtil.isEmpty(addSingUserIdList)) {
return;
}
@ -799,18 +797,17 @@ public class BpmTaskServiceImpl implements BpmTaskService {
if (StrUtil.isBlank(addSignId)) {
continue;
}
createChildrenTask(taskEntity, addSignId);
createSignTask(taskEntity, addSignId);
}
}
// TODO @海：注释要不改成，创建加签子任务；然后方法名，就是 createSignTask；因为它还是在创建加签任务，目前哈；
/**
* 创建子任务
* 创建加签子任务
*
* @param parentTask 父任务
* @param assignee 子任务的执行人
*/
private void createChildrenTask(TaskEntityImpl parentTask, String assignee) {
private void createSignTask(TaskEntityImpl parentTask, String assignee) {
// 1. 生成子任务
TaskEntityImpl task = (TaskEntityImpl) taskService.newTask(IdUtil.fastSimpleUUID());
task = BpmTaskConvert.INSTANCE.convert(task, parentTask);
@ -832,8 +829,6 @@ public class BpmTaskServiceImpl implements BpmTaskService {
public void subSignTask(Long userId, BpmTaskSubSignReqVO reqVO) {
// 1.1 校验 task 可以被减签
Task task = validateSubSign(reqVO.getId());
// TODO @海：adminUserApi.getUser(userId) 是不是应该放到 3. 那；
AdminUserRespDTO user = adminUserApi.getUser(userId);
// 1.2 校验取消人存在
AdminUserRespDTO cancelUser = null;
if (StrUtil.isNotBlank(task.getAssignee())) {
@ -844,20 +839,22 @@ public class BpmTaskServiceImpl implements BpmTaskService {
}
Assert.notNull(cancelUser, "任务中没有所有者和审批人，数据错误");
// TODO @海：1. 和 2. 可以写一行注释；其实就是删除任务，和它的子任务；本质上，1. 和 2. 还有 3. 是一块逻辑，写成 1.1 1.2 1.3 会更易懂
// 1. 获取所有需要删除的任务 ID ，包含当前任务和所有子任务
// 2. 删除任务和对应子任务
// 2.1 获取所有需要删除的任务 ID ，包含当前任务和所有子任务
List<String> allTaskIdList = getAllChildTaskIds(task.getId());
// 2. 删除任务和所有子任务
// 2.2 删除任务和所有子任务
taskService.deleteTasks(allTaskIdList);
// 3. 修改扩展表状态为取消
// 2.3 修改扩展表状态为取消
AdminUserRespDTO user = adminUserApi.getUser(userId);
taskExtMapper.updateBatchByTaskIdList(allTaskIdList, new BpmTaskExtDO().setResult(BpmProcessInstanceResultEnum.CANCEL.getResult())
.setReason(StrUtil.format("由于{}操作[减签]，任务被取消", user.getNickname())));
// 4. 记录日志到父任务中。先记录日志是因为，通过 handleParentTask 方法之后，任务可能被完成了，并且不存在了，会报异常，所以先记录
String comment = StrUtil.format(BpmCommentTypeEnum.SUB_SIGN.getTemplateComment(), user.getNickname(), cancelUser.getNickname());
// 3. 记录日志到父任务中。先记录日志是因为，通过 handleParentTask 方法之后，任务可能被完成了，并且不存在了，会报异常，所以先记录
String comment = StrUtil.format(BpmCommentTypeEnum.SUB_SIGN.getComment(), user.getNickname(), cancelUser.getNickname());
taskService.addComment(task.getParentTaskId(), task.getProcessInstanceId(),
BpmCommentTypeEnum.SUB_SIGN.getType().toString(), comment);
// 5. 处理当前任务的父任务
// 4. 处理当前任务的父任务
handleParentTask(task);
}
@ -869,14 +866,28 @@ public class BpmTaskServiceImpl implements BpmTaskService {
*/
private Task validateSubSign(String id) {
Task task = validateTaskExist(id);
// 必须有 parentId
// TODO @海：是不是通过 scopeType 去判断更合适哈？因为别的情况下，也可能有 parentId
if (StrUtil.isEmpty(task.getParentTaskId())) {
// 必须有 scopeType
String scopeType = task.getScopeType();
if (StrUtil.isEmpty(scopeType)) {
throw exception(TASK_SUB_SIGN_NO_PARENT);
}
// 并且值为 向前和向后加签
if (!validateSignType(scopeType)) {
throw exception(TASK_SUB_SIGN_NO_PARENT);
}
return task;
}
/**
* 判断当前类型是否为加签
* @param scopeType 任务的 scopeType
* @return 当前 scopeType 为加签则返回 true
*/
private boolean validateSignType(String scopeType){
return StrUtil.equalsAny(scopeType,BpmTaskAddSignTypeEnum.BEFORE.getType(),scopeType, BpmTaskAddSignTypeEnum.AFTER.getType());
}
/**
* 获取所有要被取消的删除的任务 ID 集合
*
@ -885,30 +896,31 @@ public class BpmTaskServiceImpl implements BpmTaskService {
*/
public List<String> getAllChildTaskIds(String parentTaskId) {
List<String> allChildTaskIds = new ArrayList<>();
// TODO @海：这里可以把递归改成 for 循环，可以试试看哈；整体思路，是一层一层查询；然后判断某一层查不出来了，就是结束了；
// 最好不用无限递归，一般是 for （int i = 0; i < Short.MAX），避免脏数据导致无限递归；
//1. 先将自己放入
allChildTaskIds.add(parentTaskId);
//2. 递归获取子级
recursiveGetChildTaskIds(parentTaskId, allChildTaskIds);
// 1. 递归获取子级
Stack<String> stack = new Stack<>();
// 1.1 将根任务ID入栈
stack.push(parentTaskId);
//控制遍历的次数不超过 Byte.MAX_VALUE，避免脏数据造成死循环
int count = 0;
while (!stack.isEmpty() && count<Byte.MAX_VALUE) {
// 1.2 弹出栈顶任务ID
String taskId = stack.pop();
// 1.3 将任务ID添加到结果集合中
allChildTaskIds.add(taskId);
// 1.4 获取该任务的子任务列表
List<String> childrenTaskIdList = getChildrenTaskIdList(taskId);
if (CollUtil.isNotEmpty(childrenTaskIdList)) {
for (String childTaskId : childrenTaskIdList) {
// 1.5 将子任务ID入栈，以便后续处理
stack.push(childTaskId);
}
}
count++;
}
return allChildTaskIds;
}
/**
* 递归处理子级任务
*
* @param taskId 当前任务ID
* @param taskIds 结果
*/
private void recursiveGetChildTaskIds(String taskId, List<String> taskIds) {
List<String> childrenTaskIdList = getChildrenTaskIdList(taskId);
for (String childTaskId : childrenTaskIdList) {
taskIds.add(childTaskId); // 将子任务的ID添加到集合中
recursiveGetChildTaskIds(childTaskId, taskIds); // 递归获取子任务的子任务
}
}
// TODO @海：一般情况下，除非对性能特别有要求，才只查询 ID_ 单字段；一般层级不多，数据量不大；其实整查就好啦，无非是带宽稍微浪费电，但是基本看不出啥性能差距；
/**
* 获取指定父级任务的所有子任务 ID 集合
*
@ -916,38 +928,43 @@ public class BpmTaskServiceImpl implements BpmTaskService {
* @return 所有子任务的 ID 集合
*/
private List<String> getChildrenTaskIdList(String parentTaskId) {
String tableName = managementService.getTableName(TaskEntity.class);
String sql = "select ID_ from " + tableName + " where PARENT_TASK_ID_=#{parentTaskId}";
List<Task> childrenTaskList = taskService.createNativeTaskQuery().sql(sql).parameter("parentTaskId", parentTaskId).list();
return convertList(childrenTaskList, Task::getId);
return convertList(getChildrenTaskList0(parentTaskId), Task::getId);
}
/**
* 获取指定父级任务的所有子任务 ID 集合
*
* @param parentTaskId 父任务 ID
* @return 所有子任务的 ID 集合
*/
private List<Task> getChildrenTaskList0(String parentTaskId) {
String tableName = managementService.getTableName(TaskEntity.class);
// taskService.createTaskQuery() 没有 parentId 参数，所以写 sql 查询
String sql = "select ID_,OWNER_,ASSIGNEE_ from " + tableName + " where PARENT_TASK_ID_=#{parentTaskId}";
return taskService.createNativeTaskQuery().sql(sql).parameter("parentTaskId", parentTaskId).list();
}
@Override
public List<BpmTaskSubSignRespVO> getChildrenTaskList(String taskId) {
// 1. 只查询进行中的任务
List<String> childrenTaskIdList = getChildrenTaskIdList(taskId);
if (CollUtil.isEmpty(childrenTaskIdList)) {
public List<BpmTaskSubSignRespVO> getChildrenTaskList(String parentId) {
// 1. 只查询进行中的任务 后加签的任务，可能不存在 assignee，所以还需要查询 owner
List<Task> taskList = getChildrenTaskList0(parentId);
if (CollUtil.isEmpty(taskList)) {
return Collections.emptyList();
}
// TODO @海：bpmTaskExtDOList 可以改成 taskExtList；因为当前已经在 bpm 模块，不用前缀；然后，DO 一般情况下不用带；
List<BpmTaskExtDO> bpmTaskExtDOList = taskExtMapper.selectProcessListByTaskIds(childrenTaskIdList);
List<String> childrenTaskIdList = convertList(taskList, Task::getId);
// 2. 后加签的任务，可能不存在 assignee，所以还需要查询 owner
// TODO @海：1. 和 2. 是不是有点重复哈；1. 先查询到了子节点，然后返回了 ids 集合；然后又去 in 查询了一次。。。。按道理，taskService 查询 taskList 就完事？
List<Task> taskList = taskService.createTaskQuery().taskIds(childrenTaskIdList).list();
Map<String, Task> idTaskMap = convertMap(taskList, TaskInfo::getId);
// 3. 将 owner 和 assignee 统一到一个集合中
// TODO @海：下面 userId 的获取，可以考虑抽个小方法；
List<Long> userIds = taskList.stream()
.flatMap(control ->
Stream.of(control.getAssignee(), control.getOwner())
.filter(Objects::nonNull))
.distinct()
.map(NumberUtils::parseLong)
.collect(Collectors.toList());
// 2. 将 owner 和 assignee 统一到一个集合中
List<Long> userIds = convertListByMultiAttr(taskList,control ->
Stream.of(NumberUtils.parseLong(control.getAssignee()), NumberUtils.parseLong(control.getOwner()))
.filter(Objects::nonNull));
// 3. 组装数据
Map<Long, AdminUserRespDTO> userMap = adminUserApi.getUserMap(userIds);
return BpmTaskConvert.INSTANCE.convertList(bpmTaskExtDOList, userMap, idTaskMap);
List<BpmTaskExtDO> taskExtList = taskExtMapper.selectProcessListByTaskIds(childrenTaskIdList);
Map<String, Task> idTaskMap = convertMap(taskList, TaskInfo::getId);
return BpmTaskConvert.INSTANCE.convertList(taskExtList, userMap, idTaskMap);
}
}