BJ_ZTEITS-Developers / parking-cloud-yudao

Commit 6388950ab2b6db8d25a209789064d270da1e0846

Authored by zhijiantianya@gmail.com
1 parent 45a2cd70

code review：【工作流】—— 加签的实现

Inline Side-by-side
Showing 11 changed files with 133 additions and 82 deletions
yudao-framework/yudao-common/src/main/java/cn/iocoder/yudao/framework/common/enums/SymbolConstant.java
  View file @6388950
1 1 package cn.iocoder.yudao.framework.common.enums;
2 2  
  3 +// TODO 这种简单的，暂时不用枚举哈，直接代码里写死就好啦；
3 4 /**
4 5 * 符号常量
5 6 */
... ...
yudao-module-bpm/yudao-module-bpm-api/src/main/java/cn/iocoder/yudao/module/bpm/enums/ErrorCodeConstants.java
  View file @6388950
... ... @@ -54,6 +54,7 @@ public interface ErrorCodeConstants {
54 54 ErrorCode TASK_ADD_SIGN_TYPE_ERROR = new ErrorCode(1_009_005_010, "任务加签：当前任务已经{}，不能{}");
55 55 ErrorCode TASK_ADD_SIGN_USER_REPEAT = new ErrorCode(1_009_005_011, "任务加签失败，加签人与现有审批人[{}]重复");
56 56 ErrorCode TASK_SUB_SIGN_NO_PARENT = new ErrorCode(1_009_005_011, "任务减签失败，被减签的任务必须是通过加签生成的任务");
  57 +
57 58 // ========== 流程任务分配规则 1-009-006-000 ==========
58 59 ErrorCode TASK_ASSIGN_RULE_EXISTS = new ErrorCode(1_009_006_000, "流程({}) 的任务({}) 已经存在分配规则");
59 60 ErrorCode TASK_ASSIGN_RULE_NOT_EXISTS = new ErrorCode(1_009_006_001, "流程任务分配规则不存在");
... ...
yudao-module-bpm/yudao-module-bpm-api/src/main/java/cn/iocoder/yudao/module/bpm/enums/task/BpmCommentTypeEnum.java
  View file @6388950
... ... @@ -14,6 +14,7 @@ public enum BpmCommentTypeEnum {
14 14 REJECT(2, "不通过"),
15 15 CANCEL(3, "已取消"),
16 16  
  17 + // TODO @海：18 行可以去掉哈；这个是之前为了 status 隔离用的；
17 18 // ========== 流程任务独有的状态 ==========
18 19  
19 20 BACK(4, "退回"), // 退回
... ... @@ -22,6 +23,7 @@ public enum BpmCommentTypeEnum {
22 23 SUB_SIGN(7,"减签"),
23 24 ;
24 25  
  26 + // TODO @海：字段叫 type 更合适噢
25 27 /**
26 28 * 结果
27 29 */
... ...
yudao-module-bpm/yudao-module-bpm-api/src/main/java/cn/iocoder/yudao/module/bpm/enums/task/BpmProcessInstanceResultEnum.java
  View file @6388950
... ... @@ -26,20 +26,20 @@ public enum BpmProcessInstanceResultEnum {
26 26 BACK(5, "驳回"), // 退回
27 27 DELEGATE(6, "委派"),
28 28 /**
29   - * 源任务已经审批完成，但是它使用了后加签，后加签的任务未完成，源任务就会是这个状态
30   - * 例如：A审批， A 后加签了 B ，并且审批通过了任务，但是 B 还未审批，则当前任务状态为 待后加签任务完成
  29 + * 【加签】源任务已经审批完成，但是它使用了后加签，后加签的任务未完成，源任务就会是这个状态
  30 + * 例如：A审批， A 后加签了 B，并且审批通过了任务，但是 B 还未审批，则当前任务状态为“待后加签任务完成”
31 31 */
32   - ADD_SIGN_AFTER(7, "待后加签任务完成"),
  32 + ADD_SIGN_AFTER(7, "待后加签任务完成"), // TODO @海：这个定义，是不是 通过（待后加签任务完成），相当于是 APPROVE 的特殊状态
33 33 /**
34   - * 源任务未审批，但是向前加签了，所以源任务状态变为 待前加签任务完成
35   - * 例如：A审批， A 前加签了 B ，B 还未审核
  34 + * 【加签】源任务未审批，但是向前加签了，所以源任务状态变为“待前加签任务完成”
  35 + * 例如：A 审批， A 前加签了 B，B 还未审核
36 36 */
37   - ADD_SIGN_BEFORE(8, "待前加签任务完成"),
  37 + ADD_SIGN_BEFORE(8, "待前加签任务完成"), // TODO @海：这个定义，是不是 处理中（待前加签任务审批），相当于是 PROCESS 的特殊状态
38 38 /**
39   - * 后加签任务被创建时的初始状态
  39 + * 【加签】后加签任务被创建时的初始状态
40 40 * 因为需要源任务先完成，才能到后加签的人来审批，所以加了一个状态区分
41 41 */
42   - WAIT_BEFORE_TASK(9, "待前置任务完成");
  42 + WAIT_BEFORE_TASK(9, "待前置任务完成"); // TODO @海：这个定义，是不是 处理中（待前置任务审批），相当于是 PROCESS 的特殊状态
43 43  
44 44 /**
45 45 * 结果
... ... @@ -66,6 +66,7 @@ public enum BpmProcessInstanceResultEnum {
66 66 ADD_SIGN_AFTER.getResult());
67 67 }
68 68  
  69 + // TODO @海：静态变量，需要放到成员变量前面；另外，如果是复数，可以加 S(ES) 或者 LIST
69 70 /**
70 71 * 能被减签的状态
71 72 */
... ...
yudao-module-bpm/yudao-module-bpm-api/src/main/java/cn/iocoder/yudao/module/bpm/enums/task/BpmTaskAddSignTypeEnum.java
  View file @6388950
... ... @@ -36,5 +36,6 @@ public enum BpmTaskAddSignTypeEnum {
36 36 }
37 37 return null;
38 38 }
  39 +
39 40 }
40 41  
41 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 @6388950
... ... @@ -100,23 +100,29 @@ public class BpmTaskController {
100 100 return success(true);
101 101 }
102 102  
  103 + // TODO @海：权限统一使用 bpm:task:update；是否可以加减签，可以交给后续的权限配置实现；
103 104 @PutMapping("/add-sign")
104   - @Operation(summary = "加签", description = "before, after为前加签后加签")
  105 + @Operation(summary = "加签", description = "before 前加签，after 后加签")
105 106 @PreAuthorize("@ss.hasPermission('bpm:task:add-sign')")
106 107 public CommonResult<Boolean> addSign(@Valid @RequestBody BpmTaskAddSignReqVO reqVO) {
  108 + // TODO @海：userId 建议作为第一个参数；一般是，谁做了什么操作；另外，addSignTask，保持风格统一哈；
107 109 taskService.addSign(reqVO,getLoginUserId());
108 110 return success(true);
109 111 }
110 112  
  113 + // TODO @海：权限统一使用 bpm:task:update；是否可以加减签，可以交给后续的权限配置实现；
111 114 @PutMapping("/sub-sign")
112   - @Operation(summary = "减签", description = "")
  115 + @Operation(summary = "减签")
113 116 @PreAuthorize("@ss.hasPermission('bpm:task:sub-sign')")
  117 + // TODO @海： @RequestBody BpmTaskSubSignReqVO 应该是一个空格；然后参数名可以简写成 reqVO；
114 118 public CommonResult<Boolean> subSign(@Valid @RequestBody BpmTaskSubSignReqVO bpmTaskSubSignReqVO) {
115 119 taskService.subSign(bpmTaskSubSignReqVO,getLoginUserId());
116 120 return success(true);
117 121 }
  122 +
  123 + // TODO @海：是不是 url 和方法名，叫 get-child-task-list，更抽象和复用一些？
118 124 @GetMapping("/get-sub-sign")
119   - @Operation(summary = "获取能被减签的任务", description = "")
  125 + @Operation(summary = "获取能被减签的任务")
120 126 @PreAuthorize("@ss.hasPermission('bpm:task:sub-sign')")
121 127 public CommonResult<List<BpmTaskSubSignRespVO>> getChildrenTaskList(@RequestParam("taskId") String taskId) {
122 128 return success(taskService.getChildrenTaskList(taskId));
... ...
yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/task/vo/task/BpmTaskAddSignReqVO.java
  View file @6388950
... ... @@ -12,7 +12,7 @@ import java.util.Set;
12 12 public class BpmTaskAddSignReqVO {
13 13  
14 14 @Schema(description = "加签的用户 ID")
15   - @NotEmpty(message = "加签用户ID不能为空")
  15 + @NotEmpty(message = "加签用户 ID 不能为空")
16 16 private Set<Long> userIdList;
17 17  
18 18 @Schema(description = "加签类型，before 向前加签，after 向后加签")
... ... @@ -23,7 +23,9 @@ public class BpmTaskAddSignReqVO {
23 23 @NotEmpty(message = "加签原因不能为空")
24 24 private String reason;
25 25  
  26 + // TODO @海：重要参数，可以放到最前面哈；
26 27 @Schema(description = "需要加签的任务 ID")
27 28 @NotEmpty(message = "任务编号不能为空")
28 29 private String id;
  30 +
29 31 }
30 32 \ No newline at end of file
... ...
yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/convert/task/BpmTaskConvert.java
  View file @6388950
... ... @@ -147,6 +147,7 @@ public interface BpmTaskConvert {
147 147 .setDefinitionKey(element.getId()));
148 148 }
149 149  
  150 + // TODO @海：可以使用 mapstruct 映射么？
150 151 default TaskEntityImpl convert(TaskEntityImpl task,TaskEntityImpl parentTask){
151 152 task.setCategory(parentTask.getCategory());
152 153 task.setDescription(parentTask.getDescription());
... ...
yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/dal/mysql/task/BpmTaskExtMapper.java
  View file @6388950
... ... @@ -32,7 +32,8 @@ public interface BpmTaskExtMapper extends BaseMapperX&lt;BpmTaskExtDO&gt; {
32 32 return selectOne(BpmTaskExtDO::getTaskId, taskId);
33 33 }
34 34  
35   - default void updateBatchByTaskIdList(List<String> taskIdList, BpmTaskExtDO entity){
36   - update(entity,new LambdaQueryWrapper<BpmTaskExtDO>().in(BpmTaskExtDO::getTaskId, taskIdList));
  35 + default void updateBatchByTaskIdList(List<String> taskIdList, BpmTaskExtDO updateObj) {
  36 + update(updateObj, new LambdaQueryWrapper<BpmTaskExtDO>().in(BpmTaskExtDO::getTaskId, taskIdList));
37 37 }
  38 +
38 39 }
... ...
yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/task/BpmTaskService.java
  View file @6388950
... ... @@ -65,8 +65,8 @@ public interface BpmTaskService {
65 65  
66 66  
67 67 /**
68   - * 通过任务 ID 集合，获取任务扩展表信息集合
69   - * @param taskIdList 任务 ID
  68 + * 通过任务 ID 集合，获取任务扩展表信息集合 // TODO @海洋：方法注释，和下面的参数，需要空一行
  69 + * @param taskIdList 任务 ID 集合
70 70 * @return 任务列表
71 71 */
72 72 List<BpmTaskExtDO> getTaskListByTaskIdList(List<String> taskIdList);
... ... @@ -158,22 +158,26 @@ public interface BpmTaskService {
158 158  
159 159 /**
160 160 * 任务加签
161   - * @param reqVO 被加签的用户和任务ID，加签类型
  161 + *
  162 + * @param reqVO 被加签的用户和任务 ID，加签类型
162 163 * @param userId 当前用户 ID
163 164 */
164 165 void addSign(BpmTaskAddSignReqVO reqVO, Long userId);
165 166  
166 167 /**
167   - * 减签
168   - * @param bpmTaskSubSignReqVO 被减签的任务ID，理由
  168 + * 任务减签名
  169 + *
  170 + * @param bpmTaskSubSignReqVO 被减签的任务 ID，理由
169 171 * @param loginUserId 当前用户ID
170 172 */
171 173 void subSign(BpmTaskSubSignReqVO bpmTaskSubSignReqVO, Long loginUserId);
172 174  
173 175 /**
174 176 * 获取指定任务的子任务和审批人信息
  177 + *
175 178 * @param taskId 指定任务ID
176 179 * @return 子任务列表
177 180 */
178 181 List<BpmTaskSubSignRespVO> getChildrenTaskList(String taskId);
  182 +
179 183 }
... ...
yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/task/BpmTaskServiceImpl.java
  View file @6388950
... ... @@ -218,12 +218,15 @@ public class BpmTaskServiceImpl implements BpmTaskService {
218 218 approveDelegateTask(reqVO, task);
219 219 return;
220 220 }
  221 +
221 222 // 情况二：后加签的任务
222   - if(BpmTaskAddSignTypeEnum.AFTER.getType().equals(task.getScopeType())) {
223   - //后加签处理
  223 + if (BpmTaskAddSignTypeEnum.AFTER.getType().equals(task.getScopeType())) {
  224 + // 后加签处理
  225 + // TODO @海洋：这个是不是 approveAfterSignTask
224 226 handleAfterSignTask(task, reqVO);
225 227 return;
226 228 }
  229 +
227 230 // 情况三：自己审批的任务，调用 complete 去完成任务
228 231 // 完成任务，审批通过
229 232 taskService.complete(task.getId(), instance.getProcessVariables());
... ... @@ -231,31 +234,34 @@ public class BpmTaskServiceImpl implements BpmTaskService {
231 234 taskExtMapper.updateByTaskId(
232 235 new BpmTaskExtDO().setTaskId(task.getId()).setResult(BpmProcessInstanceResultEnum.APPROVE.getResult())
233 236 .setReason(reqVO.getReason()));
234   - //处理加签任务
235   - this.handleParentTask(task);
  237 + // 处理加签任务
  238 + handleParentTask(task);
236 239 }
237 240  
238 241 /**
239   - * 当前任务存在后加签任务，则不能马上完成，需要一个中间状态，并激活剩余所有子任务
  242 + * 审批通过存在“后加签”的任务。
  243 + *
  244 + * 注意：该任务不能马上完成，需要一个中间状态（ADD_SIGN_AFTER），并激活剩余所有子任务（PROCESS）为可审批处理
  245 + *
240 246 * @param task 当前任务
241 247 * @param reqVO 前端请求参数
242 248 */
243 249 private void handleAfterSignTask(Task task,BpmTaskApproveReqVO reqVO){
244   - //1.有向后加签，则该任务状态临时设置为 等待后加签任务完成 状态
  250 + // 1. 有向后加签，则该任务状态临时设置为 ADD_SIGN_AFTER 状态
245 251 taskExtMapper.updateByTaskId(
246 252 new BpmTaskExtDO().setTaskId(task.getId()).setResult(BpmProcessInstanceResultEnum.ADD_SIGN_AFTER.getResult())
247 253 .setReason(reqVO.getReason()).setEndTime(LocalDateTime.now()));
248   - //2. 激活子任务
  254 +
  255 + // 2. 激活子任务
249 256 List<String> childrenTaskIdList = getChildrenTaskIdList(task.getId());
250 257 for (String childrenTaskId : childrenTaskIdList) {
251 258 taskService.resolveTask(childrenTaskId);
252 259 }
253   - //更新任务扩展表中子任务为进行中
  260 + // 更新任务扩展表中子任务为进行中
254 261 taskExtMapper.updateBatchByTaskIdList(childrenTaskIdList,
255 262 new BpmTaskExtDO().setResult(BpmProcessInstanceResultEnum.PROCESS.getResult()));
256 263 }
257 264  
258   -
259 265 /**
260 266 * 处理当前任务的父任务
261 267 *
... ... @@ -263,62 +269,70 @@ public class BpmTaskServiceImpl implements BpmTaskService {
263 269 */
264 270 private void handleParentTask(Task task) {
265 271 String parentTaskId = task.getParentTaskId();
  272 + // TODO @ 海：if return 原则
266 273 if (StrUtil.isNotBlank(parentTaskId)) {
267   - //1. 判断当前任务的父任务是否还有子任务
  274 + // 1. 判断当前任务的父任务是否还有子任务
268 275 long subTaskCount = getSubTaskCount(parentTaskId);
  276 + // TODO @ 海：if >= 0 return；这样括号又可以少一层；
269 277 if (subTaskCount == 0) {
270   - //2. 获取父任务
  278 + // 2. 获取父任务
271 279 Task parentTask = validateTaskExist(parentTaskId);
  280 +
  281 + // 3. 情况一：处理向前加签
272 282 String scopeType = parentTask.getScopeType();
273   - //3. 处理向前加签
274 283 if (BpmTaskAddSignTypeEnum.BEFORE.getType().equals(scopeType)) {
275   - //3.1 如果是向前加签的任务，则调用 resolveTask 指派父任务，将 owner 重新赋值给父任务的 assignee
  284 + // 3.1 如果是向前加签的任务，则调用 resolveTask 指派父任务，将 owner 重新赋值给父任务的 assignee
276 285 taskService.resolveTask(parentTaskId);
277   - //3.2 更新任务拓展表为处理中
  286 + // 3.2 更新任务拓展表为处理中
278 287 taskExtMapper.updateByTaskId(
279 288 new BpmTaskExtDO().setTaskId(parentTask.getId()).setResult(BpmProcessInstanceResultEnum.PROCESS.getResult()));
280   - }else if (BpmTaskAddSignTypeEnum.AFTER.getType().equals(scopeType)) {
281   - //4. 处理向后加签
  289 + } else if (BpmTaskAddSignTypeEnum.AFTER.getType().equals(scopeType)) {
  290 + // 3. 情况二：处理向后加签
282 291 handleAfterSign(parentTask);
283 292 }
284   - //5. 子任务已处理完成，清空 scopeType 字段，修改 parentTask 信息，方便后续可以继续向前后向后加签
  293 +
  294 + // 4. 子任务已处理完成，清空 scopeType 字段，修改 parentTask 信息，方便后续可以继续向前后向后加签
285 295 // 再查询一次的原因是避免报错：Task was updated by another transaction concurrently
286 296 // 因为前面处理后可能会导致 parentTask rev 字段被修改，需要重新获取最新的
287 297 parentTask = getTask(parentTaskId);
288   - if(parentTask !=null){
289   - //为空的情况是：已经通过 handleAfterSign 方法将任务完成了，所以 ru_task 表会查不到数据
  298 + // TODO @ 海：if return 原则；
  299 + if (parentTask != null) {
  300 + // 为空的情况是：已经通过 handleAfterSign 方法将任务完成了，所以 ru_task 表会查不到数据
290 301 clearTaskScopeTypeAndSave(parentTask);
291 302 }
292   -
293 303 }
294 304 }
295 305 }
296 306  
  307 + // TODO @海：这个方法的 4.1 从 1 开始计数哈；另外；看看能不能用 if return 进一步简化代码的层级；
297 308 /**
298 309 * 处理后加签任务
299 310 *
300 311 * @param parentTask 当前审批任务的父任务
301 312 */
302 313 private void handleAfterSign(Task parentTask) {
  314 + // TODO @海：这个方法在注释下。感觉整体是，先完成自己；然后递归处理父节点；但是完成机子被放到了 5.1，就感觉上有点割裂；
303 315 String parentTaskId = parentTask.getId();
304 316 //4.1 更新 parentTask 的任务拓展表为通过
305 317 BpmTaskExtDO currentTaskExt = taskExtMapper.selectByTaskId(parentTask.getId());
306 318 BpmTaskExtDO currentTaskUpdateEntity = new BpmTaskExtDO().setTaskId(parentTask.getId())
307 319 .setResult(BpmProcessInstanceResultEnum.APPROVE.getResult());
308 320 if (currentTaskExt.getEndTime() == null) {
309   - //有这个判断是因为
310   - //4.2 以前没设置过结束时间，才去设置
  321 + // 有这个判断是因为
  322 + // 4.2 以前没设置过结束时间，才去设置
311 323 currentTaskUpdateEntity.setEndTime(LocalDateTime.now());
312 324 }
313 325 taskExtMapper.updateByTaskId(currentTaskUpdateEntity);
314   - //5. 继续往上处理，父任务继续往上查询
315   - //5.1 先完成自己
  326 +
  327 + // 5. 继续往上处理，父任务继续往上查询
  328 + // 5.1 先完成自己
316 329 taskService.complete(parentTaskId);
  330 + // 5.2 如果有父级，递归查询上级任务是否都已经完成
  331 + // TODO @海：这块待讨论，脑子略乱；感觉 handleAfterSign 的后半段，和 handleParentTask 有点重叠？？？
317 332 if (StrUtil.isNotEmpty(parentTask.getParentTaskId())) {
318   - //5.2 如果有父级，递归查询上级任务是否都已经完成
319   - //判断整条链路的任务是否完成
320   - //例如从 A 任务加签了一个 B 任务， B 任务又加签了一个 C 任务，C任务加签了 D 任务
321   - //此时，D 任务完成，要一直往上找到祖先任务 A ，调用 complete 方法完成 A 任务
  333 + // 判断整条链路的任务是否完成
  334 + // 例如从 A 任务加签了一个 B 任务，B 任务又加签了一个 C 任务，C 任务加签了 D 任务
  335 + // 此时，D 任务完成，要一直往上找到祖先任务 A调用 complete 方法完成 A 任务
322 336 boolean allChildrenTaskFinish = true;
323 337 while (StrUtil.isNotBlank(parentTask.getParentTaskId())) {
324 338 parentTask = validateTaskExist(parentTask.getParentTaskId());
... ... @@ -327,23 +341,23 @@ public class BpmTaskServiceImpl implements BpmTaskService {
327 341 break;
328 342 }
329 343 boolean currentTaskFinish = BpmProcessInstanceResultEnum.isEndResult(bpmTaskExtDO.getResult());
330   - //5.3 如果 allChildrenTaskFinish 已经被赋值为 false ,则不会再赋值为 true，因为整个链路没有完成
  344 + // 5.3 如果 allChildrenTaskFinish 已经被赋值为 false ,则不会再赋值为 true，因为整个链路没有完成
331 345 if (allChildrenTaskFinish) {
332 346 allChildrenTaskFinish = currentTaskFinish;
333 347 }
334 348 if (!currentTaskFinish) {
335   - //6 处理非完成状态的任务
336   - //6.1 判断当前任务的父任务是否还有子任务
  349 + // 6 处理非完成状态的任务
  350 + // 6.1 判断当前任务的父任务是否还有子任务
337 351 Long subTaskCount = getSubTaskCount(bpmTaskExtDO.getTaskId());
338 352 if (subTaskCount == 0) {
339   - //6.2 没有子任务，判断当前任务状态是否为 ADD_SIGN_BEFORE 待前加签任务完成
  353 + // 6.2 没有子任务，判断当前任务状态是否为 ADD_SIGN_BEFORE 待前加签任务完成
340 354 if (BpmProcessInstanceResultEnum.ADD_SIGN_BEFORE.getResult().equals(bpmTaskExtDO.getResult())) {
341   - //6.3 需要修改该任务状态为处理中
  355 + // 6.3 需要修改该任务状态为处理中
342 356 taskService.resolveTask(bpmTaskExtDO.getTaskId());
343 357 bpmTaskExtDO.setResult(BpmProcessInstanceResultEnum.PROCESS.getResult());
344 358 taskExtMapper.updateByTaskId(bpmTaskExtDO);
345 359 }
346   - //6.4 清空 scopeType 字段，用于任务没有子任务时使用该方法，方便任务可以再次被不同的方式加签
  360 + // 6.4 清空 scopeType 字段，用于任务没有子任务时使用该方法，方便任务可以再次被不同的方式加签
347 361 parentTask = getTask(bpmTaskExtDO.getTaskId());
348 362 if (parentTask != null) {
349 363 clearTaskScopeTypeAndSave(parentTask);
... ... @@ -352,7 +366,7 @@ public class BpmTaskServiceImpl implements BpmTaskService {
352 366 }
353 367 }
354 368 if (allChildrenTaskFinish) {
355   - //7. 完成最后的顶级祖先任务
  369 + // 7. 完成最后的顶级祖先任务
356 370 taskService.complete(parentTask.getId());
357 371 }
358 372 }
... ... @@ -369,15 +383,16 @@ public class BpmTaskServiceImpl implements BpmTaskService {
369 383 taskService.saveTask(task);
370 384 }
371 385  
  386 + // TODO @海：Sub 还有 Child 感觉整体用词不是很统一；是不是要统一下；然后 Sub 还可以指的减签；看看是不是名词确实得一致哈；
372 387 /**
373 388 * 获取子任务个数
374 389 *
375   - * @param parentTaskId 父类ID
  390 + * @param parentTaskId 父任务 ID
376 391 * @return 剩余子任务个数
377 392 */
378 393 private Long getSubTaskCount(String parentTaskId) {
379 394 String tableName = managementService.getTableName(TaskEntity.class);
380   - String sql = "select count(1) from " + tableName + " where PARENT_TASK_ID_=#{parentTaskId}";
  395 + String sql = "SELECT COUNT(1) from " + tableName + " WHERE PARENT_TASK_ID_=#{parentTaskId}";
381 396 return taskService.createNativeTaskQuery().sql(sql).parameter("parentTaskId", parentTaskId).count();
382 397 }
383 398  
... ... @@ -454,10 +469,10 @@ public class BpmTaskServiceImpl implements BpmTaskService {
454 469  
455 470 @Override
456 471 public void createTaskExt(Task task) {
457   - BpmTaskExtDO taskExtDO =
458   - BpmTaskConvert.INSTANCE.convert2TaskExt(task).setResult(BpmProcessInstanceResultEnum.PROCESS.getResult());
459   - //向后加签生成的任务，状态不能为进行中，需要等前面父任务完成
460   - if(BpmTaskAddSignTypeEnum.AFTER_CHILDREN_TASK.getType().equals(task.getScopeType())){
  472 + BpmTaskExtDO taskExtDO = BpmTaskConvert.INSTANCE.convert2TaskExt(task)
  473 + .setResult(BpmProcessInstanceResultEnum.PROCESS.getResult());
  474 + // 向后加签生成的任务，状态不能为进行中，需要等前面父任务完成
  475 + if (BpmTaskAddSignTypeEnum.AFTER_CHILDREN_TASK.getType().equals(task.getScopeType())) {
461 476 taskExtDO.setResult(BpmProcessInstanceResultEnum.WAIT_BEFORE_TASK.getResult());
462 477 }
463 478 taskExtMapper.insert(taskExtDO);
... ... @@ -526,7 +541,7 @@ public class BpmTaskServiceImpl implements BpmTaskService {
526 541  
527 542 private Task validateTaskExist(String id){
528 543 Task task = taskService.createTaskQuery().taskId(id).singleResult();
529   - if(task == null){
  544 + if (task == null) {
530 545 throw exception(TASK_NOT_EXISTS);
531 546 }
532 547 return task;
... ... @@ -691,37 +706,43 @@ public class BpmTaskServiceImpl implements BpmTaskService {
691 706 @Override
692 707 @Transactional(rollbackFor = Exception.class)
693 708 public void addSign(BpmTaskAddSignReqVO reqVO, Long userId) {
  709 + // TODO @海：// 后面要有个空格；中英文之间，也要有空格；例如说：// 1. 获取和校验任务
694 710 //1.获取和校验任务
695 711 TaskEntityImpl taskEntity = validateAddSign(userId, reqVO);
  712 + // TODO @海：每个变量，以及相关逻辑，一定要和自己的逻辑块呆在一起。例如说这里的 currentUser 获取，应该在 4. 那块
696 713 AdminUserRespDTO currentUser = adminUserApi.getUser(userId);
697 714 List<AdminUserRespDTO> userList = adminUserApi.getUserList(reqVO.getUserIdList());
698 715 if (CollUtil.isEmpty(userList)) {
699 716 throw exception(TASK_ADD_SIGN_USER_NOT_EXIST);
700 717 }
701   - //2.处理当前任务
702   - //2.1 开启计数功能
  718 + // TODO @海：大的逻辑块之间，最好有一个空格。这样的目的，是避免逻辑堆砌在一起，方便流量；
  719 + // 2.处理当前任务
  720 + // 2.1 开启计数功能 // TODO @海：这个目的可以写下；
703 721 taskEntity.setCountEnabled(true);
  722 + // TODO @海：可以直接 if，不搞一个变量哈
704 723 boolean addSignToBefore = reqVO.getType().equals(BpmTaskAddSignTypeEnum.BEFORE.getType());
705 724 if (addSignToBefore) {
706   - //2.2 向前加签，设置 owner ，置空 assign ,等子任务都完成后，再调用 resolveTask 重新将 owner 设置为 assign
707   - //原因是：不能和向前加签的子任务一起审批，需要等前面的子任务都完成才能审批
  725 + // 2.2 向前加签，设置 owner，置空 assign。等子任务都完成后，再调用 resolveTask 重新将 owner 设置为 assign
  726 + // 原因是：不能和向前加签的子任务一起审批，需要等前面的子任务都完成才能审批
708 727 taskEntity.setOwner(taskEntity.getAssignee());
709 728 taskEntity.setAssignee(null);
710   - //2.3 更新扩展表状态
  729 + // 2.3 更新扩展表状态
711 730 taskExtMapper.updateByTaskId(
712 731 new BpmTaskExtDO().setTaskId(taskEntity.getId())
713 732 .setResult(BpmProcessInstanceResultEnum.ADD_SIGN_BEFORE.getResult())
714 733 .setReason(reqVO.getReason()));
715 734 }
716   - //2.4 记录加签方式，完成任务时需要用到判断
  735 + // 2.4 记录加签方式，完成任务时需要用到判断
717 736 taskEntity.setScopeType(reqVO.getType());
718   - //2.5 保存当前任务修改后的值
  737 + // 2.5 保存当前任务修改后的值
719 738 taskService.saveTask(taskEntity);
720 739  
721   - //3. 处理加签任务
722   - this.createSignSubTasks(convertList(reqVO.getUserIdList(), String::valueOf), taskEntity);
723   - //4. 记录加签 comment，拼接结果为： [当前用户]向前加签/向后加签给了[多个用户],理由为：reason
724   - String comment = StrUtil.format("[{}]{}给了[{}],理由为：{}", currentUser.getNickname(), BpmTaskAddSignTypeEnum.formatDesc(reqVO.getType()),
  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()),
725 746 String.join(SymbolConstant.D, convertList(userList, AdminUserRespDTO::getNickname)), reqVO.getReason());
726 747 taskService.addComment(reqVO.getId(), taskEntity.getProcessInstanceId(),
727 748 BpmCommentTypeEnum.ADD_SIGN.getResult().toString(), comment);
... ... @@ -729,7 +750,10 @@ public class BpmTaskServiceImpl implements BpmTaskService {
729 750  
730 751  
731 752 /**
732   - * 校验任务存在和 存在 向前加签 的任务，则不能 向后加签，存在 向后加签 则不能 向前加签
  753 + * 校验任务的加签是否一致
  754 + *
  755 + * 1. 如果存在“向前加签”的任务，则不能“向后加签”
  756 + * 2. 如果存在“向后加签”的任务，则不能“向前加签”
733 757 *
734 758 * @param userId 当前用户 ID
735 759 * @param reqVO 请求参数，包含任务 ID 和加签类型
... ... @@ -737,18 +761,22 @@ public class BpmTaskServiceImpl implements BpmTaskService {
737 761 */
738 762 private TaskEntityImpl validateAddSign(Long userId, BpmTaskAddSignReqVO reqVO) {
739 763 TaskEntityImpl taskEntity = (TaskEntityImpl) validateTask(userId, reqVO.getId());
740   - //向前加签和向后加签不能同时存在
  764 + // 向前加签和向后加签不能同时存在
741 765 if (StrUtil.isNotBlank(taskEntity.getScopeType())
742 766 && !BpmTaskAddSignTypeEnum.AFTER_CHILDREN_TASK.getDesc().equals(taskEntity.getScopeType())) {
  767 + // TODO @海：下面这个判断，是不是可以写上面这个判断后面？
  768 + // TODO @海：一个小技巧，如果写不等于的时候，一般可以用 ObjectUtil.notEquals，这样少一层取反，理解起来简单点；
743 769 if (!taskEntity.getScopeType().equals(reqVO.getType())) {
744 770 throw exception(TASK_ADD_SIGN_TYPE_ERROR,
745 771 BpmTaskAddSignTypeEnum.formatDesc(taskEntity.getScopeType()), BpmTaskAddSignTypeEnum.formatDesc(reqVO.getType()));
746 772 }
747 773 }
748   - //同一个 key 的任务，审批人不重复
  774 + // 同一个 key 的任务，审批人不重复
749 775 List<Task> taskList = taskService.createTaskQuery().processInstanceId(taskEntity.getProcessInstanceId())
750 776 .taskDefinitionKey(taskEntity.getTaskDefinitionKey()).list();
  777 + // TODO @海：这里是不是 Task::getAssignee 解析成 List<Long> 下面会更简洁一点？
751 778 List<String> currentAssigneeList = convertList(taskList, Task::getAssignee);
  779 + // TODO @海：frontAssigneeList 改成 addAssigneeList，新增的；避免和 front 前端这样界面耦合的名词哈；
752 780 List<String> frontAssigneeList = convertList(reqVO.getUserIdList(), String::valueOf);
753 781 currentAssigneeList.retainAll(frontAssigneeList);
754 782 if (CollUtil.isNotEmpty(currentAssigneeList)) {
... ... @@ -761,20 +789,22 @@ public class BpmTaskServiceImpl implements BpmTaskService {
761 789 /**
762 790 * 创建加签子任务
763 791 *
764   - * @param addSingUserIdList 被加签的用户ID
  792 + * @param addSingUserIdList 被加签的用户 ID
765 793 * @param taskEntity 被加签的任务
766 794 */
767 795 private void createSignSubTasks(List<String> addSingUserIdList, TaskEntityImpl taskEntity) {
  796 + // TODO @海：可以 if return；这样括号层级少一点；下面的 if (StrUtil.isNotBlank(addSignId)) { 也是类似；
768 797 if (CollUtil.isNotEmpty(addSingUserIdList)) {
769   - // 创建加签人的新任务,全部基于 taskEntity 为父任务来创建
  798 + // 创建加签人的新任务，全部基于 taskEntity 为父任务来创建
770 799 addSingUserIdList.forEach(addSignId -> {
771 800 if (StrUtil.isNotBlank(addSignId)) {
772   - this.createSubTask(taskEntity, addSignId);
  801 + createSubTask(taskEntity, addSignId);
773 802 }
774 803 });
775 804 }
776 805 }
777 806  
  807 + // TODO @海：这个是不是命名上，要和 createSignSubTasks 保持一致？
778 808 /**
779 809 * 创建子任务
780 810 *
... ... @@ -783,18 +813,19 @@ public class BpmTaskServiceImpl implements BpmTaskService {
783 813 * @return
784 814 */
785 815 private void createSubTask(TaskEntityImpl parentTask, String assignee) {
786   - //1.生成子任务
  816 + // 1. 生成子任务
787 817 TaskEntityImpl task = (TaskEntityImpl) taskService.newTask(IdUtil.fastSimpleUUID());
788 818 task = BpmTaskConvert.INSTANCE.convert(task,parentTask);
789 819 if (BpmTaskAddSignTypeEnum.BEFORE.getType().equals(parentTask.getScopeType())) {
790   - // 2. 前加签，才设置审批人，否则设置 owner
  820 + // 2.1 前加签，才设置审批人，否则设置 owner
791 821 task.setAssignee(assignee);
792 822 } else {
793   - //2.2 设置 owner 不设置 assignee 是因为不能同时审批，需要等父任务完成
  823 + // 2.2.1 设置 owner 不设置 assignee 是因为不能同时审批，需要等父任务完成
794 824 task.setOwner(assignee);
795   - //2.3 设置向后加签任务的 scopeType 为 afterChildrenTask，用于设置任务扩展表的状态
  825 + // 2.2.2 设置向后加签任务的 scopeType 为 afterChildrenTask，用于设置任务扩展表的状态
796 826 task.setScopeType(BpmTaskAddSignTypeEnum.AFTER_CHILDREN_TASK.getType());
797 827 }
  828 + // 2. 保存子任务
798 829 taskService.saveTask(task);
799 830 }
800 831  
... ...