Event-driven low-code intelligent orchestration method and system

Abstract

This application provides an event-driven low-code intelligent orchestration method and system, belonging to the field of low-code orchestration technology. The method includes: matching event feature vectors with feature label vectors of each logic module in a logic library to determine the target logic module corresponding to the event; the event feature vector is a feature vector extracted from different types of events; the logic library is a pre-defined collection storing multiple different logic modules; and the feature label vector is a vector describing the event features applicable to the logic module; determining event flow nodes based on the target logic module and combining these flow nodes to obtain the initial event flow; and configuring corresponding parameters for the event flow nodes of the initial flow based on the event type to obtain the target event flow. The event-driven low-code intelligent orchestration method and system provided in this application can meet the complex and ever-changing business needs of enterprises.

Description

Technical Field

[0001] This application belongs to the field of low-code orchestration technology, and more specifically, relates to an event-driven low-code intelligent orchestration method and system. Background Technology

[0002] In today's rapidly evolving digital age, businesses face an ever-increasing demand for business application development. Traditional software development methods not only require specialized programming knowledge and extensive coding work, resulting in long development cycles and high costs, but also struggle to respond quickly to changing business needs.

[0003] The emergence of low-code has alleviated development pressure to some extent due to the above problems. However, in the context of low-code platform applications, conventional event-driven low-code intelligent orchestration methods are difficult to accurately and seamlessly connect events to logic. When automatically generating complex processes, problems such as low generation efficiency and poor adaptability to complex business scenarios often occur, resulting in insufficient optimization of the generated business processes and difficulty in meeting the complex and ever-changing business needs of enterprises. Summary of the Invention

[0004] The purpose of this application is to provide an event-driven, low-code intelligent orchestration method and system to meet the complex and ever-changing business needs of enterprises.

[0005] A first aspect of this application provides an event-driven low-code intelligent orchestration method, comprising:

[0006] The target logic module corresponding to an event is determined by matching the event feature vector with the feature label vector of each logic module in the logic library. The event feature vector is a feature vector after feature extraction of different types of events. The logic library is a pre-defined collection that stores multiple different logic modules. The feature label vector is a vector that describes the event features applicable to the logic module.

[0007] The event flow nodes are determined based on the target logic module, and the flow nodes are combined to obtain the initial flow of the event.

[0008] Configure the corresponding parameters for the event flow nodes of the initial process based on the event type to obtain the target flow of the event.

[0009] A second aspect of this application provides an event-driven low-code intelligent orchestration system, comprising:

[0010] The matching module is used to match the event feature vector with the feature label vector of each logic module in the logic library to determine the target logic module corresponding to the event. The event feature vector is a feature vector after feature extraction of different types of events. The logic library is a pre-defined collection that stores multiple different logic modules. The feature label vector is a vector that describes the event features applicable to the logic module.

[0011] The node determination module is used to determine the event flow nodes based on the target logic module, and combine the flow nodes to obtain the initial flow of the event;

[0012] The parameter configuration module is used to configure the corresponding parameters for the event flow nodes of the initial process based on the event type, so as to obtain the target flow of the event.

[0013] A third aspect of this application provides an electronic device, including a memory, a processor, and a computer program stored in the memory and running on the processor, wherein the processor executes the computer program to implement the steps of the event-driven low-code intelligent orchestration method described above.

[0014] A fourth aspect of this application provides a computer-readable storage medium storing a computer program that, when executed by a processor, implements the steps of the event-driven low-code intelligent orchestration method described above.

[0015] The beneficial effects of the event-driven low-code intelligent orchestration method and system provided in this application are as follows: This application determines the target logic module by matching the event feature vector with the feature label vector of the logic module in the logic library, which can quickly and accurately locate the applicable module from a rich set of logic modules, improving the targeting of event processing. Based on the target logic module, process nodes are determined and combined to generate an initial process, building an orderly processing framework. Then, the target process is obtained by configuring parameters according to the event type, realizing intelligent orchestration of the process, thereby better meeting diverse business needs. Attached Figure Description

[0016] To more clearly illustrate the technical solutions in the embodiments of this application, 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 of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0017] Figure 1 A flowchart illustrating an event-driven low-code intelligent orchestration method provided in an embodiment of this application;

[0018] Figure 2A structural block diagram of an event-driven low-code intelligent orchestration system provided in an embodiment of this application;

[0019] Figure 3 This is a schematic block diagram of an electronic device provided in an embodiment of this application. Detailed Implementation

[0020] In the following description, specific details such as particular system architectures and techniques are set forth for illustrative purposes and not for limitation, in order to provide a thorough understanding of the embodiments of this application. However, those skilled in the art will understand that this application may also be implemented in other embodiments without these specific details. In other instances, detailed descriptions of well-known systems, circuits, and methods are omitted so as not to obscure the description of this application with unnecessary detail.

[0021] To make the objectives, technical solutions, and advantages of this application clearer, the following description will be provided in conjunction with the accompanying drawings and specific embodiments.

[0022] Please refer to Figure 1 , Figure 1 A flowchart illustrating an event-driven low-code intelligent orchestration method provided in an embodiment of this application is available. This method can be executed by an electronic device and may include:

[0023] S101: Based on the matching of event feature vectors with the feature label vectors of each logic module in the logic library, the target logic module corresponding to the event is determined; the event feature vector is a feature vector after feature extraction of different types of events, the logic library is a pre-defined collection that stores multiple different logic modules, and the feature label vector is a vector describing the event features applicable to the logic module.

[0024] In this embodiment, the event is triggered by an external event, which can be a user operation (such as clicking a button or entering information), a change in sensor data, a time-triggered event, etc.

[0025] Low-code is a visual application development methodology that allows for the rapid creation of applications through a graphical interface and minimal code writing. It lowers the technical barrier to software development, enabling non-technical developers (such as business personnel) to participate in the application development process and implement complex business logic through simple drag-and-drop and configuration operations.

[0026] Intelligent orchestration is the automatic combination and arrangement of different functional modules, process steps, etc., based on specific rules and conditions to achieve complex business logic or task processing.

[0027] A logic library is a pre-defined collection that stores multiple different logical modules. Each logical module represents a specific function or processing logic, such as data validation, business rule judgment, or data processing algorithms. When handling different events, appropriate logical modules can be selected from the logic library to construct the processing flow.

[0028] The feature label vector corresponds to each logic module in the logic library and is used to describe the event features applicable to that logic module. For example, a module used to process the "order payment successful" logic has a feature label vector with specific values ​​in dimensions such as "payment amount", "payment method", and "order type", indicating the feature range of order payment-related events applicable to that module.

[0029] In this embodiment, features can be extracted from different types of events, transforming them into event feature vectors. The purpose is to represent complex and diverse events in a numerical form that is easy for computers to process and compare. For example, for a "user places an order" event on an e-commerce platform, this embodiment can extract key features such as user information, product information, order time, and payment method, and transform them into an event feature vector.

[0030] In this embodiment, the event feature vector is matched with the feature label vector of each logic module in the logic library. The matching process can compare the degree of fit between the two by calculating similarity. For example, the cosine similarity algorithm is used to calculate the similarity between the event feature vector and the feature label vector of each logic module. The higher the similarity, the better the logic module matches the current event.

[0031] Based on the matching results, the target logic module corresponding to the event is determined from the logic library. The target logic module is selected from a large number of logic modules, whose functions and applicable event characteristics are most similar to the current event, and will serve as the basis for building the event handling process.

[0032] S102: Determine the event flow nodes based on the target logic module, and combine the flow nodes to obtain the initial flow of the event.

[0033] In this embodiment, event flow nodes are the basic units that constitute the event processing flow. Each node represents a specific operation or task, such as data acquisition, data transformation, condition judgment, and result output. Multiple flow nodes can be combined in a certain order to form a complete event processing flow. Each node has its specific input, output, and processing logic.

[0034] The initial process is an event handling flow obtained by determining the process nodes based on the target logic module and combining these nodes according to certain logical relationships. At this stage, the flow has not yet been configured with parameters specific to the characteristics of the specific events.

[0035] In this embodiment, after the target logic module is determined, event flow nodes can be determined based on the target logic module. Each logic module corresponds to a specific set of flow nodes, which represent the specific operational steps required to complete the logic function.

[0036] For example, if the target logic module is "order processing", the corresponding process nodes could be "order information verification", "inventory check", "payment processing", "order status update", etc.

[0037] This embodiment can combine these process nodes according to a set logical relationship to obtain the initial process of the event. This combination method can be based on a preset process template, the execution order defined within the logic module, or business rules, etc.

[0038] For example, following the normal logic of order processing, first verify the order information, then check the inventory, then process the payment, and finally update the order status. This establishes a preliminary process framework for handling "user order placement" events.

[0039] S103: Configure the corresponding parameters for the event flow nodes of the initial process based on the event type to obtain the target flow of the event.

[0040] In this embodiment, the target process is the final event processing flow obtained by configuring corresponding parameters for each process node according to the event type, based on the initial process. The target process is customized for a specific event, enabling it to accurately and effectively handle the event and meet actual business needs.

[0041] In this embodiment, since different types of events may have different parameter requirements in the specific processing, after obtaining the initial process, this embodiment needs to configure corresponding parameters for each event process node of the initial process based on the type of the event.

[0042] For example, for different types of goods on an e-commerce platform (such as virtual goods and physical goods), certain nodes in the order processing flow (such as the shipping node) need to be configured with different parameters. For virtual goods, the shipping node can only perform authorization operations for virtual goods; while for physical goods, the shipping node needs to be configured with parameters such as logistics company and shipping address.

[0043] In this embodiment, by configuring appropriate parameters for each node, the initial process can accurately handle specific types of events, ultimately yielding the target process for that event. The target process is customized and configured to effectively handle the event in practical applications, meeting business requirements.

[0044] For example, in response to the event of "a user placing an order for physical goods", the target process after parameter configuration can accurately complete the entire order processing process, including verifying order information, checking physical goods inventory, processing payment, and arranging logistics and delivery.

[0045] For example, suppose a "user places an order" event occurs in an e-commerce platform scenario.

[0046] First, features are extracted from the "user places an order" event to form an event feature vector, which includes information such as user membership level, type of goods purchased, quantity, amount, and payment method.

[0047] The logic library stores various logic modules such as order verification, inventory management, payment processing, and logistics allocation, along with their corresponding feature tag vectors.

[0048] By calculating the similarity between the event feature vector and the feature label vector of each logical module, for example, if the "normal order processing" logical module is found to have a high matching degree, it is determined to be the target logical module.

[0049] Based on the target logic module of "normal order processing", event flow nodes are determined, such as "order information verification", "inventory query", "payment confirmation" and "order generation".

[0050] By combining these nodes according to the business logic, the initial process is obtained: first, the order information is checked to ensure that the information filled in by the user is accurate; then, the product inventory is checked to see if the product is in stock; next, the payment is confirmed to verify whether the payment is successful; finally, the order is generated.

[0051] Since this event falls under the "Ordinary Goods Purchase Order" type, parameters are configured for each node. In the "Order Information Verification" node, strict validation rules are set for mandatory information such as user name, address, and phone number; in the "Inventory Inquiry" node, corresponding warehouse query paths are set for different products; in the "Payment Confirmation" node, corresponding interface parameters are configured based on the user's chosen payment method (such as WeChat Pay, Alipay, etc.); and in the "Order Generation" node, different order numbering rules are set based on product type. Ultimately, this results in a target workflow suitable for this "User Order Placement" event, ensuring accurate and efficient order processing.

[0052] As can be seen from the above, this application determines the target logic module by matching the event feature vector with the feature label vector of the logic module in the logic library. This allows for rapid and accurate location of the applicable module from a rich set of logic modules, improving the targeting of event processing. Based on the target logic module, process nodes are determined and combined to generate an initial process, establishing an orderly processing framework. Then, the target process is obtained by configuring parameters according to the event type, achieving intelligent orchestration of the process.

[0053] In one embodiment of this application, the target logic module corresponding to the event is determined by matching the event feature vector with the feature label vector of each logic module in the logic library, including:

[0054] Based on the similarity between the event feature vector and the feature label vector of each logical module in the logic library, the initial logical module is determined. The initial logical module contains at least two logical modules from the logic library.

[0055] The initial logic modules are filtered based on the priority scoring of events to obtain the target logic modules.

[0056] In this embodiment, the event is first subjected to feature extraction, which transforms it into an event feature vector. The event feature vector contains key information about the event and can provide a basis for subsequent matching.

[0057] For example, for an e-commerce platform's "out-of-stock alert" event, information such as product name, inventory quantity, alert threshold, and product category can be extracted to form a feature vector.

[0058] Then, the similarity between the event feature vector and the feature label vector of each logic module in the logic library is calculated. This embodiment uses a cosine similarity algorithm to obtain the similarity value between the event and each logic module. This value represents the degree of matching between the features of the two.

[0059] Based on the similarity results, and according to preset rules (such as setting a similarity threshold and selecting logic modules with similarity higher than the threshold), at least two logic modules are selected from the logic library to form an initial set of logic modules. For example, when processing a "product out of stock alert" event, the "inventory replenishment notification" logic module and the "emergency product procurement process initiation" logic module can be selected as the initial logic modules because these two logic modules have a high degree of matching with the event at the feature level.

[0060] In this embodiment, the priority score of an event can be determined by taking into account multiple factors.

[0061] For example, in e-commerce scenarios, the "out-of-stock alert for limited-time promotional items" event may have a higher priority due to the timeliness of the promotional activity; while the "regular inventory alert for ordinary items" event has a relatively lower priority.

[0062] This embodiment filters initial logic modules based on event priority scoring. For high-priority events, logic modules that can quickly and efficiently resolve the problem or have a significant impact on key business processes are preferred. For example, for a "limited-time promotional item out-of-stock warning" event, the "emergency procurement process activation" logic module can be prioritized because it can quickly resolve the stockout issue and ensure the promotion continues. For low-priority events, logic modules can be selected based on factors such as resource utilization efficiency or cost control. Through this screening method, the most suitable target logic module for handling the current event is ultimately determined, laying the foundation for building an accurate and effective event handling process.

[0063] As can be seen from the above, this embodiment determines the initial logic module by calculating similarity, which broadens the range of options and avoids overlooking potential solutions. Furthermore, based on priority scoring, the urgency and importance of events can be fully considered to select the most suitable target logic module, making event processing more targeted and efficient, optimizing resource allocation, and meeting the needs of diverse business scenarios.

[0064] In one embodiment of this application, the similarity calculation method between the event feature vector and the feature label vector of each logical module in the logic library includes:

[0065] Construct a feature correlation matrix based on the degree of correlation between each event feature vector;

[0066] The similarity between the event feature vector and the feature label vector of each logic module in the logic library is obtained by fusing the cosine similarity and feature association matrix.

[0067] In this embodiment, the feature correlation matrix is ​​a matrix used to describe the degree of correlation between each event feature vector. The element values ​​in the matrix represent the correlation strength between two corresponding features. The feature correlation matrix can reflect the interrelationships between the various features of an event.

[0068] In this embodiment, the event feature vector is first analyzed to determine the degree of correlation between the various features.

[0069] For example, in e-commerce scenarios, analyzing user purchase events reveals correlations between features such as "purchase amount," "quantity of purchased items," and "unit price of items." The degree of correlation between each pair of features can be determined using association rule mining algorithms like Apriori or based on business expert experience, and then represented in matrix form. The rows and columns of the matrix correspond to different event features, and the values ​​of the matrix elements represent the strength of the correlation between the corresponding two features; larger values ​​indicate a stronger correlation.

[0070] Traditional cosine similarity calculation methods measure the directional similarity between two vectors, but do not consider the correlation information between features. In this embodiment, the cosine similarity between the event feature vector and the feature label vector of each logic module in the logic library is first calculated to obtain a preliminary similarity value. Then, the cosine similarity result is fused with the constructed feature association matrix. By incorporating the feature association information contained in the feature association matrix into the similarity calculation, the final similarity not only considers the directional similarity between vectors but also takes into account the intrinsic relationship between features.

[0071] For example, if two features show a close correlation in the feature association matrix, the weight of the matching between these two features on the final similarity score will be increased accordingly when calculating the similarity. This results in a more comprehensive and accurate similarity score that reflects the degree of matching between the event and the logical module.

[0072] As can be seen from the above, this embodiment constructs a feature association matrix, considers the inherent relationships between various features of an event, and then fuses it with cosine similarity to make the calculated similarity more comprehensive and accurate. This more accurately reflects the degree of matching between events and logical modules, enabling the selection of target logical modules with higher suitability, thereby improving the accuracy and reliability of event-driven low-code intelligent orchestration.

[0073] In one embodiment of this application, the similarity between the event feature vector and the feature label vector of each logic module in the logic library is expressed as follows:

[0074]

[0075] in, This represents the similarity between the event feature vector and the feature label vector of each logic module in the logic library. This represents the weight corresponding to the feature vector of the i-th event. This represents the weight corresponding to the j-th feature label vector. This represents the feature vector of the i-th event. Let C represent the feature label vector of the j-th feature, and let C represent the feature correlation matrix. This represents the degree of correlation between the i-th event feature vector and the j-th event feature vector, where n represents the number of event feature vectors.

[0076] In this embodiment, Some calculations take into account event feature vectors. Feature label vector and the weights between them , and degree of correlation Weight and This reflects the relative importance of different feature vectors. For example, in e-commerce scenarios, for the "purchase amount" event, the weight of the "purchase amount" feature vector may be higher than the weight of the "purchase time" feature vector, because the amount has a greater impact on business decisions. and The importance of each event's feature vector can be determined subjectively through experience.

[0077] This reflects the degree of correlation between the feature vector of the i-th event and the feature vector of the j-th event. For example, "quantity of goods purchased" and "amount of goods purchased" have a high degree of correlation. The value is reflected in this way. The molecule comprehensively considers all eigenvectors, their weights, and correlations to calculate a comprehensive correlation value among them.

[0078] This part involves normalization of the molecules. This part also considers weights. And the feature association matrix C. By normalization, the calculated similarity S value is made to be in the interval [0,1], which makes it easier to compare the similarity between the feature vectors of different events and the feature label vectors of logical modules.

[0079] In this embodiment, the similarity calculation formula incorporates feature weights and feature association information on the basis of traditional cosine similarity. It comprehensively considers the importance of each dimension of the event feature vector and the intrinsic relationship between the features. This allows for a more accurate measurement of the similarity between the two, which helps to more accurately select suitable logic modules to handle specific events in event-driven low-code intelligent orchestration.

[0080] In one embodiment of this application, the calculation method for the priority score of an event includes:

[0081] Priority scoring is determined based on the importance and urgency of the events.

[0082] The priority score is calculated as follows:

[0083]

[0084] in, Indicates the priority score of the event. The weights represent the degree of importance of an event. Indicates the importance of the event. The weights representing the urgency of an event. It indicates the urgency of the event.

[0085] In this embodiment, the importance of the event This indicates the degree of impact of an event on business objectives, business processes, etc. For example, in an e-commerce scenario, events involving the transaction process are of higher importance, while events involving ordinary user feedback (such as suggestions on interface colors) are of relatively lower importance.

[0086] The urgency of the incident This indicates the urgency of an event needing to be addressed. For example, a system failure during a major e-commerce promotion with only one hour left before the event starts is extremely urgent; while routine database maintenance events are relatively less urgent.

[0087] The weight corresponding to the importance of an event This is used to measure the weight of importance in the priority score calculation. The weight corresponding to the urgency of the event. This is used to measure the weight of urgency in the calculation of priority scores. and It can be determined based on the degree of importance that the business places on certain factors.

[0088] In this embodiment, the priority score calculation formula shows that the priority score of an event is not determined by a single factor, but rather by a combination of two key factors: the importance and urgency of the event. Events of high importance have a significant impact on the long-term development of the business and core objectives; events of high urgency, if not handled promptly, may lead to serious consequences. By incorporating these two factors into the calculation, the priority of events can be reflected more comprehensively.

[0089] and The degree of importance and urgency can be determined based on the different emphases of the business scenario. For example, in a medical emergency dispatch system, the urgency of the event is often more critical. The value of will be relatively large; however, in the handling of events related to corporate strategic planning, the importance of the event has a profound impact on the long-term development of the company. The value will be higher. By reasonably adjusting the weights, the priority score can be made more closely match the actual business needs, ensuring that resources are allocated to the events that have the greatest impact on the business.

[0090] In this embodiment, the final priority score Y is obtained through linear weighting. This calculation method can quickly and effectively quantify the priority of events. For example, for an event with an importance score of 8 (out of 10) and an urgency score of 6 (out of 10), if β1=0.6 and β2=0.4, then the priority score Y of this event is 0.6×8+0.4×6=7.2. Using this priority score, this embodiment can more scientifically sort and process events, prioritizing events with higher scores, thereby improving the efficiency and effectiveness of overall business processing.

[0091] As can be seen from the above, the priority scoring in this embodiment is calculated using a linear weighted method, which can comprehensively and scientifically quantify event priorities. This enables more reasonable allocation of resources, prioritizing the handling of events that have a significant and urgent impact on business operations, thereby improving business processing efficiency and effectiveness.

[0092] In one embodiment of this application, initial logic modules are filtered based on event priority scoring to obtain target logic modules, including:

[0093] Calculate the degree of correlation between the event and the initial logic module to obtain a correlation score;

[0094] The relevance score and the priority score of the event are combined to obtain a comprehensive score;

[0095] The initial logic module with the highest overall score is selected as the target logic module.

[0096] In this embodiment, the relevance score is a quantitative indicator that measures the degree of correlation between an event and an initial logic module. The relevance score reflects the degree of matching between the initial logic module and the current event.

[0097] In this embodiment, the correlation between an event and each initial logic module can be evaluated from multiple dimensions to derive a correlation score. These dimensions may include the matching degree between the functionality of the logic module and the event requirements, the consistency between the data processed by the logic module and the data involved in the event, and the historical processing performance of the logic module for similar events in similar business scenarios. For example, when handling the "abnormal user order amount" event on an e-commerce platform, for the "order amount verification logic module," this embodiment can analyze the module's ability to handle different abnormal amount situations, the consistency between the processed data format and the order data format, and the success rate of using this module to handle similar events in the past. These factors are then combined to calculate the correlation score between the module and the "abnormal user order amount" event.

[0098] In this embodiment, after obtaining the correlation score between the event and the initial logic module, it is fused with the priority score of the event itself. A weighted summation method can also be used for this fusion. Weighted summation considers both the importance and urgency of the event itself and the matching degree between the logic module and the event, making the final score more comprehensive and accurate. For example, for an event with a high priority score but generally low correlation with each initial logic module, the fused score can identify the most suitable logic module for handling the event.

[0099] In this embodiment, the comprehensive scores of each initial logic module are compared, and the initial logic module with the highest comprehensive score is selected as the target logic module. This is because the highest comprehensive score means that the logic module performs best in terms of its matching degree with the event and its adaptation to the importance and urgency of the event, and is most likely to handle the event efficiently and accurately.

[0100] For example, when handling the "insufficient stock of limited-time promotional items" event, after calculating and comparing the comprehensive scores of each initial logic module, the "emergency replenishment logic module" has the highest comprehensive score and is therefore identified as the target logic module for handling the event, thus laying the foundation for building an effective event handling process in the future.

[0101] As can be seen from the above, this embodiment calculates the relevance score to assess the matching degree between the event and the initial logic module, and then integrates it with the priority score to obtain a comprehensive score, thereby selecting the target logic module. This approach takes into account both the characteristics of the event itself and ensures the compatibility of the logic module, improving the accuracy and efficiency of event processing.

[0102] In one embodiment of this application, the method further includes:

[0103] In response to an event flow node in the target process having an execution time exceeding a preset time threshold, the parameters of the event flow node are updated based on the event's business rules to obtain a new target process; the business rules are rules that ensure the target process meets the actual operational requirements.

[0104] In response to a mismatch between the execution results of event flow nodes in the target process and the execution criteria, the order of the event flow nodes is adjusted to obtain a new target process; the execution criteria are the pre-set expected standards for the execution results of the event flow nodes.

[0105] In this embodiment, the preset time threshold is a pre-defined time standard value used to measure whether the execution time of an event flow node in the target process is too long. The preset time threshold can be determined based on factors such as business experience, historical data, or system performance requirements. For example, in an e-commerce order processing flow, the preset time threshold for the "payment confirmation" node may be set to 30 seconds. If the execution time of this node exceeds this threshold, the corresponding processing mechanism is triggered.

[0106] Business rules are rules that ensure target processes meet actual operational requirements. Business rules can be formulated based on business logic, industry standards, and internal corporate policies. For example, in a financial transaction process, business rules may include transaction amount limits and customer identity verification requirements to ensure that the transaction process is legal, compliant, and meets actual business needs.

[0107] Execution criteria are pre-defined expected standards for the execution results of event flow nodes. Execution criteria clearly define the state or result that should be achieved after each node is executed.

[0108] In this embodiment, when the target process is running, the execution time of each event process node can be monitored in real time. Once it is found that the execution time of a certain node exceeds a preset time threshold, it indicates that the execution efficiency of that node may affect the performance of the entire process. At this time, this embodiment can update the parameters of that node according to the business rules of the event.

[0109] For example, in the logistics and distribution process, if the "parcel sorting" node takes too long to execute, but the business rules stipulate that urgent orders should be delivered first, the sorting parameters can be adjusted, such as changing the sorting priority algorithm to prioritize urgent order parcels, thereby obtaining a new target process, improving the overall process efficiency, and ensuring that it meets the actual business operation requirements.

[0110] Similarly, during the execution of the target process, this embodiment can compare the execution result of each event flow node with a preset execution standard. If the execution result does not match the execution standard, it means that the execution of that node has not achieved the expected effect. At this time, this embodiment can adjust the order of the event flow nodes.

[0111] For example, in a software development process, if the "code testing" node discovers a large number of code errors, and the "code review" node is executed after "code testing," it will be impossible to promptly identify and correct problems in the code writing process. This embodiment can advance the "code review" node to execute immediately after "code writing," and by adjusting the node order, a new target flow is obtained, making the flow more reasonable and ensuring that subsequent execution results meet the expected standards.

[0112] As can be seen from the above, when the execution time of an event flow node exceeds the threshold, updating the parameters according to business rules can improve process efficiency; when the execution result of an event flow node does not meet the standard, adjusting the node order can ensure the rationality of the process. This makes the target process better fit the actual operational requirements, enhances the stability and reliability of the system, and thus effectively meets the ever-changing business needs.

[0113] Corresponding to the event-driven low-code intelligent orchestration method in the above embodiments, Figure 2 This is a block diagram illustrating the structure of an event-driven low-code intelligent orchestration system according to an embodiment of this application. For ease of explanation, only the parts relevant to the embodiment of this application are shown. References Figure 2 The event-driven low-code intelligent orchestration system 20 includes: a matching module 21, a node determination module 22, and a parameter configuration module 23.

[0114] Among them, the matching module 21 is used to match the event feature vector with the feature label vector of each logic module in the logic library to determine the target logic module corresponding to the event; the event feature vector is the feature vector after feature extraction of different types of events, the logic library is a pre-defined collection that stores multiple different logic modules, and the feature label vector is a vector that describes the event features applicable to the logic module;

[0115] The node determination module 22 is used to determine the event flow nodes based on the target logic module and combine the flow nodes to obtain the initial flow of the event.

[0116] The parameter configuration module 23 is used to configure the corresponding parameters for the event flow nodes of the initial process based on the event type, so as to obtain the target flow of the event.

[0117] In one embodiment of this application, the matching module 21 is specifically used for:

[0118] Based on the similarity between the event feature vector and the feature label vector of each logical module in the logic library, the initial logical module is determined. The initial logical module contains at least two logical modules from the logic library.

[0119] The initial logic modules are filtered based on the priority scoring of events to obtain the target logic modules.

[0120] In one embodiment of this application, the matching module 21 is further configured to:

[0121] Construct a feature correlation matrix based on the degree of correlation between each event feature vector;

[0122] The similarity between the event feature vector and the feature label vector of each logic module in the logic library is obtained by fusing the cosine similarity and feature association matrix.

[0123] In one embodiment of this application, the similarity between the event feature vector and the feature label vector of each logic module in the logic library is expressed as follows:

[0124]

[0125] in, This represents the similarity between the event feature vector and the feature label vector of each logic module in the logic library. This represents the weight corresponding to the feature vector of the i-th event. This represents the weight corresponding to the j-th feature label vector. This represents the feature vector of the i-th event. Let C represent the feature label vector of the j-th feature, and let C represent the feature correlation matrix. This represents the degree of correlation between the i-th event feature vector and the j-th event feature vector, where n represents the number of event feature vectors.

[0126] In one embodiment of this application, the matching module 21 is further configured to:

[0127] Priority scoring is determined based on the importance and urgency of the events.

[0128] The priority score is calculated as follows:

[0129]

[0130] in, Indicates the priority score of the event. The weights represent the degree of importance of an event. Indicates the importance of the event. The weights representing the urgency of an event. It indicates the urgency of the event.

[0131] In one embodiment of this application, the matching module 21 is further configured to:

[0132] Calculate the degree of correlation between the event and the initial logic module to obtain a correlation score;

[0133] The relevance score and the priority score of the event are combined to obtain a comprehensive score;

[0134] The initial logic module with the highest overall score is selected as the target logic module.

[0135] In one embodiment of this application, a process update module is further included; specifically used for:

[0136] In response to an event flow node in the target process having an execution time exceeding a preset time threshold, the parameters of the event flow node are updated based on the event's business rules to obtain a new target process; the business rules are rules that ensure the target process meets the actual operational requirements.

[0137] In response to a mismatch between the execution results of event flow nodes in the target process and the execution criteria, the order of the event flow nodes is adjusted to obtain a new target process; the execution criteria are the pre-set expected standards for the execution results of the event flow nodes.

[0138] See Figure 3 , Figure 3 This is a schematic block diagram of an electronic device provided according to an embodiment of this application. Figure 3The electronic device 300 in this embodiment may include one or more processors 301, one or more input devices 302, one or more output devices 303, and one or more memories 304. The processors 301, input devices 302, output devices 303, and memories 304 communicate with each other via a communication bus 305. The memories 304 store computer programs, including program instructions. The processors 301 execute the program instructions stored in the memories 304. Specifically, the processors 301 are configured to invoke the program instructions to perform the functions of the modules in the aforementioned system embodiments, for example... Figure 2 The functions of the matching module 21, node determination module 22, and parameter configuration module 23 are shown.

[0139] It should be understood that, in the embodiments of this application, the processor 301 may be a central processing unit (CPU), or it may be other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. The general-purpose processor may be a microprocessor or any conventional processor.

[0140] Input device 302 may include a touchpad, a fingerprint sensor (for collecting the user's fingerprint information and fingerprint orientation information), a microphone, etc., and output device 303 may include a display (LCD, etc.), a speaker, etc.

[0141] The memory 304 may include read-only memory and random access memory, and provides instructions and data to the processor 301. A portion of the memory 304 may also include non-volatile random access memory. For example, the memory 304 may also store information such as feature tag vectors and execution criteria of logic modules.

[0142] In specific implementations, the processor 301, input device 302, and output device 303 described in the embodiments of this application can execute the implementation methods described in the event-driven low-code intelligent orchestration method provided in the embodiments of this application, or they can execute the implementation methods of the electronic devices described in the embodiments of this application, which will not be repeated here.

[0143] In another embodiment of this application, a computer-readable storage medium is provided. This computer-readable storage medium stores a computer program, which includes program instructions. When executed by a processor, the program instructions implement all or part of the processes in the methods described above. Alternatively, the computer program can instruct related hardware to implement these processes. The computer program can be stored in a computer-readable storage medium, and when executed by a processor, it can implement the steps of the various method embodiments described above. The computer program includes computer program code, which can be in the form of source code, object code, executable files, or certain intermediate forms. The computer-readable medium can include any entity or system capable of carrying computer program code, a recording medium, a USB flash drive, a portable hard drive, a magnetic disk, an optical disk, a computer memory, a read-only memory (ROM), a random access memory (RAM), an electrical carrier signal, a telecommunication signal, and a software distribution medium, etc.

[0144] The computer-readable storage medium can be an internal storage unit of the electronic device in any of the foregoing embodiments, such as a hard disk or memory of the electronic device. The computer-readable storage medium can also be an external storage device of the electronic device, such as a plug-in hard disk, smart media card (SMC), secure digital card (SD), flash card, etc., equipped on the electronic device. Furthermore, the computer-readable storage medium can include both internal and external storage units of the electronic device. The computer-readable storage medium is used to store computer programs and other programs and data required by the electronic device. The computer-readable storage medium can also be used to temporarily store data that has been output or will be output.

[0145] Those skilled in the art will recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, computer software, or a combination of both. To clearly illustrate the interchangeability of hardware and software, the components and steps of the various examples have been generally described in terms of functionality in the foregoing description. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementations should not be considered beyond the scope of this application.

[0146] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the specific working process of the electronic devices and units described above can be referred to the corresponding process in the foregoing method embodiments, and will not be repeated here.

[0147] In the several embodiments provided in this application, it should be understood that the disclosed electronic devices and methods can be implemented in other ways. For example, the system embodiments described above are merely illustrative; for instance, the division of units is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple modules may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the mutual coupling or direct coupling or communication connections shown or discussed may be indirect coupling or communication connections through some interfaces or units, or they may be electrical, mechanical, or other forms of connection.

[0148] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of the embodiments of this application, depending on actual needs.

[0149] Furthermore, the functional modules in the various embodiments of this application can be integrated into a single processing unit, or each module can exist physically separately, or two or more modules can be integrated into a single system. The integrated modules described above can be implemented in hardware or as software functional modules.

[0150] The above are merely specific embodiments of this application, but the scope of protection of this application is not limited thereto. Any person skilled in the art can easily conceive of various equivalent modifications or substitutions within the technical scope disclosed in this application, and these modifications or substitutions should all be covered within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the scope of the claims.

Claims

1. An event-driven, low-code intelligent orchestration method, characterized in that, include: Based on the similarity between the event feature vector and the feature label vector of each logic module in the logic library, an initial logic module is determined, wherein the initial logic module contains at least two logic modules from the logic library; The similarity calculation method between the event feature vector and the feature label vector of each logical module in the logic library includes: Construct a feature correlation matrix based on the degree of correlation between each event feature vector; The event feature vector is fused with the cosine similarity of the event feature vector with the feature label vector of each logic module in the logic library and the feature association matrix to obtain the similarity between the event feature vector and the feature label vector of each logic module in the logic library. The initial logic modules are filtered based on the priority scores of the events to obtain the target logic modules; The event feature vector is a feature vector extracted from different types of events; the logic library is a pre-defined collection that stores multiple different logic modules; and the feature label vector is a vector describing the event features applicable to the logic module. The event flow nodes are determined based on the target logic module, and the flow nodes are combined to obtain the initial flow of the event; Based on the type of the event, the corresponding parameters are configured for the event flow nodes of the initial process to obtain the target flow of the event.

2. The event-driven low-code intelligent orchestration method as described in claim 1, characterized in that, The similarity between the event feature vector and the feature label vector of each logic module in the logic library is expressed as follows: in, This indicates the similarity between the event feature vector and the feature label vector of each logic module in the logic library. This represents the weight corresponding to the feature vector of the i-th event. This represents the weight corresponding to the j-th feature label vector. This represents the feature vector of the i-th event. Let C represent the feature label vector of the j-th feature, and let C represent the feature correlation matrix. This represents the degree of correlation between the i-th event feature vector and the j-th event feature vector, where n represents the number of event feature vectors.

3. The event-driven low-code intelligent orchestration method as described in claim 1, characterized in that, The calculation method for the priority score of the event includes: The priority score of the event is determined based on its importance and urgency. The priority score is calculated as follows: in, This indicates the priority score of the event. The weights represent the degree of importance of the events. Indicates the importance of the event. The weights representing the urgency of the events are indicated. This indicates the urgency of the event.

4. The event-driven low-code intelligent orchestration method as described in claim 1, characterized in that, The process of filtering the initial logic modules based on the priority score of the events to obtain the target logic modules includes: Calculate the degree of association between the event and the initial logic module to obtain an association score; The relevance score is combined with the priority score of the event to obtain a comprehensive score; The initial logic module with the highest overall score is selected as the target logic module.

5. The event-driven low-code intelligent orchestration method as described in claim 1, characterized in that, Also includes: In response to the execution time of an event flow node in the target flow exceeding a preset time threshold, the parameters of the event flow node are updated based on the business rules of the event to obtain a new target flow. The business rules are rules that ensure the target process meets the actual operational requirements; In response to a mismatch between the execution result of an event flow node in the target flow and the execution standard, the order of the event flow nodes is adjusted to obtain a new target flow; the execution standard is a preset expected standard for the execution result of the event flow node.

6. An event-driven, low-code intelligent orchestration system, characterized in that, include: A matching module is used to determine an initial logical module based on the similarity between the event feature vector and the feature label vector of each logical module in the logical library. The initial logical module contains at least two logical modules from the logical library. The initial logic modules are filtered based on the priority score of the events to obtain the target logic modules; the event feature vector is a feature vector after feature extraction of different types of events; the logic library is a pre-defined collection that stores multiple different logic modules; and the feature label vector is a vector describing the event features applicable to the logic module. The matching module is specifically used for: Construct a feature correlation matrix based on the degree of correlation between each event feature vector; The event feature vector is fused with the cosine similarity of the event feature vector with the feature label vector of each logic module in the logic library and the feature association matrix to obtain the similarity between the event feature vector and the feature label vector of each logic module in the logic library. The node determination module is used to determine the event flow nodes based on the target logic module, and combine the flow nodes to obtain the initial flow of the event; The parameter configuration module is used to configure corresponding parameters for the event flow nodes of the initial process based on the type of the event, so as to obtain the target flow of the event.

7. An electronic device comprising a memory, a processor, and a computer program stored in the memory and running on the processor, characterized in that, When the processor executes the computer program, it implements the steps of the method as described in any one of claims 1 to 5.

8. A computer-readable storage medium storing a computer program, characterized in that, When the computer program is executed by a processor, it implements the steps of the method as described in any one of claims 1 to 5.

Images