Workflow parallel branch dynamic rejection method, device and medium

Abstract

Embodiments of the present application disclose a workflow parallel branch dynamic rejection method, device and medium. A rejection request sent by a current node is acquired; wherein the rejection request includes information of the current node and information of a rejection target node; an execution flow relationship corresponding to the current node and the rejection target node is determined based on the rejection request; wherein the execution flow relationship at least includes a same flow relationship and a parent-child flow relationship; a preset rejection node set corresponding to the current node is determined based on the execution flow relationship; information of the current node is compared with node information in the preset rejection node set, and a request pass notification is sent to the current node in a case where the target node belongs to the preset rejection node set, so that the current node rejects a to-do task to the rejection target node. The above method solves the problem of path repetition caused by rejection.

Description

Technical Field

[0001] This application relates to the field of computer technology, and in particular to a method, device and medium for dynamic rejection of parallel branching in a workflow. Background Technology

[0002] In workflow systems, rejection is an operation performed by a workflow participant on their own pending tasks, whereby the participant actively rolls back the pending task to a designated node. However, the actual application scenarios of rejection are very complex, including serial rejection, parallel rejection, rejection from within a parallel region to outside the parallel region, rejection from a branch to the main trunk, rejection from the main trunk to a branch, and rejection involving multiple aggregations.

[0003] Existing technologies for rejecting tasks in workflow systems, especially for dynamic rejection of parallel branches, often result in path duplication when retracing paths due to the large number of branches and difficulty in ensuring that the target node for rejection is within the rejection range. Summary of the Invention

[0004] This application provides a method, device, and medium for dynamic rejection of parallel branches in a workflow, which solves the following technical problem: In the prior art, when dynamically rejecting parallel branches in a workflow system, due to the large number of branches, it is difficult to ensure whether the rejection target node is within the rejection range, which often results in path duplication when retracing the path.

[0005] The embodiments of this application adopt the following technical solutions:

[0006] This application provides a method for dynamic rejection of parallel branches in a workflow. It includes: acquiring a rejection request sent by the current node; wherein the rejection request includes information about the current node and information about a target node; determining the execution flow relationship between the current node and the target node based on the rejection request; wherein the execution flow relationship includes at least a co-flow relationship and a parent-child flow relationship; determining a preset set of rejection nodes corresponding to the current node based on the execution flow relationship; comparing the information of the current node with the node information in the preset set of rejection nodes; and if the target node belongs to the preset set of rejection nodes, sending a request approval notification to the current node so that the current node rejects the pending task to the target node.

[0007] This application's embodiments introduce the concept of execution flow, limiting the rejection scope in rejection rules during process design. For example, the current node can only reject rejections to the same execution flow node or its parent execution flow node, but not to branches containing other parallel execution flows. Furthermore, in the process engine, runtime performs normalization verification on the target node for rejection based on the execution flow, checking whether the target node is within the acceptable rejection range. This dual verification at design and runtime avoids the problem of duplicate paths that might result from rejections when retracing paths.

[0008] In one implementation of this application, determining the execution flow relationship between the current node and the rejection target node based on the rejection request specifically includes: obtaining first path information corresponding to the current node and obtaining second path information corresponding to the rejection target node; wherein, both the first path information and the second path information include a parent path and / or a child path; comparing the first path information and the second path information to determine the execution flow relationship between the current node and the rejection target node.

[0009] In one implementation of this application, after determining the execution flow relationship between the current node and the target node based on the rejection request, the method further includes: if the current node and the target node do not belong to the same execution flow, determining whether the current node and the target node correspond to the same parent execution flow; if the current node and the target node do not correspond to the same parent execution flow, sending a rejection-not-allowed message.

[0010] In one implementation of this application, after the current node rejects the pending task to the rejection target node, the method further includes: when the current node and the rejection target node correspond to the same parent execution flow, performing a rejection sequence transfer to terminate one or more child execution flows corresponding to the parent execution flow.

[0011] In one implementation of this application, before obtaining the rejection request sent by the current node, the method further includes: verifying the number of parallel gateways in the process; and determining that the current process meets the conditions if it is determined whether the parallel gateways exist in pairs and the execution flow flowing out of the start node of the process is consistent with the execution flow flowing into the end node.

[0012] In one implementation of this application, before obtaining the rejection request sent by the current node, the method further includes: generating an initial execution flow based on the starting node; splitting the initial execution flow into multiple sub-execution flows based on the flow lines flowing out from a preset first parallel gateway; wherein the number of sub-execution flows is equal to the number of flow lines; and aggregating the multiple sub-execution flows into a parent execution flow based on a preset second parallel gateway.

[0013] In one implementation of this application, after determining the execution flow relationship between the current node and the rejection target node based on the rejection request, the method further includes: if the current node and the rejection target node belong to the same execution flow, directly sending a request approval notification to the current node.

[0014] In one implementation of this application, several nodes in the execution flow are each associated with a path identifier.

[0015] This application provides a workflow parallel branch dynamic rejection device, including: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, and the instructions are executed by the at least one processor to enable the at least one processor to: obtain a rejection request sent by a current node; wherein the rejection request includes information about the current node and information about a rejection target node; determine the execution flow relationship between the current node and the rejection target node based on the rejection request; wherein the execution flow relationship includes at least a co-flow relationship and a parent-child flow relationship; determine a preset set of rejection nodes corresponding to the current node based on the execution flow relationship; compare the information of the current node with the node information in the preset set of rejection nodes, and if the target node belongs to the preset set of rejection nodes, send a request pass notification to the current node so that the current node rejects the pending task to the rejection target node.

[0016] This application provides a non-volatile computer storage medium storing computer-executable instructions, which are configured to: acquire a rejection request sent by a current node; wherein the rejection request includes information about the current node and information about a rejection target node; determine the execution flow relationship between the current node and the rejection target node based on the rejection request; wherein the execution flow relationship includes at least a co-flow relationship and a parent-child flow relationship; determine a preset set of rejection nodes corresponding to the current node based on the execution flow relationship; compare the information of the current node with the node information in the preset set of rejection nodes; and if the target node belongs to the preset set of rejection nodes, send a request approval notification to the current node so that the current node rejects the pending task to the rejection target node.

[0017] The above-mentioned technical solutions adopted in the embodiments of this application can achieve the following beneficial effects: By introducing the concept of execution flow, the embodiments of this application restrict the scope of rejection in the rejection rules during process design. For example, the current node can only be rejected to the same execution flow node or the parent execution flow node, and cannot be rejected to the branch where other parallel execution flows are located. Furthermore, in the process engine, the target node of rejection is normalized and verified at runtime according to the execution flow to check whether the target node of rejection is within the scope of rejection. The dual verification at design time and runtime avoids the problem of duplicate paths when retracing paths due to rejection. Attached Figure Description

[0018] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments recorded in this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort. In the drawings:

[0019] Figure 1 A flowchart of a workflow parallel branch dynamic rejection method provided in this application embodiment;

[0020] Figure 2 A schematic diagram of a workflow parallel branch dynamic rejection method provided in an embodiment of this application;

[0021] Figure 3 A schematic diagram of the execution flow provided in an embodiment of this application;

[0022] Figure 4 A flowchart illustrating a workflow parallel branch dynamic rejection process is provided in this application embodiment;

[0023] Figure 5This is a schematic diagram of the structure of a workflow parallel branch dynamic rejection device provided in an embodiment of this application. Detailed Implementation

[0024] This application provides a method for dynamically rejecting parallel branches in a workflow. It also includes equipment and media.

[0025] To enable those skilled in the art to better understand the technical solutions in this application, the technical solutions in the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, and not all embodiments. Based on the embodiments of this specification, all other embodiments obtained by those skilled in the art without creative effort should fall within the scope of protection of this application.

[0026] In workflow systems, rejection is an operation performed by a workflow participant on their own pending tasks, whereby the participant actively rolls back the pending task to a designated node. However, the actual application scenarios of rejection are very complex, including serial rejection, parallel rejection, rejection from within a parallel region to outside the parallel region, rejection from a branch to the main trunk, rejection from the main trunk to a branch, and rejection involving multiple aggregations.

[0027] Existing technologies for rejecting tasks in workflow systems, especially for dynamic rejection of parallel branches, often result in path duplication when retracing paths due to the large number of branches and difficulty in ensuring that the target node for rejection is within the rejection range.

[0028] To address the aforementioned issues, this application provides a method for dynamically rejecting parallel branches in a workflow. By introducing the concept of execution flow, the rejection scope in the rejection rules is limited during workflow design. For example, the current node can only reject branches within the same execution flow or its parent execution flow, but not branches containing other parallel execution flows. Furthermore, in the workflow engine, the target node for rejection is normalized and validated at runtime based on the execution flow to verify whether it falls within the acceptable rejection range. This dual validation at both design and runtime avoids the problem of duplicate paths that might result from rejection during retracing.

[0029] The technical solutions proposed in the embodiments of this application will be described in detail below with reference to the accompanying drawings.

[0030] Figure 1 A flowchart illustrating a workflow parallel branch dynamic rejection method provided in this application embodiment. Figure 1 As shown, the workflow parallel branch dynamic rejection method includes the following steps:

[0031] S101. Obtain the rejection request sent by the current node. The rejection request includes information about the current node and information about the target node for rejection.

[0032] In one embodiment of this application, an initial execution flow is generated based on the starting node. The initial execution flow is then divided into multiple sub-execution flows based on the flow lines flowing out from a preset first parallel gateway, wherein the number of sub-execution flows is equal to the number of flow lines. The multiple sub-execution flows flowing into the parent execution flow are then converged based on a preset second parallel gateway. In one embodiment of this application, several nodes in the execution flow each correspond to a path identifier.

[0033] Specifically, in this embodiment of the application, a flowchart is first designed using a flowchart designer, and an execution flow attribute is assigned to each flowchart element. The execution flow includes several nodes, each with a corresponding path identifier based on its path.

[0034] Figure 2 This is a schematic diagram of a workflow parallel branch dynamic rejection method provided in an embodiment of this application. Figure 2 As shown, when a parallel gateway exists, the execution flow is split into sub-flows by the parallel gateway, and the sub-flows are then aggregated into a parent flow by the parallel gateway. Execution flow E0 is generated from the starting node. When it passes through parallel gateway 1 (splitting), it is split into new sub-execution flows (E0E1, E0E2, E0E3). When multiple sub-execution flows (E0E1, E0E2, E0E3) pass through parallel gateway 2 (aggregation), they are aggregated into a new execution flow (E0).

[0035] Figure 3 This is a schematic diagram of an execution flow provided for an embodiment of this application. For example... Figure 3 As shown, Figure 2 The flowchart in the code is drawn using execution flow. Figure 3 Nodes in Figure 2 The nodes in the process correspond to each other. Execution flow E0 is split into sub-execution flows E1, E2, and E3 through the parallel gateway. Sub-execution flows E1, E2, and E3 are then converged through the parallel gateway to form a new execution flow E0.

[0036] In one embodiment of this application, the number of parallel gateways in the process is verified through the execution flow. If it is determined whether the parallel gateways exist in pairs and the execution flow flowing out from the start node of the process is consistent with the execution flow flowing into the end node, the current process is determined to meet the conditions.

[0037] Specifically, in process design, parallel gateways should exist in pairs: one parallel gateway splits the execution flow, and the other merges it. After passing through a parallel gateway (splitting), if there are multiple outgoings, new sub-execution flows are generated (e.g., E0 splits into E0E1, E0E2, and E0E3). After passing through a parallel gateway (merging), multiple incomings should be merged into one (e.g., E0E3E4 and E0E3E5 should merge into E0E3). Parallel branches should exist in pairs. When passing through a merging parallel gateway, the parent paths of the linked lists should be checked for consistency. For example, E0E3E4 and E0E3E5 both have the parent path E0E3, so they merge into E0E3 after passing through the parallel gateway. If the two execution flows are E0E2E4 and E0E3E5, they cannot be merged because their parent paths are different (one is E0E2, the other E0E3).

[0038] Furthermore, according to the process specifications, there should only be one main execution flow (E0) from start to finish. If the execution flow flowing into the final node is not E0, the flowchart is not drawn correctly. The process designer can perform flowchart specification verification based on the execution flow, and fail to save flowcharts that do not conform to the specifications. It can also infer where the problem lies in the flowchart based on the execution flow.

[0039] In one embodiment of this application, during operation, when the current node needs to reject a pending task, it needs to send a rejection request to the server. Upon receiving the rejection request, the server obtains the information of the current node and the target node from the request. The current node's information includes its path identifier, and the target node's information includes its corresponding path identifier. Using the obtained path identifiers, the server analyzes the rejected task to determine whether it can be rejected.

[0040] S102. Determine the execution flow relationship between the current node and the target node based on the rejection request. The execution flow relationship includes at least co-flow relationship and parent-child flow relationship.

[0041] In one embodiment of this application, first path information corresponding to the current node and second path information corresponding to the rejection target node are obtained, wherein both the first path information and the second path information include a parent path and / or a child path. The first path information and the second path information are compared to determine the execution flow relationship between the current node and the rejection target node.

[0042] Specifically, in the process design, this application's embodiments restrict the scope of rejection in the rejection rules. For example, the current node can only be rejected to the same execution flow node or the parent execution flow node, but cannot be rejected to the branch where other parallel execution flows are located. Furthermore, in the process engine, the runtime performs normalized verification on the target node of rejection based on the execution flow to check whether the target node of rejection is within the scope of rejection.

[0043] Furthermore, the first path information corresponding to the current node is compared with the second path information corresponding to the rejection target node to determine whether the rejection target node and the current node belong to the same execution flow, or whether the rejection target node is the parent execution flow node of the current node.

[0044] S103. Based on the execution flow relationship, determine the set of preset rejection nodes corresponding to the current node.

[0045] In one embodiment of this application, if the current node and the rejection target node do not belong to the same execution flow, it is determined whether the current node and the rejection target node correspond to the same parent execution flow. If the current node and the rejection target node do not correspond to the same parent execution flow, a rejection denial message is sent.

[0046] Specifically, based on the received rejection request, the server determines the execution flow relationship between the current node and the rejection target node. If the current node and the rejection target node do not belong to the same execution flow, the server determines whether the current node and the rejection target node correspond to the same parent execution flow. If the current node and the rejection target node do not correspond to the same parent execution flow, it means that the current rejection target node does not meet the rejection scope. In this case, a rejection-disallowed message is sent to the current node.

[0047] Specifically, when the current node and the target node belong to the same execution flow, or when the current node and the target node correspond to the same parent execution flow, a preset set of rejection nodes corresponding to the current node is determined. The target node is then compared with this preset set to determine if it is within the set. If the target node is in the preset set, it is within the rejection scope, and the rejection task can be performed. If the target node is not in the preset set, it is outside the rejection scope, and the rejection task cannot be performed.

[0048] S104. Compare the information of the current node with the node information in the preset rejection node set. If the target node belongs to the preset rejection node set, send a request to pass notification to the current node so that the current node rejects the pending task to the rejection target node.

[0049] In one embodiment of this application, when the current node and the rejection target node belong to the same parent execution flow, a rejection sequence is executed, terminating one or more child execution flows corresponding to the parent execution flow. In another embodiment of this application, when the current node and the rejection target node belong to the same execution flow, a request approval notification is directly sent to the current node.

[0050] Specifically, this application embodiment pre-sets rejection rules, that is, pre-sets a set of rejection nodes corresponding to each node. Rejection redirects should all occur within the same stream; sub-streams can reject back to the parent stream, but the parent stream cannot reject back to the sub-stream (however, rejection back to a parallel gateway on the parent stream can be considered). Figure 2 For example:

[0051] For example, in the case of approval activity LL, the scope of rejection should be approval activities AA, DD, EE, and MM.

[0052] For example, in approval activity II: the scope of his rejection should be approval activity AA, approval activity DD, approval activity EE, approval activity HH, and approval activity MM.

[0053] Furthermore, the execution flow for rejection differs, and the specific implementation of the process engine also differs. For example... Figure 2 For example:

[0054] Rejection Scenario 1: If an approval activity II is rejected, the rejection and redirection within the same flow as approval activity HH are unrestricted;

[0055] Rejection Scenario 2: If the rejection is approved sequentially, the parent flow E0E3 needs to be terminated (e.g., flow E0E3E5);

[0056] Rejection Scenario 3: Rejection from Approval Activity II to a different flow within Approval Activity AA (e.g., rejection from a child flow to a parent flow). It is necessary to review the rejection rules, namely:

[0057] 1. If a resubmission to this node is rejected, the parent flow E0E3 does not need to be terminated;

[0058] 2. If the approval order is rejected, E0E3E4 should be identified as the rejection path and returned to flow E0. Flows with parent flow E0 need to be terminated, such as E0E1, E0E2, E0E3, and E0E3E5.

[0059] Figure 4 This application provides a flowchart of a workflow parallel branch dynamic rejection process. For example... Figure 4As shown, upon receiving a rejection request from the current node, it is determined whether the current node and the target rejection node belong to the same execution flow. If they belong to the same execution flow, other parallel flows are not interfered with. If the current node and the target rejection node do not belong to the same execution flow, it is necessary to determine whether the current node and the target rejection node correspond to the same parent execution flow. If they correspond to the same parent execution flow, the request is resubmitted to this node without interfering with other parallel flows. Simultaneously, sequential flow is performed, terminating other child execution flows of the parent execution flow. If the current node and the target rejection node do not correspond to the same parent execution flow, a prompt is displayed, disallowing rejection.

[0060] Figure 5 This is a schematic diagram of a workflow parallel branch dynamic rejection device provided in an embodiment of this application. Figure 5 As shown, the workflow parallel branch dynamic rejection device includes:

[0061] At least one processor; and,

[0062] A memory communicatively connected to the at least one processor; wherein,

[0063] The memory stores instructions executable by the at least one processor, which, when executed by the at least one processor, enable the at least one processor to:

[0064] Obtain the rejection request sent by the current node; wherein the rejection request includes information about the current node and information about the target node for rejection;

[0065] The execution flow relationship between the current node and the target node of the rejection is determined based on the rejection request; wherein, the execution flow relationship includes at least a co-flow relationship and a parent-child flow relationship;

[0066] Based on the execution flow relationship, determine the set of preset rejection nodes corresponding to the current node;

[0067] The information of the current node is compared with the node information in the preset rejection node set. If the target node belongs to the preset rejection node set, a request pass notification is sent to the current node so that the current node rejects the pending task to the rejection target node.

[0068] This application embodiment also provides a non-volatile computer storage medium storing computer-executable instructions, wherein the computer-executable instructions are configured as follows:

[0069] Obtain the rejection request sent by the current node; wherein the rejection request includes information about the current node and information about the target node for rejection;

[0070] The execution flow relationship between the current node and the target node of the rejection is determined based on the rejection request; wherein, the execution flow relationship includes at least a co-flow relationship and a parent-child flow relationship;

[0071] Based on the execution flow relationship, determine the set of preset rejection nodes corresponding to the current node;

[0072] The information of the current node is compared with the node information in the preset rejection node set. If the target node belongs to the preset rejection node set, a request pass notification is sent to the current node so that the current node rejects the pending task to the rejection target node.

[0073] The various embodiments in this application are described in a progressive manner. Similar or identical parts between embodiments can be referred to mutually. Each embodiment focuses on describing the differences from other embodiments. In particular, the embodiments of apparatus, devices, and non-volatile computer storage media are basically similar to the method embodiments, so the descriptions are relatively simple; relevant parts can be referred to the descriptions of the method embodiments.

[0074] The foregoing has described specific embodiments of this application. Other embodiments are within the scope of the appended claims. In some cases, the actions or steps recited in the claims may be performed in a different order than that shown in the embodiments and may still achieve the desired results. Furthermore, the processes depicted in the drawings do not necessarily require the specific or sequential order shown to achieve the desired results. In some embodiments, multitasking and parallel processing are also possible or may be advantageous.

[0075] The above description is merely an embodiment of this application and is not intended to limit this application. For those skilled in the art, various modifications and variations can be made to the embodiments of this application. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principle of the embodiments of this application should be included within the scope of the claims of this application.

Claims

1. A workflow parallel branch dynamic rejection method, characterized in that, The method includes: Obtain the rejection request sent by the current node; wherein the rejection request includes information about the current node and information about the target node for rejection; The execution flow relationship between the current node and the target node of the rejection is determined based on the rejection request; wherein, the execution flow relationship includes at least a co-flow relationship and a parent-child flow relationship; Based on the execution flow relationship, determine the set of preset rejection nodes corresponding to the current node; The information of the current node is compared with the node information in the preset rejection node set. If the rejection target node belongs to the preset rejection node set, a request pass notification is sent to the current node so that the current node rejects the pending task to the rejection target node. After determining the execution flow relationship between the current node and the target node based on the rejection request, the method further includes: If the current node and the rejection target node do not belong to the same execution flow, determine whether the current node and the rejection target node correspond to the same parent execution flow; If the current node and the rejection target node do not correspond to the same parent execution flow, a rejection disallowment message is sent. After the current node rejects the pending task to the rejection target node, the method further includes: If the current node and the rejection target node correspond to the same parent execution flow, the rejection sequence will be transferred, and one or more child execution flows corresponding to the parent execution flow will be terminated. Before obtaining the rejection request sent by the current node, the method further includes: Perform parallel gateway count verification on the process; If it is determined that the parallel gateways exist in pairs, and the execution flow flowing out of the start node of the process is consistent with the execution flow flowing into the end node, then the current process is determined to meet the conditions. Before obtaining the rejection request sent by the current node, the method further includes: Generate an initial execution flow based on the start node; The initial execution flow is divided into multiple sub-execution flows based on the flow lines output from the pre-set first parallel gateway; wherein the number of sub-execution flows is equal to the number of flow lines. Multiple incoming sub-execution flows are aggregated into a parent execution flow based on a pre-configured second parallel gateway; Determining the execution flow relationship between the current node and the target node based on the rejection request specifically includes: Obtain the first path information corresponding to the current node, and Obtain the second path information corresponding to the rejection target node; wherein, both the first path information and the second path information include a parent path and / or a child path; The first path information is compared with the second path information to determine the execution flow relationship between the current node and the rejection target node; After determining the execution flow relationship between the current node and the target node based on the rejection request, the method further includes: If the current node and the rejection target node belong to the same execution flow, a request approval notification is sent directly to the current node; Each of the nodes in the execution flow has a corresponding path identifier.

2. A workflow parallel branch dynamic rejection device, comprising: At least one processor; as well as, A memory communicatively connected to the at least one processor; wherein, The memory stores instructions executable by the at least one processor, which, when executed by the at least one processor, enable the at least one processor to: Obtain the rejection request sent by the current node; wherein the rejection request includes information about the current node and information about the target node for rejection; The execution flow relationship between the current node and the target node of the rejection is determined based on the rejection request; wherein, the execution flow relationship includes at least a co-flow relationship and a parent-child flow relationship; Based on the execution flow relationship, determine the set of preset rejection nodes corresponding to the current node; The information of the current node is compared with the node information in the preset rejection node set. If the rejection target node belongs to the preset rejection node set, a request pass notification is sent to the current node so that the current node rejects the pending task to the rejection target node. After determining the execution flow relationship between the current node and the target node based on the rejection request, the method further includes: If the current node and the rejection target node do not belong to the same execution flow, determine whether the current node and the rejection target node correspond to the same parent execution flow; If the current node and the rejection target node do not correspond to the same parent execution flow, a rejection disallowment message is sent. After the current node rejects the pending task to the rejection target node, the method further includes: If the current node and the rejection target node correspond to the same parent execution flow, the rejection sequence will be transferred, and one or more child execution flows corresponding to the parent execution flow will be terminated. Before obtaining the rejection request sent by the current node, the process also includes: Perform parallel gateway count verification on the process; If it is determined that the parallel gateways exist in pairs, and the execution flow flowing out of the start node of the process is consistent with the execution flow flowing into the end node, then the current process is determined to meet the conditions. Before obtaining the rejection request sent by the current node, the process also includes: Generate an initial execution flow based on the start node; The initial execution flow is divided into multiple sub-execution flows based on the flow lines output from the pre-set first parallel gateway; wherein the number of sub-execution flows is equal to the number of flow lines. Multiple incoming sub-execution flows are aggregated into a parent execution flow based on a pre-configured second parallel gateway; Determining the execution flow relationship between the current node and the target node based on the rejection request specifically includes: Obtain the first path information corresponding to the current node, and Obtain the second path information corresponding to the rejection target node; wherein, both the first path information and the second path information include a parent path and / or a child path; The first path information is compared with the second path information to determine the execution flow relationship between the current node and the rejection target node; After determining the execution flow relationship between the current node and the target node based on the rejection request, the method further includes: If the current node and the rejection target node belong to the same execution flow, a request approval notification is sent directly to the current node; Each of the nodes in the execution flow has a corresponding path identifier.

3. A non-volatile computer storage medium storing computer-executable instructions, wherein the computer... Executable instructions are set as follows: Retrieve the rejection requests sent by the current node; where, The rejection request includes information about the current node and information about the target node to be rejected. The execution flow relationship between the current node and the target node of the rejection is determined based on the rejection request; wherein, the execution flow relationship includes at least a co-flow relationship and a parent-child flow relationship; Based on the execution flow relationship, determine the set of preset rejection nodes corresponding to the current node; The information of the current node is compared with the node information in the preset rejection node set. If the rejection target node belongs to the preset rejection node set, a request pass notification is sent to the current node so that the current node rejects the pending task to the rejection target node. After determining the execution flow relationship between the current node and the target node based on the rejection request, the method further includes: If the current node and the rejection target node do not belong to the same execution flow, determine whether the current node and the rejection target node correspond to the same parent execution flow; If the current node and the rejection target node do not correspond to the same parent execution flow, a rejection disallowment message is sent. After the current node rejects the pending task to the rejection target node, the method further includes: If the current node and the rejection target node correspond to the same parent execution flow, the rejection sequence will be transferred, and one or more child execution flows corresponding to the parent execution flow will be terminated. Before obtaining the rejection request sent by the current node, the process also includes: Perform parallel gateway count verification on the process; If it is determined that the parallel gateways exist in pairs, and the execution flow flowing out of the start node of the process is consistent with the execution flow flowing into the end node, then the current process is determined to meet the conditions. Before obtaining the rejection request sent by the current node, the process also includes: Generate an initial execution flow based on the start node; The initial execution flow is divided into multiple sub-execution flows based on the flow lines output from the pre-set first parallel gateway; wherein the number of sub-execution flows is equal to the number of flow lines. Multiple incoming sub-execution flows are aggregated into a parent execution flow based on a pre-configured second parallel gateway; Determining the execution flow relationship between the current node and the target node based on the rejection request specifically includes: Obtain the first path information corresponding to the current node, and Obtain the second path information corresponding to the rejection target node; wherein, both the first path information and the second path information include a parent path and / or a child path; The first path information is compared with the second path information to determine the execution flow relationship between the current node and the rejection target node; After determining the execution flow relationship between the current node and the target node based on the rejection request, the method further includes: If the current node and the rejection target node belong to the same execution flow, a request approval notification is sent directly to the current node; Each of the nodes in the execution flow has a corresponding path identifier.

Images