Data flow processing method and system for low-code application

Abstract

The invention discloses a data flow processing method and system for low-code application. The method comprises the following steps: designing an input parameter group and an output parameter group by a component; the output parameter data of each component can be bound to the input parameters of other components, so that a data dependency relationship among different components is established; the data output by the components are defined by using the exportRelys, so that the latest data in the input box can be obtained by other components in real time; importRelys is used for defining data needing to be received by the component, so that other components can transmit the data to the input box component; closely paying close attention to changes of data source nodes by using a data hijacking technology; and once the data source node changes, notifying the data receiving node which establishes the dependency relationship with the data source node to perform corresponding data updating or trigger a preset action. According to the method, the development process is simplified, the code quantity is reduced, and maintenance is easy, so that the application development efficiency of developers and the user experience are improved.

Description

Technical Field

[0001] The present invention relates to the field of rapid development technology of enterprise informatization, and in particular to a data flow processing method and system for low-code applications. Background Art

[0002] Low-code development platforms and logic orchestration tools are tools that help developers create software and programs faster and more easily. They allow developers to complete their work through a graphical interface instead of writing a lot of code.

[0003] Low-code development platforms (LCAPs) allow developers to quickly build applications, such as common customer relationship management (CRM) or enterprise resource planning (ERP) systems, by dragging and dropping and configuring. This method saves a lot of trouble in manually writing code and is faster and more convenient. However, if the application involves very complex business logic or special needs, this method may not be enough and developers will need to write the code themselves.

[0004] Logic orchestration tools are tools that help developers design workflows through graphical interfaces. They provide some preset components and rules that developers can combine like building blocks to form a complete workflow. This approach can make workflows more flexible and easier to adjust. However, if you encounter very complex or special workflow requirements, these tools may not be able to meet them.

[0005] Although both tools are very useful, they also have some problems. For example, they may not be flexible enough to meet all needs; they may be difficult to maintain because the graphical interface usually does not have detailed documentation and comments; there may be security risks, such as data leakage or permission management issues; and using these tools also requires certain skills and experience, and the training cost is high. Summary of the invention

[0006] In view of this, the present invention proposes a data flow processing method and system for low-code applications to solve the problems of rigidity and difficult maintenance of low-code development tools in the prior art.

[0007] The specific technical solutions of the present invention are as follows:

[0008] A data flow processing method for a low-code application, comprising:

[0009] Determine data dependencies: Components are designed with input parameter groups and output parameter groups. The input parameter group is used to receive data, and the output parameter group is used to transmit data. The output parameter data of each component can be bound to the input parameters of other components, thereby establishing data dependencies between different components. When the data of a component changes, the component will pass the data to the input parameters of other components through the output parameter group, triggering data updates of other components.

[0010] Design data structure: use exportRelys to define the data output by the component to ensure that other components can obtain the latest data in the input box in real time; use importRelys to define the data that the component needs to receive so that other components can pass data to the input box component;

[0011] Establish a data dependency trigger mechanism: Use data hijacking technology to closely monitor changes in data source nodes; once a data source node changes, notify the receiving data node that has established a dependent relationship with it to perform corresponding data updates or trigger preset actions.

[0012] Specifically, the data dependency trigger mechanism is divided into two types: synchronous dependency and asynchronous dependency according to needs to meet data processing requirements in different scenarios.

[0013] Specifically, the data flow processing method of low-code applications also includes implementing data verification.

[0014] Specifically, implementing data verification includes:

[0015] Rule validation logic: allows users to validate data based on business rules;

[0016] Data integrity verification: ensuring that data with dependencies is complete throughout the entire processing process;

[0017] Data comparison and verification: Compare data obtained from different data sources to ensure data consistency.

[0018] Specifically, the execution process of the method includes the following steps:

[0019] Step 1: The user performs data operations in the low-code application, inputs, edits, or deletes data, triggering a data change event;

[0020] Step 2: Systematically analyze the changed data path to determine if other components or functions depend on the data;

[0021] Step 3: If there is a dependency, and the change result is a unique ID of an asynchronous task pool, the system monitors this asynchronous task;

[0022] Step 4: The system temporarily stores the asynchronous callback function in the asynchronous task pool and obtains the unique ID of the asynchronous task;

[0023] Step 5: The system throws the unique ID of the asynchronous task to force triggering of all dependent components or functions related to the asynchronous task, and then returns to step 2 to wait for the next data change event.

[0024] Specifically, another execution flow of the method is: when the asynchronous task starts, the system sends the result of the asynchronous task to all components or functions currently observing the asynchronous task, and then enters step 5.

[0025] A data flow processing system for a low-code application, applying any of the above-mentioned data flow processing methods for a low-code application, comprising:

[0026] A data dependency determination module, used to determine data dependencies between components;

[0027] Data structure design module, used to design data structure;

[0028] Data dependency trigger mechanism module, used to establish data dependency trigger mechanism;

[0029] Data verification module, used to implement data verification.

[0030] Specifically, the system also includes a data verification module, which includes rule verification logic, data integrity verification and data comparison verification.

[0031] Specifically, the data dependency trigger mechanism module is divided into two modes: synchronous dependency and asynchronous dependency according to the needs.

[0032] The beneficial effects of the present invention are:

[0033] The present invention ensures the accuracy, integrity and real-time performance of data during the circulation process by determining data dependencies, designing reasonable data structures, establishing efficient data dependency trigger mechanisms, and implementing strict data verification. These technologies provide developers with a more convenient and efficient development experience, and promote the widespread application and development of low-code platforms. BRIEF DESCRIPTION OF THE DRAWINGS

[0034] In order to more clearly illustrate the technical solutions in the embodiments of the present application, the drawings required for use in the embodiments or the description of the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present application. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying creative labor.

[0035] Figure 1 A flow chart of a data flow processing method for a low-code application of the present invention;

[0036] Figure 2 This is a structural diagram of the data flow processing system for the low-code application of the present invention. DETAILED DESCRIPTION

[0037] In order to make the technical problems, technical solutions and beneficial effects to be solved by the present invention more clearly understood, the present invention is further described in detail below in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are only used to explain the present invention and are not intended to limit the present invention.

[0038] This invention is about how to figure out the relationship between different data, and creates a basic data structure to help handle these relationships. In this design, some components of the low-code system are placed in two special objects, just like the input and output in a mathematical formula, which makes it easier to understand and handle the relationship between different data.

[0039] The present invention also introduces two data dependency methods: synchronous dependency and asynchronous dependency.

[0040] Synchronous dependency means that when data is updated, new data is immediately sent to the part that needs it through triggers or callback functions, so as to ensure the real-time and consistency of data. Just like when you shop online and pay, the system will immediately update your order status and send you a confirmation email, so that you and the merchant can see the latest order information.

[0041] Asynchronous dependencies send data out through some means (such as message queues or event buses) after the data is updated. This can reduce the burden on the system and improve the system's response speed. This is a bit like when you order food in a restaurant, the waiter will first write down your order and then send it to the kitchen. The advantage of this is that even if the restaurant is busy, the waiter can quickly write down your order, and the kitchen can prepare food at its own pace.

[0042] However, when synchronous dependencies and asynchronous dependencies exist at the same time, some problems may occur, such as data conflicts. In order to solve this problem, the present invention provides a conflict resolution mechanism to ensure that the system can run stably when data is updated. This mechanism can help the system correctly handle and resolve potential data conflicts when facing multiple data updates occurring simultaneously, thereby ensuring the integrity and consistency of the data.

[0043] Overall, the goal of this invention is to help us better manage relationships between data and ensure that data is updated correctly and consistently when handling those relationships.

[0044] Specifically, the present invention proposes a data flow processing method for low-code applications, which mainly involves the following aspects:

[0045] 1. Determine data dependencies: In low-code applications, determining data dependencies is a crucial step. To achieve this goal, two properties are designed inside the component: input parameter group and output parameter group. The input parameter group is the interface for the component to receive data, while the output parameter group is the exit for the component to pass data to other components. Through the output parameter group, the output parameter data of each component can be bound to the input parameter of other components.

[0046] This design allows data dependencies between different components to be established. When the data of a component changes, it passes the data to the input parameters of other components through the output parameter group, thereby triggering data updates in other components. This data dependency ensures accurate data transmission and processing, making the data flow of the entire application smoother and more efficient.

[0047] 2. Design data structure:

[0048] When designing low-code applications, data structure is a very important concept. In order to achieve effective data management and operation, low-code platforms pay special attention to the design of data structure.

[0049] Let's take an input box component as an example to see what its overall data structure is like.

[0050]

[0051]

[0052] In this data structure, there are two very critical dependency data structures, exportRelys and importRelys. The "path" in these two structures represents the address of the data.

[0053] exportRelys is responsible for defining the data that the component outputs. That is, when we enter content in the input box and the content changes, exportRelys will be responsible for passing the changed data to other components. In this way, other components can obtain the latest data in the input box in real time.

[0054] ImportRelys defines the data that the component needs to receive. If other components want to pass data to the input box component, they can do so through importRelys. This design makes data transfer between components simpler and more efficient.

[0055] Through this data structure-dependent design, data transfer between different components becomes clearer and more efficient. We can ensure accurate data transfer and processing, avoiding data confusion and loss.

[0056] In addition to these dependent data structures, the input box component has many other basic properties and settings. For example, it has properties such as component name, rendering box name, icon, size, border color, border radius, etc. These properties provide basic style and function settings for the input box component, making it easier for us to use and customize this component.

[0057] 3. Establish a data dependency trigger mechanism: In order to ensure the real-time update and accuracy of data in low-code applications, the present invention establishes a data dependency trigger mechanism. This mechanism closely monitors the changes of data source nodes through data hijacking technology. Once the data source node changes, it will immediately notify the receiving data node with which it has established a dependency to perform corresponding data updates or trigger preset actions. This mechanism is very flexible and can be divided into two modes: synchronous dependency and asynchronous dependency according to different needs, so as to meet the data processing requirements in different scenarios. Through this mechanism, the accurate transmission and processing of data can be ensured, data confusion and loss can be avoided, and development efficiency and user experience can be improved.

[0058] 4. Implement data verification: Data verification is an important part of ensuring the accuracy and integrity of data in low-code applications. To implement data verification, the present invention adopts the following three methods:

[0059] (1) Rule verification logic: Based on business rules, users can verify data independently. For example, in the relationship between orders and products, data consistency can be checked by verifying whether the total price of the order is equal to the unit price of the product multiplied by the quantity of the product. If the data is found to be inconsistent with the rules, corresponding processing is performed.

[0060] (2) Data integrity verification: For data with dependencies, it is necessary to ensure that the entire data flow is complete. For example, when deleting an order, it is necessary to ensure that all products under the order have also been deleted to avoid data inconsistency.

[0061] (3) Data comparison and verification: Data obtained from different data sources need to be compared and verified to ensure data consistency. For example, when obtaining sales data from different systems, the data needs to be compared and verified to ensure data accuracy and consistency.

[0062] Through these verification methods, the accuracy and completeness of data in low-code applications can be ensured, improving development efficiency and user experience.

[0063] The data flow processing method of low-code applications is an efficient and flexible data processing process suitable for rapid development and deployment of applications. The following is a detailed process of this method (such as Figure 1 Steps and explanations:

[0064] Step 1: User triggers data change: When a user performs data operations in a low-code application, such as entering, editing, or deleting data, a data change event is triggered.

[0065] Step 2: Check if the changed data path has dependencies: The system analyzes the changed data path to determine if there are other components or functions that depend on the data. This dependency may be defined during the design phase of the application.

[0066] Step 3: Determine whether the change result is the unique ID of the asynchronous task pool: If the changed data path has a dependency and the change result is the unique ID of an asynchronous task pool, the system will monitor this asynchronous task. This means that the system needs to wait for the asynchronous task to complete before continuing processing.

[0067] Step 4: Temporarily store the asynchronous callback in the asynchronous task pool and obtain the unique ID of the asynchronous task: The system temporarily stores the asynchronous callback function in the asynchronous task pool and obtains the unique identifier (ID) of the asynchronous task. This ensures the correct management and tracking of asynchronous tasks.

[0068] Step 5: Throw out the unique ID of the task (force triggering all dependencies) and return to step 2: The system throws out the unique ID of the asynchronous task to force trigger all dependent components or functions related to the asynchronous task. This ensures the integrity and consistency of the data. Then, the system returns to step 2 and waits for the next data change event.

[0069] The present invention also provides another embodiment: when an asynchronous task starts, the asynchronous result is sent to all observers of the current asynchronous task, and then the above step 5 is entered. In this embodiment, when the asynchronous task starts, the system sends the result of the asynchronous task to all components or functions that are currently observing the asynchronous task. In this way, real-time update and response of data can be achieved. Then, the system enters the above step 5 to continue processing data flow.

[0070] The present invention also proposes a data flow processing system for low-code applications. The implementation of the system is as follows: Figure 2 As shown in the figure, a low-code application allows you to view the data access volume of different provinces and cities. The details are as follows:

[0071] 1. Province drop-down selection: Just like the drop-down menu you see in the app, it lists different provinces. When you select a province, the selection will be recorded.

[0072] 2. City query interface: This is a function that, when you select a province, it will tell you all the cities belonging to this province. For example, if you select "Guangdong", it will tell you that Guangdong includes Guangzhou, Shenzhen and other cities.

[0073] 3. City drop-down selection: After you know all the cities belonging to the selected province, you can select a specific city in another drop-down menu.

[0074] 4. Interface for querying the number of visits under a province or city: This is another function that tells you how many people have visited the application or website under the selected province or city.

[0075] These features work together in the following way:

[0076] *When you select a province from the "Province Drop-down Selection", your selection will tell the "City Query Interface" which province's cities to query. Then, the "City Query Interface" will return a list of cities, which will be passed to the "City Drop-down Selection" so that you can select a city from it.

[0077] *Whether you select from the "Province drop-down selection" or "City drop-down selection", this selection will tell the "Interface for querying the number of visits under the province or city" which province or city to query the number of visits. Then, this interface will return the corresponding number of visits data.

[0078] In short, this low-code application's data flow processing system allows users to view visit data for different provinces and cities through simple selection operations.

[0079] In summary, the data flow processing method and system of low-code applications is a comprehensive system engineering. It ensures the accuracy, integrity and real-time nature of data during the flow process by determining data dependencies, designing reasonable data structures, establishing efficient data dependency trigger mechanisms, and implementing strict data verification. These technologies provide developers with a more convenient and efficient development experience, and promote the widespread application and development of low-code platforms.

[0080] The beneficial effects of the present invention are:

[0081] 1. Make development easier: Developers only need to connect data and interface elements (such as buttons, text boxes, etc.), and the system will automatically ensure that the data and interface are synchronized, without having to manually adjust them every time. In this way, the development process becomes much simpler.

[0082] 2. Improve development speed: Because the system can automatically handle data and interface synchronization issues, developers can focus on other more important work, thereby improving development speed.

[0083] 3. Better user experience: When users use the application, their operations (such as entering data) will be immediately displayed on the interface, so that the application responds faster and the user experience is better.

[0084] 4. Reduce the amount of code: Developers do not need to write so much code to handle the relationship between data and interface, so the amount of code will be reduced, and the project will be more readable and easier to maintain.

[0085] 5. Easier to maintain: The relationship between data and interface becomes clearer and the code is less complicated, making it easier to modify or add features in the future.

[0086] In general, this invention can help developers develop applications more efficiently while also providing a better user experience.

[0087] The above are only preferred embodiments of the present invention and are not intended to limit the present invention. Any modifications, equivalent substitutions and improvements made within the spirit and principles of the present invention should be included in the protection scope of the present invention.

Claims

1. A data flow processing method for low-code applications, It is characterized in that include: Determine data dependencies: Components are designed with input parameter groups and output parameter groups. The input parameter group is used to receive data, and the output parameter group is used to transmit data. The output parameter data of each component can be bound to the input parameters of other components, thereby establishing data dependencies between different components. When the data of a component changes, the component will pass the data to the input parameters of other components through the output parameter group, triggering data updates of other components. Design data structure: use exportRelys to define the data output by the component to ensure that other components can obtain the latest data in the input box in real time; Use importRelys to define the data that the component needs to receive, so that other components can pass data to the input box component; Establish a data dependency trigger mechanism: Use data hijacking technology to closely monitor changes in data source nodes; Once a data source node changes, the receiving data node with which it has a dependency relationship is notified to perform corresponding data updates or trigger preset actions.

2. The data flow processing method of the low-code application according to claim 1, It is characterized in that The data dependency trigger mechanism is divided into two modes: synchronous dependency and asynchronous dependency according to the needs, to meet the data processing needs in different scenarios.

3. The data flow processing method of the low-code application according to claim 1, It is characterized in that The data flow processing method of the low-code application also includes implementing data verification.

4. The data flow processing method of the low-code application as claimed in claim 3, It is characterized in that The data verification implementation includes: Rule validation logic: allows users to validate data based on business rules; Data integrity verification: ensuring that data with dependencies is complete throughout the entire processing process; Data comparison and verification: Compare data obtained from different data sources to ensure data consistency.

5. The data flow processing method of the low-code application according to claim 1, It is characterized in that The execution process of the method specifically includes the following steps: Step 1: The user performs data operations in the low-code application, inputs, edits, or deletes data, triggering a data change event; Step 2: Systematically analyze the changed data path to determine if other components or functions depend on the data; Step 3: If there is a dependency, and the change result is a unique ID of an asynchronous task pool, the system monitors this asynchronous task; Step 4: The system temporarily stores the asynchronous callback function in the asynchronous task pool and obtains the unique ID of the asynchronous task; Step 5: The system throws the unique ID of the asynchronous task to force triggering of all dependent components or functions related to the asynchronous task, and then returns to step 2 to wait for the next data change event.

6. The data flow processing method of the low-code application according to claim 5, It is characterized in that Another execution flow of the method is: when the asynchronous task starts, the system sends the result of the asynchronous task to all components or functions currently observing the asynchronous task, and then enters step 5.

7. A data flow processing system for a low-code application, applying the data flow processing method for a low-code application as described in any one of claims 1 to 6, It is characterized in that include: A data dependency determination module, used to determine data dependencies between components; Data structure design module, used to design data structure; Data dependency trigger mechanism module, used to establish data dependency trigger mechanism; Data verification module, used to implement data verification.

8. The data flow processing system for low-code applications according to claim 7, It is characterized in that It also includes a data verification module, which includes rule verification logic, data integrity verification and data comparison verification.

9. The data flow processing system for low-code applications according to claim 7, It is characterized in that The data dependency trigger mechanism module is divided into two modes: synchronous dependency and asynchronous dependency according to the requirements.

Images