From 0bbe3ac971a3eaf0ba0cc542a4bbef86da7c9e13 Mon Sep 17 00:00:00 2001 From: lorne <1991wangliang@gmail.com> Date: Mon, 16 Nov 2026 20:50:40 +0800 Subject: [PATCH] =?UTF-8?q?fix:=20=E9=80=80=E5=9B=9E=E5=80=99=E9=80=89?= =?UTF-8?q?=E8=8A=82=E7=82=B9=E6=94=B9=E4=B8=BA=E5=9F=BA=E4=BA=8E=E6=89=A7?= =?UTF-8?q?=E8=A1=8C=E5=8E=86=E5=8F=B2=E5=B9=B6=E6=94=B6=E7=B4=A7=E9=80=80?= =?UTF-8?q?=E5=9B=9E=E6=A0=A1=E9=AA=8C=20(framework)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - FlowContent 新增 backNodes:只包含当前记录真实执行过的历史节点, 倒序去重保证"最近经过的节点"优先(停留在 C 时为 B、A), 且没有候选时不向展示按钮集合下发 RETURN,修正开始节点 "退回按钮可点但提交必然失败"的错误交互(issue #270) - BackNodeHelper 新增 historyBackNodes,按记录 id 正序倒序遍历历史记录, 同一节点多次执行只保留最近一次,未执行的分支节点天然被排除 - ActionManager 收紧 RETURN 校验:开始节点不支持退回; 退回目标必须存在于当前记录的历史执行链(并行/条件分支中 "结构上不是下游但从未执行"的节点同样被拒绝) - FlowStateException 新增 nodeNotSupportReturn / backNodeNotInHistory - BaseAction.show 兼容缺少 display 配置的旧流程数据,避免详情接口空指针 - 新增 FlowIssue270ReturnNodeControlTest(历史候选、最近优先、未执行分支拒绝、开始节点) Closes #270 --- .../com/codingapi/flow/action/BaseAction.java | 4 +- .../flow/exception/FlowStateException.java | 21 ++ .../codingapi/flow/manager/ActionManager.java | 34 ++ .../flow/node/helper/BackNodeHelper.java | 67 +++- .../flow/pojo/response/FlowContent.java | 31 +- .../flow/service/impl/FlowDetailService.java | 22 ++ .../FlowIssue270ReturnNodeControlTest.java | 343 ++++++++++++++++++ 7 files changed, 513 insertions(+), 9 deletions(-) create mode 100644 flow-engine-framework/src/test/java/com/codingapi/flow/service/FlowIssue270ReturnNodeControlTest.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 be57296d..60f77b1f 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 @@ -48,7 +48,9 @@ public ActionDisplay display() { @Override public boolean show(FlowSession flowSession) { - return this.display.show(flowSession); + // 兼容早期设计/导入的流程数据:动作缺少 display 配置时按默认展示处理, + // 与 ActionDisplay 未配置展示脚本即展示的口径一致,避免详情接口空指针 + return this.display == null || this.display.show(flowSession); } @Override diff --git a/flow-engine-framework/src/main/java/com/codingapi/flow/exception/FlowStateException.java b/flow-engine-framework/src/main/java/com/codingapi/flow/exception/FlowStateException.java index cbe2599c..aac905ea 100644 --- a/flow-engine-framework/src/main/java/com/codingapi/flow/exception/FlowStateException.java +++ b/flow-engine-framework/src/main/java/com/codingapi/flow/exception/FlowStateException.java @@ -109,6 +109,27 @@ public static FlowStateException nodeNotSupportRevoke() { return new FlowStateException("node.notSupportRevoke", "Node not support revoke"); } + + /** + * Node not support return (start node has no history node to return) + * + * @return exception + */ + public static FlowStateException nodeNotSupportReturn() { + return new FlowStateException("node.notSupportReturn", "Node not support return"); + } + + /** + * Return target node is not executed in current process + * + * @param nodeId node id + * @return exception + */ + public static FlowStateException backNodeNotInHistory(String nodeId) { + return new FlowStateException("node.backNode.notInHistory", + String.format("Return target node %s is not in the executed history", nodeId)); + } + /** * Record not support urge * diff --git a/flow-engine-framework/src/main/java/com/codingapi/flow/manager/ActionManager.java b/flow-engine-framework/src/main/java/com/codingapi/flow/manager/ActionManager.java index e775e0bc..39d01fbf 100644 --- a/flow-engine-framework/src/main/java/com/codingapi/flow/manager/ActionManager.java +++ b/flow-engine-framework/src/main/java/com/codingapi/flow/manager/ActionManager.java @@ -2,6 +2,7 @@ import com.codingapi.flow.action.IFlowAction; import com.codingapi.flow.action.actions.*; +import com.codingapi.flow.exception.FlowStateException; import com.codingapi.flow.exception.FlowValidationException; import com.codingapi.flow.form.FlowForm; import com.codingapi.flow.node.IFlowNode; @@ -9,6 +10,7 @@ import com.codingapi.flow.node.nodes.EndNode; import com.codingapi.flow.node.nodes.HandleNode; import com.codingapi.flow.node.nodes.StartNode; +import com.codingapi.flow.record.FlowRecord; import com.codingapi.flow.session.FlowAdvice; import com.codingapi.flow.session.FlowSession; import com.codingapi.flow.workflow.Workflow; @@ -146,6 +148,10 @@ public void verifySession(FlowSession session) { } IFlowNode backNode = flowAdvice.getBackNode(); IFlowNode currentNode = session.getCurrentNode(); + // 开始节点没有任何历史节点,不存在可退回目标,直接拒绝(issue #270) + if (StartNode.NODE_TYPE.equals(currentNode.getType())) { + throw FlowStateException.nodeNotSupportReturn(); + } if (currentNode.equals(backNode)) { throw FlowValidationException.required("backNode"); } @@ -159,10 +165,38 @@ public void verifySession(FlowSession session) { || backNode.getType().equals(HandleNode.NODE_TYPE))) { throw FlowValidationException.required("backNode"); } + // 退回目标必须是当前记录真实执行过的历史节点: + // 并行、条件分支中"结构上不是下游但实际没走过"的节点同样不可退回(issue #270) + verifyBackNodeExecuted(session, backNode); } } + /** + * 校验退回目标是否为当前记录真实执行过的历史节点。 + * + *

仅靠“目标不是当前节点的下游”不足以约束退回:并行、条件分支里存在“不是下游但从未执行”的节点, + * 跳转到此类节点会让流程进入未走过的路径。这里以当前记录之前的历史记录为唯一依据, + * 与详情接口输出的可退回节点({@code FlowContent.backNodes})保持同一口径(issue #270)。

+ * + * @param session 当前会话 + * @param backNode 退回目标节点 + */ + private void verifyBackNodeExecuted(FlowSession session, IFlowNode backNode) { + FlowRecord currentRecord = session.getCurrentRecord(); + if (currentRecord == null) { + throw FlowValidationException.required("backNode"); + } + boolean executed = session.getRepositoryHolder() + .getFlowRecordService() + .findFlowRecordBeforeRecords(currentRecord.getProcessId(), currentRecord.getId()) + .stream() + .anyMatch(record -> backNode.getId().equals(record.getNodeId())); + if (!executed) { + throw FlowStateException.backNodeNotInHistory(backNode.getId()); + } + } + /** * 校验审批意见是否必填。 * diff --git a/flow-engine-framework/src/main/java/com/codingapi/flow/node/helper/BackNodeHelper.java b/flow-engine-framework/src/main/java/com/codingapi/flow/node/helper/BackNodeHelper.java index 32f82a5b..16d50298 100644 --- a/flow-engine-framework/src/main/java/com/codingapi/flow/node/helper/BackNodeHelper.java +++ b/flow-engine-framework/src/main/java/com/codingapi/flow/node/helper/BackNodeHelper.java @@ -4,32 +4,39 @@ import com.codingapi.flow.node.nodes.ApprovalNode; import com.codingapi.flow.node.nodes.HandleNode; import com.codingapi.flow.node.nodes.StartNode; +import com.codingapi.flow.record.FlowRecord; import com.codingapi.flow.workflow.Workflow; import lombok.Getter; import java.util.ArrayList; +import java.util.Comparator; +import java.util.HashSet; import java.util.List; +import java.util.Set; public class BackNodeHelper { + /** + * 允许作为退回目标的节点类型:只有会产生真实审批记录的节点才可退回, + * 抄送、子流程、路由等节点退出时会静默停滞,不参与退回。 + */ + private static final Set BACK_NODE_TYPES = Set.of( + StartNode.NODE_TYPE, + ApprovalNode.NODE_TYPE, + HandleNode.NODE_TYPE); + private final Workflow workflow; private final IFlowNode currentNode; @Getter private final List backNodes; - private final List backNodeTypes = new ArrayList<>(); - public BackNodeHelper(Workflow workflow, IFlowNode currentNode) { this.workflow = workflow; this.currentNode = currentNode; this.backNodes = new ArrayList<>(); - this.backNodeTypes.add(StartNode.NODE_TYPE); - this.backNodeTypes.add(ApprovalNode.NODE_TYPE); - this.backNodeTypes.add(HandleNode.NODE_TYPE); - IFlowNode startNode = workflow.getStartNode(); this.backNodes.add(startNode); @@ -41,7 +48,7 @@ private void fetchBackNodes(IFlowNode targetNode) { List nextNodes = workflow.nextNodes(targetNode); if (!nextNodes.contains(currentNode)) { for (IFlowNode nextNode : nextNodes) { - if (this.backNodeTypes.contains(nextNode.getType())) { + if (BACK_NODE_TYPES.contains(nextNode.getType())) { this.backNodes.add(nextNode); } this.fetchBackNodes(nextNode); @@ -49,4 +56,50 @@ private void fetchBackNodes(IFlowNode targetNode) { } } + /** + * 按真实执行历史计算可退回节点。 + * + *

退回只能回到当前记录实际经过的节点,因此候选来源是当前记录之前的历史记录, + * 而不是流程定义的全量节点(issue #270):

+ *
    + *
  • 历史记录按记录 id 正序排列后倒序遍历,保证“最近经过的节点”排在第一位 + * (例如停留在 C 节点时得到 B、A);
  • + *
  • 同一节点多次执行(退回后重新提交)只保留最近一次,避免重复选项;
  • + *
  • 当前节点自身不可作为退回目标,未执行过的分支节点自然不会出现。
  • + *
+ * + * @param workflow 当前流程定义 + * @param beforeRecords 当前记录之前的历史记录(可乱序) + * @param currentNodeId 当前记录所在节点 id + * @return 可退回节点,最近优先 + */ + public static List historyBackNodes(Workflow workflow, + List beforeRecords, + String currentNodeId) { + if (beforeRecords == null || beforeRecords.isEmpty()) { + return new ArrayList<>(); + } + List sortedRecords = beforeRecords.stream() + .sorted(Comparator.comparingLong(FlowRecord::getId)) + .toList(); + + List historyBackNodes = new ArrayList<>(); + Set visitedNodeIds = new HashSet<>(); + for (int i = sortedRecords.size() - 1; i >= 0; i--) { + String nodeId = sortedRecords.get(i).getNodeId(); + if (!visitedNodeIds.add(nodeId)) { + continue; + } + if (nodeId.equals(currentNodeId)) { + continue; + } + IFlowNode node = workflow.getFlowNode(nodeId); + if (node == null || !BACK_NODE_TYPES.contains(node.getType())) { + continue; + } + historyBackNodes.add(node); + } + return historyBackNodes; + } + } diff --git a/flow-engine-framework/src/main/java/com/codingapi/flow/pojo/response/FlowContent.java b/flow-engine-framework/src/main/java/com/codingapi/flow/pojo/response/FlowContent.java index 183770ef..2be97fc9 100644 --- a/flow-engine-framework/src/main/java/com/codingapi/flow/pojo/response/FlowContent.java +++ b/flow-engine-framework/src/main/java/com/codingapi/flow/pojo/response/FlowContent.java @@ -1,5 +1,6 @@ package com.codingapi.flow.pojo.response; +import com.codingapi.flow.action.ActionType; import com.codingapi.flow.action.IFlowAction; import com.codingapi.flow.form.FlowForm; import com.codingapi.flow.form.permission.FormFieldPermission; @@ -176,6 +177,15 @@ public class FlowContent { */ private List nodes; + /** + * 可退回节点。 + * + *

只包含当前记录真实执行过的历史节点(剔除当前节点),并按“最近经过的节点”优先排序, + * 供退回弹框直接渲染候选列表;为空表示当前记录没有可退回的节点(如开始节点)。 + * 与 {@link #nodes} 的全量流程定义节点区分,避免前端从定义节点中截取导致越界选择(issue #270)。

+ */ + private List backNodes; + /** * 支持撤销 */ @@ -227,7 +237,7 @@ public void pushCurrentNode(FlowSession flowSession) { if (currentNode != null) { ActionManager actionManager = currentNode.actionManager(); NodeStrategyManager strategyManager = currentNode.strategyManager(); - this.actions = toActionMaps(actionManager.filterActions(flowSession)); + this.actions = filterUnsupportedActions(toActionMaps(actionManager.filterActions(flowSession))); this.actionList = toActionMaps(actionManager.getActions()); this.adviceRequired = strategyManager.isAdviceRequired(); this.signRequired = strategyManager.isSignRequired(); @@ -244,6 +254,25 @@ public void pushCurrentNode(FlowSession flowSession) { } } + /** + * 过滤当前不可执行的按钮。 + * + *

没有任何可退回节点时(开始节点或流程首个节点),退回动作不应出现在展示按钮集合中, + * 否则会出现“按钮可点但提交必然失败”的错误交互(issue #270)。 + * {@link #actionList} 仍保留节点配置的全部按钮,前端按展示集合自行隐藏。

+ * + * @param actions 节点过滤后的展示动作 + * @return 过滤后的展示动作 + */ + private List> filterUnsupportedActions(List> actions) { + if (this.backNodes != null && !this.backNodes.isEmpty()) { + return actions; + } + return actions.stream() + .filter(action -> !ActionType.RETURN.name().equals(action.get("type"))) + .toList(); + } + /** * 输出动作配置,并附加运行期能力标记。 * diff --git a/flow-engine-framework/src/main/java/com/codingapi/flow/service/impl/FlowDetailService.java b/flow-engine-framework/src/main/java/com/codingapi/flow/service/impl/FlowDetailService.java index 6d8a3552..10ba61c1 100644 --- a/flow-engine-framework/src/main/java/com/codingapi/flow/service/impl/FlowDetailService.java +++ b/flow-engine-framework/src/main/java/com/codingapi/flow/service/impl/FlowDetailService.java @@ -6,9 +6,11 @@ import com.codingapi.flow.form.FlowForm; import com.codingapi.flow.form.FormData; import com.codingapi.flow.node.IFlowNode; +import com.codingapi.flow.node.helper.BackNodeHelper; import com.codingapi.flow.operator.IFlowOperator; import com.codingapi.flow.pojo.request.FlowDetailRequest; import com.codingapi.flow.pojo.response.FlowContent; +import com.codingapi.flow.pojo.response.NodeOption; import com.codingapi.flow.record.FlowRecord; import com.codingapi.flow.service.FlowRecordService; import com.codingapi.flow.service.WorkflowService; @@ -145,9 +147,29 @@ private void loadCurrentNode() { this.flowContent.pushCurrentNode(this.flowSession); } + /** + * 加载可退回节点。 + * + *

候选来自当前记录真实执行过的历史记录(而不是流程定义的全量节点), + * 由 {@link BackNodeHelper#historyBackNodes} 按最近优先输出,供前端直接渲染退回候选列表。 + * 必须在 {@link #loadCurrentNode()} 之前执行:没有可退回节点时,退回按钮不会下发到展示按钮集合。

+ */ + private void loadBackNodes() { + if (this.flowRecord == null) { + this.flowContent.setBackNodes(List.of()); + return; + } + List beforeRecords = flowRecordService.findFlowRecordBeforeRecords( + this.flowRecord.getProcessId(), this.flowRecord.getId()); + List backNodes = BackNodeHelper.historyBackNodes( + this.workflow, beforeRecords, this.flowRecord.getNodeId()); + this.flowContent.setBackNodes(backNodes.stream().map(NodeOption::new).toList()); + } + public FlowContent create() { this.loadCurrentOperator(); this.loadWorkflow(); + this.loadBackNodes(); this.loadCurrentNode(); this.loadTodoFlowRecords(); this.loadHistoryRecords(); diff --git a/flow-engine-framework/src/test/java/com/codingapi/flow/service/FlowIssue270ReturnNodeControlTest.java b/flow-engine-framework/src/test/java/com/codingapi/flow/service/FlowIssue270ReturnNodeControlTest.java new file mode 100644 index 00000000..6d2f72ec --- /dev/null +++ b/flow-engine-framework/src/test/java/com/codingapi/flow/service/FlowIssue270ReturnNodeControlTest.java @@ -0,0 +1,343 @@ +package com.codingapi.flow.service; + +import com.alibaba.fastjson.JSONArray; +import com.alibaba.fastjson.JSONObject; +import com.codingapi.flow.action.ActionType; +import com.codingapi.flow.action.IFlowAction; +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.FlowException; +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.ConditionBranchNode; +import com.codingapi.flow.node.nodes.ConditionElseBranchNode; +import com.codingapi.flow.node.nodes.ConditionNode; +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.FlowDetailRequest; +import com.codingapi.flow.pojo.response.FlowContent; +import com.codingapi.flow.pojo.response.NodeOption; +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.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * issue #270 退回节点的操作控制。 + * + *

流程设计:A(开始) -> B(审批) -> C(审批) -> D(结束),B、C 均开启退回动作。 + * + *

    + *
  • 可退回节点只能来自当前记录真实执行过的历史节点,且按“最近优先”排序;
  • + *
  • 未执行过的分支节点不能作为退回目标(即使它不是当前节点的下游);
  • + *
  • 开始节点没有可退回节点,不对外展示退回动作。
  • + *
+ */ +class FlowIssue270ReturnNodeControlTest { + + private final MyFlowServiceFactory factory = new MyFlowServiceFactory(); + + /** + * 线性流程:B 节点待办只能退回 A,C 节点待办按“最近优先”返回 B、A。 + */ + @Test + void detailShouldProvideHistoryBackNodesNearestFirst() { + // given:A -> B(b1、b2 或签) -> C(c1) -> D + 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, true); + Workflow workflow = saveWorkflow(a1, startNode, bNode, cNode, EndNode.builder().build()); + Map data = data(); + + // when:流程提交到 B 节点 + startAndSubmit(workflow, startNode, a1, data); + FlowContent bDetail = detail(todoOf(b1, bNode), b1); + + // then:B 节点只能退回开始节点 + assertEquals(List.of(startNode.getId()), backNodeIds(bDetail), "B 节点只应能退回开始节点"); + + // when:b1 审批通过,流程提交到 C 节点 + pass(todoOf(b1, bNode), bNode, b1, data); + FlowContent cDetail = detail(todoOf(c1, cNode), c1); + + // then:C 节点可退回 B、A,且最近的 B 排第一,不包含当前节点与结束节点 + assertEquals(List.of(bNode.getId(), startNode.getId()), backNodeIds(cDetail), + "C 节点可退回节点应为 B、A(最近优先)"); + assertEquals(List.of("B审批", "开始节点"), backNodeNames(cDetail)); + } + + /** + * 条件分支:未执行的分支节点不能作为退回目标,也不应出现在可退回列表中。 + */ + @Test + void shouldRejectBackNodeNotExecutedInConditionBranch() { + // given:A -> B -> 条件(days<=3 走 D,否则走 E) -> F -> 结束,本次数据命中 D 分支 + User a1 = new User(1, "a1"); + User b1 = new User(2, "b1"); + User d1 = new User(3, "d1"); + User e1 = new User(4, "e1"); + User f1 = new User(5, "f1"); + registerUsers(a1, b1, d1, e1, f1); + + StartNode startNode = startNode(); + ApprovalNode bNode = approvalNode("B审批", "[2]", null, true); + ApprovalNode dNode = approvalNode("D审批", "[3]", null, true); + ApprovalNode eNode = approvalNode("E审批", "[4]", null, true); + ApprovalNode fNode = approvalNode("F审批", "[5]", null, true); + + ConditionBranchNode hitBranch = ConditionBranchNode.builder() + .name("命中分支") + .conditionScript(FlowGroovyScriptFactory.createConditionScript( + "def run(request){return request.getFormData('days') <= 3}").getKey()) + .order(1) + .blocks(dNode) + .build(); + ConditionElseBranchNode elseBranch = ConditionElseBranchNode.builder() + .name("else分支") + .order(2) + .blocks(eNode) + .build(); + ConditionNode conditionNode = ConditionNode.builder() + .name("条件控制") + .blocks(hitBranch, elseBranch) + .build(); + + Workflow workflow = saveWorkflow(a1, startNode, bNode, conditionNode, fNode, + EndNode.builder().build()); + Map data = data(); + + startAndSubmit(workflow, startNode, a1, data); + pass(todoOf(b1, bNode), bNode, b1, data); + pass(todoOf(d1, dNode), dNode, d1, data); + FlowRecord fTodo = todoOf(f1, fNode); + + // then 1:可退回节点只包含执行过的 D、B、A,未执行的 E 不在其中 + FlowContent fDetail = detail(fTodo, f1); + assertEquals(List.of("D审批", "B审批", "开始节点"), backNodeNames(fDetail), + "未执行的分支节点不应出现在可退回列表中"); + + // then 2:即使绕过前端直接指定未执行过的 E,也必须被拒绝 + assertThrows(FlowException.class, + () -> returnTo(fTodo, fNode, f1, eNode, data), + "退回到未执行过的节点必须被拒绝"); + } + + /** + * 开始节点即使被配置了退回动作,也不应对外暴露退回按钮与候选节点。 + */ + @Test + void startNodeShouldNotExposeReturnAction() { + // given:A -> B -> D,并在开始节点的流程定义 JSON 中写入 RETURN(模拟设计器按钮配置) + User a1 = new User(1, "a1"); + User b1 = new User(2, "b1"); + registerUsers(a1, b1); + + StartNode startNode = startNode(); + ApprovalNode bNode = approvalNode("B审批", "[2]", null, false); + Workflow workflow = saveWorkflow(a1, startNode, bNode, EndNode.builder().build()); + + JSONObject json = JSONObject.parseObject(workflow.toJson()); + JSONArray nodes = json.getJSONArray("nodes"); + JSONObject startJson = nodes.getJSONObject(0); + JSONObject returnAction = new JSONObject(); + returnAction.put("id", "start-return-action"); + returnAction.put("type", ActionType.RETURN.name()); + returnAction.put("title", "退回"); + returnAction.put("enable", true); + startJson.getJSONArray("actions").add(returnAction); + Workflow parsed = Workflow.formJson(json.toJSONString()); + factory.workflowService.saveWorkflow(parsed); + + // when:发起流程后停留在开始节点 + FlowRecord startTodo = create(parsed, a1, data()); + FlowContent detail = detail(startTodo, a1); + + // then 1:开始节点不展示退回动作,也没有可退回节点 + assertTrue(detail.getBackNodes() == null || detail.getBackNodes().isEmpty(), + "开始节点不应有可退回节点"); + assertFalse(detail.getActions().stream() + .anyMatch(action -> ActionType.RETURN.name().equals(action.get("type"))), + "开始节点不应下发退回按钮"); + assertFalse(parsed.getStartNode().actionManager().getActions().stream() + .noneMatch(action -> ActionType.RETURN.name().equals(action.type())), + "前置条件:开始节点确实配置了退回动作"); + + // then 2:直接调用退回接口同样被拒绝 + IFlowNode parsedStartNode = parsed.getStartNode(); + IFlowNode parsedBNode = parsed.getFlowNode(bNode.getId()); + assertThrows(FlowException.class, () -> returnTo(startTodo, parsedStartNode, a1, parsedBNode, data()), + "开始节点发起退回必须被拒绝"); + } + + // ==================== 流程装配 ==================== + + 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("issue270") + .code("issue270") + .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("issue270", "name", PermissionType.WRITE) + .addPermission("issue270", "days", PermissionType.WRITE) + .build()); + } + + private StartNode startNode() { + return StartNode.builder() + .strategies(NodeStrategyBuilder.builder() + .addStrategy(perm()) + .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("issue270") + .code("issue270") + .createdOperator(creator) + .form(form()); + for (IFlowNode node : nodes) { + builder.addNode(node); + } + Workflow workflow = builder.build(); + factory.workflowService.saveWorkflow(workflow); + return workflow; + } + + // ==================== 操作与断言 ==================== + + private FlowRecord create(Workflow workflow, User operator, Map data) { + List startActions = workflow.getStartNode().actionManager().getActions(); + FlowCreateRequest createRequest = new FlowCreateRequest(); + createRequest.setWorkCode(workflow.getCode()); + createRequest.setFormData(data); + createRequest.setActionId(startActions.get(0).id()); + createRequest.setOperatorId(operator.getUserId()); + factory.flowService.create(createRequest); + return todoOf(operator, workflow.getStartNode()); + } + + private void startAndSubmit(Workflow workflow, StartNode startNode, User user, Map data) { + create(workflow, user, data); + 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 returnTo(FlowRecord record, IFlowNode node, User operator, + IFlowNode backNode, 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(backNode.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 FlowContent detail(FlowRecord record, User operator) { + return factory.flowService.detail(new FlowDetailRequest(record.getId(), operator.getUserId())); + } + + private List backNodeIds(FlowContent detail) { + return detail.getBackNodes().stream().map(NodeOption::getId).toList(); + } + + private List backNodeNames(FlowContent detail) { + return detail.getBackNodes().stream().map(NodeOption::getName).toList(); + } + + 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); + } +}