fix(bpm): 优化加减签状态流转并补充 Flowable 单测

YunaiV
1 parent e0f0cab7
Showing 4 changed files with 575 additions and 42 deletions
yudao-module-bpm/src/main/java/cn/iocoder/yudao/module/bpm/enums/ErrorCodeConstants.java
yudao-module-bpm/src/main/java/cn/iocoder/yudao/module/bpm/service/task/BpmTaskServiceImpl.java
yudao-module-bpm/src/test/java/cn/iocoder/yudao/module/bpm/framework/flowable/BpmTaskSignFlowableTest.java
yudao-module-bpm/src/test/java/cn/iocoder/yudao/module/bpm/service/task/BpmTaskServiceImplTest.java
@@ -66,6 +66,9 @@ public interface ErrorCodeConstants {
     ErrorCode TASK_WITHDRAW_FAIL_TASK_NOT_EXISTS = new ErrorCode(1_009_005_018, "撤回失败，未查询到用户已办任务！");
     ErrorCode TASK_WITHDRAW_FAIL_NOT_ALLOW = new ErrorCode(1_009_005_019, "撤回失败，此流程不允许撤回操作！");
     ErrorCode TASK_WITHDRAW_FAIL_NEXT_TASK_NOT_ALLOW = new ErrorCode(1_009_005_020, "撤回失败，下一节点不满足撤回条件！");
+    ErrorCode TASK_SIGN_DELETE_FAIL_NOT_SELF = new ErrorCode(1_009_005_021, "任务减签失败，原因：你不是该任务的加签人");
+    ErrorCode TASK_OPERATE_FAIL_APPROVING = new ErrorCode(1_009_005_022, "操作失败，原因：该任务已审批通过，等待加签任务审批完成");
+    ErrorCode TASK_SIGN_CREATE_TYPE_NOT_EXISTS = new ErrorCode(1_009_005_023, "任务加签失败，加签类型({})不存在");
     // ========== 动态表单模块 1-009-010-000 ==========
     ErrorCode FORM_NOT_EXISTS = new ErrorCode(1_009_010_000, "动态表单不存在");
@@ -323,6 +323,18 @@ public class BpmTaskServiceImpl implements BpmTaskService {
                 && ObjectUtil.notEqual(userId, NumberUtils.parseLong(task.getAssignee()))) {
             throw exception(TASK_OPERATE_FAIL_ASSIGN_NOT_SELF);
         }
+        // 为什么 assignee 为空、owner 非空时，不允许操作？
+        // 例如说：【加签】等待中（WAIT）的任务（向前加签的父任务、向后加签的子任务），只有 owner 没有 assignee，
+        // 需要等待其它任务审批后，才能恢复 assignee 继续审批。此时，任何人都不能直接审批、拒绝它
+        if (StrUtil.isBlank(task.getAssignee()) && StrUtil.isNotBlank(task.getOwner())) {
+            throw exception(TASK_OPERATE_FAIL_ASSIGN_NOT_SELF);
+        }
+        // 为什么审批通过中（APPROVING）时，不允许操作？
+        // 例如说：【向后加签】的父任务已经审批通过，需要等待加签出来的子任务审批完成后自动完成。此时，不能重复审批、拒绝、继续加签等
+        Integer status = (Integer) task.getTaskLocalVariables().get(BpmnVariableConstants.TASK_VARIABLE_STATUS);
+        if (BpmTaskStatusEnum.APPROVING.getStatus().equals(status)) {
+            throw exception(TASK_OPERATE_FAIL_APPROVING);
+        }
         return task;
     }
@@ -763,11 +775,7 @@ public class BpmTaskServiceImpl implements BpmTaskService {
         // 2. 激活子任务
         List<Task> childrenTaskList = getTaskListByParentTaskId(task.getId());
-        for (Task childrenTask : childrenTaskList) {
-            taskService.resolveTask(childrenTask.getId());
-            // 更新子 task 状态
-            updateTaskStatus(childrenTask.getId(), BpmTaskStatusEnum.RUNNING.getStatus());
-        }
+        childrenTaskList.forEach(childrenTask -> resolveWaitTask(childrenTask.getId()));
     }
     /**
@@ -789,8 +797,8 @@ public class BpmTaskServiceImpl implements BpmTaskService {
         }
         // 1.2 只处理加签的父任务
         Task parentTask = validateTaskExists(parentTaskId);
-        String scopeType = parentTask.getScopeType();
-        if (BpmTaskSignTypeEnum.of(scopeType) == null) {
+        BpmTaskSignTypeEnum signType = BpmTaskSignTypeEnum.of(parentTask.getScopeType());
+        if (signType == null) {
             return;
         }
@@ -799,14 +807,11 @@ public class BpmTaskServiceImpl implements BpmTaskService {
         parentTaskImpl.setScopeType(null);
         taskService.saveTask(parentTaskImpl);
-        // 3.1 情况一：处理向【向前】加签
-        if (BpmTaskSignTypeEnum.BEFORE.getType().equals(scopeType)) {
-            // 3.1.1 owner 重新赋值给父任务的 assignee，这样它就可以被审批
-            taskService.resolveTask(parentTaskId);
-            // 3.1.2 更新流程任务 status
-            updateTaskStatus(parentTaskId, BpmTaskStatusEnum.RUNNING.getStatus());
+        // 3.1 情况一：处理向【向前】加签，owner 重新赋值给父任务的 assignee，这样它就可以被审批
+        if (signType == BpmTaskSignTypeEnum.BEFORE) {
+            resolveWaitTask(parentTaskId);
             // 3.2 情况二：处理向【向后】加签
-        } else if (BpmTaskSignTypeEnum.AFTER.getType().equals(scopeType)) {
+        } else {
             // 只有 parentTask 处于 APPROVING 的情况下，才可以继续 complete 完成
             // 否则，一个未审批的 parentTask 任务，在加签出来的任务都被减签的情况下，就直接完成审批，这样会存在问题
             Integer status = (Integer) parentTask.getTaskLocalVariables().get(BpmnVariableConstants.TASK_VARIABLE_STATUS);
@@ -928,6 +933,31 @@ public class BpmTaskServiceImpl implements BpmTaskService {
         taskService.setVariableLocal(id, BpmnVariableConstants.TASK_VARIABLE_REASON, reason);
     }
+    /**
+     * 保存【加签】等待中的任务：设置 owner、置空 assignee，并更新状态为 WAIT
+     * <p>
+     * 适用于向前加签的父任务、向后加签的子任务，它们需要等待其它任务审批后，再通过 {@link #resolveWaitTask(String)} 恢复审批
+     *
+     * @param task  任务
+     * @param owner 拥有人，恢复审批时成为 assignee
+     */
+    private void saveWaitTask(TaskEntityImpl task, String owner) {
+        task.setOwner(owner);
+        task.setAssignee(null);
+        taskService.saveTask(task);
+        updateTaskStatus(task.getId(), BpmTaskStatusEnum.WAIT.getStatus());
+    }
+
+    /**
+     * 恢复【加签】等待中的任务：将 owner 重新赋值给 assignee，并更新状态为 RUNNING，这样它就可以被审批
+     *
+     * @param id 任务编号
+     */
+    private void resolveWaitTask(String id) {
+        taskService.resolveTask(id);
+        updateTaskStatus(id, BpmTaskStatusEnum.RUNNING.getStatus());
+    }
+
     @Override
     @Transactional(rollbackFor = Exception.class)
     @DataPermission(enable = false) // 关闭数据权限，避免查询不到用户数据。相关案例：https://gitee.com/zhijiantianya/yudao-cloud/issues/ID1UYA
@@ -1167,26 +1197,22 @@ public class BpmTaskServiceImpl implements BpmTaskService {
         // 1. 获取和校验任务
         TaskEntityImpl taskEntity = validateTaskCanCreateSign(userId, reqVO);
         List<AdminUserRespDTO> userList = adminUserApi.getUserList(reqVO.getUserIds());
-        if (CollUtil.isEmpty(userList)) {
+        if (CollUtil.isEmpty(userList) || userList.size() != reqVO.getUserIds().size()) {
             throw exception(TASK_SIGN_CREATE_USER_NOT_EXIST);
         }
         // 2. 处理当前任务
         // 2.1 开启计数功能，主要用于为了让表 ACT_RU_TASK 中的 SUB_TASK_COUNT_ 字段记录下总共有多少子任务，后续可能有用
         taskEntity.setCountEnabled(true);
-        // 2.2 向前加签，设置 owner，置空 assign。等子任务都完成后，再调用 resolveTask 重新将 owner 设置为 assign
-        // 原因是：不能和向前加签的子任务一起审批，需要等前面的子任务都完成才能审批
-        if (reqVO.getType().equals(BpmTaskSignTypeEnum.BEFORE.getType())) {
-            taskEntity.setOwner(taskEntity.getAssignee());
-            taskEntity.setAssignee(null);
-        }
-        // 2.4 记录加签方式，完成任务时需要用到判断
+        // 2.2 记录加签方式，完成任务时需要用到判断
         taskEntity.setScopeType(reqVO.getType());
-        // 2.5 保存当前任务修改后的值
-        taskService.saveTask(taskEntity);
-        // 2.6 更新 task 状态为 WAIT，只有在向前加签的时候
-        if (reqVO.getType().equals(BpmTaskSignTypeEnum.BEFORE.getType())) {
-            updateTaskStatus(taskEntity.getId(), BpmTaskStatusEnum.WAIT.getStatus());
+        // 2.3 保存当前任务修改后的值
+        // 向前加签，设置 owner，置空 assignee，状态为 WAIT。等子任务都完成后，再调用 resolveWaitTask 重新将 owner 设置为 assignee
+        // 原因是：不能和向前加签的子任务一起审批，需要等前面的子任务都完成才能审批
+        if (BpmTaskSignTypeEnum.BEFORE.getType().equals(reqVO.getType())) {
+            saveWaitTask(taskEntity, taskEntity.getAssignee());
+        } else {
+            taskService.saveTask(taskEntity);
         }
         // 3. 创建加签任务
@@ -1202,6 +1228,7 @@ public class BpmTaskServiceImpl implements BpmTaskService {
     /**
      * 校验任务是否可以加签，主要校验加签类型是否一致：
      * <p>
+     * 0. 加签类型必须存在
      * 1. 如果存在“向前加签”的任务，则不能“向后加签”
      * 2. 如果存在“向后加签”的任务，则不能“向前加签”
      *
@@ -1210,6 +1237,9 @@ public class BpmTaskServiceImpl implements BpmTaskService {
      * @return 当前任务
      */
     private TaskEntityImpl validateTaskCanCreateSign(Long userId, BpmTaskSignCreateReqVO reqVO) {
+        if (BpmTaskSignTypeEnum.of(reqVO.getType()) == null) {
+            throw exception(TASK_SIGN_CREATE_TYPE_NOT_EXISTS, reqVO.getType());
+        }
         TaskEntityImpl taskEntity = (TaskEntityImpl) validateTask(userId, reqVO.getId());
         // 向前加签和向后加签不能同时存在
         if (taskEntity.getScopeType() != null
@@ -1260,20 +1290,14 @@ public class BpmTaskServiceImpl implements BpmTaskService {
         TaskEntityImpl task = (TaskEntityImpl) taskService.newTask(IdUtil.fastSimpleUUID());
         BpmTaskConvert.INSTANCE.copyTo(parentTask, task);
-        // 2.1 向前加签，设置审批人
+        // 2.1 向前加签，设置审批人，子任务可以直接审批
         if (BpmTaskSignTypeEnum.BEFORE.getType().equals(parentTask.getScopeType())) {
             task.setAssignee(assignee);
-            // 2.2 向后加签，设置 owner 不设置 assignee 是因为不能同时审批，需要等父任务完成
-        } else {
-            task.setOwner(assignee);
-        }
-        // 2.3 保存子任务
-        taskService.saveTask(task);
-
-        // 3. 向后前签，设置子任务的状态为 WAIT，因为需要等父任务审批完
-        if (BpmTaskSignTypeEnum.AFTER.getType().equals(parentTask.getScopeType())) {
-            updateTaskStatus(task.getId(), BpmTaskStatusEnum.WAIT.getStatus());
+            taskService.saveTask(task);
+            return;
         }
+        // 2.2 向后加签，设置 owner 不设置 assignee，状态为 WAIT，是因为不能同时审批，需要等父任务审批完
+        saveWaitTask(task, assignee);
     }
     @Override
@@ -1282,7 +1306,7 @@ public class BpmTaskServiceImpl implements BpmTaskService {
     @SuppressWarnings("DataFlowIssue")
     public void deleteSignTask(Long userId, BpmTaskSignDeleteReqVO reqVO) {
         // 1.1 校验 task 可以被减签
-        Task task = validateTaskCanSignDelete(reqVO.getId());
+        Task task = validateTaskCanSignDelete(userId, reqVO.getId());
         // 1.2 校验取消人存在
         AdminUserRespDTO cancelUser = null;
         if (StrUtil.isNotBlank(task.getAssignee())) {
@@ -1376,11 +1400,15 @@ public class BpmTaskServiceImpl implements BpmTaskService {
     /**
      * 校验任务是否能被减签
+     * <p>
+     * 1. 被减签的任务，必须是通过加签生成的任务
+     * 2. 当前用户，必须是父任务（或祖先任务）的审批人、拥有人，即加签人
      *
-     * @param id 任务编号
+     * @param userId 当前用户编号
+     * @param id     任务编号
      * @return 任务信息
      */
-    private Task validateTaskCanSignDelete(String id) {
+    private Task validateTaskCanSignDelete(Long userId, String id) {
         Task task = validateTaskExists(id);
         if (task.getParentTaskId() == null) {
             throw exception(TASK_SIGN_DELETE_NO_PARENT);
@@ -1392,9 +1420,38 @@ public class BpmTaskServiceImpl implements BpmTaskService {
         if (BpmTaskSignTypeEnum.of(parentTask.getScopeType()) == null) {
             throw exception(TASK_SIGN_DELETE_NO_PARENT);
         }
+        if (!isSignCreateUser(userId, parentTask)) {
+            throw exception(TASK_SIGN_DELETE_FAIL_NOT_SELF);
+        }
         return task;
     }
+    /**
+     * 判断指定用户，是否为父任务（或祖先任务）的审批人、拥有人
+     * <p>
+     * 为什么包含祖先任务？多层加签时，最上层的加签人，可以减签它下面所有层级的加签任务
+     *
+     * @param userId     用户编号
+     * @param parentTask 父任务
+     * @return 是否
+     */
+    private boolean isSignCreateUser(Long userId, Task parentTask) {
+        if (userId == null) {
+            return false;
+        }
+        Task task = parentTask;
+        for (int i = 0; i < Short.MAX_VALUE && task != null; i++) {
+            if (isAssignUserTask(userId, task) || isOwnerUserTask(userId, task)) {
+                return true;
+            }
+            if (task.getParentTaskId() == null) {
+                return false;
+            }
+            task = getTask(task.getParentTaskId());
+        }
+        return false;
+    }
+
     // ========== Event 事件相关方法 ==========
     @Override
@@ -1671,7 +1728,10 @@ public class BpmTaskServiceImpl implements BpmTaskService {
             log.error("[processTaskTimeout][processInstanceId({}) 没有找到流程实例]", processInstanceId);
             return;
         }
-        List<Task> taskList = getRunningTaskListByProcessInstanceId(processInstanceId, true, taskDefineKey);
+        // 过滤【向后加签】审批通过中（APPROVING）的父任务：它已经审批通过，等待加签任务审批后自动完成，无需超时处理
+        List<Task> taskList = filterList(getRunningTaskListByProcessInstanceId(processInstanceId, true, taskDefineKey),
+                task -> ObjectUtil.notEqual(task.getTaskLocalVariables().get(BpmnVariableConstants.TASK_VARIABLE_STATUS),
+                        BpmTaskStatusEnum.APPROVING.getStatus()));
         // TODO 优化：未来需要考虑加签的情况
         if (CollUtil.isEmpty(taskList)) {
             log.error("[processTaskTimeout][processInstanceId({}) 定义Key({}) 没有找到任务]", processInstanceId, taskDefineKey);
+package cn.iocoder.yudao.module.bpm.framework.flowable;
+
+import cn.iocoder.yudao.module.bpm.api.task.dto.BpmProcessInstanceCreateReqDTO;
+import cn.iocoder.yudao.module.bpm.controller.admin.task.vo.task.*;
+import cn.iocoder.yudao.module.bpm.enums.task.BpmCommentTypeEnum;
+import cn.iocoder.yudao.module.bpm.enums.task.BpmProcessInstanceStatusEnum;
+import cn.iocoder.yudao.module.bpm.enums.task.BpmTaskSignTypeEnum;
+import cn.iocoder.yudao.module.bpm.enums.task.BpmTaskStatusEnum;
+import cn.iocoder.yudao.module.bpm.framework.flowable.core.enums.BpmnVariableConstants;
+import cn.iocoder.yudao.module.bpm.service.task.BpmProcessInstanceServiceImpl;
+import cn.iocoder.yudao.module.bpm.service.task.BpmTaskServiceImpl;
+import jakarta.annotation.Resource;
+import org.flowable.engine.RepositoryService;
+import org.flowable.engine.TaskService;
+import org.flowable.engine.repository.Deployment;
+import org.flowable.task.api.Task;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+import static cn.iocoder.yudao.framework.test.core.util.AssertUtils.assertServiceException;
+import static cn.iocoder.yudao.module.bpm.enums.ErrorCodeConstants.*;
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * {@link BpmTaskServiceImpl} 加签、减签的 Flowable 集成测试
+ *
+ * <p>覆盖向前/向后加签、多层加签、加签任务审批不通过、部分减签、递归减签，以及等待中（WAIT）任务、减签的权限校验</p>
+ *
+ * @author HUIHUI
+ */
+public class BpmTaskSignFlowableTest extends BaseFlowableUnitTest {
+
+    @Resource
+    private RepositoryService repositoryService;
+    @Resource
+    private TaskService flowableTaskService;
+
+    @Resource
+    private BpmTaskServiceImpl bpmTaskService;
+    @Resource
+    private BpmProcessInstanceServiceImpl processInstanceService;
+
+    private Deployment deployment;
+
+    @BeforeEach
+    public void setUp() {
+        // 部署两级审批流程：task1 -> task2；审批人统一由测试上下文计算为用户 1
+        deployment = repositoryService.createDeployment()
+                .addClasspathResource("bpmn/two-step-approve.bpmn20.xml")
+                .deploy();
+        mockFlowableBackedServices(repositoryService);
+    }
+
+    @AfterEach
+    public void tearDown() {
+        // 清理测试数据：加签子任务没有 execution，需要先删除，否则 Flowable 级联删除流程实例时会空指针
+        List<String> signTaskIds = flowableTaskService.createTaskQuery().deploymentId(deployment.getId()).list()
+                .stream().filter(task -> task.getExecutionId() == null).map(Task::getId).toList();
+        flowableTaskService.deleteTasks(signTaskIds);
+        repositoryService.deleteDeployment(deployment.getId(), true);
+    }
+
+    // ========== 加签 ==========
+
+    @Test
+    public void testCreateSignTask_beforeMultiLevel_thenApprove() {
+        // 准备参数：task1 向前加签给用户 2，用户 2 再向前加签给用户 3
+        String processInstanceId = startProcessInstance();
+        Task task1 = getRunningTask(processInstanceId);
+        Task childTask = createSignTask(1L, task1.getId(), BpmTaskSignTypeEnum.BEFORE, 2L).get(0);
+        Task grandchildTask = createSignTask(2L, childTask.getId(), BpmTaskSignTypeEnum.BEFORE, 3L).get(0);
+        // 断言：task1、子任务都处于等待中，只有孙任务可以审批
+        assertWaitTask(task1.getId(), "1", BpmTaskSignTypeEnum.BEFORE);
+        assertWaitTask(childTask.getId(), "2", BpmTaskSignTypeEnum.BEFORE);
+        assertRunningTask(grandchildTask.getId(), "3");
+
+        // 调用：用户 3 审批孙任务
+        approveTask(3L, grandchildTask.getId());
+        // 断言：子任务恢复给用户 2 审批，task1 继续等待
+        assertRunningTask(childTask.getId(), "2");
+        assertNull(bpmTaskService.getTask(childTask.getId()).getScopeType());
+        assertWaitTask(task1.getId(), "1", BpmTaskSignTypeEnum.BEFORE);
+
+        // 调用：用户 2 审批子任务
+        approveTask(2L, childTask.getId());
+        // 断言：task1 恢复给用户 1 审批
+        assertRunningTask(task1.getId(), "1");
+        assertNull(bpmTaskService.getTask(task1.getId()).getScopeType());
+
+        // 调用：用户 1 审批 task1
+        approveTask(1L, task1.getId());
+        // 断言：流程流转到 task2
+        assertEquals("task2", getRunningTask(processInstanceId).getTaskDefinitionKey());
+    }
+
+    @Test
+    public void testCreateSignTask_afterMultiLevel_thenApprove() {
+        // 准备参数：task1 向后加签给用户 2，用户 1 审批后，用户 2 再向后加签给用户 3
+        String processInstanceId = startProcessInstance();
+        Task task1 = getRunningTask(processInstanceId);
+        Task childTask = createSignTask(1L, task1.getId(), BpmTaskSignTypeEnum.AFTER, 2L).get(0);
+        assertWaitTask(childTask.getId(), "2", null);
+        approveTask(1L, task1.getId());
+        assertEquals(BpmTaskStatusEnum.APPROVING.getStatus(), getTaskStatus(task1.getId()));
+        assertRunningTask(childTask.getId(), "2");
+        Task grandchildTask = createSignTask(2L, childTask.getId(), BpmTaskSignTypeEnum.AFTER, 3L).get(0);
+        assertWaitTask(grandchildTask.getId(), "3", null);
+
+        // 调用：用户 2 审批子任务
+        approveTask(2L, childTask.getId());
+        // 断言：子任务处于审批通过中，孙任务恢复给用户 3 审批
+        assertEquals(BpmTaskStatusEnum.APPROVING.getStatus(), getTaskStatus(childTask.getId()));
+        assertRunningTask(grandchildTask.getId(), "3");
+
+        // 调用：用户 3 审批孙任务
+        approveTask(3L, grandchildTask.getId());
+        // 断言：子任务、task1 依次递归完成，流程流转到 task2
+        assertEquals(BpmTaskStatusEnum.APPROVE.getStatus(), getTaskStatus(childTask.getId()));
+        assertNull(bpmTaskService.getTask(childTask.getId()));
+        assertEquals(BpmTaskStatusEnum.APPROVE.getStatus(), getTaskStatus(task1.getId()));
+        assertEquals("task2", getRunningTask(processInstanceId).getTaskDefinitionKey());
+    }
+
+    // ========== 等待中（WAIT）任务的权限 ==========
+
+    @Test
+    public void testApproveTask_beforeSignParentWait() {
+        // 准备参数：task1 向前加签给用户 2，task1 只有 owner 没有 assignee
+        String processInstanceId = startProcessInstance();
+        Task task1 = getRunningTask(processInstanceId);
+        Task childTask = createSignTask(1L, task1.getId(), BpmTaskSignTypeEnum.BEFORE, 2L).get(0);
+
+        // 调用，并断言异常：任何人（包括 owner、无 userId 的系统调用）都不能直接操作等待中的 task1
+        assertServiceException(() -> approveTask(1L, task1.getId()), TASK_OPERATE_FAIL_ASSIGN_NOT_SELF);
+        assertServiceException(() -> approveTask(3L, task1.getId()), TASK_OPERATE_FAIL_ASSIGN_NOT_SELF);
+        assertServiceException(() -> approveTask(null, task1.getId()), TASK_OPERATE_FAIL_ASSIGN_NOT_SELF);
+        assertServiceException(() -> bpmTaskService.rejectTask(3L, new BpmTaskRejectReqVO()
+                .setId(task1.getId()).setReason("不同意")), TASK_OPERATE_FAIL_ASSIGN_NOT_SELF);
+        assertServiceException(() -> bpmTaskService.transferTask(3L, new BpmTaskTransferReqVO()
+                .setId(task1.getId()).setAssigneeUserId(3L).setReason("转办")), TASK_OPERATE_FAIL_ASSIGN_NOT_SELF);
+        assertServiceException(() -> createSignTask(1L, task1.getId(), BpmTaskSignTypeEnum.BEFORE, 3L),
+                TASK_OPERATE_FAIL_ASSIGN_NOT_SELF);
+        // 断言：task1 仍等待子任务审批，流程未结束
+        assertWaitTask(task1.getId(), "1", BpmTaskSignTypeEnum.BEFORE);
+        assertNotNull(processInstanceService.getProcessInstance(processInstanceId));
+
+        // 调用 + 断言：用户 2 审批子任务后，用户 1 可以正常审批 task1
+        approveTask(2L, childTask.getId());
+        approveTask(1L, task1.getId());
+        assertEquals("task2", getRunningTask(processInstanceId).getTaskDefinitionKey());
+    }
+
+    @Test
+    public void testApproveTask_afterSignChildWait() {
+        // 准备参数：task1 向后加签给用户 2，子任务只有 owner 没有 assignee
+        String processInstanceId = startProcessInstance();
+        Task task1 = getRunningTask(processInstanceId);
+        Task childTask = createSignTask(1L, task1.getId(), BpmTaskSignTypeEnum.AFTER, 2L).get(0);
+
+        // 调用，并断言异常：task1 审批前，任何人（包括 owner）都不能直接操作等待中的子任务
+        assertServiceException(() -> approveTask(2L, childTask.getId()), TASK_OPERATE_FAIL_ASSIGN_NOT_SELF);
+        assertServiceException(() -> approveTask(3L, childTask.getId()), TASK_OPERATE_FAIL_ASSIGN_NOT_SELF);
+        assertServiceException(() -> approveTask(null, childTask.getId()), TASK_OPERATE_FAIL_ASSIGN_NOT_SELF);
+        assertServiceException(() -> bpmTaskService.rejectTask(3L, new BpmTaskRejectReqVO()
+                .setId(childTask.getId()).setReason("不同意")), TASK_OPERATE_FAIL_ASSIGN_NOT_SELF);
+        // 断言：子任务仍等待，task1 未审批，流程未结束
+        assertWaitTask(childTask.getId(), "2", null);
+        assertEquals(BpmTaskStatusEnum.RUNNING.getStatus(), getTaskStatus(task1.getId()));
+        assertNotNull(processInstanceService.getProcessInstance(processInstanceId));
+
+        // 调用 + 断言：用户 1 审批 task1 后，用户 2 可以正常审批子任务
+        approveTask(1L, task1.getId());
+        approveTask(2L, childTask.getId());
+        assertEquals(BpmTaskStatusEnum.APPROVE.getStatus(), getTaskStatus(task1.getId()));
+        assertEquals("task2", getRunningTask(processInstanceId).getTaskDefinitionKey());
+    }
+
+    @Test
+    public void testApproveTask_emptyAssigneeAndOwner_withoutUserId() {
+        // 准备参数：task1 计算不到审批人，没有 assignee、owner
+        when(taskCandidateInvoker.calculateUsersByTask(any())).thenReturn(Set.of());
+        String processInstanceId = startProcessInstance();
+        Task task1 = getRunningTask(processInstanceId);
+        assertNull(task1.getAssignee());
+        assertNull(task1.getOwner());
+
+        // 调用：保持自动审批的历史行为，userId 为 null 时允许审批
+        when(taskCandidateInvoker.calculateUsersByTask(any())).thenReturn(Set.of(1L));
+        approveTask(null, task1.getId());
+        // 断言：流程流转到 task2
+        assertEquals(BpmTaskStatusEnum.APPROVE.getStatus(), getTaskStatus(task1.getId()));
+        assertEquals("task2", getRunningTask(processInstanceId).getTaskDefinitionKey());
+    }
+
+    // ========== 审批不通过 ==========
+
+    @Test
+    public void testRejectTask_afterSignChild() {
+        // 准备参数：task1 向后加签给用户 2，并且用户 1 已审批 task1
+        String processInstanceId = startProcessInstance();
+        Task task1 = getRunningTask(processInstanceId);
+        Task childTask = createSignTask(1L, task1.getId(), BpmTaskSignTypeEnum.AFTER, 2L).get(0);
+        approveTask(1L, task1.getId());
+        // 断言：审批通过中的 task1，不能再被审批不通过
+        assertServiceException(() -> bpmTaskService.rejectTask(1L, new BpmTaskRejectReqVO()
+                .setId(task1.getId()).setReason("不同意")), TASK_OPERATE_FAIL_APPROVING);
+
+        // 调用：用户 2 审批不通过加签任务
+        bpmTaskService.rejectTask(2L, new BpmTaskRejectReqVO().setId(childTask.getId()).setReason("不同意"));
+        // 断言：加签任务、task1 都标记为不通过，流程实例不通过并结束，没有残留的任务
+        assertEquals(BpmTaskStatusEnum.REJECT.getStatus(), getTaskStatus(childTask.getId()));
+        assertEquals(BpmTaskStatusEnum.REJECT.getStatus(), getTaskStatus(task1.getId()));
+        verify(commentService).createComment(eq(task1.getId()), eq(processInstanceId),
+                eq(BpmCommentTypeEnum.REJECT), eq("加签任务不通过"));
+        assertProcessInstanceRejected(processInstanceId);
+    }
+
+    @Test
+    public void testRejectTask_afterMultiLevelMiddle_afterDeleteSign() {
+        // 准备参数：task1 向后加签给用户 2、用户 4，用户 1 审批后，用户 2 再向后加签给用户 3
+        String processInstanceId = startProcessInstance();
+        Task task1 = getRunningTask(processInstanceId);
+        Map<String, Task> childTasks = createSignTask(1L, task1.getId(), BpmTaskSignTypeEnum.AFTER, 2L, 4L).stream()
+                .collect(Collectors.toMap(Task::getOwner, Function.identity()));
+        approveTask(1L, task1.getId());
+        Task childTask = childTasks.get("2");
+        Task grandchildTask = createSignTask(2L, childTask.getId(), BpmTaskSignTypeEnum.AFTER, 3L).get(0);
+
+        // 调用：用户 1 减签用户 4
+        bpmTaskService.deleteSignTask(1L, new BpmTaskSignDeleteReqVO().setId(childTasks.get("4").getId())
+                .setReason("减签"));
+        // 断言：用户 4 的任务被取消，task1 仍处于审批通过中，等待用户 2 审批
+        assertEquals(BpmTaskStatusEnum.CANCEL.getStatus(), getTaskStatus(childTasks.get("4").getId()));
+        assertEquals(BpmTaskStatusEnum.APPROVING.getStatus(), getTaskStatus(task1.getId()));
+        assertRunningTask(childTask.getId(), "2");
+        assertWaitTask(grandchildTask.getId(), "3", null);
+
+        // 调用：用户 2（中间节点）审批不通过
+        bpmTaskService.rejectTask(2L, new BpmTaskRejectReqVO().setId(childTask.getId()).setReason("不同意"));
+        // 断言：中间节点、task1 标记为不通过，等待中的孙任务被取消，流程实例不通过并结束，没有残留的任务
+        assertEquals(BpmTaskStatusEnum.REJECT.getStatus(), getTaskStatus(childTask.getId()));
+        assertEquals(BpmTaskStatusEnum.REJECT.getStatus(), getTaskStatus(task1.getId()));
+        assertEquals(BpmTaskStatusEnum.CANCEL.getStatus(), getTaskStatus(grandchildTask.getId()));
+        assertProcessInstanceRejected(processInstanceId);
+    }
+
+    // ========== 减签 ==========
+
+    @Test
+    public void testDeleteSignTask_afterPartial_thenApprove() {
+        // 准备参数：task1 向后加签给用户 2、用户 3，并且用户 1 已审批 task1
+        String processInstanceId = startProcessInstance();
+        Task task1 = getRunningTask(processInstanceId);
+        Map<String, Task> childTasks = createSignTask(1L, task1.getId(), BpmTaskSignTypeEnum.AFTER, 2L, 3L).stream()
+                .collect(Collectors.toMap(Task::getOwner, Function.identity()));
+        approveTask(1L, task1.getId());
+
+        // 调用：用户 1 减签用户 2
+        bpmTaskService.deleteSignTask(1L, new BpmTaskSignDeleteReqVO().setId(childTasks.get("2").getId())
+                .setReason("减签"));
+        // 断言：用户 2 的任务被取消，task1 仍处于审批通过中，等待用户 3 审批
+        assertNull(bpmTaskService.getTask(childTasks.get("2").getId()));
+        assertEquals(BpmTaskStatusEnum.CANCEL.getStatus(), getTaskStatus(childTasks.get("2").getId()));
+        assertEquals(BpmTaskStatusEnum.APPROVING.getStatus(), getTaskStatus(task1.getId()));
+        assertEquals(BpmTaskSignTypeEnum.AFTER.getType(), bpmTaskService.getTask(task1.getId()).getScopeType());
+        assertRunningTask(childTasks.get("3").getId(), "3");
+        verify(commentService).createComment(eq(task1.getId()), eq(processInstanceId),
+                eq(BpmCommentTypeEnum.SUB_SIGN), eq("用户1"), eq("用户2"));
+
+        // 调用：用户 3 审批
+        approveTask(3L, childTasks.get("3").getId());
+        // 断言：task1 审批通过，流程流转到 task2
+        assertEquals(BpmTaskStatusEnum.APPROVE.getStatus(), getTaskStatus(task1.getId()));
+        assertEquals("task2", getRunningTask(processInstanceId).getTaskDefinitionKey());
+    }
+
+    @Test
+    public void testDeleteSignTask_afterLast_completeApprovingParent() {
+        // 准备参数：task1 向后加签给用户 2，并且用户 1 已审批 task1
+        String processInstanceId = startProcessInstance();
+        Task task1 = getRunningTask(processInstanceId);
+        Task childTask = createSignTask(1L, task1.getId(), BpmTaskSignTypeEnum.AFTER, 2L).get(0);
+        approveTask(1L, task1.getId());
+
+        // 调用：减签最后一个加签任务
+        bpmTaskService.deleteSignTask(1L, new BpmTaskSignDeleteReqVO().setId(childTask.getId()).setReason("减签"));
+        // 断言：审批通过中的 task1 直接完成，流程流转到 task2
+        assertEquals(BpmTaskStatusEnum.CANCEL.getStatus(), getTaskStatus(childTask.getId()));
+        assertEquals(BpmTaskStatusEnum.APPROVE.getStatus(), getTaskStatus(task1.getId()));
+        assertEquals("task2", getRunningTask(processInstanceId).getTaskDefinitionKey());
+    }
+
+    @Test
+    public void testDeleteSignTask_recursive() {
+        // 准备参数：task1 向前加签给用户 2，用户 2 再向前加签给用户 3
+        String processInstanceId = startProcessInstance();
+        Task task1 = getRunningTask(processInstanceId);
+        Task childTask = createSignTask(1L, task1.getId(), BpmTaskSignTypeEnum.BEFORE, 2L).get(0);
+        Task grandchildTask = createSignTask(2L, childTask.getId(), BpmTaskSignTypeEnum.BEFORE, 3L).get(0);
+
+        // 调用：用户 1 减签用户 2
+        bpmTaskService.deleteSignTask(1L, new BpmTaskSignDeleteReqVO().setId(childTask.getId()).setReason("减签"));
+        // 断言：子任务、孙任务都被取消删除，task1 恢复给用户 1 审批
+        assertNull(bpmTaskService.getTask(childTask.getId()));
+        assertNull(bpmTaskService.getTask(grandchildTask.getId()));
+        assertEquals(BpmTaskStatusEnum.CANCEL.getStatus(), getTaskStatus(childTask.getId()));
+        assertEquals(BpmTaskStatusEnum.CANCEL.getStatus(), getTaskStatus(grandchildTask.getId()));
+        assertRunningTask(task1.getId(), "1");
+        assertNull(bpmTaskService.getTask(task1.getId()).getScopeType());
+        verify(commentService).createComment(eq(task1.getId()), eq(processInstanceId),
+                eq(BpmCommentTypeEnum.SUB_SIGN), eq("用户1"), eq("用户2"));
+
+        // 调用 + 断言：用户 1 审批，流程流转到 task2
+        approveTask(1L, task1.getId());
+        assertEquals("task2", getRunningTask(processInstanceId).getTaskDefinitionKey());
+    }
+
+    @Test
+    public void testDeleteSignTask_notSignUser() {
+        // 准备参数：task1 向前加签给用户 2、用户 3
+        String processInstanceId = startProcessInstance();
+        Task task1 = getRunningTask(processInstanceId);
+        Map<String, Task> childTasks = createSignTask(1L, task1.getId(), BpmTaskSignTypeEnum.BEFORE, 2L, 3L).stream()
+                .collect(Collectors.toMap(Task::getAssignee, Function.identity()));
+        String childTaskId = childTasks.get("2").getId();
+
+        // 调用，并断言异常：其它加签人、被减签人自己、无关用户、无 userId，都不能减签
+        for (Long userId : new Long[]{3L, 2L, 99L, null}) {
+            assertServiceException(() -> bpmTaskService.deleteSignTask(userId, new BpmTaskSignDeleteReqVO()
+                    .setId(childTaskId).setReason("减签")), TASK_SIGN_DELETE_FAIL_NOT_SELF);
+        }
+        // 断言：加签任务都还在，task1 继续等待
+        assertRunningTask(childTaskId, "2");
+        assertEquals(2, bpmTaskService.getTaskListByParentTaskId(task1.getId()).size());
+        assertWaitTask(task1.getId(), "1", BpmTaskSignTypeEnum.BEFORE);
+    }
+
+    @Test
+    public void testDeleteSignTask_byParentAndAncestorSignUser() {
+        // 准备参数：task1 向前加签给用户 2，用户 2 再向前加签给用户 3、用户 4
+        String processInstanceId = startProcessInstance();
+        Task task1 = getRunningTask(processInstanceId);
+        Task childTask = createSignTask(1L, task1.getId(), BpmTaskSignTypeEnum.BEFORE, 2L).get(0);
+        Map<String, Task> grandchildTasks = createSignTask(2L, childTask.getId(), BpmTaskSignTypeEnum.BEFORE, 3L, 4L)
+                .stream().collect(Collectors.toMap(Task::getAssignee, Function.identity()));
+
+        // 调用：用户 2（父任务的加签人）减签用户 3
+        bpmTaskService.deleteSignTask(2L, new BpmTaskSignDeleteReqVO().setId(grandchildTasks.get("3").getId())
+                .setReason("减签"));
+        // 断言：用户 3 的任务被取消，子任务继续等待用户 4
+        assertEquals(BpmTaskStatusEnum.CANCEL.getStatus(), getTaskStatus(grandchildTasks.get("3").getId()));
+        assertWaitTask(childTask.getId(), "2", BpmTaskSignTypeEnum.BEFORE);
+
+        // 调用：用户 1（祖先任务的加签人）减签用户 4
+        bpmTaskService.deleteSignTask(1L, new BpmTaskSignDeleteReqVO().setId(grandchildTasks.get("4").getId())
+                .setReason("减签"));
+        // 断言：子任务恢复给用户 2 审批，task1 继续等待
+        assertEquals(BpmTaskStatusEnum.CANCEL.getStatus(), getTaskStatus(grandchildTasks.get("4").getId()));
+        assertRunningTask(childTask.getId(), "2");
+        assertWaitTask(task1.getId(), "1", BpmTaskSignTypeEnum.BEFORE);
+    }
+
+    // ========== 私有方法 ==========
+
+    private String startProcessInstance() {
+        return processInstanceService.createProcessInstance(1L, new BpmProcessInstanceCreateReqDTO()
+                .setProcessDefinitionKey("twoStepApprove").setBusinessKey("business-1"));
+    }
+
+    private Task getRunningTask(String processInstanceId) {
+        List<Task> tasks = bpmTaskService.getRunningTaskListByProcessInstanceId(processInstanceId, null, null);
+        assertEquals(1, tasks.size());
+        return tasks.get(0);
+    }
+
+    private List<Task> createSignTask(Long userId, String taskId, BpmTaskSignTypeEnum type, Long... userIds) {
+        bpmTaskService.createSignTask(userId, new BpmTaskSignCreateReqVO().setId(taskId)
+                .setType(type.getType()).setUserIds(Set.of(userIds)).setReason("加签"));
+        List<Task> childTasks = bpmTaskService.getTaskListByParentTaskId(taskId);
+        assertEquals(userIds.length, childTasks.size());
+        return childTasks;
+    }
+
+    private void approveTask(Long userId, String taskId) {
+        bpmTaskService.approveTask(userId, new BpmTaskApproveReqVO().setId(taskId).setReason("同意"));
+    }
+
+    private Integer getTaskStatus(String taskId) {
+        return (Integer) bpmTaskService.getHistoricTask(taskId).getTaskLocalVariables()
+                .get(BpmnVariableConstants.TASK_VARIABLE_STATUS);
+    }
+
+    /**
+     * 断言流程实例不通过并结束，并且没有残留的任务（包括没有 execution 的加签任务）
+     */
+    private void assertProcessInstanceRejected(String processInstanceId) {
+        assertNull(processInstanceService.getProcessInstance(processInstanceId));
+        assertEquals(BpmProcessInstanceStatusEnum.REJECT.getStatus(), processInstanceService
+                .getHistoricProcessInstance(processInstanceId).getProcessVariables()
+                .get(BpmnVariableConstants.PROCESS_INSTANCE_VARIABLE_STATUS));
+        assertEquals(0, flowableTaskService.createTaskQuery().deploymentId(deployment.getId()).count());
+    }
+
+    /**
+     * 断言任务处于等待中：只有 owner 没有 assignee，状态为 WAIT
+     */
+    private void assertWaitTask(String taskId, String owner, BpmTaskSignTypeEnum signType) {
+        Task task = bpmTaskService.getTask(taskId);
+        assertEquals(owner, task.getOwner());
+        assertNull(task.getAssignee());
+        assertEquals(signType != null ? signType.getType() : null, task.getScopeType());
+        assertEquals(BpmTaskStatusEnum.WAIT.getStatus(), getTaskStatus(taskId));
+    }
+
+    /**
+     * 断言任务可以被 assignee 审批：状态为 RUNNING
+     */
+    private void assertRunningTask(String taskId, String assignee) {
+        Task task = bpmTaskService.getTask(taskId);
+        assertEquals(assignee, task.getAssignee());
+        assertEquals(BpmTaskStatusEnum.RUNNING.getStatus(), getTaskStatus(taskId));
+    }
+
+}
@@ -156,6 +156,33 @@ public class BpmTaskServiceImplTest extends BaseMockitoUnitTest {
     }
     @Test
+    public void testValidateTask_ownerOnly() {
+        // 准备参数：加签等待中的任务，只有 owner 没有 assignee
+        BpmTaskServiceImpl spyService = spy(taskService);
+        doReturn(task).when(spyService).validateTaskExists("task-1");
+        when(task.getAssignee()).thenReturn(null);
+        when(task.getOwner()).thenReturn("1");
+
+        // 调用，并断言异常：owner 自己、其它用户、无 userId 都不允许操作
+        assertServiceException(() -> spyService.validateTask(1L, "task-1"), TASK_OPERATE_FAIL_ASSIGN_NOT_SELF);
+        assertServiceException(() -> spyService.validateTask(2L, "task-1"), TASK_OPERATE_FAIL_ASSIGN_NOT_SELF);
+        assertServiceException(() -> spyService.validateTask(null, "task-1"), TASK_OPERATE_FAIL_ASSIGN_NOT_SELF);
+    }
+
+    @Test
+    public void testValidateTask_approving() {
+        // 准备参数：向后加签的父任务，已审批通过，等待加签任务审批
+        BpmTaskServiceImpl spyService = spy(taskService);
+        doReturn(task).when(spyService).validateTaskExists("task-1");
+        when(task.getAssignee()).thenReturn("1");
+        when(task.getTaskLocalVariables()).thenReturn(Map.of(BpmnVariableConstants.TASK_VARIABLE_STATUS,
+                BpmTaskStatusEnum.APPROVING.getStatus()));
+
+        // 调用，并断言异常
+        assertServiceException(() -> spyService.validateTask(1L, "task-1"), TASK_OPERATE_FAIL_APPROVING);
+    }
+
+    @Test
     public void testValidateTaskExists_notExists() {
         // 准备参数
         BpmTaskServiceImpl spyService = spy(taskService);
@@ -443,6 +470,14 @@ public class BpmTaskServiceImplTest extends BaseMockitoUnitTest {
     }
     @Test
+    public void testCreateSignTask_typeNotExists() {
+        // 调用，并断言异常
+        assertServiceException(() -> taskService.createSignTask(1L, new BpmTaskSignCreateReqVO().setId("task-1")
+                        .setType("unknown").setUserIds(Set.of(2L)).setReason("加签")),
+                TASK_SIGN_CREATE_TYPE_NOT_EXISTS, "unknown");
+    }
+
+    @Test
     public void testDeleteSignTask_parentNotExists() {
         // 准备参数
         BpmTaskServiceImpl spyService = spy(taskService);