Method and apparatus for constructing process engine, use method for process engine, electronic device, and storage medium

Abstract

Embodiments of the present application provide a method and apparatus for constructing a process engine, a use method for a process engine, an electronic device, and a storage medium. The construction method comprises: determining one or more task nodes and one or more page nodes, the one or more task nodes being used for implementing corresponding process steps, and the one or more page nodes being used for generating corresponding user pages; generating a process engine model on the basis of the one or more task nodes and the one or more page nodes; and acquiring business-related information, and parsing the process engine model on the basis of the business-related information to obtain the process engine.

Description

The construction methods, usage methods, construction devices, electronic devices, and storage media of the process engine

[0001] Cross-references to related applications

[0002] This application claims priority to Chinese Patent Application No. 202510084072.7, filed on January 17, 2025, entitled “Method and Apparatus for Constructing a Process Engine”, the entire contents of which are incorporated herein by reference. Technical Field

[0003] This application relates to the field of computer technology, and in particular to a method for constructing a process engine, a method for using it, a construction device, an electronic device, and a storage medium. Background Technology

[0004] Currently, the process engine model is built on Business Process Model & Notation (BPMN) 2.0.

[0005] In related technologies, task nodes are designed based on business scenarios, and process engine models are built by designing process forms. Summary of the Invention

[0006] This application provides a method for building a process engine, a method for using it, a building apparatus, an electronic device, and a storage medium.

[0007] In a first aspect, embodiments of this application provide a method for constructing a process engine, comprising:

[0008] One or more task nodes and one or more page nodes are identified, wherein the one or more task nodes are used to implement the corresponding process steps, and the one or more page nodes are used to generate the corresponding user pages;

[0009] Generate a process engine model based on the one or more task nodes and the one or more page nodes; and

[0010] Obtain business-related information, and parse and process the process engine model based on the business-related information to obtain the process engine.

[0011] In some embodiments, the one or more task nodes are multiple, and the one or more page nodes are multiple. Determining the one or more task nodes and the one or more page nodes includes:

[0012] Based on the required functions of the process engine model, determine the multiple task nodes, the multiple page nodes, and the correspondence between the multiple task nodes and the multiple page nodes.

[0013] In some embodiments, determining one or more task nodes and one or more page nodes includes:

[0014] Based on multiple node elements, determine the first task node and the first page node; or

[0015] Based on the reuse process model, the second task node and the second page node are determined in the reuse process model.

[0016] In some embodiments, the one or more task nodes are multiple, and the one or more page nodes are multiple. Determining the one or more task nodes and the one or more page nodes includes:

[0017] Based on multiple node elements, determine the first task node and the first page node;

[0018] Based on the reuse process model, a second task node and a second page node are determined in the reuse process model; and

[0019] Determine the first task node and the second task node, and determine the first page node and the second page node.

[0020] In some embodiments, determining the first task node and the first page node based on multiple node elements includes:

[0021] Display a first modeling page, which includes the plurality of node elements;

[0022] In response to a connection operation on a plurality of first node elements among the plurality of node elements, a first task node is generated, wherein the first task node includes a plurality of first node elements having connection relationships; and

[0023] In response to a connection operation on a plurality of second node elements among the plurality of node elements, a first page node is generated, wherein the first page node includes a plurality of second node elements that are connected.

[0024] In some embodiments, determining the second task node and the second page node in the reuse process model based on the reuse process model includes:

[0025] Based on the degree of overlap between the functions required by the process engine model and the functions of the process engine models in the model database, determine whether to use the reused process model;

[0026] When it is determined that the reuse process model will be used, the reuse process model is loaded; and

[0027] Based on the reuse process model, a second task node and a second page node are determined in the reuse process model.

[0028] In some embodiments, the plurality of node elements includes one or more of the following:

[0029] Functions, operations, page elements, and containers.

[0030] In some embodiments, the one or more task nodes are multiple, and the one or more page nodes are multiple. Generating a process engine model based on the one or more task nodes and the one or more page nodes includes:

[0031] Display a second modeling page, which includes the plurality of task nodes and the plurality of page nodes; and

[0032] The process engine model is generated in response to a first connection operation between the plurality of task nodes and / or a second connection operation between the plurality of task nodes and the plurality of page nodes.

[0033] Wherein, the first connection operation is used to indicate the execution order among the plurality of task nodes, and the second connection operation is used to indicate the correspondence between the plurality of task nodes and the plurality of page nodes.

[0034] In some embodiments, the step of parsing the process engine model based on the business-related information to obtain the process engine includes:

[0035] The process engine model is parsed and processed by the backend parser to obtain the memory model;

[0036] The front-end parser calls the service interface of the back-end parser to load the memory model and parse the memory model to obtain model data.

[0037] Based on the aforementioned business-related information, the model data is processed by the front-end parser to render the user page; and

[0038] The process engine is determined, and the process engine includes the memory model and the user page.

[0039] In some embodiments, the model data includes task data corresponding to the task node and page data corresponding to the page node.

[0040] In some embodiments, the step of processing the model data through the front-end parser based on the business-related information and rendering the user page includes:

[0041] Determine the event corresponding to the process engine;

[0042] Create a binding relationship between the event and the model data; and

[0043] The user page is rendered based on the page data and the business-related information.

[0044] In some embodiments, creating the binding relationship between the event and the model data includes:

[0045] The front-end parser decomposes the task data and the page data into multiple node element data; wherein, the multiple node element data includes node element data corresponding to page components; and

[0046] The front-end parser creates the binding relationship between the event and the data model.

[0047] In some embodiments, the event is one or more of the following:

[0048] Click the button, enter content, select options, upload files, or drag and drop.

[0049] In some embodiments, the method further includes:

[0050] The third modeling page displays the process engine model corresponding to the process engine;

[0051] The process engine model is updated to obtain an updated process engine model; and

[0052] Based on the update process engine model, an update process engine corresponding to the process engine is generated.

[0053] Secondly, embodiments of this application provide a method for using a process engine, wherein the process engine is a process engine constructed according to any one of the process engine construction methods according to claims 1 to 14; the method includes:

[0054] The front-end parser obtains the request information based on the events responded to by the user's page;

[0055] The front-end parser sends the request information to the back-end parser;

[0056] The backend parser executes the task nodes based on the request information and obtains the process result;

[0057] The backend parser sends the process result to the frontend parser; and

[0058] The front-end parser re-renders the user page based on the process result.

[0059] In some embodiments, the request information includes business data, wherein the business data includes one or more of the following:

[0060] The input data, the data items to be queried, and the type of operation to be performed.

[0061] Thirdly, embodiments of this application provide a process engine construction apparatus, comprising:

[0062] The determination module is used to determine one or more task nodes and one or more page nodes, wherein the one or more task nodes are used to implement the corresponding process steps, and the one or more page nodes are used to generate the corresponding user pages.

[0063] The generation module is used to generate a process engine model based on the one or more task nodes and the one or more page nodes; and

[0064] The parsing module is used to determine business-related information and, based on the business-related information, parse and process the process engine model to obtain the process engine.

[0065] In some embodiments, the one or more task nodes are multiple, and the one or more page nodes are multiple. The determining module is used to determine the one or more task nodes and the one or more page nodes, specifically for:

[0066] Based on multiple node elements, determine the first task node and the first page node;

[0067] Based on the reuse process model, a second task node and a second page node are determined in the reuse process model; and

[0068] Determine the first task node and the second task node, and determine the first page node and the second page node.

[0069] Fourthly, embodiments of this application provide an electronic device, including: a memory and a processor;

[0070] The memory stores computer-executed instructions;

[0071] The processor executes computer execution instructions stored in the memory, causing the processor to perform the first and second aspects as described above, and / or various possible implementations of the first and second aspects.

[0072] Fifthly, embodiments of this application provide a computer-readable storage medium storing computer-executable instructions, which, when executed by a processor, are used to implement the first and second aspects as described above, and / or various possible implementations of the first and second aspects.

[0073] Sixthly, embodiments of this application provide a computer program product, including a computer program that, when executed by a processor, implements the first and second aspects as described above, and / or various possible implementations of the first and second aspects.

[0074] This application provides a method for constructing a process engine, a method for using it, a construction device, an electronic device, and a storage medium. By determining task nodes and page nodes, a process engine model is generated. Then, based on business-related information, the process engine model is parsed to obtain the process engine. Since task nodes are independent of business scenarios, when business in the business scenario is updated, it is only necessary to update the new task nodes and new page nodes corresponding to the new business on the basis of the process engine model, and then obtain the corresponding process engine through parsing, thereby improving the scalability of the process engine model. Attached Figure Description

[0075] The accompanying drawings, which are incorporated in and form part of this specification, illustrate embodiments consistent with this application and, together with the description, serve to explain the principles of this application.

[0076] Figure 1 is a schematic diagram of the structure of the process engine construction system provided in the embodiment of this application.

[0077] Figure 2 is a flowchart illustrating the method for constructing a process engine provided in an embodiment of this application.

[0078] Figure 3 is a flowchart illustrating the method for constructing a process engine provided in an embodiment of this application.

[0079] Figure 4 is a schematic diagram of the first modeling page provided in an embodiment of this application.

[0080] Figure 5 is a schematic diagram of the functionality of the process engine model provided in the embodiments of this application.

[0081] Figure 6 is a schematic diagram of the first connection operation between multiple task nodes provided in an embodiment of this application.

[0082] Figure 7 is a schematic diagram showing the connection of multiple node elements of a task node provided in an embodiment of this application.

[0083] Figure 8 is a schematic diagram of the connection of multiple node elements of a page node provided in an embodiment of this application.

[0084] Figure 9 is a schematic diagram of the functionality of the process engine provided in the embodiments of this application.

[0085] Figure 10 is a schematic diagram of the construction process of the process engine provided in the embodiment of this application.

[0086] Figure 11 is a schematic diagram of the construction process of the process engine provided in the embodiment of this application.

[0087] Figure 12 is a flowchart illustrating the method for constructing a process engine according to an embodiment of this application.

[0088] Figure 13 is a flowchart illustrating the process engine update method provided in an embodiment of this application.

[0089] Figure 14 is a schematic diagram of the construction of the extended functions provided in the embodiments of this application.

[0090] Figure 15 is a flowchart illustrating the usage method of the process engine provided in the embodiment of this application.

[0091] Figure 16 is a schematic diagram of a user page provided in an embodiment of this application.

[0092] Figure 17 is a schematic diagram of the structure of the process engine construction device provided in the embodiment of this application.

[0093] Figure 18 is a schematic diagram of the structure of the electronic device provided in the embodiment of this application.

[0094] The accompanying drawings illustrate specific embodiments of this application, which will be described in more detail below. These drawings and descriptions are not intended to limit the scope of the concept in any way, but rather to illustrate the concept of this application to those skilled in the art through reference to particular embodiments. Detailed Implementation

[0095] Exemplary embodiments will now be described in detail, examples of which are illustrated in the accompanying drawings. When the following description relates to the drawings, unless otherwise indicated, the same numbers in different drawings denote the same or similar elements. The embodiments described in the following exemplary embodiments do not represent all embodiments consistent with this application. Rather, they are merely examples of apparatuses and methods consistent with some aspects of this application as detailed in the appended claims.

[0096] First, the terms used in this application will be explained.

[0097] A process engine automates part or all of a business process in an electronic device, enabling data storage, related calculations, and data forwarding across multiple task nodes and page nodes according to certain predefined rules, thereby completing a certain process and achieving a certain expected task goal of the process.

[0098] A node element is the smallest unit element in the process engine model and is a general element not bound to the business in the business scenario.

[0099] A task node is a time point or position in the business scenario where one or several businesses end and allow one or several subsequent businesses to start. It marks a certain stage in the process and ensures that the businesses before this stage have been completed according to the predefined rules.

[0100] The page node corresponds to the task node. The page node can be any element in the user page, such as labels, attributes, text content, etc. One or more page nodes together constitute the structure and content of the user page.

[0101] In the embodiments of this application, terms such as "first" and "second" are used to distinguish identical or similar items with basically the same functions and effects. For example, the first value and the second value are only used to distinguish different values and do not limit their order. Those skilled in the art can understand that terms such as "first" and "second" do not limit the quantity and execution order, and terms such as "first" and "second" do not necessarily mean different.

[0102] It should be noted that in the embodiments of this application, words such as "exemplarily" or "for example" are used to give examples, illustrations or explanations. Any embodiment or design solution described as "exemplarily" or "for example" in this application should not be construed as more preferred or more advantageous than other embodiments or design solutions.确切而言,使用“示例性地”或者“例如”等词旨在以具体方式呈现相关概念。Rather, the use of words such as "exemplarily" or "for example" aims to present related concepts in a specific manner.

[0103] In the embodiments of this application, "at least one" means one or more, and "multiple" means two or more. "And / or" describes the association relationship of associated objects and indicates that there can be three relationships. For example, A and / or B can represent: A exists alone, A and B exist simultaneously, and B exists alone, where A and B can be singular or plural. The character " / " generally indicates that the associated objects before and after are in an "or" relationship. "At least one (item)" or its similar expression refers to any combination of these items, including any combination of single item (item) or plural items (items). For example, at least one (item) of a, b, or c can represent: a, b, c, a - b, a - c, b - c, or a - b - c, where a, b, c can be single or multiple.

[0104] Currently, the process engine models in related process engine products widely adopt the BPMN 2.0 specification or are designed based on meta-models. In the construction of process engine models using related methods, multiple task nodes are built based on business scenarios. By designing process forms, a process engine model is constructed to realize data storage, related calculations, and forwarding among multiple task nodes.

[0105] However, there are some problems with the construction methods of the relevant process engine models, especially when the business scenario changes, the scalability and reusability of the model are limited. The changes in the business scenario include business updates and business scenario transformations.

[0106] Specifically, traditional process engine models are usually designed based on specific business scenarios, resulting in overly granular models that include too many details of the business scenarios and specific business logic within those scenarios.

[0107] When updating business processes in a business scenario, the task nodes of the original process engine model may be too granular to directly adapt to new requirements. This necessitates extensive modifications and expansions to the entire process engine model, which not only increases development and maintenance costs but also reduces the system's scalability.

[0108] When business scenarios change, because the process engine model is strongly bound to specific business, it is impossible to directly reuse the nodes in the existing process engine model. It is necessary to rebuild the nodes in the process engine model corresponding to the current business scenario, making it difficult to achieve reuse between cross-process engine models, which limits the flexibility and application scope of the process engine model.

[0109] The exemplary embodiments of this application propose a method for constructing a process engine. This method designs the task nodes and page nodes for constructing the process engine model as general nodes, which are not bound to specific business scenarios, thus having higher scalability.

[0110] Figure 1 is a schematic diagram of the structure of the process engine construction system provided in an embodiment of this application. As shown in Figure 1, the system includes: a model tool, a model database, and a parser. The model tool can communicate with the parser.

[0111] The model tool is used to identify multiple task nodes and multiple page nodes, and to generate a process engine model based on the multiple task nodes and multiple page nodes, and to store the process engine model in the model database.

[0112] The model database is used to store process engine models.

[0113] The parser is used to determine business-related information and, based on this information, to parse and process the process engine model to obtain the process engine.

[0114] The technical solution of this application and how the technical solution of this application solves the above-mentioned technical problems are described in detail below with specific embodiments. These specific embodiments can be combined with each other, and the same or similar concepts or processes may not be described again in some embodiments. The embodiments of this application will now be described with reference to the accompanying drawings.

[0115] Figure 2 is a flowchart of one of the methods for building a process engine provided in the embodiments of this application. As shown in Figure 2, the method includes the following steps.

[0116] S201. Identify multiple task nodes and multiple page nodes.

[0117] Task nodes are used to implement the corresponding process steps, and page nodes are used to generate the corresponding user pages.

[0118] Process steps include, but are not limited to, data processing, information verification, approval, and data storage. Process steps are used to execute the data processing functions within the process.

[0119] Optionally, page nodes are used to generate user pages that users can interact with, including but not limited to form filling pages, confirmation pages, and result display pages.

[0120] Optionally, based on the required functions of the process engine model, determine multiple task nodes, multiple page nodes, and the correspondence between multiple task nodes and multiple page nodes.

[0121] Optionally, page nodes can correspond one-to-one with task nodes, or multiple task nodes can correspond to one page node. For example, multiple task nodes include task node 1, task node 2, and task node 3, and multiple page nodes include page node 1 and page node 2. In this case, task node 1 and task node 2 correspond to page node 1, and task node 3 corresponds to page node 2.

[0122] S202. Generate a process engine model based on multiple task nodes and multiple page nodes.

[0123] In some embodiments, multiple task nodes and multiple page nodes can be connected in a modeling tool to obtain a process engine model. The process engine model includes multiple task nodes, multiple page nodes, and the connection relationships between the multiple task nodes and multiple page nodes.

[0124] In some embodiments, the generated process engine model is stored in a model database.

[0125] S203. Determine the relevant business information, and based on the relevant business information, parse and process the process engine model to obtain the process engine.

[0126] In some embodiments, the process engine is used to execute process steps.

[0127] Optionally, the business-related information refers to the relevant information corresponding to the business in the business scenario. For example, when the business scenario is procurement, the business includes submitting a purchase request, reviewing the purchase request, entering order information, entering supplier delivery information, and entering warehouse receiving information, etc. The business-related information includes the amount of the purchase request, supplier information, review rules, approval status, etc.

[0128] The process engine construction method provided in this application generates a process engine model by determining task nodes and page nodes, and then parses the process engine model according to business-related information to obtain the process engine. Since the task nodes are independent of the business scenario, when the business in the business scenario is updated, it is only necessary to update the new task nodes and new page nodes corresponding to the new business on the basis of the process engine model, and then obtain the corresponding process engine through parsing, which reduces the development and maintenance costs and improves the scalability of the process engine model.

[0129] Figure 3 is a second schematic flowchart of the process engine construction method provided in the embodiment of this application. As shown in Figure 3, the method includes the following steps.

[0130] S301. Based on multiple node elements, construct multiple first task nodes and multiple first page nodes.

[0131] In some embodiments, the plurality of node elements includes a plurality of first node elements and a plurality of second node elements.

[0132] Multiple first task nodes and multiple first page nodes can be constructed as follows: display a first modeling page, which includes multiple node elements; generate multiple first task nodes in response to a connection operation on multiple first node elements among the multiple node elements; generate multiple first page nodes in response to a connection operation on multiple second node elements among the multiple node elements, where each first task node includes multiple first node elements with a connection relationship, and each first page node includes multiple second node elements with a connection relationship.

[0133] The first modeling page can be displayed as follows: Based on the page domain, construct multiple node elements; display the first modeling page, which includes multiple node elements.

[0134] Optionally, the page domain may include page scripts, page actions, page modules, and page components.

[0135] For example, page scripts are JavaScript code that executes when a user page loads; page actions are actions performed by the user on the user page, such as clicking, typing, dragging, etc.; page components are specific elements on the user page, such as input boxes, buttons, labels, etc.; and page modules refer to independent functional blocks on the user page, such as navigation bars, sidebars, content areas, etc.

[0136] Optionally, node elements may include function flows, actions, divisions (DIV), and containers.

[0137] Figure 4 is a schematic diagram of a first modeling page provided in an embodiment of this application. As shown in Figure 4, the first modeling page includes: functions, operations, page elements, and containers.

[0138] S302. Load the reuse process model and determine multiple second task nodes and multiple second page nodes in the reuse process model.

[0139] Optionally, depending on the degree of overlap between the functionality required by the constructed process engine model and the functionality of the process engine models in the model database, it may be possible to choose whether to load a reused process model.

[0140] Optionally, loading a reused process model means loading a process engine model from a model database. The process engine model in the model database includes a common model and process engine models that have already been generated and stored. The common model includes authentication management, engine general services, network authorization, etc.

[0141] Users can select multiple secondary task nodes and multiple page nodes within the reuse process model. For example, the various nodes in the reuse process model can be displayed on the modeling page, where users can select multiple secondary task nodes and multiple page nodes.

[0142] Figure 5 is a schematic diagram illustrating the functionality of a process engine model provided in an embodiment of this application. As shown in Figure 5, it includes four process engine models: an access center, a general engine service, authentication management, and network authorization. The access center is connected to the general engine service, authentication management, and network authorization.

[0143] The access center has functions including access process functions, network control functions, and other functions. Among them, the network control functions include access control rule functions and edge computing gateway (EG) authorization linkage functions.

[0144] The access control process includes multiple page nodes, such as access management, wired general authentication process, one-click network access process, and other page nodes.

[0145] The access control rules function includes multiple page nodes, such as access control rules, access control rule editing, and access control rule basic information.

[0146] The EG authorization linkage function includes multiple page nodes, such as EG authorization linkage.

[0147] The access center connects to the engine's general services, authentication management, and network authorization through multiple page nodes.

[0148] S303, determine that multiple task nodes include multiple first task nodes and / or multiple second task nodes, and determine that multiple page nodes include multiple first page nodes and / or multiple second page nodes.

[0149] In some embodiments, depending on the degree of overlap between the functionality required by the constructed process engine model and the functionality of the process engine model in the model database, one or more steps in S301 and S302 may be selected to be executed.

[0150] For example, when the overlap is higher than 30% but less than 100%, S301 and S302 are executed, and S303a is: determining that multiple task nodes include multiple first task nodes and multiple second task nodes, and determining that multiple page nodes include multiple first page nodes and multiple second page nodes.

[0151] For example, when the overlap is less than or equal to 30%, S301 is executed and S302 is not executed. S303b is: determining that multiple task nodes include multiple first task nodes, and determining that multiple page nodes include multiple first page nodes.

[0152] For example, when the overlap is equal to 100%, S301 is not executed, S302 is executed, and S303c is: determining that multiple task nodes include multiple second task nodes, and determining that multiple page nodes include multiple second page nodes.

[0153] S304. Display the second modeling page, which includes multiple task nodes and multiple page nodes.

[0154] S305, in response to the first connection operation between multiple task nodes and the second connection operation between multiple task nodes and multiple page nodes, generate a process engine model.

[0155] The first connection operation is used to indicate the execution order among multiple task nodes, and the second connection operation is used to indicate the correspondence between task nodes and page nodes.

[0156] Optionally, the process engine model includes multiple task nodes, multiple page nodes, the execution order between multiple task nodes, and the correspondence between multiple task nodes and multiple page nodes.

[0157] Optionally, multiple task nodes cooperate with the gateway to perform the first connection operation, whereby the user ensures the execution of process steps during the first connection operation.

[0158] Optionally, the second connection operation is used to ensure consistency between the user page and the process steps.

[0159] Figure 6 is a schematic diagram of a first connection operation between multiple task nodes provided in an embodiment of this application. As shown in Figure 6, the schematic diagram illustrates: 8 task nodes, 3 gateways, and a server.

[0160] The eight task nodes are: applicant initiation, direct supervisor approval, business process (BP) approval, finance department approval, department manager approval, business unit general approval, and business unit (BU) general approval. The three gateways are gateway 1, gateway 2, and gateway 3.

[0161] The server is used to send a request for approval to the direct supervisor when an applicant initiates an application.

[0162] Eight task nodes, in conjunction with three gateways, perform the first connection operation, which indicates the execution order among the eight task nodes.

[0163] For example, direct supervisor approval, in conjunction with gateway 1, establishes the first connection with BP approval, finance department approval, and department manager approval. When direct supervisor approval is approved by gateway 1, the next task node (BP approval, finance department approval, or department manager approval) is automatically selected and executed.

[0164] Figure 7 is a schematic diagram of the connection of multiple node elements of a task node provided in an embodiment of this application. As shown in Figure 7, the task node is for department manager approval. This task node includes multiple node elements and multiple forms contained in the node elements. The multiple node elements include approval page information, approval page application details, workflow application details, workflow application details query function, approval page approval dynamics, workflow progress, workflow progress query function, approval page button, approve application button, approve application button callback function, reject application button, reject application button callback function, approve application pop-up, approve application form, approve application form opinion field, approve application confirmation button, approve application confirmation button callback function, reject application pop-up, reject application form, reject application form opinion field, reject application confirmation button, reject application confirmation button callback function. The multiple forms include Form 1, Form 2, Form 3, Form 4, Form 5, Form 6, Form 7, and Form 8.

[0165] Node elements are linked together using slots.

[0166] The approval page information, approval page application details, workflow application details, and workflow application details query function are interconnected. The workflow application details query function allows access to and retrieval of workflow application details. Figure 7 exemplarily illustrates the approval page application details of Form 1 (approval page information), the workflow application details of Form 2 (approval page application details), and the workflow application details query function.

[0167] The approval page information, approval page status, workflow progress, and workflow progress query function are interconnected, and the workflow progress can be accessed and retrieved through the workflow progress query function.

[0168] The approval page button, the "agree to application" button, and the callback function for the "agree to application" button are interconnected. The callback function for the "agree to application" button executes the corresponding approval process steps when the "agree to application" button is clicked.

[0169] The approval page button, the reject application button, and the reject application button callback function are interconnected. The reject application button callback function enables the execution of the corresponding approval process steps when the reject application button is clicked.

[0170] The approval application pop-up, approval application form, and approval application form comments are interconnected. The approval application pop-up, approval application confirmation button, and approval application confirmation button callback function are also interconnected. Through the approval application confirmation button callback function, when the approval application confirmation button is clicked in the approval application pop-up and the corresponding approval application form comments are filled in, the corresponding approval process steps are executed.

[0171] The application rejection pop-up, application rejection form, and application rejection form comment field, along with the application rejection pop-up, application rejection confirmation button, and application rejection confirmation button callback function, are interconnected. The application rejection confirmation button callback function enables the execution of the corresponding approval process steps when the application rejection confirmation button is clicked in the application rejection pop-up and the corresponding application rejection form comment field is filled in.

[0172] Optionally, a form can be a panel, a default style, a title, a data area, a value alignment, a size, a field name, a footer, an item, extra content, a button, a label, a left-icon, an error-message, an input box, and a right-icon.

[0173] Figure 8 is a schematic diagram of the connection of multiple node elements of a page node provided in an embodiment of this application. As shown in Figure 8, the page node is "My Approvals". This page node includes multiple node elements and multiple forms contained in the node elements. The multiple node elements include a label container, a list display submodule, to-do, completed, copied to me, navigation bar, initial request, toggle (tab), pull-up loading, pull-down refresh, and card click. The multiple forms include Form 1 and Form 2.

[0174] The label container Form 1 is linked to the to-do and completed items, so that after the user fills out Form 1 and submits it, the display of "to-do" or "completed" items that match the information in Form 1 will be dynamically updated.

[0175] The label container Form 2, along with the list display submodule and the "Copy to Me" link, enables users to view the updated information in Form 2 in the list display submodule, and allows users to view only the approval items copied to them.

[0176] The navigation bar, initial request, toggle, pull-to-load, pull-to-refresh, card click, etc., are bound to the label container and its corresponding node elements through functions to achieve the corresponding functions. For example, the toggle can implement switching between "To-do" and "Completed".

[0177] Figure 9 is a schematic diagram of the functions of a process engine provided in an embodiment of this application. As shown in Figure 9, the process engine is for personnel approval. The functions of the process engine include: business hall function, my approval function, and my application function. The page nodes of the process engine include: business hall, my approval, and my application, wherein each function corresponds to a page node.

[0178] S306. Determine the relevant business information, and based on the relevant business information, parse and process the process engine model to obtain the process engine.

[0179] Figure 10 is a schematic diagram of the construction process of a process engine provided in an embodiment of this application. As shown in Figure 10, it includes: page domain, node elements, multiple task nodes, multiple page nodes, process engine model 1, process engine model 2, parser, process engine 1, and process engine 2.

[0180] The page domain includes page scripts, page actions, page modules, and page components.

[0181] Node elements include multiple functions, multiple operations, multiple page elements, and multiple containers.

[0182] As shown in Figure 10, multiple node elements are constructed based on the page domain; multiple task nodes and multiple page nodes are constructed based on the multiple node elements; based on the same task nodes and page nodes, process engine model 1 and process engine model 2 are constructed through different connection operations; through the parser, process engine model 1 and process engine model 2 are parsed and processed respectively to obtain process engine 1 corresponding to process engine model 1 and process engine 2 corresponding to process engine model 2.

[0183] Figure 11 is a second schematic diagram of the construction process of a process engine provided in an embodiment of this application. As shown in Figure 11, when the existing process engine model contains the functions required by business scenario 1 (e.g., common function 1 and common function 2), business scenario 1 only needs to construct core function 1 and core function 2 through node elements, and then construct the new process engine model required by business scenario 1 by reusing common function 1 and common function 2.

[0184] The construction method of the new process engine model required for business scenario 2 is similar to that required for business scenario 1, and will not be repeated here.

[0185] For the construction method of the relevant process engine model, when updating the function of the process engine model, it is necessary to rebuild all the functions in the new process engine model. The update complexity of the process engine model is O(n), where O represents the time complexity. In the embodiment of this application, when updating the function of the process engine model, the original functions in the process engine model are reused, and the updated functions of the process engine model are constructed based on multiple node elements to realize the update of the process engine model. The update complexity of the process engine model is O(1), which reduces the complexity of updating the process engine model.

[0186] In the process engine construction method provided in this application embodiment, multiple task nodes and multiple page nodes are constructed using node elements. A process engine model is generated in response to a first connection operation between the multiple task nodes and a second connection operation between the multiple task nodes and the multiple page nodes. Then, based on business-related information, the process engine model is parsed to obtain the process engine. Since node elements are independent of the business scenario, task nodes are also independent of the business scenario. When business updates occur in the business scenario, it is only necessary to construct new task nodes and new page nodes corresponding to the new business using node elements, connect these new task nodes and new page nodes with the task nodes and page nodes of the original process engine model, and then parse the data to obtain the corresponding process engine, thus improving the scalability of the process engine model. The use of unified node elements for the construction of task nodes and page nodes simplifies the construction of the process engine model.

[0187] Furthermore, when the functionality required by the constructed process engine model overlaps significantly with that of the process engine model in the model database, a reused process model can be loaded (an existing process engine model can be loaded from the model database). Multiple task nodes and multiple page nodes of the reused process model can be connected with multiple task nodes and multiple page nodes constructed through node elements to generate a new process engine model. Then, through parsing and processing, the corresponding process engine can be obtained, thus improving the reusability of the process engine model.

[0188] In some embodiments, the parser includes a back-end parser and a front-end parser. This embodiment will be described below with reference to FIG12.

[0189] Figure 12 is a schematic diagram of the third step in the process engine construction method provided in this application embodiment. As shown in Figure 12, the method includes the following steps.

[0190] S1201, Identify multiple task nodes and multiple page nodes.

[0191] S1202. Generate a process engine model based on multiple task nodes and multiple page nodes.

[0192] S1203. The process engine model is parsed and processed by the backend parser to obtain the memory model.

[0193] In some embodiments, the process engine model is compiled by a backend parser to obtain a memory model that can be recognized by the electronic device.

[0194] S1204. The front-end parser calls the service interface of the back-end parser to load the memory model and parse the memory model to obtain the model data.

[0195] In some embodiments, the model data includes multiple task data corresponding to multiple task nodes and multiple page data corresponding to multiple page nodes, wherein the multiple task data and multiple page data can be recognized by the electronic device.

[0196] S1205. The front-end parser determines the relevant business information, and based on the relevant business information, processes the model data and renders multiple user pages.

[0197] In some embodiments, S1205 specifically includes: determining business-related information; determining multiple events corresponding to the process engine; establishing a binding relationship between the multiple events and model data; and rendering multiple user pages based on multiple page data and business-related information.

[0198] Optionally, events may include clicking a button, entering content, selecting an option, uploading a file, or dragging and dropping.

[0199] Optionally, a binding relationship is created between multiple events, multiple task data, and multiple page data. Specifically, this includes: using a front-end parser to decompose multiple task data and multiple page data into multiple node element data, where the multiple node element data are the node element data corresponding to the page components; and using Function Flow to create a binding relationship between multiple events and multiple node element data, wherein the multiple node element data can be recognized by electronic devices.

[0200] S1206. Determine the process engine, which includes a memory model and multiple user pages.

[0201] In some embodiments, multiple user pages are displayed on the same or different electronic devices.

[0202] In the process engine construction method provided in this application embodiment, the process engine model is parsed and processed by the backend parser to obtain the memory model. The frontend parser calls the service interface of the backend parser to load the memory model and parses and processes the memory model to obtain model data. The model data is processed and rendered to obtain multiple user pages, thereby determining the process engine. The process engine includes the memory model and multiple user pages, realizing the parsing and rendering of the process engine model, so that users can trigger the process engine to execute multiple process steps in sequence by executing one or more specific events on the user page.

[0203] Based on any of the above embodiments, the construction method of the process engine will be further explained below with reference to Figure 13.

[0204] Figure 13 is a flowchart illustrating the update method of the process engine provided in this application embodiment. As shown in Figure 5, the method includes:

[0205] S1301. On the third modeling page, the process engine model corresponding to the process engine is displayed.

[0206] In some embodiments, the process engine model corresponding to the process engine is loaded into the model database.

[0207] S1302. Perform an update operation on the process engine model to obtain the updated process engine model.

[0208] The update operation for the process engine model is an extended function for updating the process engine model.

[0209] In some embodiments, if a process engine model with the same functionality as the extended functionality does not exist in the model database, S1302 includes:

[0210] Display the third modeling page, which includes multiple node elements;

[0211] In response to a join operation on multiple first node elements among multiple node elements, multiple first task nodes are generated, each first task node including multiple first node elements with a join relationship.

[0212] In response to a connection operation on multiple second node elements among multiple node elements, multiple first page nodes are generated, and the first page nodes include multiple second node elements that are connected.

[0213] In the process engine model, identify multiple third-party task nodes and multiple third-party page nodes;

[0214] The multiple task nodes are determined to include multiple first task nodes and multiple third task nodes, and the multiple page nodes are determined to include multiple first page nodes and multiple third page nodes;

[0215] In response to the first connection operation between multiple task nodes and the second connection operation between multiple task nodes and multiple page nodes, an update process engine model is generated.

[0216] In some embodiments, if a process engine model with the same functionality as the extended functionality exists in the model database, S1302 includes:

[0217] Load the reuse process model, and determine multiple second task nodes and multiple second page nodes in the reuse process model;

[0218] In the process engine model, identify multiple third-party task nodes and multiple third-party page nodes;

[0219] The multiple task nodes are determined to include multiple second task nodes and multiple third task nodes, and the multiple page nodes are determined to include multiple second page nodes and multiple third page nodes;

[0220] In response to the first connection operation between multiple task nodes and the second connection operation between multiple task nodes and multiple page nodes, an update process engine model is generated.

[0221] In some embodiments, if a process engine model with partially identical functionality to the extended functionality exists in the model database, S1302 includes:

[0222] Display the third modeling page, which includes multiple node elements;

[0223] In response to a join operation on multiple first node elements among multiple node elements, multiple first task nodes are generated, each first task node including multiple first node elements with a join relationship.

[0224] In response to a connection operation on multiple second node elements among multiple node elements, multiple first page nodes are generated, and the first page nodes include multiple second node elements that are connected.

[0225] Load the reuse process model and identify multiple second nodes in the reuse process model. The multiple second nodes include multiple second task nodes and multiple second page nodes.

[0226] In the process engine model, identify multiple third-party task nodes and multiple third-party page nodes;

[0227] The multiple task nodes are determined to include multiple first task nodes, multiple second task nodes, and multiple third task nodes; and the multiple page nodes are determined to include multiple first page nodes, multiple second page nodes, and multiple third page nodes.

[0228] In response to the first connection operation between multiple task nodes and the second connection operation between multiple task nodes and multiple page nodes, an update process engine model is generated.

[0229] Figure 14 is a schematic diagram of the construction of an extended function provided in an embodiment of this application. As shown in Figure 14, it includes: functions, operations, page elements, containers, extended function 1, and extended function 2.

[0230] Based on functions, operations, page elements, and containers, construct extended function 1 and extended function 2 respectively. Extended function 1 and extended function 2 include one or more task nodes and one or more page nodes.

[0231] Extended Function 1 and Extended Function 2 can be authentication blacklists or authentication whitelists.

[0232] S1303. Based on the updated process engine model, generate the updated process engine corresponding to the process engine.

[0233] In some embodiments, business-related information is determined, and the updated process engine model is parsed and processed based on the business-related information to obtain the updated process engine.

[0234] In the process engine update method provided in this application embodiment, when the business scenario needs to update and expand the functions, it is only necessary to construct the first task node and the first page node corresponding to the new business through node elements, and / or reuse the second task node and the second page node of the existing process engine model in the model database, and connect them with the third task node and the third page node of the original process engine model to generate the updated process engine model. Then, through parsing and processing, the corresponding updated process engine is obtained, which improves the scalability and reusability of the process engine model.

[0235] Based on any of the above embodiments, the following description, in conjunction with Figure 15, further illustrates the usage of the process engine.

[0236] Figure 15 is a flowchart illustrating a method for using a process engine according to an embodiment of this application. As shown in Figure 15, the method includes:

[0237] S1501, The user page responds to one or more specific events.

[0238] Optionally, the user page responds to one or more specific events performed by the user.

[0239] S1502. The front-end parser captures one or more events in the user page response and obtains the request information.

[0240] The request information includes a request instruction and business data. The request instruction is used to instruct the backend parser to start executing multiple task nodes, and the business data is used to instruct the backend parser to execute multiple task nodes in the order of execution.

[0241] Optionally, business data may include input data, data items to be queried, and / or the type of operation to be performed.

[0242] S1503. The front-end parser calls the service interface of the back-end parser and sends request information to the back-end parser.

[0243] S1504. The backend parser executes multiple task nodes in the order of execution based on the request information and the memory model to obtain the process result.

[0244] In some embodiments, after the backend parser identifies the request instruction in the request information, it executes multiple task nodes in the order of execution according to the business data in the request information and the memory model to obtain the process result.

[0245] S1505, The backend parser sends the process results to the frontend parser.

[0246] Optionally, the process results may include a success or failure status, generated data, error messages, etc.

[0247] S1506. The front-end parser re-renders the user page based on the process results.

[0248] In some embodiments, executing multiple task nodes in execution order includes executing N task nodes in the order of the first task node to the Nth task node. In this embodiment, the operation after executing S1501-S1503 can be:

[0249] Based on the request information, the backend parser executes the first to Nth task nodes in the order of execution through the memory model, obtaining the first to Mth process results.

[0250] When the backend parser receives the m-th process result, it sends the m-th process result to the frontend parser, where m is equal to 1 to M.

[0251] The front-end parser re-renders the user page based on the result of the m-th process.

[0252] Optionally, M and N can be equal or unequal. When M and N are equal, there is a one-to-one correspondence between task nodes and process results. When M and N are unequal, multiple task nodes correspond to one process result. Here, M and N are both integers.

[0253] Figure 16 is a schematic diagram of a user page provided in an embodiment of this application. This user page is one of the user pages used by the process engine for job change approval.

[0254] Figure 17 is a schematic diagram of a process engine building device provided in an embodiment of this application. As shown in Figure 17, the process engine building device 170 provided in this embodiment includes:

[0255] The determination module 1701 is used to determine multiple task nodes and multiple page nodes, wherein the task nodes are used to implement corresponding process steps, and the page nodes are used to generate corresponding user pages.

[0256] The generation module 1702 is used to generate a process engine model based on the plurality of task nodes and the plurality of page nodes;

[0257] The parsing module 1703 is used to determine business-related information and, based on the business-related information, to parse the process engine model to obtain the process engine.

[0258] It should be noted that the process engine construction device 170 provided in this application embodiment can implement all the method steps implemented in the above method embodiment and can achieve the same technical effect. Here, the parts that are the same as those in the method embodiment and the beneficial effects will not be described in detail.

[0259] In some embodiments, the determining module 1701 is specifically used for:

[0260] Based on multiple node elements, construct multiple first task nodes and multiple first page nodes;

[0261] Load the reuse process model, and determine multiple second task nodes and multiple second page nodes in the reuse process model;

[0262] The plurality of task nodes are determined to include the plurality of first task nodes and / or the plurality of second task nodes, and the plurality of page nodes are determined to include the plurality of first page nodes and / or the plurality of second page nodes.

[0263] In some embodiments, the determining module 1701 is specifically used for:

[0264] Display a first modeling page, which includes the plurality of node elements;

[0265] In response to a connection operation on a plurality of first node elements among the plurality of node elements, a plurality of first task nodes are generated, wherein the task nodes include a plurality of first node elements having a connection relationship.

[0266] In response to a connection operation on a plurality of second node elements among the plurality of node elements, a plurality of first page nodes are generated, wherein the page nodes include a plurality of second node elements that are connected.

[0267] In some embodiments, the generation module 1702 is specifically used for:

[0268] Display a second modeling page, which includes the plurality of task nodes and the plurality of page nodes;

[0269] The process engine model is generated in response to a first connection operation between the plurality of task nodes and a second connection operation between the plurality of task nodes and the plurality of page nodes.

[0270] The first connection operation is used to indicate the execution order among the plurality of task nodes, and the second connection operation is used to indicate the correspondence between the task nodes and the page nodes.

[0271] In some embodiments, the parsing module 1703 is specifically used for:

[0272] The process engine model is parsed and processed by the backend parser to obtain the memory model;

[0273] The front-end parser calls the service interface of the back-end parser to load the memory model and parse the memory model to obtain model data.

[0274] Based on the business-related information, the model data is processed by the front-end parser to render multiple user pages;

[0275] The process engine is determined, and the process engine includes the memory model and the multiple user pages.

[0276] In some embodiments, the model data includes multiple task data corresponding to the multiple task nodes and multiple page data corresponding to the multiple page nodes;

[0277] Parsing module 1703 is specifically used for:

[0278] Identify the multiple events corresponding to the process engine;

[0279] Create a binding relationship between the multiple events and the model data;

[0280] Based on the data from the multiple pages and the business-related information, multiple user pages are rendered.

[0281] In some embodiments, the generation module 1702 is further configured to display the process engine model corresponding to the process engine on the third modeling page;

[0282] The generation module 1702 is also used to perform an update operation on the process engine model to obtain an updated process engine model;

[0283] The parsing module 1703 is also used to generate an update process engine corresponding to the process engine based on the update process engine model.

[0284] It should be noted that the process engine construction device 170 provided in this application embodiment can implement all the method steps implemented in the above method embodiment and can achieve the same technical effect. Here, the parts that are the same as those in the method embodiment and the beneficial effects will not be described in detail.

[0285] It should be understood that the aforementioned process engine construction apparatus 170 is embodied in the form of functional modules. The term "module" here may refer to application-specific integrated circuits (ASICs), electronic circuits, processors (e.g., shared processors, proprietary processors, or group processors) and memories for executing one or more software or firmware programs, combined logic circuits, and / or other suitable components that support the described functions.

[0286] Figure 18 is a schematic diagram of the structure of an electronic device provided in an embodiment of this application. The electronic device can be replaced by other devices that perform the above-described method embodiments. As shown in Figure 18, the electronic device 180 provided in this embodiment includes at least one processor 1801 and a memory 1802. The processor 1801 and the memory 1802 are connected via a bus 1803.

[0287] In a specific implementation, at least one processor 1801 executes computer execution instructions stored in memory 1802, causing at least one processor 1801 to perform the above-described method.

[0288] The specific implementation process of processor 1801 can be found in the above method embodiments, and its implementation principle and technical effect are similar, so it will not be repeated here.

[0289] In the above embodiments, it should be understood that the processor can be a Central Processing Unit (CPU), or other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), etc. The general-purpose processor can be a microprocessor or any conventional processor. The steps of the method disclosed in this application can be directly implemented by a hardware processor, or implemented by a combination of hardware and software modules within the processor.

[0290] The memory may include random access memory (RAM) and may also include non-volatile memory (NVM), such as at least one disk storage device.

[0291] The bus can be an Industry Standard Architecture (ISA) bus, a Peripheral Component Interconnect (PCI) bus, or an Extended Industry Standard Architecture (EISA) bus, etc. Buses can be categorized as address buses, data buses, control buses, etc. For ease of illustration, the buses shown in the accompanying drawings are not limited to a single bus or a single type of bus.

[0292] This application also provides a computer program product, including a computer program that, when executed by a processor, implements the above-described method.

[0293] This application also provides a computer-readable storage medium storing computer-executable instructions, which, when executed by a processor, implement the above-described method.

[0294] The aforementioned readable storage medium can be implemented from any type of volatile or non-volatile storage device or a combination thereof, such as Static Random-Access Memory (SRAM), Electrically Erasable Programmable Read-Only Memory (EEPROM), Erasable Programmable Read-Only Memory (EPROM), Programmable Read-Only Memory (PROM), Read-Only Memory (ROM), magnetic storage, flash memory, magnetic disk, or optical disk. The readable storage medium can be any available medium accessible to a general-purpose or special-purpose computer.

[0295] An exemplary readable storage medium is coupled to a processor, enabling the processor to read information from and write information to the readable storage medium. Of course, the readable storage medium can also be a component of the processor. The processor and the readable storage medium can reside in an application-specific integrated circuit (ASIC). Alternatively, the processor and the readable storage medium can exist as discrete components in the device.

[0296] The division of units is merely a logical functional division; in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be indirect coupling or communication connection through some interfaces, devices, or units, and may be electrical, mechanical, or other forms.

[0297] 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 this embodiment according to actual needs.

[0298] In addition, the functional units in the various embodiments of this application can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit.

[0299] If a function is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solutions of the embodiments of this application, or the parts that contribute to related technologies, or parts of the technical solutions, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods of the various embodiments of this application. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, ROM, RAM, magnetic disks, or optical disks.

[0300] Those skilled in the art will understand that all or part of the steps of the above-described method embodiments can be implemented by hardware related to program instructions. The aforementioned program can be stored in a computer-readable storage medium. When executed, the program performs the steps of the above-described method embodiments; and the aforementioned storage medium includes various media capable of storing program code, such as ROM, RAM, magnetic disks, or optical disks.

[0301] Finally, it should be noted that other embodiments of this application will readily conceive of by those skilled in the art upon consideration of the specification and practice of the application disclosed herein. This application is intended to cover any variations, uses, or adaptations of this application that follow the general principles of the invention and include common knowledge or customary techniques in the art not disclosed herein, and is not limited to the precise structures described above and shown in the accompanying drawings, and various modifications and changes can be made without departing from its scope. The scope of this application is limited only by the appended claims.

Claims

1. A method for constructing a process engine, comprising: One or more task nodes and one or more page nodes are identified, wherein the one or more task nodes are used to implement the corresponding process steps, and the one or more page nodes are used to generate the corresponding user pages; Generate a process engine model based on the one or more task nodes and the one or more page nodes; as well as Obtain business-related information, and parse and process the process engine model based on the business-related information to obtain the process engine.

2. The method according to claim 1, wherein, The one or more task nodes are multiple, the one or more page nodes are multiple, and determining the one or more task nodes and the one or more page nodes includes: Based on the required functions of the process engine model, determine the multiple task nodes, the multiple page nodes, and the correspondence between the multiple task nodes and the multiple page nodes.

3. The method according to claim 1 or 2, wherein, The determination of one or more task nodes and one or more page nodes includes: Based on multiple node elements, determine the first task node and the first page node; or Based on the reuse process model, the second task node and the second page node are determined in the reuse process model.

4. The method according to claim 1 or 2, wherein, The one or more task nodes are multiple, the one or more page nodes are multiple, and determining the one or more task nodes and the one or more page nodes includes: Based on multiple node elements, determine the first task node and the first page node; Based on the reuse process model, a second task node and a second page node are determined in the reuse process model; and Determine the first task node and the second task node, and determine the first page node and the second page node.

5. The method according to claim 4, wherein, The step of determining the first task node and the first page node based on multiple node elements includes: Display a first modeling page, which includes the plurality of node elements; In response to a connection operation on a plurality of first node elements among the plurality of node elements, a first task node is generated, wherein the first task node includes a plurality of first node elements having connection relationships; and In response to a connection operation on a plurality of second node elements among the plurality of node elements, a first page node is generated, wherein the first page node includes a plurality of second node elements that are connected.

6. The method according to claim 4 or 5, wherein, The determination of the second task node and the second page node based on the reuse process model includes: Based on the degree of overlap between the functions required by the process engine model and the functions of the process engine models in the model database, determine whether to use the reused process model; When it is determined that the reuse process model will be used, the reuse process model is loaded; and Based on the reuse process model, a second task node and a second page node are determined in the reuse process model.

7. The method according to any one of claims 1 to 6, wherein, The plurality of node elements includes one or more of the following: Functions, operations, page elements, and containers.

8. The method according to any one of claims 1 to 7, wherein, The one or more task nodes are multiple, the one or more page nodes are multiple, and the step of generating a process engine model based on the one or more task nodes and the one or more page nodes includes: Display a second modeling page, which includes the plurality of task nodes and the plurality of page nodes; and The process engine model is generated in response to a first connection operation between the plurality of task nodes and / or a second connection operation between the plurality of task nodes and the plurality of page nodes. Wherein, the first connection operation is used to indicate the execution order among the plurality of task nodes, and the second connection operation is used to indicate the correspondence between the plurality of task nodes and the plurality of page nodes.

9. The method according to any one of claims 1 to 8, wherein, The step of parsing and processing the process engine model based on the business-related information to obtain the process engine includes: The process engine model is parsed and processed by the backend parser to obtain the memory model; The front-end parser calls the service interface of the back-end parser to load the memory model and parse the memory model to obtain model data. Based on the aforementioned business-related information, the model data is processed by the front-end parser to render the user page; and The process engine is determined, and the process engine includes the memory model and the user page.

10. The method according to claim 9, wherein, The model data includes task data corresponding to the task nodes and page data corresponding to the page nodes.

11. The method according to claim 10, wherein, The step of processing the model data through the front-end parser based on the business-related information and rendering the user page includes: Determine the event corresponding to the process engine; Create a binding relationship between the event and the model data; and The user page is rendered based on the page data and the business-related information.

12. The method according to claim 11, wherein, The creation of the binding relationship between the event and the model data includes: The front-end parser decomposes the task data and the page data into multiple node element data; wherein, the multiple node element data includes node element data corresponding to page components; and The front-end parser creates the binding relationship between the event and the data model.

13. The method according to claim 11 or 12, wherein, The event is one or more of the following: Click the button, enter content, select options, upload files, or drag and drop.

14. The method according to any one of claims 1 to 13, wherein, The method further includes: The third modeling page displays the process engine model corresponding to the process engine; The process engine model is updated to obtain an updated process engine model; and Based on the update process engine model, an update process engine corresponding to the process engine is generated.

15. A method for using a process engine, wherein, The process engine is a process engine constructed according to any one of the process engine construction methods according to claims 1 to 14; the method includes: The front-end parser obtains the request information based on the events responded to by the user's page; The front-end parser sends the request information to the back-end parser; The backend parser executes the task nodes based on the request information and obtains the process result; The backend parser sends the process result to the frontend parser; and The front-end parser re-renders the user page based on the process result.

16. The method according to claim 15, wherein, The request information includes business data, wherein the business data includes one or more of the following: The input data, the data items to be queried, and the type of operation to be performed.

17. A construction apparatus for a process engine, wherein, The device includes: The determination module is used to determine one or more task nodes and one or more page nodes, wherein the one or more task nodes are used to implement the corresponding process steps, and the one or more page nodes are used to generate the corresponding user pages. The generation module is used to generate a process engine model based on the one or more task nodes and the one or more page nodes; and The parsing module is used to determine business-related information and, based on the business-related information, parse and process the process engine model to obtain the process engine.

18. The apparatus according to claim 17, wherein, The one or more task nodes can be multiple, and the one or more page nodes can be multiple. The determining module is used to determine the one or more task nodes and the one or more page nodes, specifically for: Based on multiple node elements, determine the first task node and the first page node; Based on the reuse process model, a second task node and a second page node are determined in the reuse process model; as well as Determine the first task node and the second task node, and determine the first page node and the second page node.

19. An electronic device, wherein, include: Memory, processor; The memory stores computer-executed instructions; The processor executes computer execution instructions stored in the memory, causing the processor to perform the method as claimed in any one of claims 1-14 or the method as claimed in claim 15 or 16.

20. A computer-readable storage medium, wherein, The computer-readable storage medium stores computer-executable instructions, which, when executed by a processor, are used to implement the method as described in any one of claims 1-14 or the method as described in claim 15 or 16.

Images