BJ_ZTEITS-Developers / parking-cloud-yudao

Commit 7a9dbfe41d30ba7764f7cd551a7cf49361887082

Authored by YunaiV
2 parents b30754a0 6388950a

Merge remote-tracking branch 'origin/master'

Inline Side-by-side
Showing 15 changed files with 806 additions and 36 deletions
yudao-dependencies/pom.xml
  View file @7a9dbfe
... ... @@ -19,7 +19,7 @@
19 19 <!-- 统一依赖管理 -->
20 20 <spring.boot.version>2.7.16</spring.boot.version>
21 21 <!-- Web 相关 -->
22   - <springdoc.version>1.7.0</springdoc.version>
  22 + <springdoc.version>1.6.15</springdoc.version>
23 23 <knife4j.version>4.3.0</knife4j.version>
24 24 <servlet.versoin>2.5</servlet.versoin>
25 25 <!-- DB 相关 -->
... ...
yudao-framework/yudao-common/src/main/java/cn/iocoder/yudao/framework/common/enums/SymbolConstant.java 0 → 100644
  View file @7a9dbfe
  1 +package cn.iocoder.yudao.framework.common.enums;
  2 +
  3 +// TODO 这种简单的，暂时不用枚举哈，直接代码里写死就好啦；
  4 +/**
  5 + * 符号常量
  6 + */
  7 +public interface SymbolConstant {
  8 +
  9 + String D =",";
  10 +
  11 + /**
  12 + * _
  13 + */
  14 + String XH="_";
  15 + /**
  16 + * -
  17 + */
  18 + String HG="-";
  19 +
  20 + /**
  21 + * /
  22 + */
  23 + String XG="/";
  24 +
  25 + /**
  26 + * 箭头
  27 + */
  28 + String ARROWHEAD="->";
  29 +
  30 + /**
  31 + * 数组的开始元素
  32 + */
  33 + String ARRAY_START="[";
  34 +
  35 + /**
  36 + * 数组的结束元素
  37 + */
  38 + String ARRAY_END="]";
  39 +
  40 + /**
  41 + * null 字符串
  42 + */
  43 + String NULL_STRING="null";
  44 +
  45 + /**
  46 + * 点号
  47 + */
  48 + String DIAN="\\.";
  49 +}
... ...
yudao-module-bpm/yudao-module-bpm-api/src/main/java/cn/iocoder/yudao/module/bpm/enums/ErrorCodeConstants.java
  View file @7a9dbfe
... ... @@ -50,6 +50,10 @@ public interface ErrorCodeConstants {
50 50 ErrorCode TASK_RETURN_FAIL_SOURCE_TARGET_ERROR = new ErrorCode(1_009_005_006, "回退任务失败，目标节点是在并行网关上或非同一路线上，不可跳转");
51 51 ErrorCode TASK_DELEGATE_FAIL_USER_REPEAT = new ErrorCode(1_009_005_007, "任务委派失败，委派人和当前审批人为同一人");
52 52 ErrorCode TASK_DELEGATE_FAIL_USER_NOT_EXISTS = new ErrorCode(1_009_005_008, "任务委派失败，被委派人不存在");
  53 + ErrorCode TASK_ADD_SIGN_USER_NOT_EXIST = new ErrorCode(1_009_005_009, "任务加签：选择的用户不存在");
  54 + ErrorCode TASK_ADD_SIGN_TYPE_ERROR = new ErrorCode(1_009_005_010, "任务加签：当前任务已经{}，不能{}");
  55 + ErrorCode TASK_ADD_SIGN_USER_REPEAT = new ErrorCode(1_009_005_011, "任务加签失败，加签人与现有审批人[{}]重复");
  56 + ErrorCode TASK_SUB_SIGN_NO_PARENT = new ErrorCode(1_009_005_011, "任务减签失败，被减签的任务必须是通过加签生成的任务");
53 57  
54 58 // ========== 流程任务分配规则 1-009-006-000 ==========
55 59 ErrorCode TASK_ASSIGN_RULE_EXISTS = new ErrorCode(1_009_006_000, "流程({}) 的任务({}) 已经存在分配规则");
... ...
yudao-module-bpm/yudao-module-bpm-api/src/main/java/cn/iocoder/yudao/module/bpm/enums/task/BpmCommentTypeEnum.java 0 → 100644
  View file @7a9dbfe
  1 +package cn.iocoder.yudao.module.bpm.enums.task;
  2 +
  3 +import lombok.AllArgsConstructor;
  4 +import lombok.Getter;
  5 +
  6 +/**
  7 + * 流程任务 -- comment类型枚举
  8 + */
  9 +@Getter
  10 +@AllArgsConstructor
  11 +public enum BpmCommentTypeEnum {
  12 +
  13 + APPROVE(1, "通过"),
  14 + REJECT(2, "不通过"),
  15 + CANCEL(3, "已取消"),
  16 +
  17 + // TODO @海：18 行可以去掉哈；这个是之前为了 status 隔离用的；
  18 + // ========== 流程任务独有的状态 ==========
  19 +
  20 + BACK(4, "退回"), // 退回
  21 + DELEGATE(5, "委派"),
  22 + ADD_SIGN(6, "加签"),
  23 + SUB_SIGN(7,"减签"),
  24 + ;
  25 +
  26 + // TODO @海：字段叫 type 更合适噢
  27 + /**
  28 + * 结果
  29 + */
  30 + private final Integer result;
  31 + /**
  32 + * 描述
  33 + */
  34 + private final String desc;
  35 +}
... ...
yudao-module-bpm/yudao-module-bpm-api/src/main/java/cn/iocoder/yudao/module/bpm/enums/task/BpmProcessInstanceResultEnum.java
  View file @7a9dbfe
... ... @@ -4,6 +4,9 @@ import cn.iocoder.yudao.framework.common.util.object.ObjectUtils;
4 4 import lombok.AllArgsConstructor;
5 5 import lombok.Getter;
6 6  
  7 +import java.util.Arrays;
  8 +import java.util.List;
  9 +
7 10 /**
8 11 * 流程实例的结果
9 12 *
... ... @@ -21,11 +24,26 @@ public enum BpmProcessInstanceResultEnum {
21 24 // ========== 流程任务独有的状态 ==========
22 25  
23 26 BACK(5, "驳回"), // 退回
24   - DELEGATE(6, "委派");
  27 + DELEGATE(6, "委派"),
  28 + /**
  29 + * 【加签】源任务已经审批完成，但是它使用了后加签，后加签的任务未完成，源任务就会是这个状态
  30 + * 例如：A审批， A 后加签了 B，并且审批通过了任务，但是 B 还未审批，则当前任务状态为“待后加签任务完成”
  31 + */
  32 + ADD_SIGN_AFTER(7, "待后加签任务完成"), // TODO @海：这个定义，是不是 通过（待后加签任务完成），相当于是 APPROVE 的特殊状态
  33 + /**
  34 + * 【加签】源任务未审批，但是向前加签了，所以源任务状态变为“待前加签任务完成”
  35 + * 例如：A 审批， A 前加签了 B，B 还未审核
  36 + */
  37 + ADD_SIGN_BEFORE(8, "待前加签任务完成"), // TODO @海：这个定义，是不是 处理中（待前加签任务审批），相当于是 PROCESS 的特殊状态
  38 + /**
  39 + * 【加签】后加签任务被创建时的初始状态
  40 + * 因为需要源任务先完成，才能到后加签的人来审批，所以加了一个状态区分
  41 + */
  42 + WAIT_BEFORE_TASK(9, "待前置任务完成"); // TODO @海：这个定义，是不是 处理中（待前置任务审批），相当于是 PROCESS 的特殊状态
25 43  
26 44 /**
27 45 * 结果
28   - *
  46 + * <p>
29 47 * 如果新增时，注意 {@link #isEndResult(Integer)} 是否需要变更
30 48 */
31 49 private final Integer result;
... ... @@ -36,14 +54,22 @@ public enum BpmProcessInstanceResultEnum {
36 54  
37 55 /**
38 56 * 判断该结果是否已经处于 End 最终结果
39   - *
  57 + * <p>
40 58 * 主要用于一些结果更新的逻辑，如果已经是最终结果，就不再进行更新
41 59 *
42 60 * @param result 结果
43 61 * @return 是否
44 62 */
45 63 public static boolean isEndResult(Integer result) {
46   - return ObjectUtils.equalsAny(result, APPROVE.getResult(), REJECT.getResult(), CANCEL.getResult(), BACK.getResult());
  64 + return ObjectUtils.equalsAny(result, APPROVE.getResult(), REJECT.getResult(),
  65 + CANCEL.getResult(), BACK.getResult(),
  66 + ADD_SIGN_AFTER.getResult());
47 67 }
48 68  
  69 + // TODO @海：静态变量，需要放到成员变量前面；另外，如果是复数，可以加 S(ES) 或者 LIST
  70 + /**
  71 + * 能被减签的状态
  72 + */
  73 + public static final List<Integer> CAN_SUB_SIGN_STATUS = Arrays.asList(PROCESS.result, WAIT_BEFORE_TASK.result);
  74 +
49 75 }
... ...
yudao-module-bpm/yudao-module-bpm-api/src/main/java/cn/iocoder/yudao/module/bpm/enums/task/BpmTaskAddSignTypeEnum.java 0 → 100644
  View file @7a9dbfe
  1 +package cn.iocoder.yudao.module.bpm.enums.task;
  2 +
  3 +import lombok.AllArgsConstructor;
  4 +import lombok.Getter;
  5 +
  6 +
  7 +/**
  8 + * 流程任务 -- 加签类型枚举类型
  9 + */
  10 +@Getter
  11 +@AllArgsConstructor
  12 +public enum BpmTaskAddSignTypeEnum {
  13 +
  14 + /**
  15 + * 向前加签，需要前置任务审批完成，才回到原审批人
  16 + */
  17 + BEFORE("before", "向前加签"),
  18 + /**
  19 + * 向后加签，需要后置任务全部审批完，才会通过原审批人节点
  20 + */
  21 + AFTER("after", "向后加签"),
  22 + /**
  23 + * 创建后置加签时的过度状态，用于控制向后加签生成的任务状态
  24 + */
  25 + AFTER_CHILDREN_TASK("afterChildrenTask", "向后加签生成的子任务");
  26 +
  27 + private final String type;
  28 +
  29 + private final String desc;
  30 +
  31 + public static String formatDesc(String type) {
  32 + for (BpmTaskAddSignTypeEnum value : values()) {
  33 + if (value.type.equals(type)) {
  34 + return value.desc;
  35 + }
  36 + }
  37 + return null;
  38 + }
  39 +
  40 +}
  41 +
0 42 \ No newline at end of file
... ...
yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/task/BpmTaskController.java
  View file @7a9dbfe
... ... @@ -100,4 +100,32 @@ public class BpmTaskController {
100 100 return success(true);
101 101 }
102 102  
  103 + // TODO @海：权限统一使用 bpm:task:update；是否可以加减签，可以交给后续的权限配置实现；
  104 + @PutMapping("/add-sign")
  105 + @Operation(summary = "加签", description = "before 前加签，after 后加签")
  106 + @PreAuthorize("@ss.hasPermission('bpm:task:add-sign')")
  107 + public CommonResult<Boolean> addSign(@Valid @RequestBody BpmTaskAddSignReqVO reqVO) {
  108 + // TODO @海：userId 建议作为第一个参数；一般是，谁做了什么操作；另外，addSignTask，保持风格统一哈；
  109 + taskService.addSign(reqVO,getLoginUserId());
  110 + return success(true);
  111 + }
  112 +
  113 + // TODO @海：权限统一使用 bpm:task:update；是否可以加减签，可以交给后续的权限配置实现；
  114 + @PutMapping("/sub-sign")
  115 + @Operation(summary = "减签")
  116 + @PreAuthorize("@ss.hasPermission('bpm:task:sub-sign')")
  117 + // TODO @海： @RequestBody BpmTaskSubSignReqVO 应该是一个空格；然后参数名可以简写成 reqVO；
  118 + public CommonResult<Boolean> subSign(@Valid @RequestBody BpmTaskSubSignReqVO bpmTaskSubSignReqVO) {
  119 + taskService.subSign(bpmTaskSubSignReqVO,getLoginUserId());
  120 + return success(true);
  121 + }
  122 +
  123 + // TODO @海：是不是 url 和方法名，叫 get-child-task-list，更抽象和复用一些？
  124 + @GetMapping("/get-sub-sign")
  125 + @Operation(summary = "获取能被减签的任务")
  126 + @PreAuthorize("@ss.hasPermission('bpm:task:sub-sign')")
  127 + public CommonResult<List<BpmTaskSubSignRespVO>> getChildrenTaskList(@RequestParam("taskId") String taskId) {
  128 + return success(taskService.getChildrenTaskList(taskId));
  129 + }
  130 +
103 131 }
... ...
yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/task/vo/task/BpmTaskAddSignReqVO.java 0 → 100644
  View file @7a9dbfe
  1 +package cn.iocoder.yudao.module.bpm.controller.admin.task.vo.task;
  2 +
  3 +import io.swagger.v3.oas.annotations.media.Schema;
  4 +import lombok.Data;
  5 +
  6 +import javax.validation.constraints.NotEmpty;
  7 +import java.util.List;
  8 +import java.util.Set;
  9 +
  10 +@Schema(description = "管理后台 - 加签流程任务的 Request VO")
  11 +@Data
  12 +public class BpmTaskAddSignReqVO {
  13 +
  14 + @Schema(description = "加签的用户 ID")
  15 + @NotEmpty(message = "加签用户 ID 不能为空")
  16 + private Set<Long> userIdList;
  17 +
  18 + @Schema(description = "加签类型，before 向前加签，after 向后加签")
  19 + @NotEmpty(message = "加签类型不能为空")
  20 + private String type;
  21 +
  22 + @Schema(description = "加签原因")
  23 + @NotEmpty(message = "加签原因不能为空")
  24 + private String reason;
  25 +
  26 + // TODO @海：重要参数，可以放到最前面哈；
  27 + @Schema(description = "需要加签的任务 ID")
  28 + @NotEmpty(message = "任务编号不能为空")
  29 + private String id;
  30 +
  31 +}
0 32 \ No newline at end of file
... ...
yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/task/vo/task/BpmTaskRespVO.java
  View file @7a9dbfe
... ... @@ -5,6 +5,8 @@ import lombok.Data;
5 5 import lombok.EqualsAndHashCode;
6 6 import lombok.ToString;
7 7  
  8 +import java.util.List;
  9 +
8 10 @Schema(description = "管理后台 - 流程任务的 Response VO")
9 11 @Data
10 12 @EqualsAndHashCode(callSuper = true)
... ... @@ -19,6 +21,14 @@ public class BpmTaskRespVO extends BpmTaskDonePageItemRespVO {
19 21 */
20 22 private User assigneeUser;
21 23  
  24 + /**
  25 + * 父任务ID
  26 + */
  27 + private String parentTaskId;
  28 +
  29 + @Schema(description = "子任务（由加签生成）", requiredMode = Schema.RequiredMode.REQUIRED, example = "childrenTask")
  30 + private List<BpmTaskRespVO> children;
  31 +
22 32 @Schema(description = "用户信息")
23 33 @Data
24 34 public static class User {
... ...
yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/task/vo/task/BpmTaskSubSignReqVO.java 0 → 100644
  View file @7a9dbfe
  1 +package cn.iocoder.yudao.module.bpm.controller.admin.task.vo.task;
  2 +
  3 +import io.swagger.v3.oas.annotations.media.Schema;
  4 +import lombok.Data;
  5 +
  6 +import javax.validation.constraints.NotEmpty;
  7 +
  8 +@Schema(description = "管理后台 - 减签流程任务的 Request VO")
  9 +@Data
  10 +public class BpmTaskSubSignReqVO {
  11 +
  12 + @Schema(description = "被减签的任务 ID")
  13 + @NotEmpty(message = "任务编号不能为空")
  14 + private String id;
  15 +
  16 + @Schema(description = "加签原因")
  17 + @NotEmpty(message = "加签原因不能为空")
  18 + private String reason;
  19 +}
... ...
yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/task/vo/task/BpmTaskSubSignRespVO.java 0 → 100644
  View file @7a9dbfe
  1 +package cn.iocoder.yudao.module.bpm.controller.admin.task.vo.task;
  2 +
  3 +import io.swagger.v3.oas.annotations.media.Schema;
  4 +import lombok.Data;
  5 +
  6 +@Schema(description = "管理后台 - 减签流程任务的 Response VO")
  7 +@Data
  8 +public class BpmTaskSubSignRespVO {
  9 + @Schema(description = "审核的用户信息", requiredMode = Schema.RequiredMode.REQUIRED, example = "小李")
  10 + private BpmTaskRespVO.User assigneeUser;
  11 + @Schema(description = "任务 ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "12312")
  12 + private String id;
  13 + @Schema(description = "任务名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "经理审批")
  14 + private String name;
  15 +}
... ...
yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/convert/task/BpmTaskConvert.java
  View file @7a9dbfe
1 1 package cn.iocoder.yudao.module.bpm.convert.task;
2 2  
  3 +import cn.hutool.core.collection.CollUtil;
3 4 import cn.hutool.core.date.LocalDateTimeUtil;
  5 +import cn.hutool.core.util.StrUtil;
4 6 import cn.iocoder.yudao.framework.common.util.collection.CollectionUtils;
5 7 import cn.iocoder.yudao.framework.common.util.date.DateUtils;
6 8 import cn.iocoder.yudao.framework.common.util.number.NumberUtils;
7   -import cn.iocoder.yudao.module.bpm.controller.admin.task.vo.task.BpmTaskDonePageItemRespVO;
8   -import cn.iocoder.yudao.module.bpm.controller.admin.task.vo.task.BpmTaskRespVO;
9   -import cn.iocoder.yudao.module.bpm.controller.admin.task.vo.task.BpmTaskSimpleRespVO;
10   -import cn.iocoder.yudao.module.bpm.controller.admin.task.vo.task.BpmTaskTodoPageItemRespVO;
  9 +import cn.iocoder.yudao.module.bpm.controller.admin.task.vo.task.*;
11 10 import cn.iocoder.yudao.module.bpm.dal.dataobject.task.BpmTaskExtDO;
12 11 import cn.iocoder.yudao.module.bpm.service.message.dto.BpmMessageSendWhenTaskCreatedReqDTO;
13 12 import cn.iocoder.yudao.module.system.api.dept.dto.DeptRespDTO;
... ... @@ -18,9 +17,11 @@ import org.flowable.engine.history.HistoricProcessInstance;
18 17 import org.flowable.engine.runtime.ProcessInstance;
19 18 import org.flowable.task.api.Task;
20 19 import org.flowable.task.api.history.HistoricTaskInstance;
  20 +import org.flowable.task.service.impl.persistence.entity.TaskEntityImpl;
21 21 import org.mapstruct.*;
22 22 import org.mapstruct.factory.Mappers;
23 23  
  24 +import java.util.Date;
24 25 import java.util.List;
25 26 import java.util.Map;
26 27  
... ... @@ -145,4 +146,52 @@ public interface BpmTaskConvert {
145 146 .setName(element.getName())
146 147 .setDefinitionKey(element.getId()));
147 148 }
  149 +
  150 + // TODO @海：可以使用 mapstruct 映射么？
  151 + default TaskEntityImpl convert(TaskEntityImpl task,TaskEntityImpl parentTask){
  152 + task.setCategory(parentTask.getCategory());
  153 + task.setDescription(parentTask.getDescription());
  154 + task.setTenantId(parentTask.getTenantId());
  155 + task.setName(parentTask.getName());
  156 + task.setParentTaskId(parentTask.getId());
  157 + task.setProcessDefinitionId(parentTask.getProcessDefinitionId());
  158 + task.setProcessInstanceId(parentTask.getProcessInstanceId());
  159 + task.setTaskDefinitionKey(parentTask.getTaskDefinitionKey());
  160 + task.setTaskDefinitionId(parentTask.getTaskDefinitionId());
  161 + task.setPriority(parentTask.getPriority());
  162 + task.setCreateTime(new Date());
  163 + return task;
  164 + }
  165 +
  166 + default List<BpmTaskSubSignRespVO> convertList(List<BpmTaskExtDO> bpmTaskExtDOList,
  167 + Map<Long, AdminUserRespDTO> userMap,
  168 + Map<String, Task> idTaskMap){
  169 + return CollectionUtils.convertList(bpmTaskExtDOList, task->{
  170 + BpmTaskSubSignRespVO bpmTaskSubSignRespVO = new BpmTaskSubSignRespVO();
  171 + bpmTaskSubSignRespVO.setName(task.getName());
  172 + bpmTaskSubSignRespVO.setId(task.getTaskId());
  173 + Task sourceTask = idTaskMap.get(task.getTaskId());
  174 + // 后加签任务不会直接设置 assignee ,所以不存在 assignee 的情况，则去取 owner
  175 + String assignee = StrUtil.isNotEmpty(sourceTask.getAssignee()) ? sourceTask.getAssignee() : sourceTask.getOwner();
  176 + AdminUserRespDTO assignUser = userMap.get(NumberUtils.parseLong(assignee));
  177 + if (assignUser != null) {
  178 + bpmTaskSubSignRespVO.setAssigneeUser(convert3(assignUser));
  179 + }
  180 + return bpmTaskSubSignRespVO;
  181 + });
  182 + }
  183 +
  184 + /**
  185 + * 转换任务为父子级
  186 + * @param result
  187 + * @return
  188 + */
  189 + default List<BpmTaskRespVO> convertChildrenList(List<BpmTaskRespVO> result){
  190 + List<BpmTaskRespVO> childrenTaskList = CollectionUtils.filterList(result, r -> StrUtil.isNotEmpty(r.getParentTaskId()));
  191 + Map<String, List<BpmTaskRespVO>> parentChildrenTaskListMap = CollectionUtils.convertMultiMap(childrenTaskList, BpmTaskRespVO::getParentTaskId);
  192 + for (BpmTaskRespVO bpmTaskRespVO : result) {
  193 + bpmTaskRespVO.setChildren(parentChildrenTaskListMap.get(bpmTaskRespVO.getId()));
  194 + }
  195 + return CollectionUtils.filterList(result, r -> StrUtil.isEmpty(r.getParentTaskId()));
  196 + }
148 197 }
... ...
yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/dal/mysql/task/BpmTaskExtMapper.java
  View file @7a9dbfe
1 1 package cn.iocoder.yudao.module.bpm.dal.mysql.task;
2 2  
3 3 import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
  4 +import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
4 5 import cn.iocoder.yudao.module.bpm.dal.dataobject.task.BpmTaskExtDO;
  6 +import cn.iocoder.yudao.module.bpm.enums.task.BpmProcessInstanceResultEnum;
5 7 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
6 8 import org.apache.ibatis.annotations.Mapper;
7 9  
... ... @@ -19,8 +21,19 @@ public interface BpmTaskExtMapper extends BaseMapperX&lt;BpmTaskExtDO&gt; {
19 21 return selectList(BpmTaskExtDO::getTaskId, taskIds);
20 22 }
21 23  
  24 + default List<BpmTaskExtDO> selectProcessListByTaskIds(Collection<String> taskIds) {
  25 + return selectList(new LambdaQueryWrapperX<BpmTaskExtDO>()
  26 + .in(BpmTaskExtDO::getTaskId, taskIds)
  27 + .in(BpmTaskExtDO::getResult, BpmProcessInstanceResultEnum.CAN_SUB_SIGN_STATUS));
  28 + }
  29 +
  30 +
22 31 default BpmTaskExtDO selectByTaskId(String taskId) {
23 32 return selectOne(BpmTaskExtDO::getTaskId, taskId);
24 33 }
25 34  
  35 + default void updateBatchByTaskIdList(List<String> taskIdList, BpmTaskExtDO updateObj) {
  36 + update(updateObj, new LambdaQueryWrapper<BpmTaskExtDO>().in(BpmTaskExtDO::getTaskId, taskIdList));
  37 + }
  38 +
26 39 }
... ...
yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/task/BpmTaskService.java
  View file @7a9dbfe
... ... @@ -3,6 +3,7 @@ package cn.iocoder.yudao.module.bpm.service.task;
3 3 import cn.iocoder.yudao.framework.common.pojo.PageResult;
4 4 import cn.iocoder.yudao.framework.common.util.collection.CollectionUtils;
5 5 import cn.iocoder.yudao.module.bpm.controller.admin.task.vo.task.*;
  6 +import cn.iocoder.yudao.module.bpm.dal.dataobject.task.BpmTaskExtDO;
6 7 import org.flowable.task.api.Task;
7 8  
8 9 import javax.validation.Valid;
... ... @@ -62,6 +63,14 @@ public interface BpmTaskService {
62 63 */
63 64 List<BpmTaskRespVO> getTaskListByProcessInstanceId(String processInstanceId);
64 65  
  66 +
  67 + /**
  68 + * 通过任务 ID 集合，获取任务扩展表信息集合 // TODO @海洋：方法注释，和下面的参数，需要空一行
  69 + * @param taskIdList 任务 ID 集合
  70 + * @return 任务列表
  71 + */
  72 + List<BpmTaskExtDO> getTaskListByTaskIdList(List<String> taskIdList);
  73 +
65 74 /**
66 75 * 通过任务
67 76 *
... ... @@ -147,4 +156,28 @@ public interface BpmTaskService {
147 156 */
148 157 void delegateTask(BpmTaskDelegateReqVO reqVO, Long userId);
149 158  
  159 + /**
  160 + * 任务加签
  161 + *
  162 + * @param reqVO 被加签的用户和任务 ID，加签类型
  163 + * @param userId 当前用户 ID
  164 + */
  165 + void addSign(BpmTaskAddSignReqVO reqVO, Long userId);
  166 +
  167 + /**
  168 + * 任务减签名
  169 + *
  170 + * @param bpmTaskSubSignReqVO 被减签的任务 ID，理由
  171 + * @param loginUserId 当前用户ID
  172 + */
  173 + void subSign(BpmTaskSubSignReqVO bpmTaskSubSignReqVO, Long loginUserId);
  174 +
  175 + /**
  176 + * 获取指定任务的子任务和审批人信息
  177 + *
  178 + * @param taskId 指定任务ID
  179 + * @return 子任务列表
  180 + */
  181 + List<BpmTaskSubSignRespVO> getChildrenTaskList(String taskId);
  182 +
150 183 }
... ...
yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/task/BpmTaskServiceImpl.java
  View file @7a9dbfe
... ... @@ -2,7 +2,9 @@ package cn.iocoder.yudao.module.bpm.service.task;
2 2  
3 3 import cn.hutool.core.collection.CollUtil;
4 4 import cn.hutool.core.util.ArrayUtil;
  5 +import cn.hutool.core.util.IdUtil;
5 6 import cn.hutool.core.util.StrUtil;
  7 +import cn.iocoder.yudao.framework.common.enums.SymbolConstant;
6 8 import cn.iocoder.yudao.framework.common.pojo.PageResult;
7 9 import cn.iocoder.yudao.framework.common.util.date.DateUtils;
8 10 import cn.iocoder.yudao.framework.common.util.number.NumberUtils;
... ... @@ -13,8 +15,7 @@ import cn.iocoder.yudao.module.bpm.controller.admin.task.vo.task.*;
13 15 import cn.iocoder.yudao.module.bpm.convert.task.BpmTaskConvert;
14 16 import cn.iocoder.yudao.module.bpm.dal.dataobject.task.BpmTaskExtDO;
15 17 import cn.iocoder.yudao.module.bpm.dal.mysql.task.BpmTaskExtMapper;
16   -import cn.iocoder.yudao.module.bpm.enums.task.BpmProcessInstanceDeleteReasonEnum;
17   -import cn.iocoder.yudao.module.bpm.enums.task.BpmProcessInstanceResultEnum;
  18 +import cn.iocoder.yudao.module.bpm.enums.task.*;
18 19 import cn.iocoder.yudao.module.bpm.service.definition.BpmModelService;
19 20 import cn.iocoder.yudao.module.bpm.service.message.BpmMessageService;
20 21 import cn.iocoder.yudao.module.system.api.dept.DeptApi;
... ... @@ -26,15 +27,19 @@ import org.flowable.bpmn.model.BpmnModel;
26 27 import org.flowable.bpmn.model.FlowElement;
27 28 import org.flowable.bpmn.model.UserTask;
28 29 import org.flowable.engine.HistoryService;
  30 +import org.flowable.engine.ManagementService;
29 31 import org.flowable.engine.RuntimeService;
30 32 import org.flowable.engine.TaskService;
31 33 import org.flowable.engine.history.HistoricProcessInstance;
32 34 import org.flowable.engine.runtime.ProcessInstance;
33 35 import org.flowable.task.api.DelegationState;
34 36 import org.flowable.task.api.Task;
  37 +import org.flowable.task.api.TaskInfo;
35 38 import org.flowable.task.api.TaskQuery;
36 39 import org.flowable.task.api.history.HistoricTaskInstance;
37 40 import org.flowable.task.api.history.HistoricTaskInstanceQuery;
  41 +import org.flowable.task.service.impl.persistence.entity.TaskEntity;
  42 +import org.flowable.task.service.impl.persistence.entity.TaskEntityImpl;
38 43 import org.springframework.stereotype.Service;
39 44 import org.springframework.transaction.annotation.Transactional;
40 45 import org.springframework.transaction.support.TransactionSynchronization;
... ... @@ -45,6 +50,8 @@ import javax.annotation.Resource;
45 50 import javax.validation.Valid;
46 51 import java.time.LocalDateTime;
47 52 import java.util.*;
  53 +import java.util.stream.Collectors;
  54 +import java.util.stream.Stream;
48 55  
49 56 import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
50 57 import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.*;
... ... @@ -82,6 +89,9 @@ public class BpmTaskServiceImpl implements BpmTaskService {
82 89 @Resource
83 90 private BpmTaskExtMapper taskExtMapper;
84 91  
  92 + @Resource
  93 + private ManagementService managementService;
  94 +
85 95 @Override
86 96 public PageResult<BpmTaskTodoPageItemRespVO> getTodoTaskPage(Long userId, BpmTaskTodoPageReqVO pageVO) {
87 97 // 查询待办任务
... ... @@ -183,7 +193,13 @@ public class BpmTaskServiceImpl implements BpmTaskService {
183 193 Map<Long, DeptRespDTO> deptMap = deptApi.getDeptMap(convertSet(userMap.values(), AdminUserRespDTO::getDeptId));
184 194  
185 195 // 拼接数据
186   - return BpmTaskConvert.INSTANCE.convertList3(tasks, bpmTaskExtDOMap, processInstance, userMap, deptMap);
  196 + List<BpmTaskRespVO> result = BpmTaskConvert.INSTANCE.convertList3(tasks, bpmTaskExtDOMap, processInstance, userMap, deptMap);
  197 + return BpmTaskConvert.INSTANCE.convertChildrenList(result);
  198 + }
  199 +
  200 + @Override
  201 + public List<BpmTaskExtDO> getTaskListByTaskIdList(List<String> taskIdList) {
  202 + return taskExtMapper.selectListByTaskIds(taskIdList);
187 203 }
188 204  
189 205 @Override
... ... @@ -203,13 +219,181 @@ public class BpmTaskServiceImpl implements BpmTaskService {
203 219 return;
204 220 }
205 221  
206   - // 情况二：自己审批的任务，调用 complete 去完成任务
  222 + // 情况二：后加签的任务
  223 + if (BpmTaskAddSignTypeEnum.AFTER.getType().equals(task.getScopeType())) {
  224 + // 后加签处理
  225 + // TODO @海洋：这个是不是 approveAfterSignTask
  226 + handleAfterSignTask(task, reqVO);
  227 + return;
  228 + }
  229 +
  230 + // 情况三：自己审批的任务，调用 complete 去完成任务
207 231 // 完成任务，审批通过
208 232 taskService.complete(task.getId(), instance.getProcessVariables());
209 233 // 更新任务拓展表为通过
210 234 taskExtMapper.updateByTaskId(
211 235 new BpmTaskExtDO().setTaskId(task.getId()).setResult(BpmProcessInstanceResultEnum.APPROVE.getResult())
212 236 .setReason(reqVO.getReason()));
  237 + // 处理加签任务
  238 + handleParentTask(task);
  239 + }
  240 +
  241 + /**
  242 + * 审批通过存在“后加签”的任务。
  243 + *
  244 + * 注意：该任务不能马上完成，需要一个中间状态（ADD_SIGN_AFTER），并激活剩余所有子任务（PROCESS）为可审批处理
  245 + *
  246 + * @param task 当前任务
  247 + * @param reqVO 前端请求参数
  248 + */
  249 + private void handleAfterSignTask(Task task,BpmTaskApproveReqVO reqVO){
  250 + // 1. 有向后加签，则该任务状态临时设置为 ADD_SIGN_AFTER 状态
  251 + taskExtMapper.updateByTaskId(
  252 + new BpmTaskExtDO().setTaskId(task.getId()).setResult(BpmProcessInstanceResultEnum.ADD_SIGN_AFTER.getResult())
  253 + .setReason(reqVO.getReason()).setEndTime(LocalDateTime.now()));
  254 +
  255 + // 2. 激活子任务
  256 + List<String> childrenTaskIdList = getChildrenTaskIdList(task.getId());
  257 + for (String childrenTaskId : childrenTaskIdList) {
  258 + taskService.resolveTask(childrenTaskId);
  259 + }
  260 + // 更新任务扩展表中子任务为进行中
  261 + taskExtMapper.updateBatchByTaskIdList(childrenTaskIdList,
  262 + new BpmTaskExtDO().setResult(BpmProcessInstanceResultEnum.PROCESS.getResult()));
  263 + }
  264 +
  265 + /**
  266 + * 处理当前任务的父任务
  267 + *
  268 + * @param task 当前任务
  269 + */
  270 + private void handleParentTask(Task task) {
  271 + String parentTaskId = task.getParentTaskId();
  272 + // TODO @ 海：if return 原则
  273 + if (StrUtil.isNotBlank(parentTaskId)) {
  274 + // 1. 判断当前任务的父任务是否还有子任务
  275 + long subTaskCount = getSubTaskCount(parentTaskId);
  276 + // TODO @ 海：if >= 0 return；这样括号又可以少一层；
  277 + if (subTaskCount == 0) {
  278 + // 2. 获取父任务
  279 + Task parentTask = validateTaskExist(parentTaskId);
  280 +
  281 + // 3. 情况一：处理向前加签
  282 + String scopeType = parentTask.getScopeType();
  283 + if (BpmTaskAddSignTypeEnum.BEFORE.getType().equals(scopeType)) {
  284 + // 3.1 如果是向前加签的任务，则调用 resolveTask 指派父任务，将 owner 重新赋值给父任务的 assignee
  285 + taskService.resolveTask(parentTaskId);
  286 + // 3.2 更新任务拓展表为处理中
  287 + taskExtMapper.updateByTaskId(
  288 + new BpmTaskExtDO().setTaskId(parentTask.getId()).setResult(BpmProcessInstanceResultEnum.PROCESS.getResult()));
  289 + } else if (BpmTaskAddSignTypeEnum.AFTER.getType().equals(scopeType)) {
  290 + // 3. 情况二：处理向后加签
  291 + handleAfterSign(parentTask);
  292 + }
  293 +
  294 + // 4. 子任务已处理完成，清空 scopeType 字段，修改 parentTask 信息，方便后续可以继续向前后向后加签
  295 + // 再查询一次的原因是避免报错：Task was updated by another transaction concurrently
  296 + // 因为前面处理后可能会导致 parentTask rev 字段被修改，需要重新获取最新的
  297 + parentTask = getTask(parentTaskId);
  298 + // TODO @ 海：if return 原则；
  299 + if (parentTask != null) {
  300 + // 为空的情况是：已经通过 handleAfterSign 方法将任务完成了，所以 ru_task 表会查不到数据
  301 + clearTaskScopeTypeAndSave(parentTask);
  302 + }
  303 + }
  304 + }
  305 + }
  306 +
  307 + // TODO @海：这个方法的 4.1 从 1 开始计数哈；另外；看看能不能用 if return 进一步简化代码的层级；
  308 + /**
  309 + * 处理后加签任务
  310 + *
  311 + * @param parentTask 当前审批任务的父任务
  312 + */
  313 + private void handleAfterSign(Task parentTask) {
  314 + // TODO @海：这个方法在注释下。感觉整体是，先完成自己；然后递归处理父节点；但是完成机子被放到了 5.1，就感觉上有点割裂；
  315 + String parentTaskId = parentTask.getId();
  316 + //4.1 更新 parentTask 的任务拓展表为通过
  317 + BpmTaskExtDO currentTaskExt = taskExtMapper.selectByTaskId(parentTask.getId());
  318 + BpmTaskExtDO currentTaskUpdateEntity = new BpmTaskExtDO().setTaskId(parentTask.getId())
  319 + .setResult(BpmProcessInstanceResultEnum.APPROVE.getResult());
  320 + if (currentTaskExt.getEndTime() == null) {
  321 + // 有这个判断是因为
  322 + // 4.2 以前没设置过结束时间，才去设置
  323 + currentTaskUpdateEntity.setEndTime(LocalDateTime.now());
  324 + }
  325 + taskExtMapper.updateByTaskId(currentTaskUpdateEntity);
  326 +
  327 + // 5. 继续往上处理，父任务继续往上查询
  328 + // 5.1 先完成自己
  329 + taskService.complete(parentTaskId);
  330 + // 5.2 如果有父级，递归查询上级任务是否都已经完成
  331 + // TODO @海：这块待讨论，脑子略乱；感觉 handleAfterSign 的后半段，和 handleParentTask 有点重叠？？？
  332 + if (StrUtil.isNotEmpty(parentTask.getParentTaskId())) {
  333 + // 判断整条链路的任务是否完成
  334 + // 例如从 A 任务加签了一个 B 任务，B 任务又加签了一个 C 任务，C 任务加签了 D 任务
  335 + // 此时，D 任务完成，要一直往上找到祖先任务 A调用 complete 方法完成 A 任务
  336 + boolean allChildrenTaskFinish = true;
  337 + while (StrUtil.isNotBlank(parentTask.getParentTaskId())) {
  338 + parentTask = validateTaskExist(parentTask.getParentTaskId());
  339 + BpmTaskExtDO bpmTaskExtDO = taskExtMapper.selectByTaskId(parentTask.getId());
  340 + if (bpmTaskExtDO == null) {
  341 + break;
  342 + }
  343 + boolean currentTaskFinish = BpmProcessInstanceResultEnum.isEndResult(bpmTaskExtDO.getResult());
  344 + // 5.3 如果 allChildrenTaskFinish 已经被赋值为 false ,则不会再赋值为 true，因为整个链路没有完成
  345 + if (allChildrenTaskFinish) {
  346 + allChildrenTaskFinish = currentTaskFinish;
  347 + }
  348 + if (!currentTaskFinish) {
  349 + // 6 处理非完成状态的任务
  350 + // 6.1 判断当前任务的父任务是否还有子任务
  351 + Long subTaskCount = getSubTaskCount(bpmTaskExtDO.getTaskId());
  352 + if (subTaskCount == 0) {
  353 + // 6.2 没有子任务，判断当前任务状态是否为 ADD_SIGN_BEFORE 待前加签任务完成
  354 + if (BpmProcessInstanceResultEnum.ADD_SIGN_BEFORE.getResult().equals(bpmTaskExtDO.getResult())) {
  355 + // 6.3 需要修改该任务状态为处理中
  356 + taskService.resolveTask(bpmTaskExtDO.getTaskId());
  357 + bpmTaskExtDO.setResult(BpmProcessInstanceResultEnum.PROCESS.getResult());
  358 + taskExtMapper.updateByTaskId(bpmTaskExtDO);
  359 + }
  360 + // 6.4 清空 scopeType 字段，用于任务没有子任务时使用该方法，方便任务可以再次被不同的方式加签
  361 + parentTask = getTask(bpmTaskExtDO.getTaskId());
  362 + if (parentTask != null) {
  363 + clearTaskScopeTypeAndSave(parentTask);
  364 + }
  365 + }
  366 + }
  367 + }
  368 + if (allChildrenTaskFinish) {
  369 + // 7. 完成最后的顶级祖先任务
  370 + taskService.complete(parentTask.getId());
  371 + }
  372 + }
  373 + }
  374 +
  375 + /**
  376 + * 清空 scopeType 字段，用于任务没有子任务时使用该方法，方便任务可以再次被不同的方式加签
  377 + *
  378 + * @param task 需要被清空的任务
  379 + */
  380 + private void clearTaskScopeTypeAndSave(Task task) {
  381 + TaskEntityImpl taskImpl = (TaskEntityImpl) task;
  382 + taskImpl.setScopeType(null);
  383 + taskService.saveTask(task);
  384 + }
  385 +
  386 + // TODO @海：Sub 还有 Child 感觉整体用词不是很统一；是不是要统一下；然后 Sub 还可以指的减签；看看是不是名词确实得一致哈；
  387 + /**
  388 + * 获取子任务个数
  389 + *
  390 + * @param parentTaskId 父任务 ID
  391 + * @return 剩余子任务个数
  392 + */
  393 + private Long getSubTaskCount(String parentTaskId) {
  394 + String tableName = managementService.getTableName(TaskEntity.class);
  395 + String sql = "SELECT COUNT(1) from " + tableName + " WHERE PARENT_TASK_ID_=#{parentTaskId}";
  396 + return taskService.createNativeTaskQuery().sql(sql).parameter("parentTaskId", parentTaskId).count();
213 397 }
214 398  
215 399 /**
... ... @@ -226,7 +410,7 @@ public class BpmTaskServiceImpl implements BpmTaskService {
226 410 String comment = StrUtil.format("[{}]完成委派任务，任务重新回到[{}]手中，审批意见为:{}", currentUser.getNickname(),
227 411 sourceApproveUser.getNickname(), reqVO.getReason());
228 412 taskService.addComment(reqVO.getId(), task.getProcessInstanceId(),
229   - BpmProcessInstanceResultEnum.DELEGATE.getResult().toString(), comment);
  413 + BpmCommentTypeEnum.DELEGATE.getResult().toString(), comment);
230 414  
231 415 // 2.1 调用 resolveTask 完成任务。
232 416 // 底层调用 TaskHelper.changeTaskAssignee(task, task.getOwner())：将 owner 设置为 assignee
... ... @@ -276,10 +460,7 @@ public class BpmTaskServiceImpl implements BpmTaskService {
276 460 * @param taskId task id
277 461 */
278 462 private Task validateTask(Long userId, String taskId) {
279   - Task task = getTask(taskId);
280   - if (task == null) {
281   - throw exception(TASK_NOT_EXISTS);
282   - }
  463 + Task task = validateTaskExist(taskId);
283 464 if (!Objects.equals(userId, NumberUtils.parseLong(task.getAssignee()))) {
284 465 throw exception(TASK_OPERATE_FAIL_ASSIGN_NOT_SELF);
285 466 }
... ... @@ -288,8 +469,12 @@ public class BpmTaskServiceImpl implements BpmTaskService {
288 469  
289 470 @Override
290 471 public void createTaskExt(Task task) {
291   - BpmTaskExtDO taskExtDO =
292   - BpmTaskConvert.INSTANCE.convert2TaskExt(task).setResult(BpmProcessInstanceResultEnum.PROCESS.getResult());
  472 + BpmTaskExtDO taskExtDO = BpmTaskConvert.INSTANCE.convert2TaskExt(task)
  473 + .setResult(BpmProcessInstanceResultEnum.PROCESS.getResult());
  474 + // 向后加签生成的任务，状态不能为进行中，需要等前面父任务完成
  475 + if (BpmTaskAddSignTypeEnum.AFTER_CHILDREN_TASK.getType().equals(task.getScopeType())) {
  476 + taskExtDO.setResult(BpmProcessInstanceResultEnum.WAIT_BEFORE_TASK.getResult());
  477 + }
293 478 taskExtMapper.insert(taskExtDO);
294 479 }
295 480  
... ... @@ -343,23 +528,29 @@ public class BpmTaskServiceImpl implements BpmTaskService {
343 528 TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
344 529 @Override
345 530 public void afterCommit() {
346   - ProcessInstance processInstance =
347   - processInstanceService.getProcessInstance(task.getProcessInstanceId());
348   - AdminUserRespDTO startUser = adminUserApi.getUser(Long.valueOf(processInstance.getStartUserId()));
349   - messageService.sendMessageWhenTaskAssigned(
350   - BpmTaskConvert.INSTANCE.convert(processInstance, startUser, task));
  531 + if(StrUtil.isNotEmpty(task.getAssignee())){
  532 + ProcessInstance processInstance =
  533 + processInstanceService.getProcessInstance(task.getProcessInstanceId());
  534 + AdminUserRespDTO startUser = adminUserApi.getUser(Long.valueOf(processInstance.getStartUserId()));
  535 + messageService.sendMessageWhenTaskAssigned(
  536 + BpmTaskConvert.INSTANCE.convert(processInstance, startUser, task));
  537 + }
351 538 }
352 539 });
353 540 }
354 541  
355   - private Task getTask(String id) {
  542 + private Task validateTaskExist(String id){
356 543 Task task = taskService.createTaskQuery().taskId(id).singleResult();
357   - if (null == task) {
  544 + if (task == null) {
358 545 throw exception(TASK_NOT_EXISTS);
359 546 }
360 547 return task;
361 548 }
362 549  
  550 + private Task getTask(String id) {
  551 + return taskService.createTaskQuery().taskId(id).singleResult();
  552 + }
  553 +
363 554 private HistoricTaskInstance getHistoricTask(String id) {
364 555 return historyService.createHistoricTaskInstanceQuery().taskId(id).singleResult();
365 556 }
... ... @@ -367,10 +558,7 @@ public class BpmTaskServiceImpl implements BpmTaskService {
367 558 @Override
368 559 public List<BpmTaskSimpleRespVO> getReturnTaskList(String taskId) {
369 560 // 1. 校验当前任务 task 存在
370   - Task task = getTask(taskId);
371   - if (task == null) {
372   - throw exception(TASK_NOT_EXISTS);
373   - }
  561 + Task task = validateTaskExist(taskId);
374 562 // 根据流程定义获取流程模型信息
375 563 BpmnModel bpmnModel = bpmModelService.getBpmnModelByDefinitionId(task.getProcessDefinitionId());
376 564 FlowElement source = BpmnModelUtils.getFlowElementById(bpmnModel, task.getTaskDefinitionKey());
... ... @@ -437,7 +625,7 @@ public class BpmTaskServiceImpl implements BpmTaskService {
437 625 /**
438 626 * 执行回退逻辑
439 627 *
440   - * @param currentTask 当前回退的任务
  628 + * @param currentTask 当前回退的任务
441 629 * @param targetElement 需要回退到的目标任务
442 630 * @param reqVO 前端参数封装
443 631 */
... ... @@ -458,7 +646,7 @@ public class BpmTaskServiceImpl implements BpmTaskService {
458 646 return;
459 647 }
460 648 taskService.addComment(task.getId(), currentTask.getProcessInstanceId(),
461   - BpmProcessInstanceResultEnum.BACK.getResult().toString(), reqVO.getReason());
  649 + BpmCommentTypeEnum.BACK.getResult().toString(), reqVO.getReason());
462 650 });
463 651  
464 652 // 3. 执行驳回
... ... @@ -485,9 +673,8 @@ public class BpmTaskServiceImpl implements BpmTaskService {
485 673 String comment = StrUtil.format("[{}]将任务委派给[{}]，委派理由为:{}", currentUser.getNickname(),
486 674 delegateUser.getNickname(), reqVO.getReason());
487 675 String taskId = reqVO.getId();
488   - // TODO 海：后面改；感觉 comment 应该 type 做个枚举；不和 result 耦合在一起；
489 676 taskService.addComment(taskId, task.getProcessInstanceId(),
490   - BpmProcessInstanceResultEnum.DELEGATE.getResult().toString(), comment);
  677 + BpmCommentTypeEnum.DELEGATE.getResult().toString(), comment);
491 678  
492 679 // 3.1 设置任务所有人 (owner) 为原任务的处理人 (assignee)
493 680 taskService.setOwner(taskId, task.getAssignee());
... ... @@ -503,7 +690,7 @@ public class BpmTaskServiceImpl implements BpmTaskService {
503 690 * 校验任务委派参数
504 691 *
505 692 * @param userId 用户编号
506   - * @param reqVO 任务编号，接收人ID
  693 + * @param reqVO 任务编号，接收人ID
507 694 * @return 当前任务信息
508 695 */
509 696 private Task validateTaskCanDelegate(Long userId, BpmTaskDelegateReqVO reqVO) {
... ... @@ -516,4 +703,234 @@ public class BpmTaskServiceImpl implements BpmTaskService {
516 703 return task;
517 704 }
518 705  
  706 + @Override
  707 + @Transactional(rollbackFor = Exception.class)
  708 + public void addSign(BpmTaskAddSignReqVO reqVO, Long userId) {
  709 + // TODO @海：// 后面要有个空格；中英文之间，也要有空格；例如说：// 1. 获取和校验任务
  710 + //1.获取和校验任务
  711 + TaskEntityImpl taskEntity = validateAddSign(userId, reqVO);
  712 + // TODO @海：每个变量，以及相关逻辑，一定要和自己的逻辑块呆在一起。例如说这里的 currentUser 获取，应该在 4. 那块
  713 + AdminUserRespDTO currentUser = adminUserApi.getUser(userId);
  714 + List<AdminUserRespDTO> userList = adminUserApi.getUserList(reqVO.getUserIdList());
  715 + if (CollUtil.isEmpty(userList)) {
  716 + throw exception(TASK_ADD_SIGN_USER_NOT_EXIST);
  717 + }
  718 + // TODO @海：大的逻辑块之间，最好有一个空格。这样的目的，是避免逻辑堆砌在一起，方便流量；
  719 + // 2.处理当前任务
  720 + // 2.1 开启计数功能 // TODO @海：这个目的可以写下；
  721 + taskEntity.setCountEnabled(true);
  722 + // TODO @海：可以直接 if，不搞一个变量哈
  723 + boolean addSignToBefore = reqVO.getType().equals(BpmTaskAddSignTypeEnum.BEFORE.getType());
  724 + if (addSignToBefore) {
  725 + // 2.2 向前加签，设置 owner，置空 assign。等子任务都完成后，再调用 resolveTask 重新将 owner 设置为 assign
  726 + // 原因是：不能和向前加签的子任务一起审批，需要等前面的子任务都完成才能审批
  727 + taskEntity.setOwner(taskEntity.getAssignee());
  728 + taskEntity.setAssignee(null);
  729 + // 2.3 更新扩展表状态
  730 + taskExtMapper.updateByTaskId(
  731 + new BpmTaskExtDO().setTaskId(taskEntity.getId())
  732 + .setResult(BpmProcessInstanceResultEnum.ADD_SIGN_BEFORE.getResult())
  733 + .setReason(reqVO.getReason()));
  734 + }
  735 + // 2.4 记录加签方式，完成任务时需要用到判断
  736 + taskEntity.setScopeType(reqVO.getType());
  737 + // 2.5 保存当前任务修改后的值
  738 + taskService.saveTask(taskEntity);
  739 +
  740 + // 3. 创建加签任务
  741 + createSignSubTasks(convertList(reqVO.getUserIdList(), String::valueOf), taskEntity);
  742 +
  743 + // 4. 记录加签 comment，拼接结果为： [当前用户]向前加签/向后加签给了[多个用户]，理由为：reason
  744 + // TODO @海：BpmCommentTypeEnum 可以加一个 comment 字段，作为评论模版，统一管理；
  745 + String comment = StrUtil.format("[{}]{}给了[{}]，理由为：{}", currentUser.getNickname(), BpmTaskAddSignTypeEnum.formatDesc(reqVO.getType()),
  746 + String.join(SymbolConstant.D, convertList(userList, AdminUserRespDTO::getNickname)), reqVO.getReason());
  747 + taskService.addComment(reqVO.getId(), taskEntity.getProcessInstanceId(),
  748 + BpmCommentTypeEnum.ADD_SIGN.getResult().toString(), comment);
  749 + }
  750 +
  751 +
  752 + /**
  753 + * 校验任务的加签是否一致
  754 + *
  755 + * 1. 如果存在“向前加签”的任务，则不能“向后加签”
  756 + * 2. 如果存在“向后加签”的任务，则不能“向前加签”
  757 + *
  758 + * @param userId 当前用户 ID
  759 + * @param reqVO 请求参数，包含任务 ID 和加签类型
  760 + * @return 当前任务
  761 + */
  762 + private TaskEntityImpl validateAddSign(Long userId, BpmTaskAddSignReqVO reqVO) {
  763 + TaskEntityImpl taskEntity = (TaskEntityImpl) validateTask(userId, reqVO.getId());
  764 + // 向前加签和向后加签不能同时存在
  765 + if (StrUtil.isNotBlank(taskEntity.getScopeType())
  766 + && !BpmTaskAddSignTypeEnum.AFTER_CHILDREN_TASK.getDesc().equals(taskEntity.getScopeType())) {
  767 + // TODO @海：下面这个判断，是不是可以写上面这个判断后面？
  768 + // TODO @海：一个小技巧，如果写不等于的时候，一般可以用 ObjectUtil.notEquals，这样少一层取反，理解起来简单点；
  769 + if (!taskEntity.getScopeType().equals(reqVO.getType())) {
  770 + throw exception(TASK_ADD_SIGN_TYPE_ERROR,
  771 + BpmTaskAddSignTypeEnum.formatDesc(taskEntity.getScopeType()), BpmTaskAddSignTypeEnum.formatDesc(reqVO.getType()));
  772 + }
  773 + }
  774 + // 同一个 key 的任务，审批人不重复
  775 + List<Task> taskList = taskService.createTaskQuery().processInstanceId(taskEntity.getProcessInstanceId())
  776 + .taskDefinitionKey(taskEntity.getTaskDefinitionKey()).list();
  777 + // TODO @海：这里是不是 Task::getAssignee 解析成 List<Long> 下面会更简洁一点？
  778 + List<String> currentAssigneeList = convertList(taskList, Task::getAssignee);
  779 + // TODO @海：frontAssigneeList 改成 addAssigneeList，新增的；避免和 front 前端这样界面耦合的名词哈；
  780 + List<String> frontAssigneeList = convertList(reqVO.getUserIdList(), String::valueOf);
  781 + currentAssigneeList.retainAll(frontAssigneeList);
  782 + if (CollUtil.isNotEmpty(currentAssigneeList)) {
  783 + List<AdminUserRespDTO> userList = adminUserApi.getUserList(convertList(currentAssigneeList, NumberUtils::parseLong));
  784 + throw exception(TASK_ADD_SIGN_USER_REPEAT, String.join(SymbolConstant.D, convertList(userList, AdminUserRespDTO::getNickname)));
  785 + }
  786 + return taskEntity;
  787 + }
  788 +
  789 + /**
  790 + * 创建加签子任务
  791 + *
  792 + * @param addSingUserIdList 被加签的用户 ID
  793 + * @param taskEntity 被加签的任务
  794 + */
  795 + private void createSignSubTasks(List<String> addSingUserIdList, TaskEntityImpl taskEntity) {
  796 + // TODO @海：可以 if return；这样括号层级少一点；下面的 if (StrUtil.isNotBlank(addSignId)) { 也是类似；
  797 + if (CollUtil.isNotEmpty(addSingUserIdList)) {
  798 + // 创建加签人的新任务，全部基于 taskEntity 为父任务来创建
  799 + addSingUserIdList.forEach(addSignId -> {
  800 + if (StrUtil.isNotBlank(addSignId)) {
  801 + createSubTask(taskEntity, addSignId);
  802 + }
  803 + });
  804 + }
  805 + }
  806 +
  807 + // TODO @海：这个是不是命名上，要和 createSignSubTasks 保持一致？
  808 + /**
  809 + * 创建子任务
  810 + *
  811 + * @param parentTask 父任务
  812 + * @param assignee 子任务的执行人
  813 + * @return
  814 + */
  815 + private void createSubTask(TaskEntityImpl parentTask, String assignee) {
  816 + // 1. 生成子任务
  817 + TaskEntityImpl task = (TaskEntityImpl) taskService.newTask(IdUtil.fastSimpleUUID());
  818 + task = BpmTaskConvert.INSTANCE.convert(task,parentTask);
  819 + if (BpmTaskAddSignTypeEnum.BEFORE.getType().equals(parentTask.getScopeType())) {
  820 + // 2.1 前加签，才设置审批人，否则设置 owner
  821 + task.setAssignee(assignee);
  822 + } else {
  823 + // 2.2.1 设置 owner 不设置 assignee 是因为不能同时审批，需要等父任务完成
  824 + task.setOwner(assignee);
  825 + // 2.2.2 设置向后加签任务的 scopeType 为 afterChildrenTask，用于设置任务扩展表的状态
  826 + task.setScopeType(BpmTaskAddSignTypeEnum.AFTER_CHILDREN_TASK.getType());
  827 + }
  828 + // 2. 保存子任务
  829 + taskService.saveTask(task);
  830 + }
  831 +
  832 + @Override
  833 + @Transactional(rollbackFor = Exception.class)
  834 + public void subSign(BpmTaskSubSignReqVO reqVO,Long userId) {
  835 + Task task = validateSubSign(reqVO.getId());
  836 + AdminUserRespDTO user = adminUserApi.getUser(userId);
  837 + AdminUserRespDTO cancelUser = null;
  838 + if(StrUtil.isNotBlank(task.getAssignee())){
  839 + cancelUser = adminUserApi.getUser(NumberUtils.parseLong(task.getAssignee()));
  840 + }
  841 + if(cancelUser == null && StrUtil.isNotBlank(task.getOwner())){
  842 + cancelUser = adminUserApi.getUser(NumberUtils.parseLong(task.getOwner()));
  843 + }
  844 + Assert.notNull(cancelUser,"任务中没有所有者和审批人，数据错误");
  845 + //1. 获取所有需要删除的任务 ID ，包含当前任务和所有子任务
  846 + List<String> allTaskIdList = getAllChildTaskIds(task.getId());
  847 + //2. 删除任务和所有子任务
  848 + taskService.deleteTasks(allTaskIdList);
  849 + //3. 修改扩展表状态为取消
  850 + taskExtMapper.updateBatchByTaskIdList(allTaskIdList,new BpmTaskExtDO().setResult(BpmProcessInstanceResultEnum.CANCEL.getResult())
  851 + .setReason(StrUtil.format("由于{}操作[减签]，任务被取消",user.getNickname())));
  852 + //4.记录日志到父任务中 先记录日志是因为，通过 handleParentTask 方法之后，任务可能被完成了，并且不存在了，会报异常，所以先记录
  853 + String comment = StrUtil.format("{}操作了【减签】,审批人{}的任务被取消",user.getNickname(),cancelUser.getNickname());
  854 + taskService.addComment(task.getParentTaskId(),task.getProcessInstanceId(),
  855 + BpmCommentTypeEnum.SUB_SIGN.getResult().toString(),comment);
  856 + //5. 处理当前任务的父任务
  857 + this.handleParentTask(task);
  858 +
  859 + }
  860 +
  861 + /**
  862 + * 校验任务是否能被减签
  863 + * @param id 任务ID
  864 + * @return 任务信息
  865 + */
  866 + private Task validateSubSign(String id) {
  867 + Task task = validateTaskExist(id);
  868 + //必须有parentId
  869 + if(StrUtil.isEmpty(task.getParentTaskId())){
  870 + throw exception(TASK_SUB_SIGN_NO_PARENT);
  871 + }
  872 + return task;
  873 + }
  874 +
  875 + /**
  876 + * 获取所有要被取消的删除的任务 ID 集合
  877 + * @param parentTaskId 父级任务ID
  878 + * @return 所有任务ID
  879 + */
  880 + public List<String> getAllChildTaskIds(String parentTaskId) {
  881 + List<String> allChildTaskIds = new ArrayList<>();
  882 + //1. 先将自己放入
  883 + allChildTaskIds.add(parentTaskId);
  884 + //2. 递归获取子级
  885 + recursiveGetChildTaskIds(parentTaskId, allChildTaskIds);
  886 + return allChildTaskIds;
  887 + }
  888 +
  889 + /**
  890 + * 递归处理子级任务
  891 + * @param taskId 当前任务ID
  892 + * @param taskIds 结果
  893 + */
  894 + private void recursiveGetChildTaskIds(String taskId, List<String> taskIds) {
  895 + List<String> childrenTaskIdList = getChildrenTaskIdList(taskId);
  896 + for (String childTaskId : childrenTaskIdList) {
  897 + taskIds.add(childTaskId); // 将子任务的ID添加到集合中
  898 + recursiveGetChildTaskIds(childTaskId, taskIds); // 递归获取子任务的子任务
  899 + }
  900 + }
  901 +
  902 + /**
  903 + * 获取指定父级任务的所有子任务 ID 集合
  904 + * @param parentTaskId 父任务 ID
  905 + * @return 所有子任务的 ID 集合
  906 + */
  907 + private List<String> getChildrenTaskIdList(String parentTaskId){
  908 + String tableName = managementService.getTableName(TaskEntity.class);
  909 + String sql = "select ID_ from " + tableName + " where PARENT_TASK_ID_=#{parentTaskId}";
  910 + List<Task> childrenTaskList = taskService.createNativeTaskQuery().sql(sql).parameter("parentTaskId", parentTaskId).list();
  911 + return convertList(childrenTaskList, Task::getId);
  912 + }
  913 +
  914 + @Override
  915 + public List<BpmTaskSubSignRespVO> getChildrenTaskList(String taskId){
  916 + List<String> childrenTaskIdList = getChildrenTaskIdList(taskId);
  917 + if(CollUtil.isEmpty(childrenTaskIdList)){
  918 + return Collections.emptyList();
  919 + }
  920 + //1. 只查询进行中的任务
  921 + List<BpmTaskExtDO> bpmTaskExtDOList = taskExtMapper.selectProcessListByTaskIds(childrenTaskIdList);
  922 + //2. 后加签的任务，可能不存在 assignee,所以还需要查询 owner
  923 + List<Task> taskList = taskService.createTaskQuery().taskIds(childrenTaskIdList).list();
  924 + Map<String, Task> idTaskMap = convertMap(taskList, TaskInfo::getId);
  925 + //3. 将 owner 和 assignee 统一到一个集合中
  926 + List<Long> userIds = taskList.stream()
  927 + .flatMap(control ->
  928 + Stream.of(control.getAssignee(), control.getOwner())
  929 + .filter(Objects::nonNull))
  930 + .distinct()
  931 + .map(NumberUtils::parseLong)
  932 + .collect(Collectors.toList());
  933 + Map<Long, AdminUserRespDTO> userMap = adminUserApi.getUserMap(userIds);
  934 + return BpmTaskConvert.INSTANCE.convertList(bpmTaskExtDOList,userMap,idTaskMap);
  935 + }
519 936 }
... ...