Intelligent assembling method and device based on data model driving and storage medium

Abstract

The invention relates to the technical field of artificial intelligence big data processing, in particular to an intelligent assembling method and device based on data model driving and a storage medium. Through modules such as automatic code generation, a process engine, an interface engine, a display component engine and a business data structure engine, the system can automatically generate corresponding function modules after a user inputs a demand, the workload of manual coding is greatly reduced, and the development period is remarkably shortened. Based on existing templates and data models, the system can quickly match user requirements, realize modular assembly, reduce repeated development and improve development efficiency. The flexibility and expandability of the system are enhanced, and the system can be flexibly expanded according to different service requirements through a dynamic data model. And quick iteration and upgrading of functions of the basic function module or the newly added service module can be realized by adjusting the data model. User requirements are analyzed through the NLP technology, an intelligent matching engine is combined, a system can automatically assemble a new function module under the condition that new codes do not need to be written, and a highly configurable solution is provided.

Description

Technical Field

[0001] The present invention relates to the field of artificial intelligence big data processing technology, and in particular to a method, device and storage medium for intelligent assembly of system functions based on data model driving. Background Art

[0002] With the rapid development of information technology and the continuous advancement of enterprise digital transformation, enterprises' demand for information systems is growing. Traditional software development methods can no longer respond quickly to changes in market and business needs.

[0003] The data model-driven intelligent assembly method of system functions is developed on the basis of traditional software development methods, agile development, DevOps, microservice architecture, low-code / no-code platform and artificial intelligence technology. It drives the generation and assembly of system functions through data models, can quickly respond to changes in demand, improve system flexibility, reduce development costs, and support complex logic and high customization requirements. It is an important technical means for enterprises to achieve digital transformation and business agility. Summary of the invention

[0004] The core purpose of this method is to reduce the workload of manual coding and improve development efficiency through data model driving. Through the automated assembly engine, user requirements are automatically matched with functional templates to generate complete system functional modules, allowing developers to quickly respond to business needs and shorten product development cycles.

[0005] The purpose of inventing this method also includes realizing intelligent and automatic assembly of system functions. Through the combination of modules such as process engine, interface style engine, component engine, data structure engine, business code engine, etc., system functions that meet business needs are automatically generated, and flexible expansion and customization of the system are realized through modularization.

[0006] This method aims to achieve flexible response to business needs through data model drive. The natural language requirements input by users can be converted into executable functional modules through NLP technology and intelligent matching algorithms without manual intervention. This can quickly respond to business needs in different scenarios, greatly improving the adaptability and scalability of the system.

[0007] By automating function generation and code assembly, the system can reduce the workload of developers in manual coding and reduce development costs. In addition, the intelligent assembly method allows continuous iteration and upgrading of functional modules while maintaining the consistency and stability of the system, reducing maintenance costs.

[0008] Another goal of this invention is to generate diversified functional variants through intelligent algorithms (such as genetic algorithms), explore innovative solutions, and promote innovation in business models. At the same time, through the expansion of data models and automated function generation, it supports the rapid expansion of the system and the diversification of business scenario requirements.

[0009] The intelligent assembly method driven by data model includes the following steps: Step 1, the dialog interface module builds a user dialogue interface through React, Vue.js or Angular; the dialog interface module preprocesses the natural language text input by the user through NLP technology, including word segmentation, stop word removal, word form restoration and other text preprocessing; the text input by the user is segmented, using the open source word segmentation library NLTK or Jieba, supporting customized dictionaries, and the text is split into single words according to the granularity of words or subwords; the stop words are removed from the text input by the user; the text input by the user is word-formed, using the word form restoration tool WordNetLemmatizer or the word form restoration library provided by SpaCy to restore the different forms of words to their basic forms; the text input by the user is stemmed; named entities are extracted through the tool SpaCy or Stanford NER; Step 2: The visualization function generation big model includes data preparation, data cleaning, variant generation, synthetic examples, requirement analysis and conversion, code generation, and visualization interface generation, and finally returns the link address in the dialog interface. Users can view the function implementation interface by clicking the demonstration address in the dialog interface. Through the semantic understanding ability of the big model GPT-4 or BERT, the structure and content of the data source are automatically analyzed to generate a data model. According to the specific requirements input by the user, the relevant data subset is automatically selected from the large-scale data. The big model generates multiple variants of the function for users to choose from based on the requirements analysis. Step 3, the data model persistence module uses the database, NoSQL database, file storage and memory storage for user persistent storage, and synchronizes the stored data to the data preparation in step 2; The basic data model data loaded during initialization, such as user management, role management, menu management, unit management, and interface style, are stored in a relational database. The functional module data model includes a process engine, an interface style engine, a display component engine, a business data structure engine, and a business code engine, which are initialized and generated by the system function intelligent assembly method driven by the data model and stored in a NoSQL database. The newly added business data model includes new functions dynamically generated by users through the system function intelligent assembly method. The data in the initialization module is mapped into vector labels, such as user permissions, roles, units, processes, and interface features, which are used to help the large model perform more accurate demand analysis and function recommendations when generating functional modules. Step 4, the function driving module analyzes user needs and starts multiple data model engines, such as process engine, interface style engine, display component engine, business data structure engine, and business code engine, thereby automatically generating function modules that meet user requirements; Step 5, the function assembly module integrates the codes and interfaces output by each engine in step 4 to form a complete function display interface and implementation function, and generates an accessible URL address and opens it to the business system; the business system is integrated into the business production system according to the protocol standards and document description to ensure that the system can use the functions correctly; Collect the generated outputs in step 4, including the generated business process diagram, task definition and process logic; generated front-end interface code HTML, CSS, JS and styles; generated display component code, such as forms, buttons, charts; generated database table structure, API interface definition and data model; generated business logic code and service implementation; Automatically assemble functional modules, merge the front-end codes generated by the interface engine and component engine, and integrate the service codes generated by the business code engine with the interface generated by the data structure engine; create database tables and fields based on the output of the data structure engine, configure the data access layer DAO, and ensure that the front-end request can correctly access and operate the database; deploy the process definition generated by the process engine to the workflow engine, such as Camunda and Activiti; integrate the API interface generated by the data structure engine with the business logic code to ensure the implementation of the interface function. Deploy the integrated front-end code to a Web server, such as Nginx and Apache; configure the routing of the Web server or application server so that users can access the function display interface through a specific URL.

[0010] A device based on a data model driven intelligent assembly method, comprising: A memory 100, used for storing computer programs; The processor 200 can implement the steps of the business processing method disclosed in any of the foregoing embodiments when executing the computer program; the memory 100 includes a non-volatile storage medium and an internal memory; the non-volatile storage medium stores an operating system and computer-readable instructions, and the internal memory provides an environment for the operation of the operating system and computer-readable instructions in the non-volatile storage medium; the processor 200 in some embodiments can be a central processing unit, a controller, a microcontroller, a microprocessor or other data processing chip, which provides computing and control capabilities for electronic devices, and implements the steps of the business processing method disclosed in any of the foregoing embodiments when executing the computer program stored in the memory 100.

[0011] A storage medium based on a data model driven intelligent assembly method includes an electronic device, wherein the electronic device is divided into: The input interface 300 is connected to the processor 200 and is used to obtain externally imported computer programs, parameters and instructions, and save them in the memory 100 under the control of the processor 200; the input interface 300 is connected to an input device to receive parameters or instructions manually input by a user; the input device is a touch layer covered on the display screen, or a key, trackball or touchpad set on the terminal shell, or a keyboard, touchpad or mouse; The display unit 400 is connected to the processor 200 and is used to display the data processed by the processor 200 and to display a visual user interface; the display unit 400 may be an LED display, a liquid crystal display, a touch-sensitive liquid crystal display, and an OLED touch device; The network port 500 is connected to the processor 200 and is used for communication connection with external terminal devices. The communication technology used in the communication connection is a wired communication technology or a wireless communication technology, such as mobile high-definition link technology MHL, universal serial bus USB, high-definition multimedia interface HDMI, wireless fidelity technology WiFi, Bluetooth communication technology, low-power Bluetooth communication technology, and communication technology based on IEEE802.11s; The electronic device includes a memory, a processor, and a computer program stored in the memory and executable on the processor.

[0012] Beneficial effects of the present invention: 1. Improve system development efficiency. Through automatic code generation, process engine, interface engine, display component engine, business data structure engine and other modules, the system can automatically generate corresponding functional modules after the user inputs the requirements, greatly reducing the workload of manual coding and significantly shortening the development cycle. Based on existing templates and data models, the system can quickly match user needs, realize modular assembly, reduce repeated development, and improve development efficiency.

[0013] 2. Enhance the flexibility and scalability of the system. Through the dynamic data model, the system can be flexibly expanded according to different business needs. Whether it is a basic functional module or a new business module, the function can be quickly iterated and upgraded by adjusting the data model. By analyzing user needs through NLP technology and combining it with the intelligent matching engine, the system can automatically assemble new functional modules without writing new code, providing a highly configurable solution.

[0014] 3. Improve the accuracy and consistency of functions. Use the rule engine and matching algorithm to automatically match suitable function templates and components according to predefined business rules to ensure the accuracy and consistency of function generation and reduce errors caused by human operations. Through automated testing and verification processes, the function modules generated by the system are strictly tested before release to ensure stability and correctness.

[0015] 4. Reduce development and operation and maintenance costs. The system intelligent assembly method driven by data models can automatically generate business codes, interfaces and UI components, which reduces the demand for developers and reduces labor costs. Especially when dealing with complex or changing business needs, it can respond efficiently and avoid a lot of repetitive work. All functional modules are persistently stored through data models, which facilitates centralized management, updating and maintenance. The development of new functions can also be expanded based on existing data models to avoid development from scratch.

[0016] 5. Promote innovation. Through variant generation algorithms (such as genetic algorithms), the system can generate a variety of different functional combinations, explore innovative solutions, and provide more options for system functional expansion and optimization.

[0017] In summary, the effective effects of the data model-driven system intelligent assembly method include improving development efficiency, enhancing functional flexibility, reducing costs, improving consistency and accuracy of functional modules, accelerating product launch, providing customized functions, and enhancing system maintainability and scalability. This method can not only help enterprises quickly adapt to market changes, but also promote the transformation and upgrading of business models through technological innovation. BRIEF DESCRIPTION OF THE DRAWINGS

[0018] Figure 1 It is a schematic diagram of intelligent assembly of system functions of the present invention; Figure 2 It is a schematic diagram of the execution device of the present invention; Figure 3 Schematic diagram of the storage medium of the present invention. DETAILED DESCRIPTION

[0019] refer to Figure 1 ,The intelligent assembly method driven by data model includes a dialog interface module, a large model for ,visualization function generation, data persistence module, function driving module, and function ,assembly module.

[0020] The system function intelligent assembly method based on data model driving includes the following steps.

[0021] Step 1: The dialog interface module can be implemented using React, Vue.js or Angular to build a concise and intuitive user dialogue interface. For example, it can be implemented using Vue.js, using Vue's two-way binding (v-model) to process user input, using Vuex to manage the state of the entire application, including user input and visualization functions to generate large model interface feedback, and using Vue's transition effects ( <transition>Add smooth pop-up and retraction animations to the dialog box to enhance the user experience.

[0022] Furthermore, the dialog box interface module preprocesses the natural language text input by the user through NLP technology, including text preprocessing such as word segmentation, stop word removal, and lemmatization.

[0023] Furthermore, perform word segmentation on the text input by the user. Use open-source word segmentation libraries such as NLTK (suitable for English) or Jieba (suitable for Chinese), which support custom dictionaries, and split the text into individual words at the granularity of words or sub-words. For example, "I like to eat apples" should be split into "I / like / to / eat / apples" instead of "I / like to eat / apples".

[0024] Furthermore, remove stop words from the text input by the user, deleting common words that contribute little to the semantics, such as "de", "shi", "and", "the", etc., to reduce computational complexity and extract more informative content. For example, in a question sentence, necessary keywords should still be retained after removing "de" and "shi".

[0025] Furthermore, perform lemmatization on the text input by the user. Use lemmatization libraries provided by lemmatization tools such as WordNetLemmatizer or SpaCy to restore different forms of words to their basic forms (such as restoring "running" to "run").

[0026] Furthermore, perform other preprocessing steps on the text input by the user, such as extracting the stem (changing "working" to "work"). Named entities (such as person names, place names, company names) can be extracted through tools such as SpaCy or Stanford NER.

[0027] For example, the user inputs "Please help me generate a company leave approval function with an Internet-style interface". Use natural language processing (NLP) technology to perform word segmentation, entity recognition, and semantic understanding on the input, and extract the following key information: Interface style: Internet style Function type: Leave approval Business scenario: Company internal management process Participating roles: Employees, department approvers, HR Step 2, the visualization function generation large model mainly includes data preparation, data cleaning, variant generation, and synthetic example modules, completes requirement analysis and conversion, code generation, and visualization interface generation, and finally returns a link address in the dialog box interface. The user can view the function implementation interface by clicking the demo address in the dialog box interface.

[0028] Furthermore, through the semantic understanding capabilities of large models (such as GPT-4, BERT, etc.), the structure and content of the data source can be automatically analyzed to generate a data model, and relevant data subsets can be automatically selected from large-scale data based on the specific needs of the user input.

[0029] Furthermore, the big model generates multiple variants of functions for users to choose from based on demand analysis. For example, different UI styles, interaction designs, etc. Users can preview different versions of the function interface in the dialog interface and make a selection. Synthetic data is not limited to random generation, but can also generate realistic business data based on specific business rules, and display application performance under different data scenarios in the visual interface.

[0030] Step 3: The data model persistence module in the data model-driven system function intelligent assembly method uses relational databases, NoSQL databases, file storage, and memory storage to persistently store the functions confirmed by the user in the dialog box interface, and synchronize the stored data to the data preparation in step 2.

[0031] Furthermore, the basic data model data loaded during initialization, such as user management, role management, menu management, unit management, interface style, etc., are mainly stored in relational databases. The functional module data model includes the process engine, interface style engine, display component engine, business data structure engine, and business code engine. These data are initialized and generated by the system function intelligent assembly method driven by the data model and stored in the NoSQL database. The newly added business data model includes new functions dynamically generated by users through the system function intelligent assembly method.

[0032] Furthermore, the data in the initialization module is mapped into vector labels (such as user permissions, roles, units, processes, interfaces and other features) to help the large model perform more accurate demand analysis and function recommendations when generating functional modules.

[0033] Step 4, the function driving module, analyzes user needs and starts multiple data model engines (process engine, interface style engine, display component engine, business data structure engine, business code engine), thereby automatically generating function modules that meet user requirements. Take the example of user input "Please help me generate a company leave approval function with an Internet-style interface" as an example.

[0034] After parsing the keyword "leave approval", the process engine data model is loaded based on the data model-driven system function intelligent assembly method. The process engine will generate the corresponding workflow based on the existing approval process template, including application submission, department approval, HR approval, etc. The method uses the BPMN (Business Process Model and Notation) standard to automatically generate a flowchart, and users can view or adjust the approval order in the visual interface. Each step automatically sets the corresponding role (such as department approver, HR) and execution conditions (such as approval / rejection).

[0035] After parsing the "Internet style", the interface style engine data model is loaded based on the system function intelligent assembly method driven by the data model. The interface style engine will enable predefined Internet style rules, such as flat design, simple color matching and responsive layout. Select UI components that conform to the Internet style from the component library (such as Material UI, Ant Design), including forms, buttons, navigation bars, etc.

[0036] After parsing the "leave approval" function, the display component engine data model is loaded based on the data model-driven system function intelligent assembly method, and the display component engine automatically selects components that meet the approval process. Display components include: employee information input box, leave type selection box, date selector, approval progress bar, status prompt box, etc.

[0037] When parsing the "leave approval" function, the data model of the business data structure engine is loaded and displayed based on the data model-driven system function intelligent assembly method. The business data structure engine will enable the leave approval business template and define the relevant data table structure. The data tables include Employee (employee information table), LeaveRequest (leave application form), Approval (approval record table), etc. The data structure can be stored and managed through a relational database (such as MySQL, PostgreSQL) or a NoSQL database (such as MongoDB).

[0038] After parsing the "leave approval" function, the business code engine data model is loaded based on the data model-driven system function intelligent assembly method, and the business code engine generates relevant background logic, including application submission, approval process judgment, status update, etc. The code logic includes: submission and verification of leave applications, approval interface of departments and HR, and dynamic update of approval status.

[0039] Step 5, the function assembly module, integrates the codes and interfaces output by each engine (process engine, interface engine, component engine, data structure engine, business code engine) in step 4 to form a complete function display interface and implementation function, and generates an accessible URL address and opens it to the business system. The business system is integrated into the business production system in accordance with the protocol standards and document descriptions to ensure that the system can use the functions correctly.

[0040] Collect the output generated in step 4, the generated business process diagram, task definition, and process logic. The generated front-end interface code (HTML / CSS / JS) and style. The generated display component code, such as forms, buttons, charts, etc. The generated database table structure, API interface definition, and data model. The generated business logic code and service implementation. Further automate the assembly of functional modules, merge the front-end code generated by the interface engine and the component engine to form a complete user interface. Integrate the service code generated by the business code engine with the interface generated by the data structure engine. Create database tables and fields based on the output of the data structure engine. Configure the data access layer (DAO) to ensure that the front-end request can correctly access and operate the database. Deploy the process definition generated by the process engine to the workflow engine (such as Camunda, Activiti). Integrate the API interface generated by the data structure engine with the business logic code to ensure the implementation of the interface function. Deploy the integrated front-end code to a web server (such as Nginx, Apache). Configure the routing of the web server or application server so that users can access the function display interface through a specific URL. Generate the URL address that users access based on the configuration, such as https: / / example.com / leave-request. Verify that the generated URL can correctly access the function display interface. Output the URL to the dialog window in step 1.

[0041] Furthermore, the visualization function generates a large model, including steps of preparing data, cleaning data, generating variants, and synthesizing examples.

[0042] Step 21, extract the data model from the data model persistence module in step 3 to generate and optimize the visualization function model. Extract the basic data model structure from the database, such as tables, fields, indexes, foreign key constraints, etc., extract the data structure and business logic related to the function module, and extract the data structure definition of the new business requirements. For example: Basic data model data database tables: employees, leave_requests, leave_approvals. Employees table fields: employee_id, name, department, position, email. Leave_requests table fields: request_id, employee_id, start_date, end_date, leave_type, status, request_date. Leave_approvals table fields: approval_id, request_id,approver_id, approval_date, approval_status, comments. Functional module data model: Data model definition of leave process function: including the submission of leave application, approval process and record viewing. Input fields: employee ID, leave start and end date, leave type, application date. Output fields: leave application status, approval opinion, approval result. New business data model: New data field: reason (leave reason), used to record the detailed reason for the employee's leave. Updated leave application form fields: request_id, employee_id, start_date, end_date, leave_type, reason, status, request_date.

[0043] Step 22: Convert the extracted data model to a unified format (such as JSON, XML, YAML), remove duplicate data items, and unify data formats and standards. For example, in the example of step 1, unify field naming rules (such as change leave_type to leaveType) and data types (such as unify date formats).

[0044] Step 23: Generate new variants based on the existing data model, extend fields or modify table structure. Generate variants in the leave application form, for example, add the approval_deadline field to support new approval process requirements.

[0045] Specific examples: Basic data model: leave_requests (leave application form), fields: request_id, employee_id, start_date, end_date, leave_type, status, request_date Requirement: Add a new field approval_deadline (approval deadline) to support the new approval function.

[0046] Encode the data model as a genome. Each field and attribute is represented by a specific encoding. For example: request_id: 1 employee_id: 1 start_date: 1 end_date: 1 leave_type: 1 status:1 request_date: 1 approval_deadline: 0 (indicates the field does not exist) Furthermore, we define the initial population: it contains different data model variants, for example, some models include the approval_deadline field, while others do not. Here we assume that there are 4 initial data model variants, each represented by a genetic code: Individual 1 (Model A): Genome: [1, 1, 1, 1, 1, 1, 1, 0]. Explanation: Contains the fields request_id, employee_id, start_date, end_date, leave_type, status, request_date, but does not include approval_deadline.

[0047] Individual 2 (Model B): Genome: [1, 1, 1, 1, 1, 1, 1, 1]. Explanation: Contains all fields, including approval_deadline.

[0048] Individual 3 (Model C): Genome: [1, 1, 1, 1, 1, 1, 1, 0]. Explanation: Same as Model A.

[0049] Individual 4 (Model D): Genome: [1, 1, 1, 1, 1, 1, 1, 0]. Explanation: Same as Model A.

[0050] Furthermore, the data model of each variant is evaluated using the fitness function. Suppose we define the fitness function as follows: Among them, performance (Performance): whether the data model can effectively support new functions. Complexity (Complexity): the complexity of the data model. The more fields there are, the higher the complexity.

[0051] Suppose we score the performance and complexity of each model. Performance score (0-10 points): Model B supports all requirements and has the highest performance. Complexity score (0-10 points): Model B has the highest complexity.

[0052] Rating example: Model A: Performance score: 5, Complexity score: 2 Model A fitness: F(A)=5−2=3F(A) = 5 - 2 = 3F(A)=5−2=3 Model B: Performance score: 10, Complexity score: 6 Model B fitness: F(B)=10−6=4F(B) = 10 - 6 = 4F(B)=10−6=4 Model C: Performance score: 5, Complexity score: 2 Model C fitness: F(C)=5−2=3F(C) = 5 - 2 = 3F(C)=5−2=3 Model D: Performance score: 5, Complexity score: 2 Model D fitness: F(D)=5−2=3F(D) = 5 - 2 = 3F(D)=5−2=3 Furthermore, the selection probability is proportional to the fitness.

[0053] Total fitness = F(A)+F(B)+F(C)+F(D)=3+4+3+3=13 The selection probability of each model is: Model A: 3 / 13≈0.231 Model B: 4 / 13≈0.308 Model C: 3 / 13≈0.231 Model D: 3 / 13≈0.231 Further, a random position of the genome is selected, for example, the 7th gene position is selected as the crossover point.

[0054] Parent Model: Model B: [1, 1, 1, 1, 1, 1, 1, 1] Model C: [1, 1, 1, 1, 1, 1, 0] Offspring model (after crossover): Offspring 1: [1, 1, 1, 1, 1, 1, 1, 1] (take the genome of model B) Offspring 2: [1, 1, 1, 1, 1, 1, 1, 0] (take the genome of model C) Furthermore, let's perform a mutation operation. Suppose we mutate the approval_deadline field in the descendant model. Set to 0.1.

[0055] Model mutation example: Child 1: [1, 1, 1, 1, 1, 1, 1, 1] (unchanged by the mutation operation) Offspring 2: [1, 1, 1, 1, 1, 1, 1, 0] (assuming the 8th gene is mutated, changing 0 to 1) The mutated offspring 2 is: [1, 1, 1, 1, 1, 1, 1, 1].

[0056] Step 24, generate sample data based on the variant data model, and persist the tested and verified data model to step 3.

[0057] Suppose we have a base data model and generate multiple data model variants through a genetic algorithm. Each variant may include different fields or attributes. For example: Basic data model: Table: leave_requests, fields: request_id, employee_id, start_date, end_date, leave_type, status, request_date Variant data model: Variant 1: [request_id, employee_id, start_date, end_date, leave_type, status, request_date] (no new fields) Variant 2: [request_id, employee_id, start_date, end_date, leave_type, status, request_date, approval_deadline] (including the newly added field approval_deadline) Variant 3: [request_id, employee_id, start_date, end_date, leave_type, status, request_date, reason] (including the newly added field reason).

[0058] Generate synthetic sample data based on the variant data model. For example, for a variant that contains the approval_deadline field, you can create sample data like this: INSERT INTO leave_requests (request_id, employee_id, start_date, end_date, leave_type, status, request_date, approval_deadline) VALUES (1, 101, '2024-09-01', '2024-09-05', 'Annual', 'Pending', '2024-08-30', '2024-09-03'); For a variant that includes a reason field, you can create sample data like this: INSERT INTO leave_requests (request_id, employee_id, start_date, end_date, leave_type, status, request_date, reason) VALUES (2, 102, '2024-09-10', '2024-09-15', 'Sick', 'Approved', '2024-09-05', 'Flu').

[0059] Furthermore, the data model persistence module is mainly responsible for persistently storing the functions confirmed by the user in the dialog interface, and synchronizing these data to the data preparation for the visualization function to generate a large model.

[0060] Furthermore, the function driver module starts and coordinates multiple data model function engines (such as process engine, interface style engine, display component engine, business data structure engine, business code engine), including the following steps: data reading, data loading, data mapping, and function loading.

[0061] Step 41, read relevant data from the data source (database, API, configuration file, etc.) to prepare for subsequent processing. Read user input: Get the functional requirements entered by the user in the dialog box, such as "Please help me generate a company leave approval function with an Internet-style interface." Read data model: Read available interface style templates, business data structure templates, process templates, component templates, etc. from the predefined data model library. Read business logic: Read business rules and code data models related to leave approval from the business logic library. Use API requests, database queries, or read configuration files to obtain necessary data. Data includes interface style, process models, component libraries, business data structures, etc.

[0062] Step 42, load the read data into storage (specifically memory). Parse the user's input requirements into a structured data format (such as JSON or XML), including interface style, function type, process steps, etc. Load the read template data into the data model in memory, including interface style templates, business data structure templates, etc. Load the relevant business logic and code templates into memory to generate corresponding code and business processes. Use the ORM (Object-Relational Mapping) framework and JSON parsing library to convert the read data into the data model in memory.

[0063] Step 43, intelligent matching and mapping: Map user requirements with template data to determine specific engine startup parameters and configurations. Map the required fields to the corresponding template fields according to user requirements. For example, map "Internet style" to the interface style template, and map "leave approval" to the business data structure template. Convert the mapping results into the parameter configurations required by each engine. For example, the style parameters required by the interface style engine, the process step parameters required by the process engine, etc. Map user requirements to the data structure model to determine the generated database table structure and fields. Use data mapping tools (such as MapStruct) and configuration management tools to map and convert data. Automatic mapping of requirements and templates is achieved through matching algorithms or rule engines.

[0064] Furthermore, perform word segmentation and semantic analysis. Use NLP tools (such as SpaCy and BERT) to perform word segmentation, named entity recognition, and semantic extraction on the input. Extract fields: Internet style → interface style, leave approval → process type.

[0065] Further, perform intent recognition and classification. Use classification models (such as text classification models based on logistic regression or Transformer) to identify the type of user needs. Example classification: interface style, business process, data model.

[0066] Next, build a template library. Create a library that contains templates and field information. Example: { "templates": [ { "type": "Interface style", "keywords": ["Internet style", "traditional style"], "fields": ["style_theme", "color_palette"] }, { "type": "Process template", "keywords": ["leave approval", "reimbursement approval"], "fields": ["process_name", "steps", "approvers"] } ] } Furthermore, use a rule engine (such as Drools) or a JSON configuration file to define field mapping rules. Rule example: If the input contains "Internet style", map to style_theme=modern.

[0067] Furthermore, according to the mapping results, the configuration required by the interface engine is generated. Example: style_theme: modern color_palette: blue_light Furthermore, the parameters required by the process engine are determined based on the fields mapped by the user input.

[0068] { "process_name": "Leave Approval", "steps": ["Submit application", "Manager approval", "HR approval"], "approvers": ["department manager", "personnel"] } Furthermore, BERT or TF-IDF is used to calculate the semantic similarity between the user input and the template keywords. For example, input: "Internet style" → match style_theme template (similarity: 0.92), provide users with multiple matching options and sort them by similarity.

[0069] Furthermore, the requirements are matched with the mapping rules defined in the rule base, and the configuration required by each engine is dynamically generated according to the matching results.

[0070] Specific implementation cases: Use a data mapping tool (such as MapStruct). For example, define an interface to map user requirements to a specific interface template: @Mapper public interface UserRequestMapper { @Mapping(source = "style", target = "theme") @Mapping(source = "function", target = "feature") Interface UIRequestMapper { UIRequest mapToUIRequest(UserRequest userRequest); } } MapStruct automatically generates mapping implementation code at compile time, which is responsible for mapping the fields in user requirements (such as style, function) to the fields in the target data model (such as theme, feature).

[0071] Use configuration management tools to manage and maintain system configuration data, including template configuration, business rule configuration, etc.

[0072] theme: - name: "Internet style" colorScheme: "light" layout: "responsive" Configuration management tools provide APIs to read and load configuration data. For example, Spring Cloud Config can read remote configuration files through the HTTP API.

[0073] Automatically map requirements to templates through matching algorithms or rule engines, and define matching rules between requirements and templates. For example, define which user requirement fields correspond to which template fields.

[0074] Algorithm implementation, based on exact matching of field name or type. For example, map "Internet style" to the "theme" field in the interface style template: def match_user_request(user_request, template): if user_request['style'] intemplate['available_styles']: return template['theme'][user_request['style']] else: return default_style Rule engine, use rule engines (such as Drools, Easy Rules) to define complex business rules. For example, dynamically generate interface styles based on user needs: rule "Apply Internet Style" when $request : UserRequest(style == "Internet style") then $template.setTheme("light"); end Step 44: start each engine according to the mapping result and generate a functional module that meets the user's needs. Specific implementation steps: Start the process engine: Configuration: Configure the process engine according to the mapped process steps and roles.

[0075] Generate: Generate the complete process of leave approval, including the tasks and conditions of each step.

[0076] Output: Generated flowchart and execution logic.

[0077] Start the interface style engine: Configuration: Configure the interface style engine according to the mapped interface style parameters.

[0078] Generate: Generate an interface design that conforms to the Internet style, including layout, color, and components.

[0079] Output: generated front-end interface code and style.

[0080] Start the presentation component engine: Configuration: Configure the component template of the display component engine according to business functions.

[0081] Generate: Generate required components, such as forms, buttons, progress bars, etc.

[0082] Output: Generated presentation component code.

[0083] Start the business data structure engine: Configuration: Configure the data structure engine according to the mapped data structure parameters.

[0084] Generate: Generate database table structure and API interface definition.

[0085] Output: Generated database table structure and data access code.

[0086] Start the business code engine: Configuration: Configure the business code engine according to the mapped business logic parameters.

[0087] Generate: Generate code related to business logic, such as data processing, business rule implementation, etc.

[0088] Output: Generated business logic code and service interface.

[0089] Furthermore, the function automatic assembly module can effectively generate a URL or interface from the generated system function and send it to the dialogue interface in step 1. The following are the specific steps and implementation details.

[0090] Collect the output from step 4: generated business process diagram, task definition and process logic. Front-end interface code (HTML / CSS / JS) and styles. Display component code, such as forms, buttons, charts, etc. Database table structure, API interface definition and data model. Business logic code and service implementation.

[0091] Configure the build tool to process HTML, CSS, and JavaScript files. Process the code generated by the component engine and merge it into the front-end code. Generate packaged static resources (such as bundle.js and styles.css). Deploy the generated static resources to the web server. Configure the web server's routing and static resource paths. Use the build tool to automatically package business logic and API implementation code. Generate deployable service packages (such as JAR and WAR). Configure the CI / CD pipeline to automatically build and deploy back-end services. Deploy the service package to the application server (such as Tomcat and Docker container). Automatically execute database migration scripts to create and update database table structures. Configure the ORM framework for data model mapping. Automatically generate data access layer code to support data interaction between the front-end and back-end. Automatically deploy the process definition generated by the process engine to the workflow engine. Integrate the API interface generated by the data structure engine with the business code, and configure API routing and processing logic. Automatically generate and maintain API documents. Deploy the merged front-end code and static resources. Deploy the back-end service to ensure that the service can handle front-end requests. Configure the routing rules of the web server or application server to map the functional modules to the URL path. Use automated testing tools (Selenium, Jest) to automatically test whether the generated URL can correctly access the function display interface. Output the generated URL address to the dialog window in step 1.

[0092] Furthermore, the execution device of the data model-driven system intelligent assembly method. Figure 2 The figure shows a functional module diagram of a preferred embodiment of the business intelligent flow engine execution device of the present invention.

[0093] A memory 100, used for storing computer programs; The processor 200 is used to implement the steps of the business processing method disclosed in any of the aforementioned embodiments when executing the computer program.

[0094] Specifically, the memory 100 includes a non-volatile storage medium and an internal memory. The non-volatile storage medium stores an operating system and computer-readable instructions, and the internal memory provides an environment for the operation of the operating system and computer-readable instructions in the non-volatile storage medium. In some embodiments, the processor 200 can be a central processing unit (CPU), a controller, a microcontroller, a microprocessor or other data processing chip, which provides computing and control capabilities for electronic devices. When executing the computer program stored in the memory 100, the steps of the business processing method disclosed in any of the aforementioned embodiments can be implemented.

[0095] Based on the above embodiments, as a preferred embodiment, see Figure 3 As shown, the electronic device also includes: The input interface 300 is connected to the processor 200 and is used to obtain externally imported computer programs, parameters and instructions, and save them in the memory 100 under the control of the processor 200. The input interface 300 can be connected to an input device to receive parameters or instructions manually input by a user. The input device can be a touch layer covered on the display screen, or a button, trackball or touchpad set on the terminal housing, or a keyboard, touchpad or mouse.

[0096] The display unit 400 is connected to the processor 200 and is used to display data processed by the processor 200 and to display a visual user interface. The display unit 400 can be an LED display, a liquid crystal display, a touch-sensitive liquid crystal display, an OLED (Organic Light-Emitting Diode) touch device, etc.

[0097] The network port 500 is connected to the processor 200 and is used to communicate with external terminal devices. The communication technology used for the communication connection can be a wired communication technology or a wireless communication technology, such as mobile high-definition link technology (MHL), universal serial bus (USB), high-definition multimedia interface (HDMI), wireless fidelity technology (WiFi), Bluetooth communication technology, low-power Bluetooth communication technology, communication technology based on IEEE802.11s, etc.

[0098] The electronic device may include a memory, a processor, and may also include a computer program stored in the memory and executable on the processor, such as an execution program of a business intelligence flow engine.

[0099] In the several embodiments provided by the present invention, it should be understood that the disclosed systems, devices and methods can be implemented in other ways. For example, the device embodiments described above are only illustrative, for example, the division of the modules is only a logical function division, and there may be other division methods in actual implementation.

[0100] It should also be noted that, in this specification, relational terms such as first and second, etc. are only used to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Moreover, the terms "comprise", "include" or any other variants thereof are intended to cover non-exclusive inclusion, so that the process, method, article or equipment including a series of elements includes not only those elements, but also includes other elements not explicitly listed, or also includes elements inherent to such process, method, article or equipment. In the absence of further restrictions, the elements defined by the sentence "comprise a ..." do not exclude the presence of other identical elements in the process, method, article or equipment including the elements.

[0101] The above description is only a preferred specific implementation manner of the present invention, but the protection scope of the present invention is not limited thereto. Any technician familiar with the technical field can make equivalent replacements or changes according to the technical scheme and inventive concept of the present invention within the technical scope disclosed by the present invention, which should be covered by the protection scope of the present invention.

[0102] Technical points of the present invention: 1. Data model driven: By designing a multi-layer data model, including a basic data model, a functional module data model, and a new business data model, these data models provide a structured data foundation for the intelligent assembly of the system, ensuring that the system can automatically generate different business functions based on user needs and context.

[0103] 2. Variant generation: Based on the existing data model, generate different variant data models, explore different functional combinations and business logic, and achieve flexible functional adaptability.

[0104] 3. Intelligent assembly engine Process engine: Generates business processes based on data models and automatically assembles workflows through the process engine. For example, the generation and configuration of approval processes can automatically generate corresponding business processes based on user input requirements.

[0105] Interface style engine: Through the interface style engine, a front-end interface of corresponding style is generated according to user needs, and predefined themes and layout templates are automatically applied, making UI generation more flexible.

[0106] Display component engine: Generates and automatically configures interface components associated with data models, supports visual display of forms, charts, tables and other functions, and selects appropriate components for combination according to needs.

[0107] Business data structure engine: Through the business data structure engine, the system intelligent assembly method driven by the data model generates the database table structure, API interface and its data mapping logic according to the data model, thereby automatically realizing the storage and management of business data.

[0108] 4. Automatic code generation Business code engine: Based on the data model-driven system intelligent assembly method, it automatically generates business logic code and interface code to process the backend business logic. The user input requirements are converted into executable API services, database access layer and logic processing layer through the code engine.

[0109] Interface integration and assembly: The intelligent assembly module integrates the codes, components and interfaces generated by each engine, eventually forming a complete functional module and generating the corresponding URL for users to access and test.

[0110] 5. Visualization function generates large models Data preparation and cleaning: Preprocess the data model input to the system, including data cleaning, conversion, deduplication, etc., to ensure that the generated functional module data structure is complete and conforms to business logic.

[0111] Variant generation and synthesis examples: Through variant generation algorithms (such as genetic algorithms), different variant examples are generated based on the data model-driven system intelligent assembly method, and available functional modules are automatically synthesized. Test and verify based on these variants to ensure the compatibility between different functional modules.

[0112] 6. Intelligent matching and mapping Data mapping tools: By using tools such as MapStruct to achieve automatic data mapping, the fields in the business data model are associated with the database table and API parameters, ensuring the correct flow of data during the automatic assembly process based on the data model-driven system intelligent assembly method.

[0113] Matching algorithm and rule engine: Using matching algorithm and rule engine, intelligently match the requirements input by users with existing templates or functional modules. For example, through the natural language description input by users, the system intelligent assembly method driven by data model can automatically find the corresponding functional template and reduce manual intervention.

[0114] 7. NLP Natural Language Processing Requirements analysis: NLP technology is used to process the user's natural language input, extract business requirements, and convert them into executable system operations. Text preprocessing includes word segmentation, stop word removal, part-of-speech tagging, etc., to ensure that the system can correctly understand the user's intention.

[0115] 8. Efficient interface and module integration Modular design: Different modules and functional components generated by the modular engine can be efficiently integrated to support flexible expansion of the system. The system intelligent assembly method driven by data models can quickly complete the process from functional design to final launch by automatically assembling interfaces and components.

[0116] Glossary 1. Data model: A data model is an abstract representation of data structure, data relationship, and data storage method. It is used to organize and define data in the system, including entities, attributes, relationships, etc. Common data models include relational data models and document data models.

[0117] 2. Intelligent assembly: Intelligent assembly refers to the combination of different functional modules, data models, business logic and UI components through automated technical means to generate a complete system function.

[0118] 3. Process Engine: A process engine is a tool for managing and executing business processes. It is used to define, deploy, execute, monitor and analyze business processes and supports the automated execution of business logic.

[0119] 4. Interface style engine: The interface style engine is a system that manages the user interface style and layout, and can generate customized user interfaces based on predefined styles or user needs.

[0120] 5. Display component engine: The display component engine is a component engine that dynamically loads and renders the user interface according to interface requirements, including a variety of UI components (such as forms, buttons, charts, etc.).

[0121] 6. Business data structure engine: The business data structure engine is an engine used to define and process business data structures in the system, supporting data definition, storage, query and conversion operations.

[0122] 7. Business code engine: The business code engine is responsible for automatically generating code snippets related to business logic, and can generate corresponding back-end business logic codes based on user needs and system rules.

[0123] 8. Data persistence: Data persistence refers to saving temporary data or memory data in the system to a persistent storage device (such as a database or file system) so that the data can be restored after the system is restarted or fails.

[0124] 9. Variant generation: Variant generation refers to generating multiple variant versions of functional modules or data structures based on existing data models or functional modules through specific algorithms (such as genetic algorithms).

[0125] 10. NLP (Natural Language Processing): NLP refers to the automatic processing of natural language by analyzing, understanding and generating human language through computer technology.

[0126] 11. Data Cleaning: Data cleaning is the process of screening, cleaning and transforming raw data to remove erroneous, duplicate or irrelevant data and make the data more structured and consistent.

[0127] 12. Storage media: Storage media refers to physical devices or virtualized storage that stores system data. Common media include hard disks, memory, databases, etc.

[0128] 13. Rule Engine: A rule engine is a system used to define and execute business rules. It determines and automatically executes corresponding operations based on preset rule sets.

[0129] 14. Mapping tool: A mapping tool is a tool that establishes connections between data or objects in different formats, such as MapStruct, which is used for mapping between Java objects.

[0130] 15. Genetic Algorithm (GA): Genetic algorithm is an optimization algorithm that simulates the biological evolution process. It gradually evolves the optimal solution through operations such as selection, crossover, and mutation.< / transition>

Claims

1. An intelligent assembly method driven by data model, characterized by The steps include: Step 1, the dialog interface module builds a user dialogue interface through React, Vue.js or Angular; the dialog interface module preprocesses the natural language text input by the user through NLP technology, including word segmentation, stop word removal, word form restoration and other text preprocessing; the text input by the user is segmented, using the open source word segmentation library NLTK or Jieba, supporting customized dictionaries, and the text is split into single words at the granularity of words or subwords; the stop words are removed from the text input by the user; the text input by the user is word-formed, using the word form restoration tool WordNetLemmatizer or the word form restoration library provided by SpaCy to restore the different forms of words to their basic forms; the text input by the user is stemmed; named entities are extracted through the tool SpaCy or Stanford NER; Step 2: The visualization function generation big model includes data preparation, data cleaning, variant generation, synthetic examples, requirement analysis and conversion, code generation, and visualization interface generation, and finally returns the link address in the dialog interface. Users can view the function implementation interface by clicking the demonstration address in the dialog interface. Through the semantic understanding ability of the big model GPT-4 or BERT, the structure and content of the data source are automatically analyzed to generate a data model. According to the specific requirements input by the user, the relevant data subset is automatically selected from the large-scale data. The big model generates multiple variants of the function for users to choose from based on the requirements analysis. Step 3, the data model persistence module uses the database, NoSQL database, file storage and memory storage for user persistent storage, and synchronizes the stored data to the data preparation in step 2; Basic data model data loaded during initialization, such as user management, role management, menu management, unit management, and interface style; Stored in a relational database; the functional module data model includes a process engine, an interface style engine, a display component engine, a business data structure engine, and a business code engine, which are initialized and generated by a system function intelligent assembly method driven by the data model and stored in a NoSQL database; the newly added business data model includes new functions dynamically generated by users through the system function intelligent assembly method; the data in the initialization module is mapped into vector labels, such as user permissions, roles, units, processes, and interface features; It is used to help large models to perform more accurate requirements analysis and function recommendations when generating functional modules; Step 4: The function-driven module analyzes user needs and starts multiple data model engines, such as the process engine, interface style engine, display component engine, business data structure engine, and business code engine; Thus, functional modules that meet user requirements are automatically generated; Step 5, the function assembly module integrates the codes and interfaces output by each engine in step 4 to form a complete function display interface and implementation function, and generates an accessible URL address and opens it to the business system; the business system is integrated into the business production system according to the protocol standards and document description to ensure that the system can use the functions correctly; Collect the output generated in step 4, including the generated business process diagram, task definition, and process logic; the generated front-end interface code HTML, CSS, JS, and styles; the generated display component code, such as forms, buttons, and charts; Generated database table structure, API interface definition and data model; generated business logic code and service implementation; Automatically assemble functional modules, merge the front-end codes generated by the interface engine and the component engine, and integrate the service codes generated by the business code engine with the interfaces generated by the data structure engine; According to the output of the data structure engine, create database tables and fields, configure the data access layer DAO, and ensure that the front-end request can correctly access and operate the database; Deploy the process definition generated by the process engine to the workflow engine, such as Camunda and Activiti; integrate the API interface generated by the data structure engine with the business logic code to ensure the implementation of the interface function; deploy the integrated front-end code to the Web server, such as Nginx and Apache; configure the routing of the Web server or application server so that users can access the function display interface through a specific URL.

2. The device of the data model-driven intelligent assembly method according to claim 1 is characterized in that include: A memory 100, used for storing computer programs; The processor 200 can implement the steps of the business processing method disclosed in any of the foregoing embodiments when executing the computer program; the memory 100 includes a non-volatile storage medium and an internal memory; the non-volatile storage medium stores an operating system and computer-readable instructions, and the internal memory provides an environment for the operation of the operating system and computer-readable instructions in the non-volatile storage medium; the processor 200 in some embodiments can be a central processing unit, a controller, a microcontroller, a microprocessor or other data processing chip, which provides computing and control capabilities for electronic devices, and implements the steps of the business processing method disclosed in any of the foregoing embodiments when executing the computer program stored in the memory 100.

3. The storage medium of the intelligent assembly method based on data model drive according to claim 2, characterized in that Including electronic equipment, electronic equipment is divided into: The input interface 300 is connected to the processor 200 and is used to obtain externally imported computer programs, parameters and instructions, and save them in the memory 100 under the control of the processor 200; the input interface 300 is connected to an input device to receive parameters or instructions manually input by a user; the input device is a touch layer covered on the display screen, or a key, trackball or touchpad set on the terminal shell, or a keyboard, touchpad or mouse; The display unit 400 is connected to the processor 200 and is used to display the data processed by the processor 200 and to display a visual user interface; the display unit 400 may be an LED display, a liquid crystal display, a touch-sensitive liquid crystal display, and an OLED touch device; The network port 500 is connected to the processor 200 and is used for communicating with external terminal devices; The communication technology used for the communication connection is a wired communication technology or a wireless communication technology, such as mobile high-definition link technology MHL, universal serial bus USB, high-definition multimedia interface HDMI, wireless fidelity technology WiFi, Bluetooth communication technology, low-power Bluetooth communication technology, and communication technology based on IEEE802.11s; The electronic device includes a memory, a processor, and a computer program stored in the memory and executable on the processor.

Images