From c233b615dd9bbc9480dbb13f843f040c2ce44f7e Mon Sep 17 00:00:00 2001
From: lorne <1991wangliang@gmail.com>
Date: Mon, 9 Nov 2026 20:31:35 +0800
Subject: [PATCH] =?UTF-8?q?fix:=20=E9=80=80=E5=9B=9E=E6=97=B6=E8=87=AA?=
=?UTF-8?q?=E5=8A=A8=E5=8A=9E=E7=BB=93=E5=90=8C=E8=8A=82=E7=82=B9=E5=85=B6?=
=?UTF-8?q?=E4=BB=96=E5=BE=85=E5=8A=9E=EF=BC=8C=E9=81=BF=E5=85=8D=E9=87=8D?=
=?UTF-8?q?=E5=A4=8D=E5=BE=85=E5=8A=9E=20(#255)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
退回动作只更新了当前记录,多人审批(或签/并签)同节点的其他待办未被清理:
流程视图仍停留在该节点,发起人重新提交后同流程会出现重复待办。
- BaseAction 新增 autoDoneSiblingTodos,统一自动办结同节点其他待办(限定同一流程实例)
- ReturnAction 复用该方法,并改为先保存本节点状态再生成退回目标节点记录
- RejectAction 改用公共方法,行为保持不变(#235)
- 新增 FlowIssue255AnyAuditReturnTest,覆盖或签退回与并签退回场景
Closes #255
---
.../com/codingapi/flow/action/BaseAction.java | 37 ++
.../flow/action/actions/RejectAction.java | 8 +-
.../flow/action/actions/ReturnAction.java | 9 +
.../FlowIssue255AnyAuditReturnTest.java | 320 ++++++++++++++++++
4 files changed, 367 insertions(+), 7 deletions(-)
create mode 100644 flow-engine-framework/src/test/java/com/codingapi/flow/service/FlowIssue255AnyAuditReturnTest.java
diff --git a/flow-engine-framework/src/main/java/com/codingapi/flow/action/BaseAction.java b/flow-engine-framework/src/main/java/com/codingapi/flow/action/BaseAction.java
index 7218ee7b..be57296d 100644
--- a/flow-engine-framework/src/main/java/com/codingapi/flow/action/BaseAction.java
+++ b/flow-engine-framework/src/main/java/com/codingapi/flow/action/BaseAction.java
@@ -1,6 +1,7 @@
package com.codingapi.flow.action;
import com.codingapi.flow.common.IMapConvertor;
+import com.codingapi.flow.event.FlowRecordDoneEvent;
import com.codingapi.flow.event.FlowRecordTodoEvent;
import com.codingapi.flow.event.IFlowEvent;
import com.codingapi.flow.node.IFlowNode;
@@ -120,6 +121,42 @@ protected boolean isEndNodeTodoEvent(IFlowEvent event) {
&& !todoEvent.getFlowRecord().isNotEndNode();
}
+ /**
+ * 将当前节点实例中其他未办理的待办记录自动办结。
+ *
+ *
退回({@link com.codingapi.flow.action.actions.ReturnAction})、拒绝
+ * ({@link com.codingapi.flow.action.actions.RejectAction})意味着当前节点就此结束,
+ * 同节点其他审批人(或签/并签的候选审批人)的待办不能继续办理:否则会遗留待办,
+ * 流程视图仍停留在当前节点,发起人重新提交后还会出现同流程的重复待办(issue #235 / #255)。
+ *
+ *
自动办结采用 {@link FlowRecord#autoDone()}:记录置为已办但不带审批动作,
+ * 展示层标记为「自动跳过」,与或签/并签节点完成后遗留待办的处理口径一致。
+ * 仅处理同一流程实例内的记录,避免仓储按 {@code (fromId, nodeId)} 查询时误伤其他流程实例。
+ *
+ * @param flowSession 当前会话,同节点记录取自 {@link FlowSession#getCurrentNodeRecords()}
+ * @param recordList 待保存的记录集合,自动办结的记录会追加其中
+ * @param flowEvents 待推送的事件集合,每条自动办结记录都会追加一条已办事件
+ */
+ protected void autoDoneSiblingTodos(FlowSession flowSession,
+ List recordList,
+ List flowEvents) {
+ FlowRecord currentRecord = flowSession.getCurrentRecord();
+ for (FlowRecord record : flowSession.getCurrentNodeRecords()) {
+ if (record.getId() == currentRecord.getId()) {
+ continue;
+ }
+ if (!record.isTodo()) {
+ continue;
+ }
+ if (!currentRecord.getProcessId().equals(record.getProcessId())) {
+ continue;
+ }
+ record.autoDone();
+ recordList.add(record);
+ flowEvents.add(new FlowRecordDoneEvent(record, flowSession.isMock()));
+ }
+ }
+
/**
* 触发并执行后续节点
*
diff --git a/flow-engine-framework/src/main/java/com/codingapi/flow/action/actions/RejectAction.java b/flow-engine-framework/src/main/java/com/codingapi/flow/action/actions/RejectAction.java
index 108907f6..b60cdfc7 100644
--- a/flow-engine-framework/src/main/java/com/codingapi/flow/action/actions/RejectAction.java
+++ b/flow-engine-framework/src/main/java/com/codingapi/flow/action/actions/RejectAction.java
@@ -107,13 +107,7 @@ public void run(FlowSession flowSession) {
// 拒绝即结束当前节点:将同节点其他未办理的待办(或签/并签的其他审批人)自动置为已办。
// 否则节点被退回后仍会遗留待办,审批人可继续办理,流程视图也会停留在当前节点(issue #235)。
- for (FlowRecord record : flowSession.getCurrentNodeRecords()) {
- if (record.getId() != flowRecord.getId() && record.isTodo()) {
- record.autoDone();
- recordList.add(record);
- flowEvents.add(new FlowRecordDoneEvent(record, flowSession.isMock()));
- }
- }
+ this.autoDoneSiblingTodos(flowSession, recordList, flowEvents);
// 先保存当前记录及同节点待办的自动办结状态,再触发退回/终止节点。
// 终止流程时 EndNode.fillNewRecord 会按数据库中的最新记录统一置为结束状态,
diff --git a/flow-engine-framework/src/main/java/com/codingapi/flow/action/actions/ReturnAction.java b/flow-engine-framework/src/main/java/com/codingapi/flow/action/actions/ReturnAction.java
index 4dd18850..e0096645 100644
--- a/flow-engine-framework/src/main/java/com/codingapi/flow/action/actions/ReturnAction.java
+++ b/flow-engine-framework/src/main/java/com/codingapi/flow/action/actions/ReturnAction.java
@@ -58,6 +58,15 @@ public void run(FlowSession flowSession) {
flowEvents.add(new FlowRecordDoneEvent(currentRecord,flowSession.isMock()));
+ // 退回即结束当前节点:同节点其他未办理的待办(或签/并签的其他审批人)一并自动置为已办。
+ // 否则退回后仍会遗留待办,发起人重新提交到该节点时会出现同流程的重复待办(issue #255)。
+ this.autoDoneSiblingTodos(flowSession, recordList, flowEvents);
+
+ // 先保存当前记录与同节点待办的自动办结状态,再生成退回目标节点的记录,
+ // 与拒绝动作一致,避免退回目标节点的生成过程覆盖本会话中的记录状态(issue #235)
+ repositoryHolder.saveRecords(recordList);
+ recordList.clear();
+
List flowRecords = backNode.generateCurrentRecords(flowSession.updateSession(backNode));
recordList.addAll(flowRecords);
diff --git a/flow-engine-framework/src/test/java/com/codingapi/flow/service/FlowIssue255AnyAuditReturnTest.java b/flow-engine-framework/src/test/java/com/codingapi/flow/service/FlowIssue255AnyAuditReturnTest.java
new file mode 100644
index 00000000..f2d32e63
--- /dev/null
+++ b/flow-engine-framework/src/test/java/com/codingapi/flow/service/FlowIssue255AnyAuditReturnTest.java
@@ -0,0 +1,320 @@
+package com.codingapi.flow.service;
+
+import com.codingapi.flow.action.ActionType;
+import com.codingapi.flow.action.IFlowAction;
+import com.codingapi.flow.action.actions.CustomAction;
+import com.codingapi.flow.action.actions.PassAction;
+import com.codingapi.flow.action.actions.ReturnAction;
+import com.codingapi.flow.builder.ActionBuilder;
+import com.codingapi.flow.builder.FormFieldPermissionsBuilder;
+import com.codingapi.flow.builder.NodeStrategyBuilder;
+import com.codingapi.flow.context.GatewayContext;
+import com.codingapi.flow.exception.FlowStateException;
+import com.codingapi.flow.factory.MyFlowServiceFactory;
+import com.codingapi.flow.form.DataType;
+import com.codingapi.flow.form.FlowForm;
+import com.codingapi.flow.form.FlowFormBuilder;
+import com.codingapi.flow.form.permission.PermissionType;
+import com.codingapi.flow.node.IFlowNode;
+import com.codingapi.flow.node.nodes.ApprovalNode;
+import com.codingapi.flow.node.nodes.EndNode;
+import com.codingapi.flow.node.nodes.StartNode;
+import com.codingapi.flow.pojo.body.FlowAdviceBody;
+import com.codingapi.flow.pojo.request.FlowActionRequest;
+import com.codingapi.flow.pojo.request.FlowCreateRequest;
+import com.codingapi.flow.pojo.request.FlowProcessNodeRequest;
+import com.codingapi.flow.pojo.response.ProcessNode;
+import com.codingapi.flow.record.FlowRecord;
+import com.codingapi.flow.script.factory.FlowGroovyScriptFactory;
+import com.codingapi.flow.strategy.node.FormFieldPermissionStrategy;
+import com.codingapi.flow.strategy.node.MultiOperatorAuditStrategy;
+import com.codingapi.flow.strategy.node.OperatorLoadStrategy;
+import com.codingapi.flow.user.User;
+import com.codingapi.flow.workflow.Workflow;
+import com.codingapi.flow.workflow.WorkflowBuilder;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * issue #255 多人审批节点「退回」场景。
+ *
+ * 流程设计:A(开始) -> B(审批,b1/b2 或签) -> C(审批,c1) -> D(结束)。
+ *
+ *
流程停留在 B 节点时,b1 将流程退回到开始节点,B 节点即告结束:
+ *
+ * - b2 在同节点的待办应自动办结(视为已审核),不能继续审批;
+ * - 发起人重新提交后,B 节点重新生成待办,b2 不应出现两条同流程待办。
+ *
+ */
+class FlowIssue255AnyAuditReturnTest {
+
+ private final MyFlowServiceFactory factory = new MyFlowServiceFactory();
+
+ /**
+ * 或签场景:b1 退回后,b2 的待办必须一起清理;重新提交后不得出现重复待办。
+ */
+ @Test
+ void anyAuditReturnShouldAutoDoneSiblingTodoAndAvoidDuplicateTodoAfterResubmit() {
+ // given:A-B-C-D,B 为任意审核(b1、b2),C 的审批人为 c1
+ User a1 = new User(1, "a1");
+ User b1 = new User(2, "b1");
+ User b2 = new User(3, "b2");
+ User c1 = new User(4, "c1");
+ registerUsers(a1, b1, b2, c1);
+
+ StartNode startNode = startNode();
+ ApprovalNode bNode = approvalNode("B审批", "[2,3]",
+ new MultiOperatorAuditStrategy(MultiOperatorAuditStrategy.Type.ANY, 0), true);
+ ApprovalNode cNode = approvalNode("C审批", "[4]", null, false);
+ Workflow workflow = saveWorkflow(a1, startNode, bNode, cNode, EndNode.builder().build());
+ Map data = data();
+
+ // 1. 发起人提交,B 节点 b1、b2 各收到一条待办
+ startAndSubmit(workflow, startNode, a1, data);
+ FlowRecord b1Todo = todoOf(b1, bNode);
+ FlowRecord b2Todo = todoOf(b2, bNode);
+
+ // when:b1 将流程退回到开始节点
+ backToStart(b1Todo, bNode, b1, startNode, data);
+
+ // then 1:b2 的同节点待办自动办结,b1、b2 均无待办
+ assertNoTodo(b1);
+ assertNoTodo(b2);
+ FlowRecord b2AutoDone = factory.flowRecordRepository.get(b2Todo.getId());
+ assertTrue(b2AutoDone.isDone(), "b1 退回后,b2 的同节点待办应自动置为已办");
+ assertTrue(b2AutoDone.isAutoDone(), "b2 未发生实际审批,应标记为自动办结");
+
+ // then 2:流程回到开始节点,仅发起人有一条待办
+ List a1Todos = factory.flowRecordRepository.findTodoByOperator(a1.getUserId());
+ assertEquals(1, a1Todos.size(), "流程退回后发起人应收到一条待办");
+ assertEquals(startNode.getId(), a1Todos.get(0).getNodeId());
+
+ // then 3:B 节点不再展示为审批中
+ List nodeList = processNodes(a1Todos.get(0), a1, data);
+ ProcessNode bView = nodeList.stream()
+ .filter(node -> bNode.getId().equals(node.getNodeId()))
+ .filter(node -> !node.isHistory())
+ .findFirst()
+ .orElse(null);
+ assertTrue(bView == null || bView.getApproveState() != ProcessNode.ApproveState.PROCESSING,
+ "退回后 B 节点不应仍展示为审批中");
+
+ // 2. 发起人重新提交,流程再次到达 B 节点
+ pass(todoOf(a1, startNode), startNode, a1, data);
+
+ // then 4:b1、b2 各只有一条待办,不出现同流程重复待办
+ assertEquals(1, factory.flowRecordRepository.findTodoByOperator(b1.getUserId()).size(),
+ "b1 不应出现同流程重复待办");
+ assertEquals(1, factory.flowRecordRepository.findTodoByOperator(b2.getUserId()).size(),
+ "b2 不应出现同流程重复待办");
+
+ List bRecords = recordsOfNode(processRecords(b2Todo), bNode);
+ assertEquals(4, bRecords.size(), "B 节点应保留两轮共 4 条记录");
+ assertEquals(2, bRecords.stream().filter(FlowRecord::isDone).count(),
+ "上一轮的 b1、b2 记录都应为已办");
+ assertEquals(2, bRecords.stream().filter(FlowRecord::isTodo).count(),
+ "当前轮次应有 b1、b2 两条待办");
+
+ // then 5:上一轮遗留的待办不能再被审批
+ assertThrows(FlowStateException.class, () -> pass(b2Todo, bNode, b2, data),
+ "b2 的旧记录已自动办结,不应再允许审批");
+
+ // then 6:新一轮 b2 通过(或签)后流程正常到达 C 节点
+ pass(todoOf(b2, bNode), bNode, b2, data);
+ assertEquals(1, factory.flowRecordRepository.findTodoByOperator(c1.getUserId()).size(),
+ "或签通过后流程应流转到 C 节点");
+ }
+
+ /**
+ * 并签场景:b2 退回后,同节点尚未办理的 b3 待办同样应自动办结,且已发生的真实审批记录不被改写。
+ */
+ @Test
+ void mergeAuditReturnShouldAutoDoneSiblingTodos() {
+ // given:A-B-D,B 为并签(b1、b2、b3,需全部通过)
+ User a1 = new User(1, "a1");
+ User b1 = new User(2, "b1");
+ User b2 = new User(3, "b2");
+ User b3 = new User(4, "b3");
+ registerUsers(a1, b1, b2, b3);
+
+ StartNode startNode = startNode();
+ ApprovalNode bNode = approvalNode("B审批", "[2,3,4]",
+ new MultiOperatorAuditStrategy(MultiOperatorAuditStrategy.Type.MERGE, 1.0f), true);
+ Workflow workflow = saveWorkflow(a1, startNode, bNode, EndNode.builder().build());
+ Map data = data();
+
+ // 1. b1 审批通过,并签未达到比例,b2、b3 仍有待办
+ startAndSubmit(workflow, startNode, a1, data);
+ pass(todoOf(b1, bNode), bNode, b1, data);
+ FlowRecord b3Todo = todoOf(b3, bNode);
+
+ // when:b2 将流程退回到开始节点
+ backToStart(todoOf(b2, bNode), bNode, b2, startNode, data);
+
+ // then:b2、b3 均无待办,b3 的记录自动办结
+ assertNoTodo(b2);
+ assertNoTodo(b3);
+ FlowRecord b3AutoDone = factory.flowRecordRepository.get(b3Todo.getId());
+ assertTrue(b3AutoDone.isDone(), "b2 退回后,b3 的同节点待办应自动置为已办");
+ assertTrue(b3AutoDone.isAutoDone(), "b3 未发生实际审批,应标记为自动办结");
+
+ List bRecords = recordsOfNode(processRecords(b3Todo), bNode);
+ assertTrue(bRecords.stream()
+ .filter(FlowRecord::isDone)
+ .anyMatch(record -> ActionType.PASS.name().equals(record.getActionType())),
+ "b1 已发生的通过记录不应被改写");
+ assertEquals(1, factory.flowRecordRepository.findTodoByOperator(a1.getUserId()).size(),
+ "流程退回后发起人应收到一条待办");
+ }
+
+ // ==================== 流程装配 ====================
+
+ private void registerUsers(User... users) {
+ for (User user : users) {
+ factory.userGateway.save(user);
+ }
+ GatewayContext.getInstance().setFlowOperatorGateway(factory.userGateway);
+ }
+
+ private FlowForm form() {
+ return FlowFormBuilder.builder()
+ .name("issue255")
+ .code("issue255")
+ .addField("name", "name", DataType.STRING)
+ .addField("days", "days", DataType.INTEGER)
+ .build();
+ }
+
+ private Map data() {
+ return Map.of("name", "lorne", "days", 1);
+ }
+
+ private FormFieldPermissionStrategy perm() {
+ return new FormFieldPermissionStrategy(FormFieldPermissionsBuilder.builder()
+ .addPermission("issue255", "name", PermissionType.WRITE)
+ .addPermission("issue255", "days", PermissionType.WRITE)
+ .build());
+ }
+
+ private StartNode startNode() {
+ return StartNode.builder()
+ .strategies(NodeStrategyBuilder.builder()
+ .addStrategy(perm())
+ .build())
+ .actions(ActionBuilder.builder()
+ .addAction(CustomAction.defaultAction())
+ .build())
+ .build();
+ }
+
+ private ApprovalNode approvalNode(String name, String operatorIds,
+ MultiOperatorAuditStrategy auditStrategy, boolean withReturn) {
+ NodeStrategyBuilder strategyBuilder = NodeStrategyBuilder.builder()
+ .addStrategy(perm())
+ .addStrategy(new OperatorLoadStrategy(
+ FlowGroovyScriptFactory.createOperatorLoadScript("def run(request){return " + operatorIds + "}")
+ .getKey()));
+ if (auditStrategy != null) {
+ strategyBuilder.addStrategy(auditStrategy);
+ }
+ ActionBuilder actionBuilder = ActionBuilder.builder().addAction(PassAction.defaultAction());
+ if (withReturn) {
+ actionBuilder.addAction(ReturnAction.defaultAction());
+ }
+ return ApprovalNode.builder()
+ .name(name)
+ .strategies(strategyBuilder.build())
+ .actions(actionBuilder.build())
+ .build();
+ }
+
+ private Workflow saveWorkflow(User creator, IFlowNode... nodes) {
+ WorkflowBuilder builder = WorkflowBuilder.builder()
+ .title("issue255")
+ .code("issue255")
+ .createdOperator(creator)
+ .form(form());
+ for (IFlowNode node : nodes) {
+ builder.addNode(node);
+ }
+ Workflow workflow = builder.build();
+ factory.workflowService.saveWorkflow(workflow);
+ return workflow;
+ }
+
+ // ==================== 操作与断言 ====================
+
+ private void startAndSubmit(Workflow workflow, StartNode startNode, User user, Map data) {
+ List startActions = startNode.actionManager().getActions();
+ FlowCreateRequest createRequest = new FlowCreateRequest();
+ createRequest.setWorkCode(workflow.getCode());
+ createRequest.setFormData(data);
+ createRequest.setActionId(startActions.get(0).id());
+ createRequest.setOperatorId(user.getUserId());
+ factory.flowService.create(createRequest);
+
+ pass(todoOf(user, startNode), startNode, user, data);
+ }
+
+ private void pass(FlowRecord record, IFlowNode node, User operator, Map data) {
+ IFlowAction action = node.actionManager().getActions().stream()
+ .filter(item -> ActionType.PASS.name().equals(item.type()))
+ .findFirst().orElseThrow();
+ flowAction(record, operator, action, data, "同意");
+ }
+
+ private void backToStart(FlowRecord record, IFlowNode node, User operator,
+ StartNode startNode, Map data) {
+ IFlowAction action = node.actionManager().getActions().stream()
+ .filter(item -> ActionType.RETURN.name().equals(item.type()))
+ .findFirst().orElseThrow();
+ FlowActionRequest request = new FlowActionRequest();
+ request.setFormData(data);
+ request.setRecordId(record.getId());
+ FlowAdviceBody adviceBody = new FlowAdviceBody(action.id(), "退回", operator.getUserId());
+ adviceBody.setBackNodeId(startNode.getId());
+ request.setAdvice(adviceBody);
+ factory.flowService.action(request);
+ }
+
+ private void flowAction(FlowRecord record, User operator, IFlowAction action,
+ Map data, String advice) {
+ FlowActionRequest request = new FlowActionRequest();
+ request.setFormData(data);
+ request.setRecordId(record.getId());
+ request.setAdvice(new FlowAdviceBody(action.id(), advice, operator.getUserId()));
+ factory.flowService.action(request);
+ }
+
+ private FlowRecord todoOf(User user, IFlowNode node) {
+ List list = factory.flowRecordRepository.findTodoByOperator(user.getUserId()).stream()
+ .filter(record -> node.getId().equals(record.getNodeId()))
+ .toList();
+ assertEquals(1, list.size(), user.getName() + " 在 " + node.getName() + " 应有且仅有一条待办");
+ return list.get(0);
+ }
+
+ private void assertNoTodo(User user) {
+ assertEquals(0, factory.flowRecordRepository.findTodoByOperator(user.getUserId()).size(),
+ user.getName() + " 不应有待办");
+ }
+
+ private List processRecords(FlowRecord anyRecord) {
+ return factory.flowRecordRepository.findProcessRecords(anyRecord.getProcessId());
+ }
+
+ private List recordsOfNode(List records, IFlowNode node) {
+ return records.stream().filter(record -> record.getNodeId().equals(node.getId())).toList();
+ }
+
+ private List processNodes(FlowRecord record, User viewer, Map data) {
+ return factory.flowService.processNodes(
+ new FlowProcessNodeRequest(record.getId(), viewer.getUserId(), data));
+ }
+}