A method, device, and medium for generating an application model based on a low-code platform

Abstract

The present application discloses a method, device, and medium for generating an application model based on a low-code platform, which relates to the technical field of low-code application models. The method includes: collecting user business data and storing the business data through a form, where the form includes a main form and a sub-form; identifying the relationship between the main form and the sub-form to obtain model elements, where the model elements include business entities, sub-entities, and entity relationships, as well as value objects and aggregate roots; introducing an external dictionary and expressing the model elements through JSON to generate a visual script model; packaging the script model to obtain a deployment package and dynamically publishing the deployment package to a database; when exporting the deployment package from the database, saving the deployment package as a JSON file and performing compression and encryption. Through the above method, the present application realizes that after the form is abstracted into a model, a higher degree of reuse can be achieved, reducing the workload of repeated model design and application, as well as form development, and making the development process faster.

Description

Technical Field

[0001] This application relates to the technical field of low-code application models, and particularly to a method, device, and medium for generating an application model based on a low-code platform. Background Art

[0002] When traditional low-code platforms generate complex business application models, developers often need to manually write a large amount of configuration code or perform cumbersome drag-and-drop operations, which greatly extends the development cycle. As business requirements change continuously, business application models need to be iterated frequently. However, existing technologies often struggle to respond quickly to these changes, resulting in lagging model updates and affecting business efficiency. Existing technologies often have difficulty in deeply integrating with existing enterprise IT systems, databases, and applications, leading to a large amount of time and effort spent on data migration and system docking during the model construction process. When traditional low-code platforms display complex business application models, they often struggle to provide an intuitive and user-friendly visual interface, affecting user understanding and usage. The lack of multi-client real-time communication function limits team collaboration and model discussion, and often easily forms data islands.

[0003] Through the above analysis, the problems and defects of the existing technology are as follows:

[0004] In the existing technology, complex business application models cannot be generated, managed, deployed, and displayed efficiently, flexibly, and securely on a low-code platform. Summary of the Invention

[0005] Embodiments of this application provide a method, device, and medium for generating an application model based on a low-code platform, which solves the problem that complex business application models cannot be generated, managed, deployed, and displayed efficiently, flexibly, and securely on a low-code platform in the existing technology.

[0006] In a first aspect, embodiments of this application provide a method for generating an application model based on a low-code platform, which is characterized in that the method includes: collecting user business data and storing the business data through a form, where the form includes a main form and sub-forms; identifying the relationship between the main form and the sub-forms to obtain model elements, where the model elements include business entities, sub-entities, and entity relationships, as well as value objects and aggregate roots; introducing an external dictionary and expressing the model elements through JSON to generate a visual script model; packaging the script model to obtain a deployment package and dynamically publishing the deployment package to a database; when exporting the deployment package from the database, saving the deployment package as a JSON file and performing compression and encryption.

[0007] In an implementation of the present application, the relationship between the main form and the sub-form is recognized to obtain model elements, specifically including: using self-learning technology to perform unsupervised learning on the form to extract business data features; combining representation learning in deep learning to map the features to a high-dimensional space to form a unified representation vector; identifying business entities and sub-entities through clustering analysis.

[0008] In an implementation of the present application, the script model is packaged and published to the database, specifically including: interacting with the Minio object storage service through the Rest API to dynamically upload the deployment package to the storage bucket; generating a unique identifier and version label for the deployment package, and providing a permission-based access control mechanism and preview.

[0009] In an implementation of the present application, interacting with the Minio object storage service through the Rest API to dynamically upload the deployment package to the storage bucket specifically includes: providing a user interface to allow the user to input or select the name of the storage bucket in the case where the user selects customization; in the case where the user does not select customization, finding the corresponding storage bucket according to the model elements.

[0010] In an implementation of the present application, an external dictionary is introduced and the model elements are expressed through JSON, specifically including: based on the external dictionary including key-value pairs for matching, using a string similarity algorithm to match the model elements with the key-value pairs, and associating the successfully matched key-value pairs to the corresponding model elements; creating a canvas, mapping business entities, sub-entities, entity relationships, value objects, and aggregate roots, as well as key-value pairs to type nodes on the canvas, and updating according to the matching results of the external dictionary.

[0011] In an implementation of the present application, the method further includes: adding connections to the type nodes and assigning identifiers and listeners to each connection; establishing a real-time communication connection using the WebSocket library to enable real-time communication among multiple clients.

[0012] In an implementation of the present application, when the deployment package is exported from the database, after saving the deployment package as a JSON file and compressing and encrypting it, the method further includes: decompressing and decrypting the imported JSON file; selecting components through an intelligent algorithm and a low-code platform according to the context of the JSON file and the user history; displaying the script model through the components, and determining the field types, labels, and default values in the form according to the business entities, sub-entities, and entity relationships in the script model.

[0013] In an implementation of the present application, the method further includes: when the business data is updated, looking up the identifier and version label in the database; automatically triggering a version label increment mechanism after the data update operation is confirmed and submitted.

[0014] Second aspect, an embodiment of the present application further provides a device for generating an application model based on a low-code platform. The device includes at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, and the instructions are executed by the at least one processor to enable the at least one processor to: collect user business data, and store the business data through a form, the form including a main form and a sub-form; identify the relationship between the main form and the sub-form to obtain model elements, the model elements including business entities, sub-entities, and entity relationships, as well as value objects and aggregate roots; introduce an external dictionary, and express the model elements through JSON to generate a visual script model; package the script model to obtain a deployment package, and dynamically publish the deployment package to a database; when the database exports the deployment package, save the deployment package as a JSON file, and perform compression and encryption.

[0015] Third aspect, an embodiment of the present application further provides a non-volatile computer storage medium for generating an application model based on a low-code platform, storing computer-executable instructions, and the computer-executable instructions are set to: collect user business data, and store the business data through a form, the form including a main form and a sub-form; identify the relationship between the main form and the sub-form to obtain model elements, the model elements including business entities, sub-entities, and entity relationships, as well as value objects and aggregate roots; introduce an external dictionary, and express the model elements through JSON to generate a visual script model; package the script model to obtain a deployment package, and dynamically publish the deployment package to a database; when the database exports the deployment package, save the deployment package as a JSON file, and perform compression and encryption.

[0016] The method, device, and medium for generating an application model based on a low-code platform provided by the embodiments of the present application have the following promoting effects on the low-code development platform: After the form is abstracted into a model, a higher degree of reuse can be achieved, reducing the workload of repetitive model design, application, and form development. The visual interaction design reduces the dependence on professional developers and makes the development process faster. By introducing an entity model and a visual design tool, the complex business form logic is clearly presented, facilitating the application developer to quickly start work; The promoting effects on enterprises: For platform users, business forms can be quickly created and modified, flexibly responding to changes in market demands, significantly shortening the business go-live cycle, and improving business agility. Through the abstraction ability of the low-code platform, high-quality business form development can be completed with less manpower and resources, reducing the application development cost. The abstraction method of the entity model standardizes enterprise form data and business rules, facilitating subsequent data analysis and process optimization, thereby enhancing the enterprise's data governance ability. Description of the Drawings

[0017] The accompanying drawings described herein are used to provide a further understanding of the present application and form a part of the present application. The illustrative embodiments of the present application and their descriptions are used to explain the present application and do not constitute an improper limitation of the present application. In the drawings:

[0018] Figure 1 It is a flowchart of a method for generating an application model based on a low-code platform provided by an embodiment of the present application;

[0019] Figure 2 It is a schematic internal structure diagram of a device for generating an application model based on a low-code platform provided by an embodiment of the present application. Detailed implementation manners

[0020] To make the objectives, technical solutions, and advantages of the present application clearer, the technical solutions of the present application will be clearly and completely described below in conjunction with specific embodiments of the present application and the corresponding drawings. Obviously, the described embodiments are only a part of the embodiments of the present application, rather than all the embodiments. All other embodiments obtained by those of ordinary skill in the art based on the embodiments of the present application without creative efforts shall fall within the protection scope of the present application.

[0021] The embodiments of the present application provide a method, device, and medium for generating an application model based on a low-code platform, which solve the problem in the prior art that complex business application models cannot be efficiently, flexibly, and securely generated, managed, deployed, and displayed on a low-code platform.

[0022] The technical solutions proposed in the embodiments of the present application will be described in detail below with reference to the drawings.

[0023] Figure 1 It is a flowchart of a method for generating an application model based on a low-code platform provided by an embodiment of the present application. As Figure 1 shown, a method for generating an application model based on a low-code platform provided by an embodiment of the present application specifically includes the following steps:

[0024] Step 10: Collect user business data and store the business data through a form, where the form includes a main form and sub-forms.

[0025] In this step, collect user and enterprise requirements, and then design the main form and sub-forms according to the collected requirements. The main form is usually used to store core business data, such as customer information and order details, and the sub-forms are used to store detailed information associated with the main form data, such as the list of goods in an order and the contact information of a customer.

[0026] Step 20: Identify the relationships between the main form and the sub-forms to obtain model elements, where the model elements include business entities, sub-entities, and entity relationships, as well as value objects and aggregate roots.

[0027] In the embodiments of the present application, mapping form fields to entity attributes in the model is determined by the complexity of the form in the low-code platform. The application form is the expansion of real-world business and includes ordinary forms, process forms, aggregated forms, and sub-forms. These are all form relationships. There are display components and field components within the form. The display components are for better presenting the form but cannot be converted into entity attributes, while the field components carry business data and can be abstracted into entity attributes. The field definition includes: basic field information: field name, type (string, number, date, etc.), default value; field constraints: verification rules such as length limit, whether it is required, and whether it is unique; domain meaning: the business semantics of the field, which is convenient for future expansion or integration into a larger domain model.

[0028] The application stores user data through forms and expresses the association relationships in real-world business through the association relationships between forms. Usually, the association relationships of forms for complex business are also relatively complex. By abstracting the forms, the association relationships of the forms can be represented as aggregation relationships or references between entities in the model: one-to-one relationship: a direct association between one form and another form (such as a user form and a user detailed information form), which can be achieved through reference. One-to-many relationship (sub-form): The relationship between the main form and the sub-form can be modeled with an aggregate root and a child entity. For example: an order form (aggregate root) contains an order details form (child entity); many-to-many relationship: represented by an intermediate form, such as the "student form" and the "course form" are associated through the "course selection form".

[0029] As an alternative embodiment, to identify the relationship between the main form and the sub-form and obtain model elements, it may specifically include: Step 21: Use unsupervised learning technology to perform unsupervised learning on the form and extract business data features; Step 22: Combine representation learning in deep learning to map the features to a high-dimensional space to form a unified representation vector; Step 23: Identify business entities and sub-entities through clustering analysis.

[0030] In this step, according to the characteristics and requirements of the representation vector, select a suitable clustering algorithm, such as K-means, DBSCAN, to perform clustering analysis on the generated representation vector, group similar vectors into one category, and each category represents a business entity or a sub-entity. According to the clustering results, identify business entities and sub-entities, and analyze the relationships between entities, such as the master-slave relationship or the inclusion relationship.

[0031] Step 30: Introduce an external dictionary and express the model elements through JSON (JavaScript Object Notation) to generate a visual script model.

[0032] In this step, an external dictionary (such as a data dictionary or classification label) can be regarded as a service or external resource in the domain model. As a value object, this scenario is applicable to external dictionaries with a small amount of data, and the values of the external dictionary are directly referenced in form fields (such as the status field referencing the values in the "status dictionary"); as an external service: this scenario is applicable to dictionaries with a large amount of data. It is difficult to use the dictionary as a model value object, and the dictionary values are dynamically loaded through an external service interface, which is convenient for real-time updates.

[0033] As an alternative embodiment, an external dictionary is introduced, and model elements are expressed through JSON. Specifically, it may include: Step 301: Based on the key-value pairs for matching included in the external dictionary, use a string similarity algorithm to match the model elements with the key-value pairs, and associate the successfully matched key-value pairs with the corresponding model elements; Step 302: Create a canvas, map business entities, sub-entities, entity relationships, value objects, aggregate roots, and key-value pairs to type nodes on the canvas, and update according to the matching results of the external dictionary.

[0034] In this step, a canvas is created. As the carrier of the nodes, the canvas is the basis for visualization. Entities and value objects are mapped to different types of nodes on the canvas. Connections are added, and nodes are associated through Edge. The history module of AntV X6 can record user operations, which is convenient for subsequent undo and redo by users.

[0035] As an alternative embodiment, the method may further include: Step 303: Add connections to the type nodes and assign identifiers and listeners to each connection; Step 304: Use the WebSocket library to establish a real-time communication connection to enable real-time communication among multiple clients.

[0036] Step 40: Package the script model to obtain a deployment package and dynamically publish the deployment package to the database;

[0037] As an alternative embodiment, packaging the script model and publishing it to the database may specifically include: Step 401: Interact with the Minio object storage service through the Rest API to obtain the deployment package and dynamically upload the deployment package to the storage bucket;

[0038] In this step, when publishing the model, the model of the current canvas is saved to the object storage system MinIO. The model is stored in JSON format with version information attached. An incremental strategy is used to generate the version number. The published script interacts with Minio through the Rest API. The system generates a storage path for each script, such as " / model / {model_name} / {version}", which is convenient for subsequent quick access and dynamic loading. The upload process includes script compression, encryption (optional), and attachment of metadata (version number, creation time, etc.).

[0039] As an alternative embodiment, interact with the Minio object storage service through the Rest API to dynamically upload the deployment package to the storage bucket, which may specifically include: Step 4011: When the user selects customization, provide a user interface to allow the user to input or select the name of the storage bucket; Step 4012: When the user does not select customization, find the corresponding storage bucket according to the model elements.

[0040] In this step, if the storage bucket does not exist, a new storage bucket name can be generated, following the naming rules of the storage service, usually a combination of letters, numbers, hyphens, and underscores. Some strategies can be used to generate a unique storage bucket name, such as combining a timestamp, a random number, or a specific identifier.

[0041] Step 402: Generate a unique identifier and version label for the deployment package, and provide a permission-based access control mechanism and preview.

[0042] Step 50: When exporting the deployment package from the database, save the deployment package as a JSON file and perform compression and encryption.

[0043] In this step, each model is independently saved as a JSON file, including the complete structure of the model (fields, validation rules, association relationships, dictionaries). The JSON generated from the abstract model is encrypted and compressed through a compression tool to ensure data security during file transmission.

[0044] As an alternative embodiment, when exporting the deployment package from the database, after saving the deployment package as a JSON file and performing compression and encryption, the method may further include: Step 60: Decompress and decrypt the imported JSON file; Step 70: Select components through intelligent algorithms and a low-code platform based on the context of the JSON file and the user's history.

[0045] In this step, capture the user's operation history on the platform, the current project context (and component usage habits).

[0046] Step 80: Display the script model through the components, and determine the field types, labels, and default values in the form according to the business entities, sub-entities, and entity relationships in the script model.

[0047] In this step, the import of the model file is a reverse engineering process. By decompressing the encrypted JSON file, it is converted into an application entity model. Similar to the model visualization technology mentioned in the previous chapter, the imported application entity model is displayed to the user through a canvas. At the same time, the user is allowed to actively adjust the model through the visual model editor according to the actual business, publish the model version. The process from the model to the form needs to map the data types in the model to low-code platform system components or custom components. The mapping relationship of system components is maintained by the platform, as shown in the following table:

[0048] Table 1 Mapping Relationship

[0049]

[0050] In addition, the low-code platform allows users to customize components through the component factory. The mapping relationship between fields and custom components is open to users, supporting users to customize the mapping relationship between model fields and custom components. After completing the mapping relationship between the model and the components, the user-selected components can be added to the form designer according to the relationship order. The user can adjust the component layout again according to the business requirements through the layout components to complete the form design.

[0051] As an alternative embodiment, the method may further include: when the business data is updated, looking up the identifier and version label in the database; after the data update operation is confirmed and submitted, automatically triggering the version label increment mechanism.

[0052] In this step, the system records the version update log, including information such as the update time, the updated person, and the comparison of the old and new version numbers, so as to facilitate subsequent version tracking, auditing, or rollback operations.

[0053] In summary, the low-code platform application is the basic unit for solving real-world business problems and also the solution space corresponding to the real-world business problem space. It digitizes real-world business problems through forms, processes, web pages, reports, and dashboards, and visualizes them to form data assets. Users create applications on the low-code platform by dragging and dropping to design application forms, abstracting the application forms into entity models, including the modeling of form fields, validation rules, and association relationships, and then visually displaying the model through a canvas. Users can intuitively edit the model through interactive methods such as dragging and dropping, and support the release and management of model versions, including version saving, comparison, and rollback operations. The present invention completes business requirements by quickly creating forms based on the model through the abstraction and management of the model, application model export and import, and speeds up the market response speed.

[0054] The above is the method embodiment proposed by this application. Based on the same inventive concept, the embodiments of this application also provide a device for generating a low-code platform application model, the structure of which is as Figure 2 shown.

[0055] Figure 2 A schematic diagram of the internal structure of a device generated based on an application model of a low-code platform provided by an embodiment of the present application. As Figure 2 shown, the device includes:

[0056] At least one processor 201;

[0057] And a memory 202 communicatively connected to the at least one processor;

[0058] Wherein, the memory 202 stores instructions executable by the at least one processor, and the instructions are executed by the at least one processor 201 so that the at least one processor 201 can: collect user service data and store the service data through a form, the form including a main form and a sub-form; identify the relationship between the main form and the sub-form to obtain model elements, the model elements including business entities, sub-entities and entity relationships, as well as value objects and aggregate roots; introduce an external dictionary and express the model elements through JSON to generate a visual script model; package the script model to obtain a deployment package and dynamically publish the deployment package to a database; when the database exports the deployment package, save the deployment package as a JSON file and perform compression and encryption.

[0059] Corresponding to Figure 1 in some embodiments of the present application, a non-volatile computer storage medium generated based on an application model of a low-code platform stores computer-executable instructions, and the computer-executable instructions are set to: collect user service data and store the service data through a form, the form including a main form and a sub-form; identify the relationship between the main form and the sub-form to obtain model elements, the model elements including business entities, sub-entities and entity relationships, as well as value objects and aggregate roots; introduce an external dictionary and express the model elements through JSON to generate a visual script model; package the script model to obtain a deployment package and dynamically publish the deployment package to a database; when the database exports the deployment package, save the deployment package as a JSON file and perform compression and encryption.

[0060] Each embodiment in the present application is described in a progressive manner. For the same or similar parts among the embodiments, reference can be made to each other. Each embodiment focuses on the differences from other embodiments. In particular, for the embodiments of the Internet of Things device and medium, since they are basically similar to the method embodiments, the description is relatively simple, and for the relevant parts, reference can be made to the partial description of the method embodiments.

[0061] The system and medium provided by the embodiments of the present application correspond one-to-one with the method. Therefore, the system and medium also have beneficial technical effects similar to those of the corresponding method. Since the beneficial technical effects of the method have been described in detail above, the beneficial technical effects of the system and medium will not be elaborated here.

[0062] Those skilled in the art should understand that the embodiments of the present application can be provided as a method, a system, or a computer program product. Therefore, the present application can take the form of a complete hardware embodiment, a complete software embodiment, or an embodiment combining software and hardware aspects. Moreover, the present application can take the form of a computer program product implemented on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) that contain computer-usable program code.

[0063] The present application is described with reference to the flowcharts and / or block diagrams of methods, apparatuses (systems), and computer program products according to the embodiments of the present application. It should be understood that each flow and / or block in the flowchart and / or block diagram, as well as the combination of flows and / or blocks in the flowchart and / or block diagram, can be realized by computer program instructions. These computer program instructions can be provided to the processor of a general-purpose computer, a special-purpose computer, an embedded processor, or other programmable data processing devices to generate a machine, so that the instructions executed by the processor of the computer or other programmable data processing devices generate means for realizing the functions specified in one Figure 1 flow or multiple flows and / or blocks Figure 1 block or multiple blocks.

[0064] These computer program instructions can also be stored in a computer-readable memory that can direct a computer or other programmable data processing device to work in a specific manner, so that the instructions stored in the computer-readable memory generate a manufactured article including instruction means, and the instruction means realizes the functions specified in one Figure 1 flow or multiple flows and / or blocks Figure 1 block or multiple blocks.

[0065] These computer program instructions can also be loaded onto a computer or other programmable data processing device, so that a series of operation steps are executed on the computer or other programmable device to generate a computer-implemented process, and thus the instructions executed on the computer or other programmable device provide steps for realizing the functions specified in one Figure 1 flow or multiple flows and / or blocks Figure 1 block or multiple blocks.

[0066] In a typical configuration, a computing device includes one or more processors (CPUs), an input / output interface, a network interface, and a memory.

[0067] The memory may include non-permanent memory in the computer-readable medium, in the form of random access memory (RAM) and / or non-volatile memory, such as read-only memory (ROM) or flash RAM. The memory is an example of a computer-readable medium.

[0068] A computer-readable medium includes permanent and non-permanent, removable and non-removable media and can implement information storage by any method or technology. The information can be computer-readable instructions, data structures, program modules, or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technologies, compact disc read-only memory (CD-ROM), digital versatile disc (DVD) or other optical storage, magnetic cassette tapes, magnetic tape magnetic disk storage or other magnetic storage devices, or any other non-transitory medium that can be used to store information that can be accessed by a computing device. As defined herein, a computer-readable medium does not include transitory computer-readable media such as modulated data signals and carrier waves.

[0069] It should also be noted that the term "comprising", "including" or any other variant thereof is intended to cover non-exclusive inclusion, such that a process, method, commodity or device comprising a series of elements not only includes those elements but also includes other elements not expressly listed, or also includes elements inherent to such process, method, commodity or device. Without further limitation, an element defined by the statement "comprising an..." does not exclude the presence of additional identical elements in the process, method, commodity or device comprising the said element.

[0070] The above description is only for the embodiments of the present application and is not intended to limit the present application. For those skilled in the art, various changes and modifications can be made to the present application. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present application shall be included within the scope of the claims of the present application.

Claims

1. A method for generating an application model based on a low-code platform, characterized in that: The method comprises: Collect user business data and store the business data through a form, wherein the form includes a main form and a subform; Identify the relationship between the main form and the subform, and obtain model elements, wherein the model elements include business entities, subentities and entity relationships, as well as value objects and aggregate roots; Identify the relationship between the main form and the subform, and obtain model elements, including: Using autonomous learning technology to perform unsupervised learning on the form to extract business data features; Combined with representation learning in deep learning, the features are mapped to a high-dimensional space to form a unified representation vector; Identify business entities and sub-entities through cluster analysis; Import an external dictionary and express the model elements through JSON to generate a visual script model, including: Based on the key-value pairs included in the external dictionary for matching, the model elements are matched with the key-value pairs using a string similarity algorithm, and the successfully matched key-value pairs are associated with the corresponding model elements; Create a canvas, map the business entities, sub-entities, entity relationships, value objects and aggregate roots, and the key-value pairs to type nodes on the canvas, and update them according to the matching results of the external dictionary; Packaging the script model to obtain a deployment package, and dynamically publishing the deployment package to a database; When the database exports the deployment package, the deployment package is saved as a JSON file and compressed and encrypted.

2. According to the method for generating an application model based on a low-code platform according to claim 1, it is characterized in that: Packaging the script model to obtain a deployment package, and publishing the deployment package to a database, specifically includes: Interact with the Minio object storage service through the Rest API and dynamically upload the deployment package to the storage bucket; A unique identifier and version label are generated for the deployment package, and a permission-based access control mechanism and preview are provided.

3. According to the method for generating an application model based on a low-code platform according to claim 2, it is characterized in that: The interaction with the Minio object storage service through the Rest API to dynamically upload the deployment package to the storage bucket specifically includes: If the user selects custom, a user interface is provided to allow the user to enter or select a name for the bucket; When the user does not select customization, the corresponding storage bucket is searched according to the model element.

4. According to the method for generating an application model based on a low-code platform according to claim 1, it is characterized in that: The method further comprises: Adding connections to the nodes of the type, and assigning an identifier and a listener to each connection; Use the WebSocket library to establish a real-time communication connection to enable multiple clients to communicate in real time.

5. According to the method for generating an application model based on a low-code platform according to claim 1, it is characterized in that: When the database exports the deployment package, after the deployment package is saved as a JSON file and compressed and encrypted, the method further includes: Unzip and decrypt the imported JSON file; Select components through intelligent algorithms and low-code platforms based on the context of the JSON file and user history; The script model is displayed through the component, and the field type, label, and default value in the form are determined according to the business entities, sub-entities, and entity relationships in the script model.

6. According to a method for generating an application model based on a low-code platform according to claim 1, it is characterized in that: The method further comprises: When the business data is updated, searching the database for an identifier and a version tag; After the data is updated and submitted, the version tag increment mechanism is automatically triggered.

7. A device for generating an application model based on a low-code platform, characterized in that: The device comprises: at least one processor; and, a memory communicatively coupled to the at least one processor; The memory stores instructions that can be executed by the at least one processor, and the instructions are executed by the at least one processor to enable the at least one processor to: Execute the steps of a method for generating an application model based on a low-code platform as described in any one of claims 1-6.

8. A non-volatile computer storage medium generated based on a low-code platform application model, storing computer executable instructions, characterized in that: The computer executable instructions are configured to: Execute the steps of a method for generating an application model based on a low-code platform as described in any one of claims 1-6.

Images