ERP front-end code automatic generation method and system based on AI and metadata

Abstract

The invention relates to the technical field of computers, and discloses an ERP front-end code automatic generation method and system based on AI and metadata, and the method comprises the steps: analyzing a standardized demand document through an internally trained AI large model based on the large model recognition and function calling capability, converting the standardized demand document into a structured demand document, and carrying out the automatic generation of the ERP front-end code. According to the method, the front-end code of the ERP system can be automatically generated, the metadata in the structured demand document is analyzed in combination with the metadata field definition, the metadata model and the UI data model are called, and the front-end standardized page interaction DSL is generated, so that the front-end code of the ERP system can be automatically generated, and the development efficiency of the ERP system is greatly improved.

Description

Technical Field

[0001] The present invention relates to the field of computer technology, and specifically to a method and system for automatically generating ERP front-end code based on AI and metadata. The method uses AI to identify product documents and metadata models, combined with interactive CLI, to ultimately automatically generate code for page layout structure and interaction logic. Background Art

[0002] Traditional ERP systems contain numerous forms and list pages with similar structures. Due to differing business logic, repetitive development is often required. With the rapid development of the software industry, automation tools are playing an increasingly important role in improving efficiency. Automated front-end code generation technology not only improves development efficiency but also promotes consistent coding styles across teams, improving code quality.

[0003] Existing front-end code generation technologies primarily fall into four categories: 1. CLIs provided by various scaffolding tools, such as CreateReact App and Vue CLI; 2. Metadata-driven generation of UI components or entire pages; 3. Visual low-code platforms; and 4. Static site generators. These four types of front-end code generation technologies primarily address specific problems in different scenarios and fail to improve the coverage of automated code generation. For example, scaffolding CLIs only generate basic framework data flow code, lacking business data processing; metadata-driven generation of UI code and data binding lacks data flow and business logic; and visual low-code platforms often produce a specific schema or DSL, making it difficult to upgrade and maintain. Static site generators are primarily used for customizing online website homepages and are not applicable to ERP systems. Summary of the Invention

[0004] In order to solve the technical problem of heavy repetitive development tasks in ERP systems in the existing technology, the present invention proposes an automatic front-end code generation method for ERP systems based on AI and metadata. Based on AI, product documents and metadata models are identified to drive the generation of UI models and front-end page interaction DSL. Combined with an interactive command line interface, users can automatically generate front-end code for page interactions in the ERP system to reduce the amount of repetitive development tasks.

[0005] In order to solve the above technical problems, the technical solution adopted by the present invention is: a method for automatically generating ERP front-end code based on AI and metadata, comprising the following steps:

[0006] Step 1: Create a mapping relationship between metadata and UI data to obtain the metadata model and UI data model, and store them in the local server;

[0007] Step 2: Get the generated page parameters entered by the user;

[0008] Step 3: Determine whether the page generation parameters entered by the user include dynamic form components. If so, obtain the metadata code entered by the user, call the metadata model and UI data model on the server, generate dynamic form components and corresponding data verification code; then determine whether there is a page interaction document. If so, call the AI big model;

[0009] Step 4: Obtain the standardized requirements document and convert it into a structured requirements document using the AI big model. Parse the metadata in the structured requirements document based on the metadata field definition, call the metadata model and UI data model, and generate the page interaction DSL.

[0010] Step 5: Parse the master-subtable structure in the metadata model and generate the page master-subtable layout configuration code; parse the metadata UI components corresponding to the fields in the UI data model and generate the UI component configuration code corresponding to the form fields; at the same time, parse the validation rules in the UI data model and generate the UI validation configuration code;

[0011] Step 6: Combine the page interaction DSL generated in step 4 and the code generated in step 5 to generate the full ERP front-end code.

[0012] The method for automatically generating ERP front-end code based on AI and metadata further includes the following steps:

[0013] Step 7: Analyze the generated full ERP front-end code, parse the common code into an abstract syntax tree, insert the new code, and generate the new form / list code file.

[0014] In step 2, the page generation parameters are obtained from the user through command line query;

[0015] The generated page parameters include: the project module or public module corresponding to the newly added module, the routing address corresponding to the newly added module, the layout component that the newly added page depends on, whether a dynamic form component is included, and whether there is a page interaction document.

[0016] Step 2 also includes the following steps:

[0017] Generate corresponding view files, data flow files, type files, style files and prefabricated framework codes and data flow codes in the files according to the selected new module directory and new module name;

[0018] Generate routing definition related codes according to the routing address corresponding to the newly added module;

[0019] Generate UI component code and the data structure code of the Model layer corresponding to the component based on the layout components that the new page depends on.

[0020] The standardized requirement document includes: field information, trigger conditions and linkage logic.

[0021] When the AI big model converts standardized requirement documents into structured requirement documents, it structures the linkage logic into four types: linkage of field values, linkage of field visibility, configuration linkage, and linkage function.

[0022] In addition, the present invention also provides an ERP front-end code automatic generation system based on AI and metadata, which is used to implement the aforementioned ERP front-end code automatic generation method based on AI and metadata, including:

[0023] Metadata design module: used to perform data modeling based on business fields, generate metadata models, and create mappings between metadata and UI data, thereby synchronously generating UI data models.

[0024] Interface module: used to provide the user with a generation parameter input interface;

[0025] AI module: This module is used to obtain input standardized requirement documents and convert them into structured requirement documents using an internally trained AI model. It also parses the metadata in the structured requirement documents based on metadata field definitions, calls the metadata model and UI data model, and generates a page interaction DSL.

[0026] Page generation module: used to generate ERP front-end code based on the page generation parameters input by the user and the page interaction DSL generated by the AI module.

[0027] The page generation module is also used to: parse the main and sub-table structures in the metadata model to generate page main and sub-table layout configuration codes; parse the metadata UI components corresponding to the fields in the UI data model to generate UI component configuration codes corresponding to the form fields; and at the same time, parse the verification rules in the UI data model to generate UI verification configuration codes.

[0028] The ERP front-end code automatic generation system based on AI and metadata also includes:

[0029] Code analysis module: used to analyze the generated full ERP front-end code, parse the common code into an abstract syntax tree, insert new code, and generate new form / list code files.

[0030] The AI module uses a model trained based on DeepSeek-R1-Distill-Qwen-32B, and the interface module uses a command line interface tool to provide users with a generation parameter input interface.

[0031] Compared with the prior art, the present invention has the following beneficial effects:

[0032] The present invention proposes an automatic generation method of front-end code for an ERP system based on AI and metadata. Based on large model recognition and function call capabilities, the method uses an internally trained AI large model to parse standardized requirement documents and convert them into structured requirement documents. The method also parses the metadata in the structured requirement documents in combination with metadata field definitions, calls the metadata model and UI data model, and generates a front-end standardized page interaction DSL, which can realize the automatic generation of front-end code for the ERP system. In addition, the method generates a UI model based on the metadata model drive, collects user parameters in combination with a command line interface tool, generates framework code, data flow code, data type code (dynamically generates front-end Typescript data types based on metadata types), form verification code and page interaction DSL code in the page, and finally realizes the automatic generation of all logic of the ERP system page, greatly improving the development efficiency of the ERP system. BRIEF DESCRIPTION OF THE DRAWINGS

[0033] Figure 1 A flowchart of a method for automatically generating ERP front-end code based on AI and metadata provided in Example 1 of the present invention;

[0034] Figure 2 This is a schematic diagram of generating a UI data model based on metadata model driving according to the first embodiment of the present invention;

[0035] Figure 3 In order to transform the standardized requirement documents into structured requirements, the front-end page interaction DSL is generated by combining the metadata model definition and then the front-end interaction code diagram is generated;

[0036] Figure 4 A simple example of structuring requirements and converting them into a page interaction DSL;

[0037] Figure 5 A page interaction instance and its corresponding page interaction DSL. DETAILED DESCRIPTION

[0038] In order to make the purpose, technical solutions and advantages of the embodiments of the present invention clearer, the technical solutions in the embodiments of the present invention will be clearly and completely described below. Obviously, the described embodiments are part of the embodiments of the present invention, not all the embodiments; based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without making creative work are within the scope of protection of the present invention.

[0039] Example 1

[0040] like Figure 1As shown, the first embodiment of the present invention provides an automatic generation method of ERP front-end code based on AI and metadata, including the following steps:

[0041] Step 1: Create a mapping relationship between metadata and UI data to obtain a metadata model and a UI data model, and store them in a local server.

[0042] like Figure 2 The figure below shows a schematic diagram of generating a UI data model based on a metadata model in this embodiment. The corresponding relationship between the metadata model and the UI model illustrates how to map abstract data descriptions (metadata) to specific user interface elements. This mapping is a key step in achieving automated front-end code generation, ensuring a seamless transition from data definition to visualization.

[0043] Specifically, an entity in the metadata model represents a business object or concept, such as "user" or "order," which is converted into a page or view in the UI data model. The specific business object "user" corresponds to the "user list page" and "order" corresponds to the "order list page";

[0044] Specifically, entity attributes in the metadata model represent the characteristics or fields of the entity, such as "user name" and "order time", which are converted into form fields and table columns in the UI data model;

[0045] Specifically, the attribute specifications in the metadata model represent the type of the field, such as "string", "enumeration", "integer", etc., which are converted into UI components in the UI data model. "String" corresponds to the input box on the page, "enumeration" corresponds to the single-select and multiple-select boxes on the page, and "integer" corresponds to the numeric input box on the page. Finally, each attribute specification is matched with the corresponding UI display component code;

[0046] Specifically, field constraints in the metadata model, such as non-null, length restrictions, and format restrictions, correspond to the validation rule codes such as real-time validation, error prompts, and length validation in the conversion UI data model;

[0047] Specifically, the associations between entities in the metadata model, such as one-to-one and one-to-many, are converted into "reference type" components or master-sub-table structure codes in the UI data model. The "reference type" component has the ability to automatically and dynamically request associated sub-table data, and currently supports three display forms: "reference drop-down box", "reference tree structure", and "reference sub-table". The master-sub-table structure code is a layout method for the page, and the ability to append multiple data to the sub-table information is implemented in the generated form code.

[0048] Step 2: Get the generated page parameters entered by the user.

[0049] In step 2, the page generation parameters are obtained from the user through a CLI command line query.

[0050] The generation page parameters include: the newly added module directory, the newly added module name, the routing address corresponding to the newly added module, the layout components that the newly added page depends on, whether a dynamic form component is included, and whether there is a page interaction document.

[0051] Specifically, in this embodiment, step 2 further includes the following steps:

[0052] Generate corresponding view files, data flow files, type files, style files, and prefabricated framework codes and data flow codes in the files according to the selected new module project directory and the new module name;

[0053] Generate routing definition related codes according to the routing address of the newly added module;

[0054] Based on the layout components that the newly added page depends on, generate the data structure code of the component's corresponding Model layer and the corresponding Typescript data type code.

[0055] In this embodiment, after the metadata model and UI model are created, the input parameters of the user-generated code are obtained based on the CLI, the specific code file storage module, routing address, and page layout component are determined, and the type of generated page is determined in combination with the metadata model and UI model.

[0056] Furthermore, in this embodiment, the specific execution steps of step 2 are:

[0057] Step S201: calling the front-end CLI tool through a global command;

[0058] Step S202: The local node server analyzes the local code directory to determine the existing project modules and public modules;

[0059] Step S203: The user selects a new module directory and a new module name, and generates corresponding view files, data stream files, type files, style files, and prefabricated framework codes and data stream codes within the files;

[0060] Step S204: The user inputs the routing address corresponding to the module to be added, and generates routing definition and other related codes;

[0061] Step S205: The user selects the layout component that the new page depends on, and generates the data structure code of the Model layer corresponding to the component and the corresponding Typescript data type code.

[0062] Step 3: Determine whether the page generation parameters entered by the user include dynamic form components. If so, obtain the metadata code entered by the user and call the metadata model and UI data model on the server to generate dynamic form components and corresponding data verification code. Then, determine whether a standardized requirements document exists. If so, call the AI big model service to parse the requirements document and generate the front-end interactive DSL. The standardized requirements document is written based on a pre-made requirements template.

[0063] Specifically, it determines whether the user has selected the "Dynamic Form" component, which is a layout component that dynamically generates a UI view based on metadata definitions. If the dynamic form component is included, the user continues to enter the metadata code, and the command line interface tool calls to obtain the server-side metadata model and UI data model, generating the dynamic form component and the corresponding data verification code.

[0064] Specifically, if a standardized interaction document exists, the Web DSL big model service of the AI big model is called.

[0065] Step 4: Obtain the standardized requirements document and convert it into a structured requirements document using the AI big model. Parse the metadata in the structured requirements document based on the metadata field definition, call the metadata model and UI data model, and generate a page interaction DSL.

[0066] Specifically, if Figure 3 As shown in the figure, the AI big model parses the standardized interaction document into a structured requirement document for the DSL syntax, combines it with the metadata field model definition, and finally generates a page interaction DSL recognized by the front-end.

[0067] Specifically, when generating a page interaction DSL for front-end recognition through an AI big model, it is first necessary to define a template for entering a standardized requirement document. Then, by combining the AI big model and customized packaging, the page interaction DSL agent Web DSL AI Agent is obtained by internally calling the function service. Based on the natural language processing capabilities and function call capabilities of the Web DSL AI Agent, the present invention combines the standardized requirement document input by the user, the pre-defined prompt, and the field definition in the metadata to parse the standardized requirement document and output the in-page interaction DSL. The following is an introduction to the three service capabilities of the Web DSL AI Agent:

[0068] (1) Structured document service: Identify standardized requirement documents and convert them into structured requirement documents based on the pre-set prompt format and field definitions in the metadata;

[0069] (2) Metadata field parsing service: Identify Chinese characters in structured data, combine with field definitions in metadata, find matching metadata models, and parse metadata fields in translation structure requirements;

[0070] (3) Page interaction DSL generation service: Based on the rules, the AI big model is called to convert the structured requirements into a page interaction DSL that can be recognized by the front-end components.

[0071] In this embodiment, the standardized requirement document includes: field information, trigger conditions and interaction logic. The AI big model can identify the form fields, trigger conditions, and interaction conditions through the structured document service, and then convert them into a structured requirement document. Finally, the structured requirement document is converted into a page interaction DSL that can be recognized by the front-end component. Specifically, Figure 4 The figure below shows a specific example of how the Web DSL AI Agent service parses a standardized requirement document and generates a page that responds to user input and controls the display and hiding of fields. The example includes the following steps:

[0072] Step S401: Provide a standardized requirement template and enter the page interaction requirements according to the standardized requirement template. Figure 4 It describes that when the enumeration value of the "Evaluation Type" field in the user page form is set, the "Logistics Service Evaluation" field on the page is hidden;

[0073] Step S402: parsing the standardized requirements and converting the requirements into structured data;

[0074] Step S403: Parse the structured requirements through the metadata model, call the DSL service, and finally parse out the DSL code that can be recognized by the dynamic form component.

[0075] Specifically, in this embodiment, when the AI big model converts the standardized requirement document into a structured requirement document, the interaction logic is structured into four types: linkage of field values, linkage of field visibility, configuration linkage, and linkage function.

[0076] like Figure 5 The following is a detailed diagram of the form interaction structured DSL configuration for this embodiment. The page interaction logic on the form is uniformly abstracted into three types: field value linkage, field visibility linkage, and field configuration linkage. Based on these three linkage types, all page interaction logic is structured into four types: value (value linkage), visible (visible linkage), config (configuration linkage), and the interaction-triggered linkage function update. For descriptions of related fields, please refer to Table 1.

[0077] Table 1 Field description of linkage logic

[0078]

[0079] Specific linkage logic principle reference Figure 5 The specific linkage process is as follows:

[0080] (1) After the value of form field A is changed, its linkage configuration update is obtained from the DSL configuration syntax, and the update return value is obtained. The update return configuration affects three fields, namely form fields B, C, and D.

[0081] (2) The value of field B (component) in the form is modified to string 3;

[0082] (3) The C field (component) in the form is hidden;

[0083] (4) The drop-down options of the D field (component) in the form are linked to option 1 and option 2.

[0084] Step 5: Parse the master-subtable structure in the metadata model to generate page master-subtable (one-to-one, one-to-many) layout configuration code. Parse the metadata UI components corresponding to the fields in the UI data model to generate component code corresponding to the form fields. Simultaneously, parse the validation rules in the UI data model to generate form validation code. Table 2 shows some of the validation configurations.

[0085] Table 2 Partial verification configuration and corresponding description

[0086] coding name describe Required Required Whether the field is allowed to be non-empty Length length Field Required Length MaxLength Maximum length Maximum field length Range Value range Value ranges for numbers, time, etc. DigitLength decimal precision decimal precision Accept Attachment file type Attachment file type ... ... ... Regexp General regular validation General regular validation

[0087] Step 6: Combine the page interaction DSL generated in step 4 and the code generated in step 5 to generate the full ERP front-end code.

[0088] In this example, based on the front-end framework that the scaffolding relies on, the routing, module name, page layout, form field UI component configuration, validation configuration, and page interaction DSL generated by the AI large model are combined in the above steps. Finally, the full page code is generated and written to the corresponding file.

[0089] Further, if Figure 1 As shown, the method for automatically generating ERP front-end code based on AI and metadata further includes the following steps:

[0090] Step 7: Analyze the generated full ERP front-end code, parse the common code into an abstract syntax tree, insert the new code, and generate the new form / list code file.

[0091] In this embodiment, the existing public code (such as Typescript type files, public Model layer files, routing configuration, etc.) needs to be parsed into an abstract syntax tree AST through syntax analysis and lexical analysis, and the new code is inserted. For new files, the code string is directly written and generated into a file.

[0092] Example 2

[0093] A second embodiment of the present invention provides an ERP front-end code automatic generation system based on AI and metadata, which is used to realize the automatic generation of ERP front-end code, including:

[0094] Metadata design module: used to perform data modeling based on business fields, generate metadata models, and create mappings between metadata and UI data, thereby synchronously generating UI data models.

[0095] Interface module: used to provide the user with a generation parameter input interface;

[0096] AI module: This module is used to obtain input standardized requirement documents and convert them into structured requirement documents using an internally trained AI model. It also parses the metadata in the structured requirement documents based on metadata field definitions, calls the metadata model and UI data model, and generates a page interaction DSL.

[0097] Page generation module: used to generate ERP front-end code based on the page generation parameters input by the user and the page interaction DSL generated by the AI module.

[0098] Specifically, in this embodiment, the page generation module is also used to: parse the master-subtable structure in the metadata model to generate the page master-subtable layout configuration code; parse the metadata UI components corresponding to the fields in the UI data model to generate the UI component configuration code corresponding to the form fields; at the same time, parse the verification rules in the UI data model to generate the UI verification configuration code.

[0099] Furthermore, the ERP front-end code automatic generation system based on AI and metadata of this embodiment further includes:

[0100] Code analysis module: used to analyze the generated full ERP front-end code, parse the common code into an abstract syntax tree, insert new code, and generate new form / list code files.

[0101] Furthermore, in this embodiment, the AI module adopts a model trained based on DeepSeek-R1-Distill-Qwen-32B, and the interface module adopts a command line interface tool to provide the user with a generation parameter input interface.

[0102] The above description is only an embodiment of the minimum executable version of the present invention. In specific projects, the type of UI data model, verification configuration, and linkage configuration are customized and extended according to the business, and should not be understood as a limitation of the present invention.

[0103] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, rather than to limit it. Although the present invention has been described in detail with reference to the above embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the above embodiments, or replace some or all of the technical features therein with equivalents. However, these modifications or replacements do not cause the essence of the corresponding technical solutions to deviate from the scope of the technical solutions of the embodiments of the present invention.

Claims

1. A method for automatically generating ERP front-end code based on AI and metadata, characterized in that: The following steps are involved: Step 1: Create a mapping relationship between metadata and UI data to obtain the metadata model and UI data model, and store them in the local server; Step 2: Get the generated page parameters entered by the user; Step 3: Determine whether the page generation parameters entered by the user include dynamic form components. If so, obtain the metadata code entered by the user, call the metadata model and UI data model on the server, generate dynamic form components and corresponding data verification code; then determine whether there is a page interaction document. If so, call the AI big model; Step 4: Obtain the standardized requirements document and convert it into a structured requirements document using the AI big model. Parse the metadata in the structured requirements document based on the metadata field definition, call the metadata model and UI data model, and generate the page interaction DSL. Step 5: Parse the main-sub-table structure in the metadata model and generate the page main-sub-table layout configuration code; Parse the metadata UI components corresponding to the fields in the UI data model and generate the UI component configuration code corresponding to the form fields; at the same time, parse the validation rules in the UI data model and generate the UI validation configuration code; Step 6: Combine the page interaction DSL generated in step 4 and the code generated in step 5 to generate the full ERP front-end code.

2. The method for automatically generating ERP front-end code based on AI and metadata according to claim 1, characterized in that: The following steps are also included: Step 7: Analyze the generated full ERP front-end code, parse the common code into an abstract syntax tree, insert the new code, and generate the new form / list code file.

3. The method for automatically generating ERP front-end code based on AI and metadata according to claim 1, characterized in that: In step 2, the page generation parameters are obtained from the user through command line query; The generated page parameters include: the project module or public module corresponding to the newly added module, the routing address corresponding to the newly added module, the layout component that the newly added page depends on, whether a dynamic form component is included, and whether there is a page interaction document.

4. The method for automatically generating ERP front-end code based on AI and metadata according to claim 2, characterized in that: Step 2 also includes the following steps: Generate corresponding view files, data flow files, type files, style files and prefabricated framework codes and data flow codes in the files according to the selected new module directory and new module name; Generate routing definition related codes according to the routing address corresponding to the newly added module; Generate UI component code and the data structure code of the Model layer corresponding to the component based on the layout components that the new page depends on.

5. The method for automatically generating ERP front-end code based on AI and metadata according to claim 1, characterized in that: The standardized requirement document includes: field information, trigger conditions and linkage logic.

6. The method for automatically generating ERP front-end code based on AI and metadata according to claim 5, characterized in that: When the AI big model converts standardized requirement documents into structured requirement documents, it structures the linkage logic into four types: linkage of field values, linkage of field visibility, configuration linkage, and linkage function.

7. An ERP front-end code automatic generation system based on AI and metadata, characterized by: The method for automatically generating ERP front-end code according to any one of claims 1 to 6 in real time comprises: Metadata design module: used to perform data modeling based on business fields, generate metadata models, and create mappings between metadata and UI data, thereby synchronously generating UI data models. Interface module: used to provide the user with a generation parameter input interface; AI module: This module is used to obtain input standardized requirement documents and convert them into structured requirement documents using an internally trained AI model. It also parses the metadata in the structured requirement documents based on metadata field definitions, calls the metadata model and UI data model, and generates a page interaction DSL. Page generation module: used to generate ERP front-end code based on the page generation parameters input by the user and the page interaction DSL generated by the AI module.

8. The ERP front-end code automatic generation system based on AI and metadata according to claim 7 is characterized in that: The page generation module is further used to: parse the main-sub-table structure in the metadata model and generate page main-sub-table layout configuration code; Parse the metadata UI components corresponding to the fields in the UI data model and generate the UI component configuration code corresponding to the form fields; at the same time, parse the validation rules in the UI data model and generate the UI validation configuration code.

9. The ERP front-end code automatic generation system based on AI and metadata according to claim 7 is characterized in that: Also includes: Code analysis module: used to analyze the generated full ERP front-end code, parse the common code into an abstract syntax tree, insert new code, and generate new form / list code files.

10. The ERP front-end code automatic generation system based on AI and metadata according to claim 7 is characterized in that: The AI module adopts an AI large model trained based on DeepSeek-R1-Distill-Qwen-32B, and the interface module adopts a command line interface tool to provide users with a generation parameter input interface.

Images