Development method and system based on low-code configuration function engine

Abstract

The invention relates to the technical field of function engine configuration, and discloses a development method and system based on a low-code configuration function engine, and the method comprises the steps: decoupling bottom configuration information and specific business configuration according to the core capability demand of the function engine, and configuring a basic support module for the operation of the function engine; configuring a core function of the function engine based on the basic support module, and converting a core function configuration process of the function engine into an executable logic or instruction; configuration of executable logic or instructions is achieved through a visual user interface, an operation and maintenance mechanism is adjusted in real time in combination with the operation state in the operation process of the function engine, and core functions of the function engine are continuously iterated in combination with user feedback and service changes. According to the method, the function engine can be quickly configured while the code quantity is reduced, so that business changes are quickly responded, the efficiency is improved, and the cost is reduced.

Description

Technical Field

[0001] This invention relates to the field of functional engine configuration technology, and in particular to a development method and system for configuring functional engines based on low-code. Background Technology

[0002] In existing technologies, the configuration of functional engines usually relies on fixed templates, and their component parameters and logical rules are all preset (for example, the process template only supports the basic logic of "approval-rejection"). If personalized requirements such as "multi-dimensional data linkage (such as automatically triggering cross-system report updates after form submission)" and "dynamic permission control (such as different positions viewing different form fields)" are required, professional developers need to modify the underlying code of the platform, which involves a large amount of code modification, resulting in low efficiency and high cost.

[0003] Furthermore, during the configuration of the functional engine, the backend engine layer is a fixed pre-compiled module that is strongly bound to the frontend template components (for example, the "report template" can only call the fixed report engine module). When business requirements change (for example, from "single process approval" to "multi-process parallel approval"), the core logic of the engine often needs to be reconstructed, resulting in a long system iteration cycle (usually 1-2 weeks) and an inability to quickly respond to business changes. Summary of the Invention

[0004] Therefore, the technical problem to be solved by the present invention is to overcome the shortcomings of the prior art and provide a development method and system based on low-code configuration of functional engines, which can quickly configure functional engines while reducing the amount of code, thereby quickly responding to business changes, improving efficiency and reducing costs.

[0005] To address the aforementioned technical problems, this invention provides a development method based on a low-code configuration engine, comprising: Based on the core capability requirements of the functional engine, the underlying configuration information and specific business configuration are decoupled, and the basic support modules for the operation of the functional engine are configured. Based on the aforementioned basic support module, configure the core functions of the function engine and convert the core function configuration process of the function engine into executable logic or instructions. The executable logic or instructions can be configured through a visual user interface. During the operation of the functional engine, the operation and maintenance mechanism can be adjusted in real time based on the running status. The core functions of the functional engine can be continuously iterated based on user feedback and business changes.

[0006] Furthermore, the decoupling of underlying configuration information and specific business configuration based on the core capability requirements of the functional engine is specifically as follows: By uniting the roles of business, technology, and operations, we sorted out the core capability requirements of the engine, determined the performance, stability, and security requirements of the functional engine, and decomposed and designed the layered architecture and core technology stack of the functional engine based on the requirements, thus obtaining the interactive prototype of the functional engine.

[0007] Furthermore, the basic support module includes a development component management module, a configuration parsing module, and a rule engine module. The rule engine module develops a rule engine encapsulation class by introducing the Drools dependency into the backend project. The rule engine encapsulation class provides rule loading interface, rule execution interface, and rule unloading interface.

[0008] Furthermore, the process of converting the core function configuration process of the functional engine into executable logic or instructions specifically includes: The configuration rules of core functions are transformed into executable logic or UI rendering instructions, and a general configuration parser is designed, which includes a structure parser, a behavior parser, and a dynamic logic parser.

[0009] Furthermore, the behavior parser parses the interactive behaviors and events fields in the configuration, maps the runtime event listeners, and outputs a list of executable behavior functions.

[0010] Furthermore, the dynamic logic parser parses the dynamic expressions in the configuration and transforms them into runtime code, generates data dependencies, and compiles the string expressions into executable functions through the expression engine.

[0011] Furthermore, the mechanism for adjusting the operation and maintenance in real time based on the running status during the operation of the functional engine specifically includes: The real-time running status of the functional engine is monitored using Prometheus and Grafana. The real-time running status includes multiple monitoring indicators. The running score of the functional engine is calculated based on the multiple monitoring indicators. The running score is used to determine the running status of the functional engine and make real-time adjustments.

[0012] Furthermore, the calculation method for the performance score is as follows: S = k1 × S CPU + k2×S M + k3×S p , Where S is the running score, S CPU CPU utilization is scored, k1 is the CPU utilization weight, and S M Memory usage is scored, k2 is the weight of memory usage, and S p The interface error rate is scored, and k3 is the interface error rate weight, k1 + k2 + k3 = 1.

[0013] Furthermore, the calculation method for the CPU utilization score is as follows: S CPU =100-(1- R CPU )×100, Among them, R CPU CPU idle rate; The method for calculating the memory usage score is as follows: S M =100-(1- R M )×100, Among them, R M This refers to the memory free rate. The method for calculating the interface error rate score is as follows: S p =100-(1- R p ×k p )×100, Among them, R p k represents the interface error rate. p This is the weight for the interface error rate.

[0014] This invention also provides a development system based on a low-code configuration function engine, comprising: The requirements and business acquisition module is used to acquire the core capability requirements and specific business requirements of the functional engine. The functional decoupling module is used to decouple the underlying configuration information from the specific business configuration based on the core capability requirements of the functional engine. The underlying configuration module is used to configure the basic support modules for the operation of the functional engine. The configuration conversion module is used to configure the core functions of the function engine based on the basic support module, and to convert the core function configuration process of the function engine into executable logic or instructions. A visual user interface for configuring executable logic or instructions; The operation and maintenance module is used to adjust the operation and maintenance mechanism in real time based on the running status during the operation of the functional engine; The feature iteration module is used to continuously iterate the core functions of the feature engine based on user feedback and business changes.

[0015] Compared with the prior art, the above-described technical solution of the present invention has the following advantages: This invention decouples the configuration of the functional engine from specific business logic. Based on this, the core function configuration process of the functional engine is converted into executable logic or instructions and configured through a visual user interface. When business changes occur, only the configuration layer parameters need to be modified, which effectively reduces the amount and complexity of code required and enables fast business response. At the same time, this invention covers the entire lifecycle of the functional engine, including development, testing, deployment, and iteration, which can shorten the development or iteration cycle to the hour level, thereby reducing costs and improving efficiency. Attached Figure Description

[0016] To make the content of this invention easier to understand, the invention will be further described in detail below with reference to specific embodiments and accompanying drawings, wherein: Figure 1 This is a flowchart of a preferred embodiment of the present invention. Detailed Implementation

[0017] The present invention will be further described below with reference to the accompanying drawings and specific embodiments, so that those skilled in the art can better understand and implement the present invention. However, the embodiments described are not intended to limit the present invention.

[0018] Reference Figure 1 As shown, this invention discloses a development method based on a low-code configuration function engine, including: S1: Based on the core capability requirements of the functional engine, decouple the underlying configuration information and specific business configurations to design the functional engine's architecture. The core objective of this stage is to clarify the functional engine's positioning, boundaries, and technology selection, preventing later development from deviating from business needs, which is crucial to the engine's success or failure. Collaborate with business, technology, and operations teams to analyze the engine's core capability requirements, determine the functional engine's performance, stability, and security requirements, and decompose and design the functional engine's layered architecture and core technology stack based on these requirements, resulting in the functional engine's interactive prototype.

[0019] Establish a robust environment, data storage, and security system to support engine operation, ensuring fault-free underlying infrastructure. Environment setup includes containerized environment deployment (Docker, Kubernetes, Ubuntu 20.04, etc.) and basic tool installation (Maven 3.8, JDK 11, etc.). Data storage setup includes MySQL cluster deployment, Redis cluster deployment, and Elasticsearch deployment. Security protection is implemented using a Spring Security-based authentication module, integrating JWT (JSON Web Token) to achieve a process of "username and password login, generating a JWT token, and subsequently sending the token for verification in subsequent requests." In the data source configuration module, an encryption utility class is integrated to automate the process of "user input plaintext password, encryption and storage, and decryption upon database connection." A permission management component is developed based on the RBAC model to implement the logic of "role creation, permission allocation (e.g., form configuration permissions, workflow management permissions), and user role association."

[0020] S2: Prioritize the configuration of basic support modules for the operation of the functional engine. These basic modules include modules such as data source management module and component management module. Decouple and develop the underlying basic support modules in layers to gradually realize the core capabilities in the architecture design. Prioritize the development of basic support modules that ensure the operation of the engine and provide support for upper-layer functions.

[0021] The foundational support modules include core modules such as a component management module, a configuration parsing module, and a rules engine module, enabling core capabilities such as "component reuse, configuration-to-logic conversion, and rule and process execution." Component metadata specifications are defined, including "component ID (unique identifier), name, type (form component, process component, report component), attribute list (e.g., 'default value', 'validation rule' for text boxes), event list (e.g., 'click event', 'value change event'), and rendering template (Vue, React code snippets)." When configuring the rules engine module, the Drools dependency (org.drools:drools-core:7.69.0.Final) is imported into the backend project to develop a rules engine wrapper class. This wrapper class provides rule loading, rule execution, and rule unloading interfaces. The project constructs a visual rule configuration interface, specifically developing a rule configuration panel that supports two core functions: "condition configuration" and "result configuration." It provides a visual condition editor that supports selecting "fields (e.g., order amount, user level)," "operators (>, <, =, contain)," and "values ​​(fixed values, variables, such as 1000, {userLevel})," and supports multiple conditions using AND / OR combinations. The project also develops rule storage and execution logic, converting the visually configured rules into DRL file format using Drools rule syntax.

[0022] S3: Based on the basic support module, configure the core functions of the function engine and convert the core function configuration process of the function engine into executable logic or instructions.

[0023] The configuration rules of core functions are transformed into executable logic or UI rendering instructions, and a general configuration parser (such as JSON parsing based on Jackson) is designed. The configuration parser includes a structure parser, a behavior parser, and a dynamic logic parser.

[0024] The structure parser outputs a structured abstract syntax tree (AST) or a component node tree (containing node types, attributes, and hierarchical relationships).

[0025] The behavior parser parses the interactive behaviors (such as time binding, action triggering, state change) and events fields (such as onClick:{action:'submit',params:[]}) in the configuration, maps the runtime event listeners (such as addEventListener), and outputs a list of executable behavior functions.

[0026] The dynamic logic parser parses dynamic expressions in the configuration (such as data binding, conditional rendering, and loop logic) and transforms them into runtime code. For example, it parses expressions such as {{formData.name}} and generates data dependencies (such as Vue's v-model and React's useState binding). The expression engine compiles string expressions into executable functions.

[0027] In this embodiment, the configuration parser supports dynamically generating SQL statements (e.g., automatically generating CREATETABLE statements based on form fields), and returns explicit prompts (e.g., "invalid field name format") when parsing errors occur. A visual rule configuration interface (using EasyLanguage) is encapsulated, and an expression parser (supporting arithmetic operations, logical judgments, and variable references) is implemented. It is compatible with the BPMN 2.0 standard (facilitating integration with third-party workflow tools), uses a state machine pattern to manage workflow node switching, and supports the passing of workflow variables.

[0028] S4: Configuring executable logic or instructions through a visual user interface is crucial for the "ease of use" of the functional engine. A visual tool directly used by business configuration developers is key to this. In this embodiment, Vue.Draggable is used to implement drag-and-drop functionality, synchronizing canvas configuration and JSON data in real time (for easy submission to the backend for parsing). The preview simulates real form submission logic. Grid Layout is used for page layout, supporting data interaction between components (e.g., "the table automatically refreshes after form submission").

[0029] In this embodiment, a visual designer, system management module, and application generation and deployment module are developed to enable users (business / technical personnel) to easily complete configuration and use. Specifically, a Vue3 project is created (npm createvite@latestlowcode-designer----templatevue), and core dependencies are installed: vue-draggable-next (drag and drop), @antv / g6 (flowcharts), axios (interface requests), and element-plus (UI components).

[0030] The system management module includes the development of user and permission management interfaces, engine monitoring interfaces, and system configuration interfaces. The application generation and deployment module includes an "Application Creation Interface": supporting input of the application name, description, and icon, and selection of associated forms and processes (e.g., "Leave Approval Application" associated with "Leave Application Form" and "Leave Approval Process"); an "Application Preview Function": generating a temporary access address for the application, allowing users to preview the complete application functionality (form submission, process approval) through a browser. Preview data is stored only in the test environment and does not affect production data; and a "One-Click Deployment Function": calling the K8s API to deploy the application package to the target environment (creating Deployment and Service), displaying the deployment progress in real time (e.g., "Image being pulled → Container starting → Deployment successful").

[0031] Develop a rule storage interface to store DRL file content in the `rule_definition` table in MySQL, and simultaneously store the rule ID and KieSession association information in Redis (for fast loading). The workflow engine module is prepared based on the BPMN 2.0 standard, introducing BPMN parsing dependencies (such as `org.camunda.bpm.model`). camunda-bpm-model-api:7.18.0) develops a parsing utility class that supports parsing visually configured process JSON (or BPMN XML files) into process definition objects (including process ID, node list, flow rules, and participant configuration). It integrates an adaptation module and develops a "Database Data Source Configuration Interface": supporting selection of database type (MySQL, Oracle, PostgreSQL), input of connection address, port, database name, account password, and clicking the "Test Connection" button to verify connectivity. After successful verification, the data source configuration is saved (sensitive information is AES encrypted and stored in the data_source table). It also develops a "Data Query Component": supporting association of data sources in form / report configurations, configuration of query SQL (or API request parameters), execution of queries, and return of data (e.g., "Report component associated with 'Sales Order Data Source', querying order amounts for the past 30 days").

[0032] S5: Verify the performance and security of the functional engine. This stage requires full-process verification through "module testing, integration testing, performance testing, and security testing" to identify and fix issues in development and ensure that the functional engine meets the requirements specifications. This mainly includes unit-level verification, cross-module verification, and performance and security verification.

[0033] S6: After the functional engine is verified, it will be launched and run. During the operation of the functional engine, the operation and maintenance mechanism will be adjusted in real time according to the running status. By establishing a continuous operation and maintenance mechanism, problems can be responded to in a timely manner, performance can be optimized, and business can be ensured without interruption.

[0034] S6-1: Monitor the real-time running status of the functional engine through Prometheus and Grafana. The real-time running status includes multiple monitoring metrics (such as CPU utilization, memory utilization, disk utilization, interface response time, error rate, etc.).

[0035] S6-2: Calculates the performance score of the functional engine based on multiple monitoring metrics.

[0036] The calculation method for the performance score is as follows: S = k1 × S CPU + k2×S M + k3×S p , Where S is the running score, S CPU CPU utilization is scored, k1 is the CPU utilization weight, and S M Memory usage is scored, k2 is the weight of memory usage, and S p The interface error rate is scored, and k3 is the interface error rate weight, k1 + k2 + k3 = 1. The values ​​of k1, k2, and k3 are adjusted according to the actual situation. In this embodiment, k1 = 0.3, k2 = 0.3, and k3 = 0.4.

[0037] The method for calculating CPU utilization score is as follows: S CPU =100-(1- R CPU )×100, Among them, R CPU CPU idle rate; The method for calculating the memory usage score is as follows: S M =100-(1- R M )×100, Among them, R M This refers to the memory free rate. The method for calculating the interface error rate score is as follows: S p =100-(1- R p ×kp )×100, Among them, R p k represents the interface error rate. p k represents the interface error rate weight. p The value of k is adjusted according to the actual situation. In this embodiment, k p =10, which amplifies the impact of the interface error rate by setting the interface error rate weight.

[0038] S6-3: Determine the operating status of the functional engine based on the operating score and make real-time adjustments.

[0039] In this embodiment, an alarm threshold is set. When the running score is less than the alarm threshold, an alarm message is issued to prompt the operator to make adjustments. The value of the alarm threshold is adjusted according to the actual situation; it can be 60, that is, an alarm message is issued when S < 60.

[0040] Logs from the functional engines are collected using ELK (Elasticsearch + Logstash + Kibana), supporting queries by time, module, and error type for quick troubleshooting (e.g., "A user failed to configure a form; the logs indicate an error in the parsing module"). Functional engine configuration data is backed up regularly (e.g., daily full backups and incremental backups), and backup files are stored off-site to prevent data loss (e.g., for quick recovery in case of database failure).

[0041] S7: Continuously iterate the core functionality of the feature engine based on user feedback and business changes. Specifically, improve the scalability and usability of the feature engine through requirements collection and prioritization, iterative development and release.

[0042] The present invention also discloses a development system based on a low-code configuration function engine, including a requirements and business acquisition module, a function decoupling module, an underlying configuration module, a configuration conversion module, a visual user interface, a verification module, an operation and maintenance module, and a function iteration module.

[0043] The requirements and business acquisition module acquires the core capability requirements and specific business requirements of the functional engine. The functional decoupling module decouples the underlying configuration information and specific business configurations based on the core capability requirements of the functional engine. The underlying configuration module configures the basic support modules for the functional engine's operation. The configuration conversion module configures the core functions of the functional engine based on the aforementioned basic support modules, converting the core function configuration process into executable logic or instructions. A visual user interface implements the configuration of these executable logic or instructions. The verification module verifies the performance and security of the functional engine. The operation and maintenance module adjusts the operation and maintenance mechanism in real time based on the operational status during the functional engine's operation. The functional iteration module continuously iterates the core functions of the functional engine based on user feedback and business changes.

[0044] The present invention also discloses a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the functions of various modules in a development system based on a low-code configuration function engine.

[0045] The present invention also discloses an apparatus including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement the functions of various modules in a development system based on a low-code configuration function engine.

[0046] This invention decouples the configuration of the functional engine from specific business logic. Based on this, the core function configuration process of the functional engine is converted into executable logic or instructions and configured through a visual user interface. When business changes occur, only the configuration layer parameters need to be modified, which effectively reduces the amount and complexity of code required and enables fast business response. At the same time, this invention covers the entire lifecycle of the functional engine, including development, testing, deployment, and iteration, which can shorten the development or iteration cycle to the hour level, thereby reducing costs and improving efficiency.

[0047] This invention supports custom logical relationships between components through a graphical logic orchestration tool, and opens up third-party service access capabilities through an extended interface module at the engine layer, enabling personalized requirements to be met without modifying the underlying code. Furthermore, it reduces the complexity of rule configuration and achieves responsive interaction in a low-code designer by using automatic segment metadata identification and dynamic operator matching logic, a mixed configuration syntax and parsing algorithm for fixed and dynamic variables, and a visual verification mechanism for multi-condition "AND" and "OR" combinations.

[0048] The functional engine development process in this invention is a systematic project from "building the technical foundation" to "implementing the user ecosystem," which needs to take into account the engine's versatility, flexibility, and ease of use. Through the functional iteration of the built-in full range of components such as forms, processes, reports, and message push, as well as the functional engine module, various composite applications can be developed in one stop, avoiding the drawbacks of multi-platform collaboration.

[0049] Those skilled in the art will understand that embodiments of this application can be provided as methods, systems, or computer program products. Therefore, this application can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, this application can take the form of a computer program product embodied on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0050] This application is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of this application. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart... Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0051] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0052] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0053] Obviously, the above embodiments are merely illustrative examples for clear explanation and are not intended to limit the implementation. Those skilled in the art will recognize that other variations or modifications can be made based on the above description. It is neither necessary nor possible to exhaustively list all possible implementations here. However, obvious variations or modifications derived therefrom are still within the scope of protection of this invention.

Claims

1. A development method based on a low-code configuration function engine, characterized in that, include: Based on the core capability requirements of the functional engine, the underlying configuration information and specific business configuration are decoupled, and the basic support modules for the operation of the functional engine are configured. Based on the aforementioned basic support module, configure the core functions of the function engine and convert the core function configuration process of the function engine into executable logic or instructions. The executable logic or instructions can be configured through a visual user interface. During the operation of the functional engine, the operation and maintenance mechanism can be adjusted in real time based on the running status. The core functions of the functional engine can be continuously iterated based on user feedback and business changes.

2. The development method based on a low-code configuration engine according to claim 1, characterized in that: The decoupling of underlying configuration information and specific business configuration based on the core capability requirements of the functional engine is as follows: By uniting the roles of business, technology, and operations, we sorted out the core capability requirements of the engine, determined the performance, stability, and security requirements of the functional engine, and decomposed and designed the layered architecture and core technology stack of the functional engine based on the requirements, thus obtaining the interactive prototype of the functional engine.

3. The development method based on a low-code configuration engine according to claim 1, characterized in that: The basic support module includes a development component management module, a configuration parsing module, and a rule engine module. The rule engine module develops a rule engine encapsulation class by introducing the Drools dependency into the backend project. The rule engine encapsulation class provides rule loading interface, rule execution interface, and rule unloading interface.

4. The development method based on a low-code configuration engine according to claim 1, characterized in that: The process of converting the core function configuration process of the functional engine into executable logic or instructions is as follows: The configuration rules of core functions are transformed into executable logic or UI rendering instructions, and a general configuration parser is designed, which includes a structure parser, a behavior parser, and a dynamic logic parser.

5. The development method based on a low-code configuration function engine according to claim 4, characterized in that: The behavior parser parses the interactive behaviors and events fields in the configuration, maps the event listeners at runtime, and outputs a list of executable behavior functions.

6. The development method based on a low-code configuration function engine according to claim 4, characterized in that: The dynamic logic parser parses the dynamic expressions in the configuration and transforms them into runtime code, generates data dependencies, and compiles the string expressions into executable functions through the expression engine.

7. The development method based on a low-code configuration function engine according to any one of claims 1-6, characterized in that: The mechanism for adjusting the operation and maintenance in real time based on the running status during the operation of the functional engine is as follows: The real-time running status of the functional engine is monitored using Prometheus and Grafana. The real-time running status includes multiple monitoring indicators. The running score of the functional engine is calculated based on the multiple monitoring indicators. The running score is used to determine the running status of the functional engine and make real-time adjustments.

8. The development method based on a low-code configuration engine according to claim 7, characterized in that: The calculation method for the running score is as follows: S = k1 x S CPU + k2 x S M + k3 x S p , Wherein, S is the operation score, S CPU is a CPU usage score, k1 is a CPU usage weight, S M is a memory usage score, k2 is a memory usage weight, S p is an interface error rate score, k3 is an interface error rate weight, k1+ k2+ k3=1.

9. The development method based on a low-code configuration engine according to claim 8, characterized in that: The calculation method for the CPU utilization score is as follows: S CPU =100-(1- R CPU )×100, Among them, R CPU CPU idle rate; The method for calculating the memory usage score is as follows: S M =100-(1- R M )×100, Among them, R M This refers to the memory free rate. The method for calculating the interface error rate score is as follows: S p =100-(1- R p ×k p )×100, Among them, R p k represents the interface error rate. p This is the weight for the interface error rate.

10. A development system based on a low-code configuration engine, characterized in that, include: The requirements and business acquisition module is used to acquire the core capability requirements and specific business requirements of the functional engine. The functional decoupling module is used to decouple the underlying configuration information from the specific business configuration based on the core capability requirements of the functional engine. The underlying configuration module is used to configure the basic support modules for the operation of the functional engine. The configuration conversion module is used to configure the core functions of the function engine based on the basic support module, and to convert the core function configuration process of the function engine into executable logic or instructions. A visual user interface for configuring executable logic or instructions; The operation and maintenance module is used to adjust the operation and maintenance mechanism in real time based on the running status during the operation of the functional engine; The feature iteration module is used to continuously iterate the core functions of the feature engine based on user feedback and business changes.

Images