An order state linkage method for business whole-process traceability

Abstract

The application discloses a kind of order state linkage methods for business whole-process traceability, specifically relates to order workflow management field, including obtaining the order of sales transaction, process rule and task receipt, according to order item unit split pending fulfillment quantity as fulfillment unit, make task input site connect task output site according to process rule and write into knowledge graph, form order process graph for workflow management;After order content changes, locate fulfillment unit according to content before change, when there is task receipt, establish the receipt bypass of process starting point direct task output site, when there is no task receipt, keep original path, form change determination graph;By splitting order item into fulfillment unit, according to task receipt, identify executed part and unexecuted part, and keep original task relationship or rebuild task relationship after change respectively, so that order content change can be used in corresponding fulfillment unit according to actual receiving condition.

Description

Technical Field

[0001] This invention relates to the field of order workflow management technology, and more specifically, to a method for linking order status for full-process traceability in business operations. Background Technology

[0002] Existing order management systems typically employ a master order table, status fields, process nodes, and message passing mechanisms to synchronize status across sales, warehousing, logistics, settlement, and after-sales processes. When order details change, the system usually updates the order version, rewrites the master order table, or reissues the process task, allowing subsequent processes to read the updated order details. In the business of fulfilling multiple goods and multiple warehouses in batches, the same order may simultaneously include goods that have been shipped, goods that are being picked, and goods that have not yet been assigned to a warehouse. If the delivery address, quantity of goods, or delivery method changes, the changes can only apply to the part that has not yet entered actual fulfillment. The part that has already been received by the warehousing, transportation, or settlement process must still follow the original execution basis. If the entire order is switched to the changed content, tasks that have been completed or are being executed may be reinterpreted, resulting in situations such as duplicate deductions of picked items, re-delivery of packages that have already been formed, and packages at the original address being associated with a new address. If the subsequent process is still driven by the original order content, tasks that have not yet been executed cannot be rearranged according to the changed content. The reason for the above situation is that the existing processing method mainly uses order records or process nodes as the object of change, and lacks a processing mechanism to distinguish the scope of change based on whether the order content has been received by downstream business actions. The technical problem this application aims to solve is: how to determine the different scopes of influence of order changes on executed and unexecuted parts based on the actual receipt of business obligations corresponding to the order content, and thereby achieve status linkage throughout the entire order process. Summary of the Invention

[0003] To overcome the aforementioned deficiencies of the prior art, embodiments of the present invention provide an order status linkage method for full-process traceability of business. By splitting order items into fulfillment units, identifying executed and unexecuted parts based on task receipts, and retaining the original task relationships or reconstructing the changed task relationships respectively, changes to order content can be applied to the corresponding fulfillment units according to the actual receipt situation, thereby solving the problems mentioned in the background art.

[0004] To achieve the above objectives, the present invention provides the following technical solution: a method for order status linkage with full business process traceability, comprising: S1. Obtain the sales transaction orders, process rules, and task receipts. Break down the quantity to be fulfilled into fulfillment units according to the order item. Connect the task input positions to the task output positions according to the process rules and write them into the knowledge graph to form an order process graph for workflow management. S2. After the order content is changed, the fulfillment unit is located according to the content before the change. When there is a task receipt, a receipt bypass is established from the starting point of the process to the task output position. When there is no task receipt, the original path is retained, forming a change judgment diagram. S3. Execute the Rengeltajan dominance tree algorithm with the process starting point as the root node. Number the nodes in depth first, reverse the order along the predecessor and disjoint set parent chain to find the semi-dominant points and backfill the direct dominant points. Write the execution units whose task input and task output are both dominated by the previous content version node into the migration set, and write the execution units whose only task input is dominated into the retention set. S4. Based on the migration set, obtain candidate tasks for the changed content version node, form a receiving vector with the fulfillment unit allocation amount, and execute the Dijkstra alternating projection algorithm. In each round, add back the difference from the previous round, set the content mismatch coordinates to zero, correct the unfixed coordinates according to the migration amount, coordinates and differences, and correct the receiving amount according to the task priority amount and task surplus amount until the receiving vectors of two adjacent rounds are consistent, and obtain the changed receiving relationship. S5. Rewrite the order process graph according to the changed acceptance relationship. After the task output position of the retained set, generate a correction task to receive the processed fulfillment unit. Subtract the task receipt quantity from the task acceptance quantity to obtain the incomplete quantity. Update the task status and order status. Write the order change record to the traceability edge of the order status to obtain the order status linkage result.

[0005] In a preferred embodiment, S1 includes: S11. Collect the order quantity and task receipt quantity of sales transactions according to the order item identifier. Deduct the task receipt quantity from the order quantity one by one according to the execution batch and receipt order. Split the quantity after deduction according to the order item unit of measurement and generate the fulfillment unit by connecting the unit order with the order item identifier. The task receipt quantity refers to the number of processed order items recorded in the task receipt according to the order item identifier and execution batch. Each task receipt quantity corresponds to one task execution result, and the receipt order is determined according to the order in which the receipts are written. Unit priority refers to the incremental sequence number obtained by each fulfillment unit according to the order of the division after the quantity to be fulfilled of the same order item is divided by the unit of measurement. The unit priority is not repeated within the same order item. S12. Based on the process rules, each task is expanded into task input positions and task output positions, so that the task input positions are connected to the task output positions of the same task, and then the task output positions and the task input positions are connected according to the correspondence between the output fields of the previous task and the input fields of the next task, forming a task succession chain. Among them, process rules refer to rule records used to limit the writing relationship between the output field of the previous task and the input field of the next task, as well as the order of task execution. When the output field of the previous task corresponds to the input field of the next task, a succession relationship is established between the two tasks. S13. Connect order item nodes with order nodes, and then connect fulfillment units through order content version nodes. Write the fulfillment units into the task acceptance chain, and connect the corresponding task output positions one by one from the fulfillment units with the first unit in the unit order according to the number of task receipts. Connect the remaining fulfillment units to the corresponding task input positions to obtain the order flow diagram for workflow management. The order node is used to identify a sales order, the order item node is used to identify a transaction in the sales order, and the order node is connected to the corresponding order item node according to the order number; Order content version nodes are version nodes established according to the generation order of order content. Each order content version node stores the generated or modified order item content once and connects it between the corresponding order item node and the fulfillment unit.

[0006] In a preferred embodiment, S2 includes: S21. Read the order item identifier and the previous version number in the order change record, locate the previous content version node in the order flow diagram, and then obtain the affected performance unit along the connection edge between the previous content version node and the performance unit to form a change unit set. The order change record refers to the record generated when the order content is modified. It includes at least the order item identifier, the version number before the change, the version number after the change, the changed fields, and the changed values, which are used to determine the object of the change and the correspondence between the content before and after the change. The previous version number refers to the version number of the order content that took effect before the order change occurred. It is used to uniquely locate the previous version node of the original order content in the order flowchart. S22. Read the task receipts corresponding to the change unit set according to the execution batch and receipt sequence. Starting from the execution unit with the first unit sequence, deduct the task receipt quantity one by one. Connect the execution unit that has been deducted to the corresponding task output position and connect the execution unit that has not been deducted to the corresponding task input position to form the receipt boundary relationship.

[0007] In a preferred embodiment, S2 further includes: S23. For execution units that connect to task output positions, establish an acknowledgment bypass from the process start point to the corresponding task output position, and delete the connection from the previous content version node to the task output position via the corresponding task input position; for execution units that connect to task input positions, retain the original path from the previous content version node to the task output position via the task input position, forming a set of changed paths. The starting point of the process refers to the root node in the order process graph that does not have a predecessor task and is used to initiate the order task. Only one starting point is set for the same order process graph. S24. Using the process start point as the sole entry point, write the previous content version node, change path set, and corresponding task acceptance relationship into the directed graph, and delete the nodes and connecting edges that cannot be reached from the process start point to obtain the change decision graph for workflow analysis.

[0008] In a preferred embodiment, S3 includes: S31. Based on the change decision diagram, a real-world diagram and a comparison diagram are created. The receipt bypass is retained in the real-world diagram, and the receipt bypass is deleted in the comparison diagram while retaining the remaining connection relationships, thus forming a workflow path from the process start point to the task input position and the task output position, respectively. S32. Using the starting point of the process as the root node, execute the Lengeltajan dominance tree algorithm on the actual graph and the reference graph respectively. Mark the nodes according to the depth-first order, read the predecessor of the node in reverse order and obtain the predecessor node with the semi-dominance order along the disjoint set parent chain. Then, fill the direct dominance node according to the semi-dominance node and the depth-first parent node to form the actual dominance tree and the reference dominance tree. The process of executing the Rengeltajan dominating tree algorithm is as follows: Starting from the flow start point, perform a depth-first traversal and record the depth-first order and depth-first parent node of each node. Then, process the nodes except the flow start point in reverse order according to the depth-first order. For the current node, read the predecessor of each node one by one. If the predecessor order is earlier than the current node, directly read the predecessor order. If the predecessor order is later than the current node, read the semi-dominant order of the disjoint-set data structure (DFT) tag node along the parent chain of the DFT. Write the first order of the read order as the semi-dominant order of the current node. Then, write the current node into the temporary table corresponding to the semi-dominant node. Connect the current node and the depth-first parent node to the same DFT and read the nodes in the temporary table of the depth-first parent node. Determine the candidate direct dominating node of each node according to the semi-dominant order of the disjoint-set tag node. After all nodes have been reversed, correct the candidate direct dominating node according to the depth-first order. If the candidate direct dominating node is different from the semi-dominant node, replace the current candidate direct dominating node with the direct dominating node of the candidate direct dominating node to form the actual dominating tree and the control dominating tree. Depth-first traversal refers to starting from the beginning of the process, proceeding along the unread edges of the current node to the next node, and returning to the previous node to continue reading the remaining edges when there are no unread edges in the next node. When each node is first reached, an incrementing depth-first traversal order is written. A node predecessor is a node in the change decision graph that points directly to the current node via a directed edge. The parent chain of a disjoint set refers to the node chain formed by sequentially moving from the current node to the root node of the disjoint set after a node is added to the disjoint set. The disjoint set label records the node that is first in the semi-dominant order in the parent chain. Semi-dominant order refers to the depth-first order obtained after directly reading or reading the labels of the predecessors of each node in the disjoint-set data structure; a semi-dominant node is a node that has this semi-dominant order. The parent node refers to the node preceding the current node when it is first entered during the depth-first traversal, and is used to form a depth-first tree with the starting point of the process as the root node.

[0009] In a preferred embodiment, S3 further includes: S33. For each execution unit, read the control results of the content version node before the change on the task input position and task output position in the actual control tree and the comparison control tree respectively. Then delete the content version node before the change from the actual diagram and search the remaining path from the process start point to the task output position. Then delete the receipt bypass corresponding to the current execution unit and search the remaining path again to form a control difference record and bypass source record. S34. When both the task input and task output are dominated by the pre-change content version node in both dominating trees, write the corresponding fulfillment unit into the migration set. When the task input is dominated by both dominating trees, the task output is dominated only in the reference dominating tree, and the process start point cannot bypass the pre-change content version node to reach the task output after deleting the receipt bypass, write the corresponding fulfillment unit into the retention set. For fulfillment units that are not written into the migration set or retention set, check the receipt bypass according to the order item identifier, execution batch, and unit sequence. Retain the receipt bypass with consistent fields and delete the remaining receipt bypasses. Then repeat S31 to S33 until each fulfillment unit is written into the migration set or retention set.

[0010] In a preferred embodiment, S4 includes: S41. Traverse the task acceptance edges along the knowledge graph from the changed content version node, form acceptance coordinates for each task in the migration set that is consistent with the order item field of each execution unit, arrange the acceptance coordinates according to the task order and unit order, and deduct the reserved set occupancy from the task quota to obtain the candidate task table and the task surplus table. The task-receiving edge refers to the directed edge in the knowledge graph that points from the output of the previous task to the input of the next task. It is used to record the task execution order determined by the process rules and the transmission direction of the execution unit between adjacent tasks. The task quota refers to the total number of execution units received by the task record for a given execution batch. The task quota is obtained by adding the number of processing stations corresponding to the task to the number of execution units allocated to each processing station within the execution batch. The occupancy of the reserved set refers to the number of execution units in the reserved set that have been connected to the input or output bits of the current task. The same execution unit is counted only once in the current task. S42. Establish a receiving vector based on the allocation of each performance unit on the candidate task, fix the coordinates of inconsistent content versions to zero, and then perform truncated simplex projection on the corresponding coordinates of the same performance unit to make each coordinate non-negative and the sum of the coordinates equal to one. Then, generate the content difference vector and the unit difference vector by subtracting the vector after projection from the vector before projection. The allocation value refers to the coordinate value of a performance unit assigned to a candidate task. A coordinate value of one indicates that the performance unit is received by the corresponding candidate task, and a coordinate value of zero indicates that the corresponding candidate task does not receive the performance unit. The coordinate values ​​between zero and one during the projection are used to determine the allocation order of the candidate tasks. The process of performing truncated simplex projection is as follows: arrange the coordinates corresponding to the same execution unit in descending order of coordinate values, expand the sorting prefix item by item starting from the first coordinate, and obtain the offset by subtracting one from the current prefix coordinates and dividing by the number of prefix items. Keep the prefix where the last item minus the offset is positive and the next item minus the offset is not positive. Then subtract the offset from each coordinate value and rewrite the negative value to zero, so that the coordinates after projection are non-negative and the coordinate sum is one.

[0011] In a preferred embodiment, S4 further includes: S43. Add the previous projection results back to the task order difference vector and the task surplus difference vector in sequence. Perform adjacent disorder merging on the cumulative task acceptance along the task acceptance edge so that the cumulative acceptance of the later task does not exceed the cumulative output of the previous task. Then, deduct the difference between the task coordinates and the excess of the task surplus according to the proportion of each positive coordinate. Update the corresponding difference vector with the vector difference before and after each projection. Perform Dijkstra alternating projection in the order of content consistency, unit affiliation, task order and task surplus until the acceptance vectors before and after one round of projection are the same, and obtain the projection acceptance vector. The task sequence difference vector refers to the coordinate difference between the vector before and after the projection of the task sequence relationship, which is used to restore the difference that was rewritten by other projections in the previous round before the next round of task sequence relationship projection; the task surplus difference vector refers to the coordinate difference between the vector before and after the projection of the task surplus, which is used to restore the difference that was rewritten by other projections in the previous round before the next round of task surplus projection. The cumulative task acceptance volume refers to the sum of the execution unit coordinate values ​​of the tasks assigned to the current task and all tasks preceding the current task when reading from the starting point of the process according to the task sequence; the cumulative output volume of the previous tasks refers to the sum of the completed amount of the previous tasks and the execution unit coordinate values ​​of the tasks assigned to the previous tasks that have not yet generated task receipts. The process of merging adjacent out-of-order tasks is as follows: Read adjacent tasks according to their order. When the cumulative amount of tasks undertaken by a subsequent task exceeds the cumulative amount of tasks output by a preceding task, merge the coordinates of the subsequent task that exceeded the limit with the corresponding coordinates of the preceding task into a coordinate group. Divide the sum of the coordinate values ​​in the coordinate group by the number of coordinates to obtain the group value, and replace each coordinate in the coordinate group with the group value. After replacement, continue reading adjacent coordinate groups forward until the cumulative amount of tasks undertaken by a subsequent task does not exceed the cumulative amount of tasks output by a preceding task. Task coordinates refer to the position in the receiving vector that is determined by an execution unit identifier and a candidate task identifier. The numerical value of the task coordinates records the allocation amount from the corresponding execution unit to the corresponding candidate task. The process of performing Dijkstra alternating projection is as follows: Constraint sets are read in the order of content consistency, unit affiliation, task sequence, and task surplus; each time a constraint set is read, the current receiving vector is first added to the corresponding difference vector coordinate by coordinate, then projection is performed according to the current constraint set, the corresponding difference vector is updated by subtracting the projection result from the added vector, and the projection result is passed to the next constraint set; after completing four constraint sets, a round of receiving vectors is formed, and the process stops when the current round of receiving vectors is the same as the previous round of receiving vectors coordinate by coordinate, and the projected receiving vector is output; S44. Read the candidate tasks corresponding to the execution unit in descending order of the coordinate values ​​of the projection receiving vector. Fix the coordinate of the first execution unit that still has task leeway and whose output of the previous task has covered the corresponding execution unit to one. Fix the remaining coordinates of the same execution unit to zero. After deducting the task leeway, repeat S42 to S43 for the unfixed coordinates until each execution unit has only one coordinate with a value of one. Then write the coordinate correspondence into the knowledge graph to obtain the changed receiving relationship.

[0012] In a preferred embodiment, S5 includes: S51. Based on the order change sequence of the order change record, the original task acceptance edge in the order flow chart is transferred to the historical edge, the current task acceptance edge corresponding to the migration set is deleted, and the changed acceptance relationship is written between the execution unit and the task input position to form the changed task chain. S52. For the fulfillment unit in the retention set, a correction task is created after the corresponding task output position. The content version before the change and the content version after the change are compared sequentially along the order item fields. The original value is used in the position where the field value is consistent and the changed value is written in the position where the field value is inconsistent. Then the correction task output position is connected to the subsequent task input position to form a correction task chain.

[0013] In a preferred embodiment, S5 further includes: S53. Read the changed task chain and the corrected task chain according to the task order. The first task receipt with the same order item identifier, execution batch and receipt order is used for accounting. Subtract the corresponding task receipt quantity from the task acceptance quantity to get the unfinished quantity. When the task receipt quantity exceeds the task acceptance quantity, only the task acceptance quantity is used for subtraction and the excess part is written into the receipt conflict record to get the task surplus table. S54. According to the task remaining quantity table, write the task with zero unfinished quantity as completed and the task with non-zero unfinished quantity as executed. Read the first task with non-zero unfinished quantity according to the task order and write the corresponding task status as the order status. When the unfinished quantity of all tasks is zero, write the order as completed. Then write the traceability edge along the order change record, fulfillment unit, task receipt, task status and order status to obtain the order status linkage result.

[0014] The technical effects and advantages of this invention are as follows: This solution divides the order into a retainer set and a migration set by using task receipts, so that order changes apply to the executed and unexecuted parts respectively, reducing duplicate processing and the continuation of old content; The order items are broken down into fulfillment units, and the processing position is recorded according to the task instance, so that batch fulfillment, partial completion and pending content can be accounted for separately; Perform dominance calculations on the live chart and the comparison chart to determine the actual impact of order changes and reduce the synchronous migration or rollback of irrelevant tasks. Under the constraints of content consistency, task order, unit affiliation and task margin, the migration execution units are rearranged to reduce task conflicts and capacity overrun. By preserving the process relationships before and after changes through historical edges, current edges, and correction tasks, the order status can be traced back to the fulfillment unit and task receipt. Attached Figure Description

[0015] Figure 1 This is a flowchart illustrating the order status linkage process of the present invention. Detailed Implementation

[0016] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0017] Refer to the instruction manual appendix Figure 1 The present invention provides a method for linking order status for full-process traceability in business operations, comprising: S1. Obtain the sales transaction orders, process rules, and task receipts. Break down the quantity to be fulfilled into fulfillment units according to the order item. Connect the task input positions to the task output positions according to the process rules and write them into the knowledge graph to form an order process graph for workflow management. When sales orders flow between multiple tasks, it is necessary to first standardize the calculation methods for order quantity, fulfillment unit, and task receipt, and then write the current position of each fulfillment unit in the task chain into a knowledge graph so that the affected fulfillment unit can be accurately located after the order content changes. This implementation method includes the following: Once a sales order is processed, the order number, order item identifier, order quantity, and order item unit of measurement are read, and fulfillment units are generated sequentially according to the complete order quantity. If the order quantity cannot be divided by the order item unit of measurement, the remaining quantity is generated separately as a tail fulfillment unit, and the actual measurement quantity of the tail fulfillment unit is written into it. Subsequently, in S11, the fulfillment unit number is generated based on the order item identifier and unit priority. Then, the task receipts are collected according to the order item identifier, task instance number, and execution batch, and duplicate records are excluded by the task receipt number. The incremental task receipts are accumulated according to the receipt priority, and the cumulative task receipts are read to read the number of task receipts with the later receipt priority. Each task instance creates a copy of the order volume, and marks the processed intervals starting from the first fulfillment unit in the unit priority according to the number of valid task receipts. The remaining fulfillment units form the unprocessed intervals. When the number of task receipts exceeds the effective output of the preceding task, the excess will be written into the receipt conflict record. When the preceding task lacks a valid task receipt, the subsequent task receipt will not advance to the execution unit position, and finally the execution unit table and task processing interval table will be formed. During the unfolding of process relationships, the rule version, previous task number, previous task output field, subsequent task number, subsequent task input field, and task sequence in the process rules are read, and task instances are generated according to the task number and execution batch. When processing up to S12, task input bits and task output bits are established for each combination of execution unit and task instance, so that the task input bits are connected to the task output bits of the same combination. Then, when the previous task output field and the subsequent task input field correspond to each other, the previous task output bit is connected to the subsequent task input bit. When a task is connected to multiple subsequent tasks, the subsequent task is selected based on the branch field value in the order content version; when multiple preceding tasks are merged into the same subsequent task, the execution unit is allowed to enter the subsequent task input position only after all preceding tasks listed in the process rules have generated valid task receipts; rework tasks and reprocessing tasks generate task instances according to the new execution batch. When output fields are missing, field types are inconsistent, or rule versions are invalid, task connections are not established, and process rule conflict records are written, thus forming a task succession chain isolated by execution unit. The graph writing stage uses a unique number to maintain the correspondence between order objects, content versions and task locations. In S13, an order node is established according to the order number, an order item node is established according to the order number and the order item identifier, and then an order content version node is established according to the order item identifier and the content version number. This allows the process start point to connect the order node, the order item node and the currently effective order content version node in sequence, and the order content version node is connected to the corresponding execution unit. After reading the task processing interval table, the execution units in the processed interval are connected to the corresponding task output position, and the execution units in the unprocessed interval are connected to the corresponding task input position; when the same execution unit passes through multiple tasks, only the current valid task position is retained, and historical task receipts are saved through traceback edges. Each of the following nodes—order node, order item node, order content version node, fulfillment unit, task instance, task input position, task output position, and connecting edge—is written with a unique number. When the content version number is duplicated, a version conflict is recorded. When the task receipt points to a non-existent task instance, the execution unit stays at the position of the previous valid task, and finally an order process graph for workflow management is obtained. For example, if a sales order contains six items, with each item being a unit of measurement, the system generates six fulfillment units in sequence one through six. When a picking task instance records four valid task receipts, the first four fulfillment units enter the picking task output position, and the last two fulfillment units remain in the picking task input position. When a review task instance records two valid task receipts, the first two fulfillment units enter the review task output position, and the third and fourth fulfillment units remain in the review task input position. If the delivery task returns a task receipt before the review task and packaging task have generated a valid task receipt, the delivery task receipt will be written into the receipt conflict record, and the corresponding execution unit will still maintain the original task position. The resulting order flow diagram can reflect the actual processing position of sales orders in each task instance according to the fulfillment unit, and provide a unified basis for subsequent order change analysis.

[0018] S2. After the order content is changed, the fulfillment unit is located according to the content before the change. When there is a task receipt, a receipt bypass is established from the starting point of the process to the task output position. When there is no task receipt, the original path is retained, forming a change judgment diagram. When order content is modified during fulfillment, it is necessary to first fix the content version and task execution section before the change, then distinguish between fulfillment units that have been actually processed by the task and those that have not yet entered the processing stage, and generate a directed graph for subsequent control relationship calculations based on this. This implementation method includes the following: After the order change record is written, the version succession relationship between the order item identifier, the version number before the change and the version number after the change is checked first. Only when the version number before the change is consistent with the current effective version number of the order item, S21 locates the version node of the content before the change in the order flow diagram and reads the affected execution unit along the connection edge pointing to the execution unit from that node. When the changed field does not change the order quantity, the fulfillment unit under the corresponding order item that is still connected to the content version node before the change is written into the changed unit set; when the order quantity increases, the increased quantity is written into the new fulfillment unit to generate a record and connected to the content version node after the change. When the order quantity decreases, first select the fulfillment units that have not yet formed valid task receipts in reverse order of unit priority. If the reduction in quantity is still not enough, then select the fulfillment units that have formed task receipts and write them into the correction pending record. If the version number is duplicated, the version order is reversed, or the change record is duplicated, a new change unit set will not be generated, and the corresponding record will be written to the version conflict table. The determination of the receipt boundary depends on the order of writing the order change record. When processing to S22, the task receipts that are no later than the order change record writing order are used as the input for this judgment. Then, the task receipts are collected according to the task instance number, execution batch and receipt order, and duplicate records are excluded by the task receipt number. Each task instance creates a pending copy consisting of the fulfillment units that have arrived for the task. Then, based on the number of valid task receipts, the processed interval is marked starting from the fulfillment unit with the highest unit priority. The remaining fulfillment units form the pending interval. Order quantities are not cumulatively deducted between different task instances. If a preceding task does not have a valid task receipt while a subsequent task already has a task receipt, the subsequent task receipt is written into the receipt conflict table, and the original task position of the execution unit is maintained. If the task execution occurs before the order change but the task receipt is written after the order change record is written, the late receipt is recorded first. After verifying the task instance number and execution batch, the receipt boundary relationship of the corresponding fulfillment unit is regenerated. The path rewriting is completed by isolating the execution unit and the task instance. After entering S23, for each execution unit in the processed interval, the corresponding task path is copied. A receipt bypass is established in the copied path from the process start point to the task output position. The bypass number is generated by the execution unit number, the task instance number and the task receipt number. At the same time, the connection from the previous content version node to the task output position through the task input position in the copied path is deleted. The deleted connection is written into the original path recovery table for reconnection when constructing the reference diagram later. The execution units within the pending processing range will retain the original path from the previous version of the content node to the task output node via the task input bit; When there are conflicts in the task receipts, the task instance does not exist, or the number of task receipts exceeds the effective output of the preceding task, no receipt bypass is established, and the corresponding execution unit is still retained along the original path, thus forming a set of change paths isolated by execution unit; When forming a directed graph, S24 takes the process starting point as the only entry point, writes the content version node before the change, execution unit, task input position, task output position, receipt bypass and task acceptance relationship into the change decision graph, and performs traversal from the process starting point according to the direction of the directed edge. Nodes and connecting edges that cannot be reached from the start of the process are simply removed from the copy of the change decision graph. The node number and connecting edge number are simultaneously written to the unreachable record. The original nodes and original connecting edges in the order process graph remain unchanged. When a fulfillment unit has multiple branch tasks, only the path where the order content field and the branch input field are consistent is retained; when multiple preceding tasks merge into the same subsequent task, all connections from the output bits of the preceding tasks to the input bits of the subsequent tasks are retained for subsequent control analysis to determine the merging relationship. After unreachable cleanup, a change decision diagram for workflow analysis is obtained, and the original path recovery table is also provided to the construction process of the actual diagram and the comparison diagram. For example, if the delivery address of an order containing six fulfillment units changes after two fulfillment units have been completed in the review task, the order change record is written earlier than the subsequent late third review task receipt. The system first writes the six execution units into the change unit set, and then reads the first two valid task receipts according to the order of the change records. This allows the first two execution units to establish a receipt bypass from the process start point directly to the review task output position. The remaining four execution units retain the original path from the review task input position to the review task output position. After the late receipts are completed and the batch verification is completed, only the corresponding execution units are reprocessed. The resulting change decision graph ensures that the time of order change is consistent with the actual processing location of the task, and provides a definite graph structure for the division of migration set and retain set.

[0019] S3. Execute the Rengeltajan dominance tree algorithm with the process starting point as the root node. Number the nodes in depth first, reverse the order along the predecessor and disjoint set parent chain to find the semi-dominant points and backfill the direct dominant points. Write the execution units whose task input and task output are both dominated by the previous content version node into the migration set, and write the execution units whose only task input is dominated into the retention set. The determination of the scope of order changes is based on the comparison of two path states: one retains the actual execution path formed by the task receipt, and the other restores the original task path when the task receipt was not written. Then, the dominance relationship between the content version node before the change and the task input and task output bits is calculated respectively. Both paths are isolated according to execution units and task instances, ensuring that adding or deleting a receipt bypass for any execution unit does not change the graph structure of other execution units; this implementation includes the following: During the graph structure preparation phase, read the change judgment diagram, receipt bypass number and original path restoration table, and copy two copies of the nodes and connecting edges according to the performance unit number; The real-world diagram retains the receipt bypass corresponding to the current execution unit and uses the existing connection relationship in the change judgment diagram; the same receipt bypass is deleted from the comparison diagram, and the connection edge removed by S23 is read from the original path recovery table to restore the original path of the content version node before the change through the task input position to the task output position, and the remaining nodes and connection edges remain consistent. After completing the above processing, in S31, traverse the two graphs in ascending order along the connecting edge numbers from the process starting point and write the arrival records from the process starting point to the task input position and the task output position. When a node number is missing, the task instance pointed to by the restored edge is inconsistent, or two existing original paths appear in the same performance unit, the current performance unit will be written into the graph structure conflict record and will not be included in the dominance relationship calculation. After entering the dominance relationship calculation, the actual diagram and the reference diagram are processed respectively with the starting point of the process as the root node; when executing to S32, the process enters the next node from the starting point of the process along the unread connection edge. When the node is first arrived, the incrementing depth priority order is written, and the previous node before entering the current node is recorded as the depth priority parent node; if there is no unread connection edge in the next node, the process returns to the depth priority parent node to continue traversing. After numbering, process the nodes except the starting point of the process in reverse order of depth priority: read the predecessor of the node that directly points to the current node one by one. If the predecessor of the node is earlier than the current node, use the predecessor of the node as a semi-dominant candidate. If the predecessor of the node is later than the current node, compress the path along the parent chain of the disjoint set and read the semi-dominant node corresponding to the label node of the parent chain as a semi-dominant candidate. Then write the node with the higher depth priority among the candidates as the semi-dominant node of the current node. The current node is then written into the temporary table of the semi-dominant node and connected to the same disjoint set with the depth-first parent node; after reading the nodes in the temporary table of the depth-first parent node, the order of each node's label node with its respective semi-dominant node is compared, and the nodes are written into the candidate direct dominant node. After all nodes have been reversed, candidate directly dominated nodes are read in depth-first order. If a candidate directly dominated node is different from a semi-dominated node, it is rewritten as the directly dominated node of the candidate directly dominated node, thus forming the actual dominance tree and the control dominance tree. For the control verification of a single execution unit, the process returns to the starting point of the process step by step from the task input position and the task output position along the direct control node; when the return path passes through the content version node before the change, the controlled result is written, and when it does not pass through, the uncontrolled result is written. When processing up to S33, first temporarily delete the previous version content node and associated edges in the current execution unit's real-world diagram copy, then search the remaining path from the process start point to the task output position in ascending order of the connection edge number; then restore the node and associated edges, temporarily delete the receipt bypass corresponding to the current execution unit, and search the remaining path from the process start point to the task output position again. The results of the two searches, along with the input and output dominance results of the two dominance trees, are written into the dominance difference record. The receipt bypass number, task instance number, task receipt number, and path source are written into the bypass source record. After each execution unit completes verification, all temporarily deleted content is restored before processing the next execution unit, thus avoiding changes to the subsequent graph structure from the previous retrieval. The classification writing is completed jointly based on the results of two dominator trees and two remaining path retrievals; when executing S34, the task input and task output bits are written into the migration set by the execution unit that is dominated by the previous content version node in both the real dominator tree and the comparison dominator tree; When the task input is dominated in both dominance trees, the task output is detached from dominance in the current dominance tree but dominated in the reference dominance tree, and the process start point cannot bypass the previous content version node to reach the task output after deleting the current receipt bypass, the corresponding execution unit is written into the reserved set. If no classification results are obtained, check the receipt bypass according to the order item identifier, task instance number, execution batch and unit order. Keep the receipt bypass with all fields consistent, delete the receipt bypass with inconsistent fields, and then rebuild the comparison chart according to the original path recovery table and repeat S31 to S33. At least one receipt bypass with inconsistent fields should be deleted in each round, and the number of repetitions should be limited by the limited number of receipt bypasses. If no classification result is obtained after deleting all inconsistent receipts and bypasses, the task location node is copied again according to the current performance unit; if multiple existing paths still exist after reconstruction, the graph structure conflict record is written and the graph rewriting of the current order change record is stopped. For example, an order item contains four fulfillment units, of which the first two fulfillment units have received review task receipts, while the last two fulfillment units are still in the review task input field; In the actual diagram, the first two execution units reach the review task output position through the receipt bypass, and the content version node before the change no longer controls the corresponding task output position; after restoring the original path according to the diagram, the content version node before the change re-controls the task input and task output positions, so the first two execution units are written to the reserved set. The latter two execution units are both dominated by the pre-modification content version node in both dominance trees, controlling the task input and task output bits, and are therefore written into the migration set; Therefore, the control result can directly distinguish between the fulfillment units that have already formed task execution results and the fulfillment units that have not yet entered task processing when the order change occurs, and provide a definite migration set and retention set for the subsequent reconstruction of the succession relationship.

[0020] S4. Based on the migration set, obtain candidate tasks for the changed content version node, form a receiving vector with the fulfillment unit allocation amount, and execute the Dijkstra alternating projection algorithm. In each round, add back the difference from the previous round, set the content mismatch coordinates to zero, correct the unfixed coordinates according to the migration amount, coordinates and differences, and correct the receiving amount according to the task priority amount and task surplus amount until the receiving vectors of two adjacent rounds are consistent, and obtain the changed receiving relationship. Before the migration set enters the task reordering, it is necessary to first limit the next task instance that each execution unit can access, and unify the calculation caliber of task capacity, task order and order content version, so that subsequent projection is only carried out within the actual workflow. The historical task relationships in the order process graph remain unchanged, and the rearrangement results are written into new receiving edges for workflow management after order changes; the specific processing is as follows: After the migration scope is determined, the migration set is read along the connection edge pointing from the modified content version node to the execution unit. Then, starting from the current task position of each execution unit, the next task instance allowed to be accessed by the process rules is obtained along the task acceptance edge. The rollback task is deployed according to the new execution batch to prevent the same task instance from forming a loop. When a task has multiple branches, the branch field in the changed content version is read and the branch with the same input field is retained. When multiple previous tasks are merged into the same subsequent task, only the merged task is written into the candidate range where the common previous task has a valid output. When processing up to S41, the receiving coordinates are composed of the fulfillment unit identifier and the candidate task instance number, and arranged according to the task level, task instance number and unit order. The task reserve is obtained by summing the number of execution units allocated to each processing station within the same execution batch, and then deducting the number of execution units already occupied by the current task instance in the reserve set and the number of execution units that have been allocated but have not yet generated task receipts. When the task reserve is less than zero, write the task capacity conflict record and record it as zero; when the candidate task is empty or the sum of the reserve of all candidate tasks is less than the migration set, generate the acceptance conflict record and stop the rearrangement of the current order change record. The initial state of the receiving vector directly follows the task position before migration; after entering S42, if the original task still belongs to the candidate task, the corresponding receiving coordinate is written as one, and the other receiving coordinates of the same execution unit are written as zero. When the original task no longer belongs to the candidate task, the candidate assignment coordinates of the same execution unit are written as the reciprocal of the number of candidate tasks; For content versions or task input fields that are inconsistent, the receiving coordinates are fixed to zero. Then, the unfixed receiving coordinates of the same performance unit are subjected to truncated simplex projection: First, the coordinate values ​​are sorted in descending order, and the sorting prefix is ​​expanded item by item. The offset is obtained by subtracting one from the current prefix coordinates and dividing by the number of prefix items. The prefixes with positive offsets after subtracting the last item and negative offsets after subtracting the next item are retained. Then, the offsets are subtracted from each coordinate value and the negative values ​​are rewritten to zero so that the sum of the receiving coordinates of the same performance unit is equal to one. The coordinate differences between the vectors before and after projection are written into the content difference vector and the unit difference vector, respectively. All four types of difference vectors are written to zero when the first execution is performed. Constraint rotation is used to ensure that the task sequence and task margin simultaneously satisfy the process rules; when executing S43, the current receiving vector and the task sequence difference vector are first added coordinate by coordinate, and then the input quantity of each task is calculated according to the task order of the same path. The effective output of the previous task is formed only by the number of execution units corresponding to the effective task receipts. The number of tasks that have not yet generated task receipts is not included in the output of the previous task. When it is discovered that the input of a subsequent task exceeds the effective output of a previous task, the adjacent cumulative amounts that have violated the order are grouped together. The sum of the cumulative amounts in the group is divided by the number of items in the group to obtain the group value. The adjacent groups are checked forward until the input of the subsequent task does not exceed the effective output of the previous task. Then the difference between the adjacent cumulative amounts is used to restore the amount of each task. Then add back the task surplus difference vector, sum the positive coordinates of the same task instance; when the coordinate sum exceeds the task surplus, deduct the excess according to the proportion of positive coordinates, and fix the coordinates with negative values ​​to zero, and then distribute the excess that has not yet been deducted to the remaining positive coordinates until the coordinate sum equals the task surplus. One round of Dijkstra alternating projection is completed in the order of consistent content, unit affiliation, task sequence and task surplus. Each time, the corresponding difference vector is updated by subtracting the projection result from the projection input. Stop when the receiving vector, the four types of difference vectors, and the active coordinates are consistent in two adjacent rounds; when the active coordinates are repeated but the vectors are still changing, fix the first changing coordinate according to the task order, so that at least one coordinate is fixed in each round, and limit the number of rounds to be executed by the total number of receiving coordinates; In the discrete write-back stage, the projection results are transformed into a unique task access location for each execution unit. When processing up to S44, candidate tasks of the same execution unit are read in descending order of coordinate values. If the coordinate values ​​are the same, the reading order is determined by the task priority, task instance number and unit priority. Select the first task with a non-zero remaining balance and whose previous task's valid output has already covered the current execution unit's receiving coordinates, temporarily fix it to one, and temporarily fix the remaining coordinates of the same execution unit to zero. Then, re-execute S42 to S43 on the remaining unfixed coordinates. If the remaining execution units can still form a projection acceptance vector, retain the current fix and deduct the corresponding task surplus; if they cannot form a projection acceptance vector, cancel the fix and read the next candidate task. When all candidate tasks cannot be fixed, write them into the acceptance conflict record. Completed fixed results are not written back to the order process diagram. After all performance units have obtained unique acceptance coordinates, write the corresponding relationship of acceptance coordinates into the new task acceptance edge, and record the source content version number, change priority and original task acceptance edge number to form the changed acceptance relationship. For example, three migration execution units need to connect to two subsequent task instances, with the task reserves of the two task instances being two and one, respectively; The initial receiving vector first retains the original task position that still satisfies the changed content, then maintains the coordinate sum of each execution unit as one through unit affiliation projection, excludes the coordinates of the previous task that has not yet formed a valid output through task sequence projection, and restricts two task instances to receive two and one execution units respectively through task surplus projection. When the task is fixed in a discrete manner, the candidate task with the first coordinate value is first written. If the fixed task makes the remaining two execution units compete for only one task slot, the current fixed task is cancelled and the next candidate task is read. Finally, a modified succession relationship is formed in which three execution units correspond to one next task instance, so that the task rearrangement result after the order content is changed meets the requirements of workflow order, task capacity and unique ownership of execution units.

[0021] S5. Rewrite the order process graph according to the changed acceptance relationship. After the task output position of the retained set, generate a correction task to receive the processed fulfillment unit. Subtract the task receipt from the task acceptance quantity to obtain the incomplete quantity. Update the task status and order status. Write the order change record to the traceability edge of the order status to obtain the order status linkage result. After order changes are completed and tasks are rearranged, it is necessary to maintain the original process relationships, the current process relationships, and the version boundaries between processed fulfillment units. Then, based on valid task receipts, the incomplete amount of each task is calculated to ensure that task status, order status, and traceability paths remain consistent. This implementation method includes the following: The graph rewriting process first reads the change order, the version number before the change, and the version number after the change from the order change record, and then locates the current task receiving edge according to the execution unit. When S51 is executed, the current task receiving edge corresponding to the migration set retains the original edge number, writes the invalid version number and change order, and then saves it as a historical edge. Then, the current pointer of the execution unit to the original task input bit is deleted. Subsequently, a new task acceptance edge is generated based on the changed acceptance relationship. The effective version number, source historical edge number, and task acceptance instance number are written into the new task acceptance edge so that there is only one current task acceptance edge for the same execution unit under the same content version. If the order change record is late, the change order is duplicated, or the source historical edge is missing, stop rewriting the corresponding fulfillment unit and write the edge number and version number into the receiving edge conflict record; after completing the rewriting, output the changed task chain; The fulfillment unit that has been processed by the original task enters the correction process according to the process rules; S52 reads the fulfillment unit, the corresponding task output position and the change field in the order change record in the retention set, and then finds the field group to which the change field belongs and the correction task number corresponding to the field group from the process rules; Fields within the same field group are read from the modified content version node, while fields that have not changed use the field values ​​from the pre-modification content version node, thus avoiding the simultaneous reference of two content versions in the same field group. The correction task generates a task instance according to the correction task number and the new execution batch, so that the original task output is connected to the correction task input, and the correction task output is then connected to the subsequent task input specified by the process rules; When there is no corresponding correction task in the process rules, the field group is missing a required field, or the correction task input field cannot receive the changed field value, the execution unit will be written into the correction conflict record and will not be connected to subsequent tasks, thus forming a correction task chain. The receipt calculation is processed in batches and duplicate reports on a task instance basis; after reading the changed task chain and the corrected task chain, S53 first excludes duplicate records according to the task receipt number, and then reads the receipt caliber determined by the task rules. Incremental receipts are accumulated based on the execution batch and receipt order, while cumulative receipts only use the cumulative amount of receipts that come later in the order. The two methods cannot be used interchangeably for the same task instance. The number of uncompleted tasks is obtained by subtracting the number of valid task receipts from the number of accepted tasks. When the number of valid task receipts exceeds the number of accepted tasks, the number of accepted tasks is used for subtraction, and the excess quantity, task instance number, and task receipt number are written into the receipt conflict record. When a task receipt points to the historical task assignment edge, the change order is checked according to the task execution batch. Receipts executed before the change are classified as historical tasks, and receipts executed after the change are classified as current tasks. If the execution attribution cannot be determined, it is not included in the status calculation, and the final result is the task incomplete scale. The status is written based on the number of tasks accepted, the number of valid task receipts, and the number of tasks not completed. After entering S54, when the number of tasks accepted is non-zero and the number of valid task receipts is zero, the pending status is written; when the number of valid task receipts is greater than zero and the number of tasks not completed is non-zero, the execution status is written; when the number of tasks not completed is zero, the completion status is written. Tasks without a number of tasks accepted do not participate in order status generation. The serial task reads incomplete tasks according to their order and writes the status of the incomplete task that is first in the order to the order status. When there are multiple parallel tasks at the same process level, first write the process level status, and then attach the set of incomplete task instance numbers within that level; write the order completion status when all current tasks and correction tasks are in a completed state. The execution unit that has generated a task receipt is sequentially connected to the order change record, execution unit, task receipt, task status and order status. The execution unit that has not yet generated a task receipt is sequentially connected to the order change record, execution unit, current task receiving edge, task status and order status to obtain the order status linkage result. For example, after an order is changed, it includes two migration fulfillment units and one retained fulfillment unit. The original task receiving edges of the two migration fulfillment units are converted into historical edges according to the change order, and then connected to the task input bits after the change. The retained fulfillment unit has completed the original address encapsulation task. The process rule is to configure the address change task in the address field group. The system generates an address change task instance accordingly, and connects it to the delivery task after the address change task forms a valid task receipt. When a delivery task is undertaken by three fulfillment units and incremental receipts of quantity one and quantity two are received successively, the system accumulates three valid task receipts according to the receipt order and records the delivery task as completed; the same receipt number will not be accumulated repeatedly when it is reported again. Through the above processing, the order flow diagram can retain the task relationships before and after the change, distinguish between migration processing and correction processing, and trace the order status back to the specific execution unit, task receipt, and content version.

[0022] exist Figure 1 It should be noted that this diagram illustrates the process of order flowchart construction, change judgment, fulfillment unit classification, task rearrangement, and status write-back. The solid arrows in the diagram indicate the execution order and data transfer direction between each step. The branch solid lines represent the migration set entering task rearrangement and the retained set entering correction processing, respectively. The two processing paths converge in the status update stage, ultimately forming the order status linkage result.

[0023] Overall Execution and Implementation Description: This solution first breaks down sales orders into fulfillment units based on order item measurement units, and then writes task input positions, task output positions, and task succession relationships into a knowledge graph according to process rules, forming an order flow graph that reflects the actual processing position of each fulfillment unit. After the order content changes, the system establishes the actual execution path and the original process path based on the task receipt, and then compares the dominance relationship of the content version node to the task input position and task output position before the change through the Rengeltajan dominance tree algorithm. Fulfillment units that have formed execution results are written into the retention set, and fulfillment units that have not yet formed execution results are written into the migration set. Subsequently, under the constraints of content consistency, task order, unit affiliation, and task surplus, the Dijkstra alternating projection algorithm redetermines the tasks to be accepted for the migration set, generates corrective tasks for the retained set, and finally updates the task status, order status, and traceability relationship based on the task acceptance quantity and the number of valid task receipts. For example, in a sales order containing six items, two items have already been reviewed, while the remaining four are still awaiting review. At this point, the delivery address changes. The system writes each of the six items as a fulfillment unit into the order flow chart. Based on the review task receipt, it identifies that the first two items have already been reviewed, placing them into the hold set for continued processing according to the original execution criteria. An address change task is then added after the review task. The remaining four items are placed into the migration set and reassigned to subsequent tasks that conform to the flow order and still have receiving capacity, according to the changed address. After the new task assignment relationship is written back to the knowledge graph, the system continues to read the task receipts to calculate the amount of incomplete tasks, and updates the order status accordingly. At the same time, the task paths before and after the change are retained, so that the order status can be traced back to the specific product, content version and task execution record.

[0024] The above description is merely a preferred embodiment of the present invention and is not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

Claims

1. A method for linking order status for full-process traceability in business operations, characterized in that, include: S1. Obtain the sales transaction orders, process rules, and task receipts. Break down the quantity to be fulfilled into fulfillment units according to the order item. Connect the task input positions to the task output positions according to the process rules and write them into the knowledge graph to form an order process graph for workflow management. S2. After the order content is changed, the fulfillment unit is located according to the content before the change. When there is a task receipt, a receipt bypass is established from the starting point of the process to the task output position. When there is no task receipt, the original path is retained, forming a change judgment diagram. S3. Execute the Rengeltajan dominance tree algorithm with the process starting point as the root node. Number the nodes in depth first, reverse the order along the predecessor and disjoint set parent chain to find the semi-dominant points and backfill the direct dominant points. Write the execution units whose task input and task output are both dominated by the previous content version node into the migration set, and write the execution units whose only task input is dominated into the retention set. S4. Based on the migration set, obtain candidate tasks for the changed content version node, form a receiving vector with the fulfillment unit allocation amount, and execute the Dijkstra alternating projection algorithm. In each round, add back the difference from the previous round, set the content mismatch coordinates to zero, correct the unfixed coordinates according to the migration amount, coordinates and differences, and correct the receiving amount according to the task priority amount and task surplus amount until the receiving vectors of two adjacent rounds are consistent, and obtain the changed receiving relationship. S5. Rewrite the order process graph according to the changed acceptance relationship. After the task output position of the retained set, generate a correction task to receive the processed fulfillment unit. Subtract the task receipt quantity from the task acceptance quantity to obtain the incomplete quantity. Update the task status and order status. Write the order change record to the traceability edge of the order status to obtain the order status linkage result.

2. The order status linkage method for full-process traceability according to claim 1, characterized in that: S1 includes: S11. Collect the order quantity and task receipt quantity of sales transactions according to the order item identifier. Deduct the task receipt quantity from the order quantity one by one according to the execution batch and receipt order. Split the quantity after deduction according to the order item unit of measurement and generate the fulfillment unit by connecting the unit order with the order item identifier. S12. Based on the process rules, each task is expanded into task input positions and task output positions, so that the task input positions are connected to the task output positions of the same task, and then the task output positions and the task input positions are connected according to the correspondence between the output fields of the previous task and the input fields of the next task, forming a task succession chain. S13. Connect the order item node with the order node, and then connect the order item node to the fulfillment unit through the order content version node. Write the fulfillment unit into the task acceptance chain, and connect the corresponding task output position one by one from the fulfillment unit with the first unit in the unit order according to the task receipt quantity. Connect the remaining fulfillment units to the corresponding task input position to obtain the order flowchart.

3. The order status linkage method for full-process traceability according to claim 2, characterized in that: S2 includes: S21. Read the order item identifier and the previous version number in the order change record, locate the previous content version node in the order flow diagram, and then obtain the affected performance unit along the connection edge between the previous content version node and the performance unit to form a change unit set. S22. Read the task receipts corresponding to the change unit set according to the execution batch and receipt sequence. Starting from the execution unit with the first unit sequence, deduct the task receipt quantity one by one. Connect the execution unit that has been deducted to the corresponding task output position and connect the execution unit that has not been deducted to the corresponding task input position to form the receipt boundary relationship.

4. The order status linkage method for full-process traceability according to claim 3, characterized in that: S2 also includes: S23. For execution units that connect to task output positions, establish an acknowledgment bypass from the process start point to the corresponding task output position, and delete the connection from the previous content version node to the task output position via the corresponding task input position; for execution units that connect to task input positions, retain the original path from the previous content version node to the task output position via the task input position, forming a set of changed paths. S24. Using the process start point as the only entry point, write the previous content version node, the change path set and the corresponding task acceptance relationship into the directed graph, and delete the nodes and connecting edges that cannot be reached from the process start point to obtain the change judgment graph.

5. The order status linkage method for full-process traceability according to claim 4, characterized in that: S3 includes: S31. Based on the change decision diagram, a real-world diagram and a comparison diagram are created. The receipt bypass is retained in the real-world diagram, and the receipt bypass is deleted in the comparison diagram while retaining the remaining connection relationships, thus forming a workflow path from the process start point to the task input position and the task output position, respectively. S32. Using the starting point of the process as the root node, execute the Rengeltajan dominance tree algorithm on the actual graph and the reference graph respectively. Mark the nodes according to the depth-first order, read the predecessor of the node in reverse order and obtain the predecessor node with the semi-dominance order along the disjoint set parent chain. Then, fill the direct dominance node according to the semi-dominance node and the depth-first parent node to form the actual dominance tree and the reference dominance tree.

6. The order status linkage method for full-process traceability according to claim 5, characterized in that: S3 also includes: S33. For each execution unit, read the control results of the content version node before the change on the task input position and task output position in the actual control tree and the comparison control tree respectively. Then delete the content version node before the change from the actual diagram and search the remaining path from the process start point to the task output position. Then delete the receipt bypass corresponding to the current execution unit and search the remaining path again to form a control difference record and bypass source record. S34. When both the task input and task output are dominated by the pre-change content version node in both dominating trees, write the corresponding fulfillment unit into the migration set. When the task input is dominated by both dominating trees, the task output is dominated only in the reference dominating tree, and the process start point cannot bypass the pre-change content version node to reach the task output after deleting the receipt bypass, write the corresponding fulfillment unit into the retention set. For fulfillment units that are not written into the migration set or retention set, check the receipt bypass according to the order item identifier, execution batch, and unit sequence. Retain the receipt bypass with consistent fields and delete the remaining receipt bypasses. Then repeat S31 to S33 until each fulfillment unit is written into the migration set or retention set.

7. The order status linkage method for full-process traceability according to claim 6, characterized in that: S4 includes: S41. Traverse the task acceptance edges along the knowledge graph from the changed content version node, form acceptance coordinates for each task in the migration set that is consistent with the order item field of each execution unit, arrange the acceptance coordinates according to the task order and unit order, and deduct the reserved set occupancy from the task quota to obtain the candidate task table and the task surplus table. S42. Establish a receiving vector based on the allocation of each performance unit on the candidate task, fix the coordinates of inconsistent content versions to zero, and then perform truncated simplex projection on the corresponding coordinates of the same performance unit to make each coordinate non-negative and the sum of the coordinates equal to one. Then, generate the content difference vector and the unit difference vector by subtracting the vector after projection from the vector before projection.

8. The order status linkage method for full-process traceability according to claim 7, characterized in that: S4 also includes: S43. Add the previous projection results back to the task order difference vector and the task surplus difference vector in sequence. Perform adjacent disorder merging on the cumulative task acceptance along the task acceptance edge so that the cumulative acceptance of the later task does not exceed the cumulative output of the previous task. Then, deduct the difference between the task coordinates and the excess of the task surplus according to the proportion of each positive coordinate. Update the corresponding difference vector with the vector difference before and after each projection. Perform Dijkstra alternating projection in the order of content consistency, unit affiliation, task order and task surplus until the acceptance vectors before and after one round of projection are the same, and obtain the projection acceptance vector. S44. Read the candidate tasks corresponding to the execution unit in descending order of the coordinate values ​​of the projection receiving vector. Fix the coordinate of the first execution unit that still has task leeway and whose output of the previous task has covered the corresponding execution unit to one. Fix the remaining coordinates of the same execution unit to zero. After deducting the task leeway, repeat S42 to S43 for the unfixed coordinates until each execution unit has only one coordinate with a value of one. Then write the coordinate correspondence into the knowledge graph to obtain the changed receiving relationship.

9. The order status linkage method for full-process traceability according to claim 8, characterized in that: S5 includes: S51. Based on the order change sequence of the order change record, the original task acceptance edge in the order flow chart is transferred to the historical edge, the current task acceptance edge corresponding to the migration set is deleted, and the changed acceptance relationship is written between the execution unit and the task input position to form the changed task chain. S52. For the fulfillment unit in the retention set, a correction task is created after the corresponding task output position. The content version before the change and the content version after the change are compared sequentially along the order item fields. The original value is used in the position where the field value is consistent and the changed value is written in the position where the field value is inconsistent. Then the correction task output position is connected to the subsequent task input position to form a correction task chain.

10. The order status linkage method for full-process traceability according to claim 9, characterized in that: S5 also includes: S53. Read the changed task chain and the corrected task chain according to the task order. The first task receipt with the same order item identifier, execution batch and receipt order is used for accounting. Subtract the corresponding task receipt quantity from the task acceptance quantity to get the unfinished quantity. When the task receipt quantity exceeds the task acceptance quantity, only the task acceptance quantity is used for subtraction and the excess part is written into the receipt conflict record to get the task surplus table. S54. According to the task remaining quantity table, write the task with zero unfinished quantity as completed and the task with non-zero unfinished quantity as executed. Read the first task with non-zero unfinished quantity according to the task order and write the corresponding task status as the order status. When the unfinished quantity of all tasks is zero, write the order as completed. Then write the traceability edge along the order change record, fulfillment unit, task receipt, task status and order status to obtain the order status linkage result.

Images