A zero-code development method and system for enterprise application systems

Abstract

This invention relates to the field of system development platform technology, and discloses a zero-code development method and system for enterprise-level application systems. The method includes a model-driven architecture-based full-process automated mapping engine. Through a metadata-driven dynamic modeling mechanism, it converts user-defined configuration operations, such as form drag-and-drop, field definitions, and process drawing, into underlying data structures and business logic in real time, realizing design and configuration. It features collaborative design for business requirements, addressing the complexity of requirements; component-based development, enabling rapid system construction and addressing the variability of requirements; a data platform for effective data management, addressing data interoperability; and data visualization development, addressing the issue of data value mining. It can solve the problems of difficult domestic IT innovation transformation and the transformation of existing systems, and supports both pre-built components and function writing, ensuring the development framework's friendliness to various requirements.

Description

Technical Field

[0001] This invention relates to the field of system development platform technology, and in particular to a zero-code development method and system for enterprise-level application systems. Background Technology

[0002] Enterprise-level application systems refer to large-scale and complex software solutions built to meet the core operational and management needs of enterprises. Unlike consumer-grade applications aimed at individual users, the core objectives of enterprise-level applications are to optimize business processes, improve collaborative efficiency, ensure data security, and support strategic decision-making, thereby creating a sustainable competitive advantage for enterprises. Currently, enterprises utilize digital technologies to create or transform business processes, application systems, customer experiences, and business models, engaging in digital development. During this process, the development needs of enterprises or customers are complex, variable, and involve various personalized requirements. Therefore, this paper studies and improves existing structures, providing a zero-code development framework and methodology for enterprise-level application systems, aiming to achieve greater practical value.

[0003] Existing technology 1, application number 202511424920.0, discloses a zero-code visual dynamic design multi-terminal adaptation system and method for block-based reports. The method includes: component template reuse, generating component templates with unique identifiers by extracting the complete configuration of configured components, separating basic parameters and instance parameters using a two-layer parameter structure, and achieving batch synchronous updates by maintaining a directed acyclic graph structure through a dependency tracing engine; intelligent multi-terminal adaptation, building a terminal feature library to store different terminal parameters, setting adaptive rules for various components, and automatically adjusting component size, layout, and interaction methods by identifying the access terminal; and visual binding of business rules, constructing business rule logic through drag-and-drop operators and establishing a rule-component association mapping. While this improves component reuse by 80% and shortens report development cycle by 70%, providing an efficient, intelligent, and easy-to-use complete solution for enterprise-level zero-code report development, it focuses on report development scenarios. While improving report development efficiency through component templates, multi-terminal adaptation, and visual binding of business rules, its capabilities are limited to specific stages of report generation and do not cover the entire closed-loop process from business modeling, system generation, data assetization to visualization applications.

[0004] Existing technology two, application number 202511842096.0, discloses a method for intelligent routing and unified adaptation of large language models. It defines all access details of the model through a declarative configuration file, allowing new models to be added without writing any code, achieving zero-code access to large language models. It provides a completely consistent calling interface for upstream applications, shielding the heterogeneity of all downstream large language models and constructing a unified request and response abstraction layer. Through a strategy engine and JSON path technology, it accurately handles complex streaming responses, including thought content, with intelligent parsing and content extraction. It supports dynamic configuration and intelligent strategy hot updates; it achieves intelligent model routing, dynamically selecting the optimal large language model instance; and it provides enterprise-level governance capabilities, integrating circuit breaking, degradation, rate limiting, and monitoring functions to ensure stability for model calls. While comprehensively improving system maintainability, scalability, and user experience consistency, it is limited to the model service calling layer and does not involve the construction of the business system itself, the assetization of business data, or the generation of visual applications.

[0005] Prior art three, application number 202411719542.4, discloses an enterprise-level application development and data management system and method based on no-code SaaS. This system obtains user-inputted application development requirements information, extracts input and output keywords from these requirements, acquires subscription and development information for components on the SaaS platform, assigns keywords to components on the SaaS platform, selects input and output components for the user, recommends execution components for the user, and allows the user to develop the required application using the recommended components. While this eliminates the need for users to purchase and maintain software, reducing resource consumption and maintenance burden, and allows for quick access and deployment of applications without installation or configuration, and analyzes user needs and recommends the most suitable SaaS application development components based on user subscription information on the SaaS platform, it focuses primarily on component recommendation and SaaS deployment. It relies on users' subjective component selection, lacks automated business semantic parsing and structured modeling capabilities, and does not involve the assetization of runtime data or the generation of deeply visualized applications.

[0006] Current technologies 1, 2, and 3 are limited to specific stages, such as report generation, model integration, or component recommendation. They lack end-to-end automation capabilities covering business requirement input, business system generation, operational data assetization, and data application presentation. This results in fragmented development processes, low levels of data assetization, and reliance on coding or manual configuration for building visual applications. Therefore, this invention provides a zero-code development method and system for enterprise application systems. Summary of the Invention

[0007] The main objective of this invention is to provide a zero-code development method and system for enterprise-level application systems, in order to solve the problems in existing enterprise-level application development, such as fragmented processes, low data assetization, and reliance on coding or manual configuration for building visual applications.

[0008] To achieve the above objectives, the present invention provides the following technical solution: A zero-code development method for enterprise-level application systems includes a model-driven architecture-based full-process automated mapping engine. Through a metadata-driven dynamic modeling mechanism, the engine converts the user's visual configuration operations, such as form drag-and-drop, field definitions, and process drawing, into underlying data structures and business logic in real time, thereby realizing design and configuration.

[0009] To achieve the above objectives, the present invention also provides the following technical solution: A zero-code development system for enterprise-level application systems, applied to the aforementioned zero-code development method for enterprise-level application systems, wherein the zero-code development system for enterprise-level application systems comprises: The Business Semantic Modeling and Metadata Configuration module takes forms, list files, and UI drag-and-drop prototypes submitted by business personnel as input, and transforms them into standardized JSON Schema metadata models and UI rendering descriptors through a semantic parsing engine and metadata modeling tools. It outputs structured configuration data for business requirements and persists it to the metadata database. The model-driven rendering and component-based assembly module takes the output structured configuration data as input, combines a pre-built component library and a custom script engine, and automatically completes data binding, permission registration and page route generation through the model-driven rendering pipeline, compiling and outputting a business system that can be deployed independently. The data asset accumulation and tagging system construction module is used to take the full amount of business data generated by the generated business system in runtime as input, clean, transform and integrate the data through ETL tools, and reconstruct the subject domain according to the dimensional modeling specifications of the data platform; at the same time, the tag extraction engine processes and calculates user behavior tags and business tags, and outputs standardized tagged data assets. The visualization configuration and data application presentation module is used to take the output tagged data assets as input and configure them through drag-and-drop using the configuration tools of the visualization development platform. It automatically generates enterprise decision-making dashboards and leadership cockpit data applications, completing a zero-code closed loop from business needs to data visualization.

[0010] To achieve the above objectives, the present invention also provides the following technical solution: An electronic device includes a processor and a memory coupled to the processor, the memory storing program instructions executable by the processor; when the processor executes the program instructions stored in the memory, it implements the zero-code development method for enterprise application systems as described above.

[0011] To achieve the above objectives, the present invention also provides the following technical solution: A storage medium storing program instructions, which, when executed by a processor, implement a zero-code development method for enterprise application systems as described above.

[0012] Compared with the prior art, the advantages of this invention are: This invention constructs an integrated whole process of system requirements analysis, system development platform, data management, and data application through a zero-code development framework and method for enterprise-level application systems. It solves the pain points of business and technology disconnect and data and application separation in traditional development. At the same time, through the linkage of four core subsystems, namely business requirements collaborative design, component-based development, data middle platform, and data visualization development, it realizes end-to-end management of business requirements analysis, system implementation, data management, and data application.

[0013] This invention retains fixed processes and sections within its development framework and framework creation process. Simultaneously, it allows users to input various requirements via tables or fields, generating corresponding interactive interfaces and index links. Furthermore, the development system supports both pre-built components and custom functionalities, ensuring the framework's versatility across various needs. In this application system development framework, the system utilizes a B / S (Browser / Server) development and maintenance approach, requiring no environment installation. This is highly convenient for both users and developers, and it is suitable for various operating environments, including domestic servers, operating systems, and databases, improving the framework's adaptability to different environments. Moreover, this invention avoids system crashes caused by operating environment factors and delays in updates due to development environment limitations. System development requires no code uploads; only a computer and network are needed for convenient and rapid system problem resolution. Attached Figure Description

[0014] Figure 1 This is a flowchart illustrating the steps of an embodiment of the zero-code development method for enterprise application systems of the present invention. Figure 2 This is a flowchart illustrating the steps of outputting structured configuration data for business requirements in one embodiment of the zero-code development method for enterprise application systems of the present invention. Figure 3 This is a schematic diagram illustrating the steps of compiling and outputting a self-deployable business system as an embodiment of the zero-code development method for enterprise-level application systems of the present invention. Figure 4 This is a flowchart illustrating the steps of drag-and-drop configuration using a configuration tool on a visual development platform, as an embodiment of the zero-code development method for enterprise-level application systems of the present invention. Figure 5 This is a schematic diagram of the functional modules of an embodiment of the zero-code development system for enterprise-level application systems of the present invention; Figure 6 This is a schematic diagram of an embodiment of the zero-code development system for enterprise-level application systems of the present invention; Figure 7 This is a schematic diagram of the structure of an embodiment of the electronic device of the present invention; Figure 8 This is a schematic diagram of the structure of one embodiment of the storage medium of the present invention. Detailed Implementation

[0015] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only a part of the embodiments of the present invention, and not all of them. Based on the embodiments of the present invention, all other embodiments obtained by those of ordinary skill in the art without creative effort are within the scope of protection of the present invention.

[0016] The terms "first," "second," and "third" in this invention are for descriptive purposes only and should not be construed as indicating or implying relative importance or implicitly specifying the number of indicated technical features. Thus, a feature defined as "first," "second," or "third" may explicitly or implicitly include at least one of those features. In the description of this invention, "multiple" means at least two, such as two, three, etc., unless otherwise explicitly specified. All directional indications (such as up, down, left, right, front, back, etc.) in the embodiments of this invention are only used to explain the relative positional relationships and movements between components in a specific orientation (as shown in the figures). If the specific orientation changes, the directional indication changes accordingly. Furthermore, the terms "including" and "having," and any variations thereof, are intended to cover non-exclusive inclusion. For example, a process, method, system, product, or device that includes a series of steps or units is not limited to the listed steps or units, but may optionally include steps or units not listed, or may optionally include other steps or units inherent to these processes, methods, products, or devices.

[0017] References to embodiments herein mean that a particular feature, structure, or characteristic described in connection with an embodiment may be included in at least one embodiment of the invention. The appearance of this phrase in various places throughout the specification does not necessarily refer to the same embodiment, nor is it a mutually exclusive, independent, or alternative embodiment. It will be explicitly and implicitly understood by those skilled in the art that the embodiments described herein can be combined with other embodiments.

[0018] like Figure 1 As shown, this embodiment provides an example of a zero-code development method for enterprise-level application systems. Specifically, this zero-code development method includes the following steps: Step S1: Using the forms, list files, and UI drag-and-drop prototypes submitted by business personnel as input, the semantic parsing engine and metadata modeling tools are used to transform them into a standardized JSON Schema metadata model and UI rendering descriptor, outputting structured configuration data for business requirements and persisting it to the metadata database. Step S2: Using the output structured configuration data as input, combined with the pre-built component library and custom script engine, the model-driven rendering pipeline automatically completes data binding, permission registration and page route generation, and compiles the output into a business system that can be deployed independently; Step S3: Using the full amount of business data generated by the business system in runtime as input, the data is cleaned, transformed and integrated through ETL tools, and the subject domain is reconstructed according to the dimensional modeling specifications of the data platform; at the same time, the user behavior tags and business tags are processed and calculated by the tag extraction engine to output standardized tagged data assets. Step S4: Using the output tagged data assets as input, drag and drop configuration is performed through the configuration tools of the visualization development platform to automatically generate data applications such as enterprise decision-making dashboards and leadership dashboards, completing a zero-code closed loop from business needs to data visualization.

[0019] In this zero-code development method for enterprise-level application systems, the specific explanations of each technical feature and their correlation with data applications such as enterprise decision-making dashboards and leadership dashboards are as follows: Forms, list files, and UI drag-and-drop prototypes are the original requirement carriers input by business personnel. Form files, such as Word and Excel documents, describe in detail the data fields, data types, filling rules, and field columns to be displayed in the business scenario. UI drag-and-drop prototypes are interface sketches drawn by business personnel using visualization tools, including interface elements such as page layout, control positions, and operation buttons. The inputs collectively define the functional boundaries and data structure of the business system, providing a semantic basis for generating the business system. The correlation with data applications is as follows: fields defined in the forms, such as order amount and customer name, will become core data items generated by the business system, ultimately presented as analysis dimensions or indicators in the decision-making dashboard; the data range displayed in the list view planned in the UI drag-and-drop prototype will affect the data platform's identification and modeling of key business entities. Structured configuration data is the standardized output of step S1, consisting of a JSON Schema metadata model and a UI rendering descriptor. The JSON Schema metadata model describes the data structure of business objects in a structured form, including field names, data types, and constraints. The UI rendering descriptor records the interface layout, control types, and page interaction logic. Structured configuration data serves as a bridge between business requirements and technical implementation, shielding the complexity of the underlying code and enabling automatic system generation through model-driven approaches. Its connection to data applications lies in the fact that the data structure defined in the metadata model determines how the data generated by the business system is organized. During the data platform phase, this data structure is mapped to fact tables and dimension tables in dimensional modeling, thus supporting the calculation of metrics and dimensional drill-down in the decision dashboard. The independently deployable business system is the output—a complete application automatically generated based on the structured configuration data, including the front-end interface, back-end services, and database, which can be directly deployed and run. The business system is responsible for the input, query, and modification of daily business operations. It is the source of raw business data and its connection to data application lies in the fact that all business data generated by the business system during operation, such as sales orders and customer information, constitutes the raw data source of the data platform. After cleaning and integration, the data is finally presented on the decision-making dashboard in the form of charts, indicator cards, etc., to achieve visualized monitoring of business status. Dimensional modeling specifications are standardized methods followed by the data platform in step S3 when reconstructing business data. These include design principles such as star schema and snowflake schema, as well as the criteria for dividing fact tables and dimension tables. Through dimensional modeling, the raw data of the business system is transformed into fact tables organized according to business processes, such as sales facts, and dimension tables organized according to analytical perspectives, such as time dimensions and product dimensions.Its connection with data applications lies in the following: dimensional modeling specifications ensure the analytical friendliness of data assets, enabling decision dashboards to perform multi-dimensional drill-down, roll-up, and slice analysis based on a unified dimensional model; key performance indicators (KPIs) in the leadership dashboard are all calculated based on aggregated values ​​from the fact table, while dimensional attributes provide flexible grouping and filtering capabilities for indicators, thereby meeting the analytical needs of different management roles.

[0020] Preferably, this embodiment achieves automated mapping from business requirements to technical configuration. Through a semantic parsing engine and metadata modeling tools, unstructured business inputs are transformed into standardized JSON Schema metadata models and UI rendering descriptors, forming machine-readable structured configuration data. This eliminates manual coding and lowers the barrier to transforming business requirements into technical implementation. A reusable and scalable system generation mechanism is implemented. Based on a model-driven rendering pipeline, combined with a pre-built component library and a custom script engine, data binding, permission registration, and page route generation are automatically completed, achieving automated compilation and deployment from structured configuration to a complete business system, ensuring system consistency and maintainability. End-to-end data assetization and intelligent tag construction are achieved. Through automatic collection, cleaning, and topic domain reconstruction of runtime business data, structured data assets conforming to data platform specifications are formed. Combined with a tag extraction engine, multi-dimensional tagging of user behavior and business entities is achieved, providing a semantic foundation for data analysis. An end-to-end data visualization closed loop is achieved. Relying on standardized tag data assets, zero-code configuration is achieved through visual configuration tools, quickly generating decision support data applications and completing the entire process automation from original business requirements to data value presentation.

[0021] This embodiment includes: Collaborative design of business requirements: used for business decoupling and solving the problem of requirement complexity; Component-based development: used for rapid system construction and solving the problem of requirement variability; Data middle platform: used for effective data management and solving the problem of data interoperability; Data visualization development: used to solve the problem of data value mining; It can solve the problems of domestic IT innovation transformation and the difficulty of IT innovation transformation of existing systems, and supports both pre-built components and function writing, ensuring the friendliness of the development framework to various requirements. It is suitable for various different operating environments such as domestic servers, operating systems, and databases, improving the applicability of the development framework to different environments.

[0022] This embodiment can solve the problems of difficult domestic IT innovation transformation and existing system IT innovation transformation. It also supports pre-built components and function writing, ensuring the friendliness of the development framework to various needs. It is applicable to various different operating environments such as domestic servers, operating systems, and databases, thus improving the applicability of the development framework to different environments.

[0023] Furthermore, such as Figure 2As shown, the process of outputting structured configuration data for business requirements in step S1 specifically includes the following steps: Step S11: Using the forms, list files, and UI drag-and-drop prototypes submitted by business personnel as input, extract business elements such as field definitions, data types, and filling rules from the forms and list files through multimodal feature extraction, and capture interface elements such as control types, layout positions, and event responses from the drag-and-drop prototypes. Integrate the business elements and interface elements into a set of discrete semantic units. Each semantic unit encapsulates the business meaning and technical attributes of a single field in the form of key-value pairs. Step S12: Traverse all semantic units through the field reducer, identify fields with duplicate definitions and naming conflicts, and perform merging and renaming operations according to preset business priority rules; at the same time, call the field type inference library to supplement standardized data type tags for each semantic unit, forming a business object model that includes a field list, relationship and interface layout abstraction. Step S13: Transform the business object model into platform-recognizable structured configuration data through configuration compilation. The structured configuration data includes two parts: metadata definitions describing the data structure and view descriptors describing the interface rendering. Combine and encapsulate the two parts into a complete configuration package, persist it to the metadata database, and call it for subsequent component assembly.

[0024] Preferably, this embodiment achieves automated semantic extraction and structured transformation of unstructured business materials. Through multimodal feature extraction technology, business elements and interface elements are extracted from form list files and UI drag-and-drop prototypes, respectively, and integrated into a discrete set of semantic units. This achieves automated mapping from business requirements to machine-readable semantic units, providing a foundational input for subsequent structured modeling. The embodiment also achieves standardized integration and type labeling of semantic units. A field reducer identifies and handles duplicate definitions and naming conflicts, merging and renaming them based on business priority rules. Simultaneously, a field type inference library is called to supplement standardized data type tags, forming a clear, conflict-free, and type-defined business object model, ensuring the uniqueness and consistency of data definitions. Finally, the embodiment achieves automated compilation and persistence of the business object model into executable configuration. Configuration compilation transforms the business object model into structured configuration data containing metadata definitions and view descriptors, encapsulates it into a complete configuration package, and persists it to the metadata database, forming a standardized technical asset that can be directly called by subsequent modules. This achieves end-to-end automated transformation from business semantics to system configuration.

[0025] Furthermore, the process of forming a business object model containing a list of fields, relationships, and an abstract representation of the interface layout in step S12 specifically includes the following steps: Step S121: Taking the output set of semantic units as input, extract type inference clues from the key-value pairs of each semantic unit through the field feature parser, including keywords of field names, description of filling rules in form files, sample value formats in list files, and control types associated in drag-and-drop prototypes. Perform pattern matching with the built-in field feature library to generate a priority list containing several candidate data types for each semantic unit. The candidate types in the list are sorted by matching degree. Step S122: Traverse the relationships between semantic units through the context constraint analyzer, including parent-child nesting relationships, foreign key reference relationships, and adjacent position relationships in the interface layout. Based on the relationships, perform cross-validation and conflict resolution on candidate types. At the same time, combine the interface elements such as control size and input restrictions recorded in the view descriptor to perform secondary screening of candidate types, and finally determine a unique standardized data type label for each semantic unit. Step S123: Integrate all semantic units into a unified business object model through the business object assembler: First, summarize the name, data type label and business meaning of each field according to the field list. Second, construct a reference graph between objects based on the relationship between semantic units. Finally, attach the abstract representation of the interface layout captured in the drag-and-drop prototype, including container structure, control position and grouping information, to the corresponding field node of the model to form a complete business object model containing the field list, relationship and abstract representation of the interface layout.

[0026] Preferably, this embodiment implements automated field type inference based on multi-source clues and pattern matching. A field feature parser extracts type inference clues from field names, filling rules, example value formats, and associated control types, and performs pattern matching with a built-in feature library to generate a priority list of candidate data types sorted by matching degree, providing multi-dimensional and quantifiable decision-making basis for type determination. It also implements candidate type disambiguation and confirmation based on contextual association and interface constraints. A context constraint analyzer performs cross-validation and conflict resolution of candidate types by combining nesting relationships, referencing relationships, and interface adjacency relationships between semantic units. Simultaneously, interface elements such as control size and input restrictions are introduced for secondary filtering. Finally, a unique standard data type label is determined for each semantic unit, ensuring consistency between the type inference results and the interface performance. It achieves automated integration and semantic enhancement of structured business object models. Through the business object assembler, the field list, data type tags, and business meanings are summarized in a structured manner, and an object reference graph is constructed based on the relationship. At the same time, the abstract representation of the interface layout, container structure, control position, and grouping information are attached to the corresponding field nodes to form a complete business object model that integrates data definition, business relationship and interface representation, providing a unified input with rich semantic information for configuration and compilation.

[0027] Furthermore, the process of compiling the output into a self-deployable business system in step S2 specifically includes the following steps: Step S21: Extract the defined business objects and interface layout information through the column parser. According to the division rules of seven columns: Office Center, Project Center, Service Center, Decision Center, Information Center, System Management and My Department, split the structured configuration data into independent configuration fragments for each column. At the same time, call the field validator to traverse the field definitions in all configuration fragments, check the consistency of field names, data types and constraint rules, and perform merging and renaming operations on conflicting fields to ensure the uniformity of business fields. Finally, output the standardized column configuration template. Step S22: Using the output columnized configuration template as input, feed it into the model-driven rendering pipeline: Based on the configuration fragments of each column, match the corresponding page controls from the pre-built component library to generate a front-end page component tree; read the column link information defined in the configuration template, bind the corresponding back-end data interface for each column through the dynamic data source connector, and integrate the single sign-on module to connect the authentication and authorization of external third-party systems to the current business system; attach permission tags and routing rules to the page component tree to complete data binding and permission registration, and finally generate application intermediate code containing complete page logic, data interaction and external links; Step S23: Using the output application intermediate code as input, the code is compressed, resources are optimized, and dependencies are packaged through the compilation and build tools to generate a front-end static resource package and a back-end service program that can be directly deployed, forming an independently deployable business system; at the same time, the process visualization engine is called to extract the flow relationship of business links from the structured configuration data, automatically generate a business process diagram with graphics and text, and attach corresponding page links to each node of the process diagram, which are output along with the business system for users to preview and navigate.

[0028] The process includes: collaborative design of business requirements: inputting forms and list files designed by business personnel (Word, Excel, and system files are created manually through drag-and-drop), outputting standardized and structured configurations of the corresponding forms and lists, and storing them in the database; configuring a component-based development platform: inputting the configuration, database, custom scripts, and component-based functions of the preceding platform, and outputting the business system. The specific configuration steps are as follows: rapid integration of external third-party systems via single sign-on: developing corresponding interface requirements based on customer needs under zero-code application conditions, forming component-based development; multiple interactive or index sections, each configured: the designed project includes an office center, project center, service center, decision-making center, information center, system management, and my department, with the office center section as the core for configuration; designing links for each section: dynamically configuring the data sources linked to or corresponding to each section and linking them to the data platform; organizing the business processes of the business design platform: standardizing and normalizing fields, checking the consistency of business fields, and producing business functions; showcasing the developed application system: displaying the business process in a combination of text and graphics, with links added to each process; When configuring the office center's sections: Establish a quick office index, presented in a combination of text and images; list core user-used items separately for quick access to necessary task information; create a function collection section, including system-defined functions (user group information processing and user-defined functions), with a shortcut for each function (each user's menu is unique); user group information processing is applicable to each user, while user-defined functions allow for quick access to corresponding functions; establish internal messaging for convenient processing of internal business; allow users to collect and save information or files they are interested in, listed separately in the core office center; integrate AI applications, applicable to the current AI application market; dynamically configure a series of functions and hide them under a single selective function menu; the overall office center serves to create a quick index, add frequently used items, enable quick operations, and provide timely access to operational information.

[0029] When configuring the project center's sections: Present the process using flowcharts to help users quickly locate business processes and link to the required functions for processing. This section is highly user-friendly, allowing users to understand the business process and its overall framework.

[0030] When configuring the service center's sections: create different information entry menus to help users locate the corresponding business or function based on the category, and each entry section of the service center can be customized for user entry; When configuring the columns of the decision center: integrate the company's core data and display it in the form of charts. This part requires access by management or relevant authorized users to protect data security. When configuring the information center's sections: link and display news information, including five development interfaces for actual user use: Office Center, Project Center, Service Center, Decision Center, and Information Center.

[0031] When configuring system management sections: This involves configuring the system's organization, structure, users, and permissions. It's suitable for the backend management layer of functional management, allowing for custom management templates and rapid development without code editing. Form data is created through text input or system self-checks, and custom requirement titles are established through field spaces to form editable items. Default pages are designed, edited either in tabular format or through code. Function configuration can be implemented quickly, improving its effectiveness. Structured configuration is achieved through lists combined with tree-like index spaces. Zero-code or low-code configuration avoids bugs during system building. Process configuration is done through table-based structures, using field control and script interaction to form the final management interface. The process engine is then configured using table-based structures, resulting in the final interface. In the process engine's table-based structured configuration management, the indexing algorithm primarily aims to achieve rapid retrieval and location of information such as process definitions, instance data, and task assignments. Its core is a database-based B+ tree index, combined with various algorithms such as hash indexes, bitmap indexes, and full-text indexes for specific scenarios to adapt to different query needs.

[0032] In a real-world workflow engine, indexing algorithms work collaboratively based on the purpose of the data tables. For example, runtime data tables, such as ACT_RU, heavily utilize B+ trees and hash indexes to ensure high concurrency performance. Historical data tables, such as ACT_HI, may combine bitmap indexes and B+ tree indexes to support complex statistical analysis. When workflow configuration data is stored using flexible structures like JSONB, GIN indexes become crucial for fast queries. Ultimately, index configuration is completed through database management tools and becomes part of the metadata. When you complete the configuration through the management interface, the system generates or optimizes the underlying database table structure based on these designs, thereby supporting the front-end interface to achieve millisecond-level data retrieval, smooth pagination and sorting, and real-time filtering based on complex conditions.

[0033] Afterwards, users can quickly view business processes and confirm, cancel, and modify them; the system management section enables rapid assembly of functions, standardizes and unifies data, facilitates data governance and display, and is suitable for operators who are familiar with computer operations but not with code. At the same time, during the use of the management system after its development, it can simplify the development time and difficulty and increase the time spent on data and business applications.

[0034] When configuring the sections for my department, the system extracts the enterprise department information of the logged-in user based on single sign-on login information and generates a corresponding spatial map for department management. This allows for convenient and quick processing of tasks related to my department, improving task processing efficiency.

[0035] Preferably, in this embodiment, the business object and interface layout information are extracted by the column parser. The structured configuration data is split into independent configuration fragments according to the seven column division rules. A field validator is called to check the consistency of field names, data types, and constraint rules. Conflicting fields are merged and renamed to achieve uniformity of business fields. A standardized column configuration template is output, ensuring clear structure and standardized fields in the configuration data. Using the column configuration template as input, the model-driven rendering pipeline matches page controls from a pre-built component library based on the configuration fragments of each column, generating a front-end page component tree. The column link information defined in the configuration template is read, and a back-end data interface is bound to each column through a dynamic data source connector. A single sign-on module is integrated to access authentication and authorization from external third-party systems. Permission tags and routing rules are added to the page component tree to complete data binding and permission registration, generating application intermediate code containing complete page logic, data interaction, and external links. This enables rapid integration of front-end and back-end functions and unified permission management. Using intermediate application code as input, the compilation and build tools perform code compression, resource optimization, and dependency packaging to generate a front-end static resource package and back-end service program that can be directly deployed, forming an independently deployable business system. At the same time, the process visualization engine is called to extract the flow relationship of business links from the structured configuration data, automatically generate a business process diagram with graphics and text, and attach corresponding page links to each node of the process diagram. These are output along with the business system, thereby improving deployment efficiency and providing intuitive business process navigation support.

[0036] Furthermore, such as Figure 4 As shown, step S4, which involves drag-and-drop configuration using the configuration tools of the visual development platform, specifically includes the following steps: Step S41: Using the output tagged data assets as input, the data feature parser separates two types of core elements: one is the dimension fields that can be used as analytical perspectives, including time dimension, product dimension, department dimension, and classification attributes in user behavior tags; the other is the measurement fields that can be used as quantitative indicators, including numerical fields in business tags such as sales amount, order quantity, and number of visits; the data feature parser constructs a mapping matrix between dimension fields and measurement fields according to the relationship between fact tables and dimension tables defined in the dimension modeling specification, and extracts the data format, value range, and aggregation method of each field, finally outputting a data feature list containing all available analytical elements; Step S42: Using the output data feature list as input, the configuration tool's assembly engine matches it with a pre-built visualization component library. The assembly engine selects a candidate set of applicable chart types from the component library based on the number of dimension fields and the type of metric fields. At the same time, it parses the layout sketches generated by the user dragging and dropping on the canvas to determine the position area and size of each chart component. The assembly engine binds the specific fields in the feature list to the corresponding chart components one by one, specifying the time dimension and sales metric for line charts, the product dimension and percentage metric for pie charts, and the summary metric for indicator cards. Finally, it generates a visualization view description file containing data source configuration, chart type, position coordinates, and interactive response. Step S43: Using the output visualization view description file as input, the compilation and rendering engine integrates multiple independent views into a unified large-screen page according to preset layout rules; the compilation engine performs grid alignment and container encapsulation of chart components based on the position coordinates and hierarchical relationships recorded in the description file, generating page structure code that can be recognized by the front end; at the same time, it establishes a real-time data channel between each view and the underlying tagged data assets, and configures the data refresh frequency and linkage filtering rules; the compilation engine packages all views into a complete decision-making large-screen application, and generates a multi-tab navigation structure for the leadership dashboard according to the column division rules, finally outputting a directly accessible enterprise decision-making large screen and leadership dashboard.

[0037] Preferably, this embodiment utilizes drag-and-drop configuration tools within a visual development platform, combined with data feature analysis, assembly matching, and compilation rendering processes, to achieve efficient transformation from tagged data assets to decision-making dashboard applications. Data feature analysis converts tagged data assets into a structured list of analytical elements, establishes field mapping relationships based on dimensional modeling specifications, and extracts field formats, ranges, and aggregation methods, providing standardized input for visual configuration and ensuring accurate correspondence between data sources and business logic. The assembly engine automatically matches the data feature list with the visual component library, filters applicable charts based on the number of dimensions and metric types, binds specific fields to chart components using layout sketches, and generates a view description file containing data configuration, chart type, location coordinates, and interactive responses, reducing the complexity of manual configuration and improving the standardization and consistency of visual design. The compilation rendering engine integrates multiple views into a unified dashboard page, generates a front-end identifiable page structure through grid alignment and container encapsulation, establishes a real-time channel between the view and underlying data, configures refresh frequency and linkage rules, and ultimately outputs a decision-making dashboard application with multi-tab navigation, supporting dynamic data updates and interactive filtering, enhancing the real-time and holistic nature of business monitoring and decision analysis. This embodiment shortens the development cycle, improves the maintainability and scalability of visualization applications, and enables the rapid transformation of data assets into decision support through automated matching, standardized configuration, and integrated rendering.

[0038] Furthermore, the process of generating front-end recognizable page structure code in step S43 specifically includes the following steps: Step S431: Extract the position coordinates and size information of each chart component on the canvas using the coordinate calibrator, and read the grid baseline parameters implicit in the visualization view description file; the coordinate calibrator matches the coordinate values ​​of each component with the nearest grid baseline, performs snap correction on coordinates with offsets less than a set threshold, so that components in the same row or column are aligned in the horizontal or vertical direction, and outputs the component coordinate set after grid alignment calibration. Step S432: Analyze the top and bottom coverage order and spatial overlap between components. Based on the hierarchical relationship, group mutually contained or closely adjacent components into the same container group. Calculate the coordinates and size of the minimum bounding rectangle that can wrap all child components for each container group. At the same time, record the nesting hierarchy structure inside the container group. Finally, output the component layout tree with container boundary information and nesting relationship. Step S433: Convert each container node and component node in the component layout tree into a corresponding front-end page element description, attach coordinate style attributes such as position, width and height, and hierarchy style attributes such as stacking order to each element, and establish a reference identifier between the element and the underlying data channel; organize all element descriptions into complete page structure code according to the nesting relationship of the component layout tree, and integrate the style and script resource references required by each chart component, and finally output the front-end page structure code that can be directly parsed by the browser.

[0039] Preferably, this embodiment achieves automated parsing of layout descriptions and efficient generation of front-end code through coordinate calibration, containerized grouping, and standardized transformation, reducing the need for manual coding, enhancing the consistency and maintainability of visual applications, and supporting the rapid construction and dynamic adjustment of complex large-screen pages.

[0040] Furthermore, step S432, which calculates the coordinates and size of the minimum bounding rectangle that can enclose all sub-components for each container group, specifically includes the following steps: Step S4321: Traverse all sub-components within each container group, extract the offsets of the left, top, right, and bottom boundaries of each sub-component relative to the reference origin of the container group from its coordinate information, record the values ​​of the boundaries of each sub-component, and filter out the smallest left boundary, smallest top boundary, largest right boundary, and largest bottom boundary within the container group to form the original outer envelope parameter set of the container group. Step S4322: Read the grid baseline parameters used, match the minimum left boundary and minimum upper boundary downwards to the nearest grid baseline, and match the maximum right boundary and maximum lower boundary upwards to the nearest grid baseline, so that the outer boundary of the container is consistent with the global grid system; at the same time, according to the preset inner margin requirements of the container type, compensate and adjust the boundary values ​​after matching, and output the outer envelope boundary values ​​after grid normalization. Step S4323: Calculate the x-coordinate of the top left corner or the normalized minimum left boundary, the y-coordinate of the top left corner or the normalized minimum top boundary, the rectangle width or the normalized maximum right boundary minus the minimum left boundary, and the rectangle height or the normalized maximum bottom boundary minus the minimum top boundary of the minimum bounding rectangle; encapsulate the values ​​into container boundary descriptors, associate them with the corresponding container group identifiers, and output the coordinates and dimensions of the minimum bounding rectangle for each container group.

[0041] Preferably, the process of calculating the coordinates and dimensions of the minimum bounding rectangle of the container group in this embodiment involves extracting and filtering the boundary values ​​of sub-components to form the original outer envelope, then combining it with the mesh baseline for boundary regularization and inner margin compensation, ultimately calculating the coordinates and dimensions of the rectangle aligned with the mesh system. This process ensures the consistency between the container boundary and the global layout mesh, while adjusting the inner margins to meet the visual spacing requirements of the container type, thereby outputting a standardized and reusable container boundary descriptor, providing an accurate geometric reference for layout calculation and rendering.

[0042] Furthermore, the process of compensating and adjusting the matched boundary values ​​in step S4322 specifically includes the following steps: Step S43221: Taking the minimum left boundary, minimum top boundary, maximum right boundary, maximum bottom boundary after grid matching, and the container type identifier corresponding to each container group as input, extract the corresponding left inner margin, right inner margin, top inner margin, and bottom inner margin values ​​from the preset inner margin rule library according to the container type identifier to form the inner margin parameter set of the container group. Step S43222: Using the output inner margin parameter set and the boundary values ​​after mesh matching as input, subtract the left inner margin from the minimum left boundary to obtain the expanded left boundary; subtract the upper inner margin from the minimum upper boundary to obtain the expanded upper boundary; add the right inner margin to the maximum right boundary to obtain the expanded right boundary; add the lower inner margin to the maximum lower boundary to obtain the expanded lower boundary, and generate the compensated boundary value quadruple. Step S43223: Using the compensated left boundary, upper boundary, right boundary, and lower boundary as input, recombine them into a complete set of outer envelope boundary values, and attach the corresponding container group identifier. Finally, output the outer envelope boundary values ​​adjusted by inner margin compensation.

[0043] Preferably, in this embodiment, the process of compensating and adjusting the matched boundary values ​​involves extracting the inner margin parameters from the rule base based on the container type identifier and expanding the boundary after grid matching in both directions, thereby achieving precise control of the visual spacing inside the container. This ensures that the container boundary, on the basis of grid alignment, further meets the layout spacing requirements of a specific container type, thereby generating a set of boundary values ​​that includes inner margin compensation, providing a geometric benchmark that conforms to design specifications for rectangle calculation.

[0044] Furthermore, the process of generating the compensated boundary value quadruple in step S43222 specifically includes the following steps: Step S432221: Check whether the minimum left boundary, minimum upper boundary, maximum right boundary, and maximum lower boundary after mesh matching meet the numerical range requirements of the container coordinate system; at the same time, verify whether the four values ​​in the inner margin parameter set are non-negative; normalize the boundary values ​​that pass the check, unify their coordinate reference system origin, and output the verified boundary value and inner margin combination pair. Step S432222: Subtract the left inner margin from the minimum left boundary value, subtract the top inner margin from the minimum top boundary value, add the right inner margin to the maximum right boundary value, and add the bottom inner margin to the maximum bottom boundary value; generate four temporary boundary values ​​and form a temporary quadruple in the order of left, top, right, and bottom, while attaching the current container group's identifier information, and output the temporary boundary value quadruple containing the container group identifier; Step S432223: Check whether the left boundary is smaller than the right boundary and whether the upper boundary is smaller than the lower boundary to ensure that the compensated rectangle has a positive area; at the same time, normalize the boundary values ​​and align them to the decimal places or integer units of the container coordinate system; the boundary values ​​that pass the verification are re-encapsulated into a complete compensated boundary value quadruple and bound to the container group identifier.

[0045] Preferably, in this embodiment, the process of generating the compensated boundary value quadruples involves verifying the numerical range of the boundary values ​​and checking the non-negativity of the inner margins, and combining this with normalization to ensure coordinate system consistency. Subsequently, temporary quadruples are generated through addition and subtraction operations, followed by rectangle validity checks and numerical normalization, ultimately outputting boundary value quadruples that meet the positive area requirements and are aligned with the container coordinate system. This ensures the mathematical validity of the boundary values ​​after inner margin compensation and the consistency of the format within the system, providing reliable and structured geometric data for layout calculations.

[0046] Furthermore, the process of aligning it to the decimal places or integer units of the container coordinate system in step S432223 specifically includes the following steps: Step S4322231: Obtain the temporary boundary value quadruple and the configuration description of the container coordinate system. Parse the precision reference of the coordinate values ​​from the configuration description, including the minimum unit length, such as integer pixel units or the number of decimal places to retain. At the same time, read the preset rounding mode parameters, such as rounding towards negative infinity, rounding towards positive infinity, or rounding towards the nearest representable value, and generate a set of regularization control parameters containing the precision reference and rounding mode. Step S4322232: The left and upper boundaries are rounded according to the rounding mode, usually by rounding towards negative infinity or towards the nearest representable value, to an integer multiple of the precision reference or a specified number of bits. The right and lower boundaries are rounded according to the rounding mode, usually by rounding towards positive infinity or towards the nearest representable value, to an integer multiple of the precision reference or a specified number of bits. The quantized boundary value quadruples are then output. Step S4322233: Check if the left boundary is smaller than the right boundary and if the upper boundary is smaller than the lower boundary; if the boundaries are found to be equal or inverted, adjust them according to the preset boundary correction strategy, such as increasing the right boundary by a minimum unit length or increasing the lower boundary by a minimum unit length to ensure that the rectangle has a positive area and the boundary order is correct; repackage the boundary values ​​that have passed the verification and correction into a normalized compensated boundary value quadruple, attach a container group identifier, and output the normalized boundary values.

[0047] Preferably, in this embodiment, the process of aligning the boundary values ​​to the decimal or integer units of the container coordinate system involves generating normalization control parameters by analyzing the coordinate system's precision benchmark and rounding mode, and performing directional rounding quantization on the boundary values ​​to ensure they conform to the coordinate system's precision specifications. Subsequently, a rectangle validity check is performed, and the boundaries are adjusted according to a correction strategy if necessary. Finally, a normalized boundary value quadruple is output, satisfying the positive area requirement and having the correct boundary order. This achieves a standardized expression of boundary values ​​in the container coordinate system, ensuring numerical consistency and geometric validity in the layout calculation.

[0048] like Figure 5 As shown, this embodiment also provides an embodiment of an enterprise-level application system zero-code development system. In this embodiment, the enterprise-level application system zero-code development system is applied to the enterprise-level application system zero-code development method as described in the above embodiment. The enterprise-level application system zero-code development system includes a business semantic modeling and metadata configuration module 1, a model-driven rendering and component assembly module 2, a data asset accumulation and tag system construction module 3, and a visualization configuration and data application presentation module 4, which are electrically connected in sequence. Its principle is referenced in the appendix. Figure 6 .

[0049] The business semantic modeling and metadata configuration module 1 takes forms, list files, and UI drag-and-drop prototypes submitted by business personnel as input. Through a semantic parsing engine and metadata modeling tools, it transforms these into a standardized JSONSchema metadata model and UI rendering descriptor, outputting structured configuration data for business requirements, which is then persisted to a metadata database. The model-driven rendering and component-based assembly module 2 takes the output structured configuration data as input. Combined with a pre-built component library and a custom script engine, it automatically completes data binding, permission registration, and page route generation through the model-driven rendering pipeline, compiling and outputting a independently deployable business system. The asset accumulation and tagging system construction module 3 takes the full amount of business data generated by the generated business system in runtime as input, performs data cleaning, transformation and integration through ETL tools, and reconstructs the subject domain according to the dimensional modeling specifications of the data platform; at the same time, the tag extraction engine processes and calculates user behavior tags and business tags, and outputs standardized tagged data assets; the visualization configuration and data application presentation module 4 takes the output tagged data assets as input, performs drag-and-drop configuration through the configuration tools of the visualization development platform, automatically generates data applications such as enterprise decision-making dashboards and leadership dashboards, and completes a zero-code closed loop from business needs to data visualization.

[0050] The zero-code development framework for enterprise application systems includes: collaborative design of business requirements: used for business decoupling and solving the problem of requirement complexity; component-based development: used for rapid system construction and solving the problem of requirement variability; data platform: used for effective data management and solving the problem of data interoperability; and data visualization development: used to solve the problem of data value mining. Specifically: Collaborative design based on business requirements standardizes business planning during business decoupling, ensuring the uniformity of business fields and producing business functions; Component-based development provides quick form setup functionality during system construction, allowing users to define a new form and corresponding access control, or quickly define their required application functions by selecting some standard components. Component-based development also provides process creation tools for rapid process definition and modeling, completing process setup and role management; and the data platform provides data governance while managing data, standardizing data usage. The specific process for data normalization is as follows: First-stage normalization: This involves cleaning and standardizing the data source. Normalization typically occurs after data is entered into the database or aggregated, but before formal analysis. Its main goal is to eliminate the differences in dimensions and orders of magnitude of the original data, making it clean and comparable data with uniform specifications. This is similar to establishing a standardized processing baseline for raw materials of various shapes. Common algorithms: The most typical are Min-Max Scaling and Z-Score normalization. Min-Max Scaling maps data to a specific interval (e.g., [0, 1]) through a linear transformation, with the formula x' = (x - min) / (max - min); it eliminates dimensions but is sensitive to outliers. Z-Score normalization, on the other hand, processes the data based on the mean and standard deviation, with the formula x' = (x - μ) / σ. After processing, the data has a mean of 0 and a standard deviation of 1, making it more suitable for data distributions with outliers.

[0051] The second normalization: a deep formatting process tailored to a specific model or task. This normalization is performed before specific analysis or model training, focusing on meeting the underlying requirements of specific algorithms or application scenarios. For example, in machine learning, different algorithms make different assumptions about data distribution; this processing is to adapt to these requirements. Common algorithms may include more specialized decimal scaling normalization, logarithmic transformation, or reusing the Z-Score, but calculating new parameters based on the data after the first processing. In certain specific domains, such as ensuring the consistency of XML digital signatures, XML canonicalization algorithms are used to convert data into a standard byte sequence. For non-normally distributed data, methods such as quantile normalization may also be used. Through these two targeted processing steps, data inconsistencies can be eliminated more thoroughly, accelerating model convergence and improving the model's accuracy and generalization ability. A unified input standard also enhances the model's stability across different batches of data.

[0052] Data visualization development enables users to interact with data on a large screen while simultaneously completing enterprise-level system applications.

[0053] In component-based development, the defined functions include: defining and generating the database and data tables; defining basic information for form names, defining form buttons and operation functions, and initialization definitions; defining and controlling form field controls, including field display, read / write, uniqueness validation, and required field settings. The system automatically generates the corresponding data table based on the defined fields and automatically registers and saves it as a component; page design, using Word documents to design the form display interface, enabling users to define their desired interface using Word, and automatically saving the interface as a component; corresponding lists, entry menus, and permissions, the system automatically generates the required query list based on the form content, configures basic query items and corresponding function buttons, and generates permissions for... The corresponding entry menu and permissions; subsequently, in list management, advanced application adjustments are made to the corresponding list configurations; rapid process design, based on which, the corresponding process control is quickly established for this form, and the system automatically connects to the application of this form, and the form and query list correspond one-to-one. In the generation process: the core of automatic generation is not a single algorithm, but the result of the collaborative work of a series of engines on the platform: model synchronization mechanism: when saving the form design, the system will determine whether it is necessary to create new fields or new tables, and automatically generate the corresponding database structure, i.e., dynamic model; it can be regarded as a storage mapping algorithm based on form component type, for example, text input boxes are mapped to VARCHAR type columns, and date pickers are mapped to DATETIME type columns.

[0054] Automated workflow integration: Integration with systems and applications, such as CRM and email systems, is typically achieved through configuring webhooks and API interfaces. For example, when a form is submitted, trigger conditions can be configured to automatically call the target system's API interface, pushing the form data to the other party according to predetermined rules and executing actions. Some platforms also provide visual tools that allow developers to configure such simple logical processes through drag-and-drop, thereby quickly establishing workflow control. Advanced feature definition: Here, customers define advanced logic applications for forms, such as data processing logic during workflow execution, data processing logic when the form is saved, or custom backend logic.

[0055] In component-based development, process setup and role management include: process management for defining, modifying, and deleting workflows, including: flow definition, constraint setting, activity collaboration strategy definition, role, permission, and form settings; custom configuration control for reading, writing, and hiding / showing form fields at each stage; and different strategy configurations for timeouts at each stage, such as timeout reminders and automatic approval. Processes can be nested, i.e., sub-processes, to implement various complex business processes such as sequential flow, branching flow, arbitrary flow, and cross-node rollback. Convenient functions for signing, circulating, and initiating countersigning are provided. Personnel roles in the process are divided into dynamic roles (referring to roles in the project) and static roles. Roles can be directly authorized, and personnel permissions change depending on their roles in different projects. Roles in the process can be temporarily replaced during the process flow, and customized processes can be saved as components for future reuse. Delegation of the entire process or specific stages is supported.

[0056] Preferably, the automated transformation from business requirements to system implementation in this embodiment involves: using semantic parsing and metadata modeling tools to convert unstructured forms, prototypes, and other business inputs into standardized, machine-readable configurations, eliminating manual coding, lowering the technical threshold, and improving the efficiency of requirement transformation. Based on a model-driven rendering pipeline, combined with a pre-built component library and script engine, automated compilation and deployment from structured configurations to a complete business system are achieved, supporting dynamic permission binding and route generation to ensure system consistency and maintainability. Through automatic collection, cleaning, and topic domain reconstruction of runtime business data, structured data assets conforming to data platform specifications are formed. Combined with a tag extraction engine, multi-dimensional tagging of user behavior and business entities is achieved, providing a semantic foundation for data analysis. Relying on standardized tag data assets, zero-code configuration is achieved through visual configuration tools, quickly generating decision support data applications such as large screens and dashboards, completing the entire process of automation from original business requirements to data value presentation.

[0057] like Figure 7 As shown, this embodiment provides an embodiment of an electronic device 5, which includes a processor 51 and a memory 52 coupled to the processor 51.

[0058] The memory 52 stores program instructions for implementing the zero-code development method for enterprise application systems in any of the above embodiments.

[0059] The processor 51 is used to execute program instructions stored in the memory 52 for zero-code development of enterprise application systems.

[0060] The processor 51 can also be referred to as a CPU (Central Processing Unit). The processor 51 may be an integrated circuit chip with signal processing capabilities. The processor 51 can also be a general-purpose processor, a digital signal processor (DSP), an application-specific integrated circuit (ASIC), a field-programmable gate array (FPGA), or other programmable logic devices, discrete gate or transistor logic devices, or discrete hardware components. A general-purpose processor can be a microprocessor or any conventional processor.

[0061] Furthermore, Figure 8 This is a schematic diagram of the structure of a storage medium according to an embodiment of this application. The storage medium 6 in this embodiment stores program instructions 61 capable of implementing all the methods described above. These program instructions 61 can be stored in the storage medium in the form of a software product, including several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) or processor to execute all or part of the steps of the methods described in the various embodiments of this application. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks, or terminal devices such as computers, servers, mobile phones, and tablets.

[0062] In the several embodiments provided by this invention, it should be understood that the disclosed systems, apparatuses, and methods can be implemented in other ways. For example, the apparatus embodiments described above are merely illustrative; for instance, the division of units is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be an indirect coupling or communication connection between apparatuses or units through some interfaces, and may be electrical, mechanical, or other forms.

[0063] Furthermore, the functional units in the various embodiments of the present invention can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated units described above can be implemented in hardware or as software functional units. The above are merely embodiments of the present invention and do not limit the patent scope of the present invention. Any equivalent structural or procedural transformations made based on the description and drawings of the present invention, or direct or indirect applications in other related technical fields, are similarly included within the patent protection scope of the present invention.

[0064] The specific embodiments of the invention have been described in detail above, but these are merely examples, and the invention is not limited to the specific embodiments described above. For those skilled in the art, any equivalent modifications or substitutions to the invention are also within the scope of this invention. Therefore, all equivalent transformations, modifications, and improvements made without departing from the spirit and principles of this invention should be included within the scope of this invention.

Claims

1. A zero-code development method for enterprise-level application systems, characterized in that, The enterprise-level application system zero-code development method includes a full-process automatic mapping engine based on a model-driven architecture. Through a metadata-driven dynamic modeling mechanism, the user's visual configuration operation, form dragging, field definition, and process drawing are converted into underlying data structures and business logic in real time, realizing design and configuration.

2. The zero code development method for enterprise level application system according to claim 1, characterized in that, With the form, list file, and UI drag prototype submitted by the business personnel as input, the semantic analysis engine and metadata modeling tool are used to convert them into standardized JSON Schema metadata models and UI rendering descriptors, output structured configuration data of business requirements, and persist them to the metadata database. With the output structured configuration data as input, combined with the pre-set component library and custom script engine, the model-driven rendering pipeline automatically completes data binding, permission registration, and page routing generation, and compiles the output into a standalone deployable business system. With the full-amount business data generated by the generated business system in the running state as input, the ETL tool is used for data cleaning, conversion, and integration, and the theme domain is reconstructed according to the dimension modeling specification of the data center. At the same time, the user behavior label and business label are calculated by the label extraction engine, and the standardized labeled data asset is output.

3. The zero-code development method for enterprise-level application systems according to claim 2, characterized in that, With the output labeled data asset as input, the configuration tool of the visual development platform is used for drag-and-drop configuration to automatically generate enterprise decision-making screens and leader cockpit data applications, completing the zero-code closed loop from business requirements to data visualization.

4. The zero-code development method for enterprise-level application systems according to claim 3, characterized in that, The process of drag-and-drop configuration through the configuration tool of the visual development platform includes the following steps: With the output labeled data asset as input, the data feature parser separates two types of core elements from it: one is the dimension field that can be used as an analysis angle, and the other is the measurement field that can be used as a quantitative indicator. The data feature parser constructs a mapping matrix of dimension fields and measurement fields according to the association relationship between fact tables and dimension tables defined in the dimension modeling specification, extracts the data format, value range, and aggregation method of each field, and finally outputs a data feature list containing all available analysis elements; With the output data feature list as input, the assembly engine of the configuration tool matches it with the pre-set visual component library. The assembly engine selects the applicable chart type candidate set from the component library according to the number of dimension fields and the type of measurement fields, and analyzes the layout sketch generated by the user on the canvas to determine the position area and size of each chart component. The assembly engine binds each field in the feature list to the corresponding chart component one by one, specifies the time dimension and sales measurement for the line chart, specifies the product dimension and proportion measurement for the pie chart, and specifies the summary measurement for the index card, and finally generates a visual view description file containing data source configuration, chart type, position coordinates, and interactive response; Taking the output visualization view description file as input, the compilation and rendering engine integrates multiple independent views into a unified large-screen page according to preset layout rules. Based on the position coordinates and hierarchical relationships recorded in the description file, the compilation engine performs grid alignment and container encapsulation on the chart components, generating page structure code that can be recognized by the front end. At the same time, it establishes real-time data channels between each view and the underlying tagged data assets, and configures the data refresh frequency and linkage filtering rules. The compilation engine packages all views into a complete decision-making large screen application, and generates a multi-tab navigation structure for the leadership dashboard according to the column division rules, finally outputting a directly accessible enterprise decision-making large screen and leadership dashboard.

5. The zero-code development method for enterprise-level application system according to claim 4, characterized in that, The process of generating front-end recognizable page structure code includes the following steps: The coordinate calibrator extracts the position coordinates and size information of each chart component on the canvas, and reads the grid baseline parameters implicit in the visualization description file. The coordinate calibrator matches the coordinate values ​​of each component with the nearest grid baseline, performs snap correction on the coordinates with an offset less than a set threshold, so that the components in the same row or column are aligned in the horizontal or vertical direction, and outputs the component coordinate set after grid alignment calibration. Analyze the top and bottom cover order and spatial overlap between components, group mutually contained or closely adjacent components into the same container group according to the hierarchical relationship, calculate the coordinates and size of the minimum bounding rectangle that can wrap all child components for each container group, record the nesting hierarchy within the container group, and finally output a component layout tree with container boundary information and nesting relationship. Each container node and component node in the component layout tree is converted into a corresponding front-end page element description. Coordinate style attributes and hierarchy style attributes are attached to each element, and a reference identifier between the element and the underlying data channel is established. All element descriptions are organized into complete page structure code according to the nesting relationship of the component layout tree. At the same time, the style and script resource references required by each chart component are integrated, and finally, the front-end page structure code that can be directly parsed by the browser is output.

6. The zero code development method for enterprise level application system according to claim 5, characterized in that, The process of calculating the coordinates and size of the minimum bounding rectangle that can wrap all child components for each container group includes the following steps: Iterate through all child components within each container group, extract the offsets of the left, top, right, and bottom boundaries of each child component relative to the reference origin of the container group from the coordinate information of each child component, record the values ​​of the boundaries of each child component, and filter out the smallest left boundary, smallest top boundary, largest right boundary, and largest bottom boundary within the container group to form the original outer envelope parameter set of the container group. Read the grid baseline parameters used, match the minimum left boundary and minimum top boundary downwards to the nearest grid baseline, and match the maximum right boundary and maximum bottom boundary upwards to the nearest grid baseline, so that the outer boundary of the container is consistent with the global grid system; at the same time, according to the preset inner margin requirements of the container type, compensate and adjust the matched boundary values, and output the outer envelope boundary values ​​after grid normalization. Calculate the top-left corner x-coordinate or normalized minimum left boundary, top-left corner y-coordinate or normalized minimum top boundary, rectangle width or normalized maximum right boundary minus minimum left boundary, and rectangle height or normalized maximum bottom boundary minus minimum top boundary of the minimum bounding rectangle; encapsulate the values ​​into container boundary descriptors, associate them with the corresponding container group identifiers, and output the coordinates and dimensions of the minimum bounding rectangle for each container group.

7. The zero-code development method for enterprise-level application systems according to claim 6, characterized in that, The process of compensating and adjusting the matched boundary values ​​includes the following steps: Taking the minimum left boundary, minimum top boundary, maximum right boundary, maximum bottom boundary after grid matching, and the container type identifier corresponding to each container group as input, the corresponding left inner margin, right inner margin, top inner margin, and bottom inner margin values ​​are extracted from the preset inner margin rule library according to the container type identifier to form the inner margin parameter set of the container group. Using the output set of inner margin parameters and the boundary values ​​after mesh matching as input, the left inner margin is subtracted from the minimum left boundary to obtain the expanded left boundary; the upper inner margin is subtracted from the minimum upper boundary to obtain the expanded upper boundary; the right inner margin is added to the maximum right boundary to obtain the expanded right boundary; and the lower inner margin is added to the maximum lower boundary to obtain the expanded lower boundary, thus generating a quadruple of compensated boundary values. The output of the compensated left boundary, top boundary, right boundary, and bottom boundary is used as input to recombine them into a complete set of outer envelope boundary values, and the corresponding container group identifier is attached. Finally, the outer envelope boundary values ​​adjusted by inner margin compensation are output.

8. The zero-code development method for enterprise-level application systems according to claim 7, characterized in that, The process of generating compensated boundary value quadruples includes the following steps: Check whether the minimum left boundary, minimum top boundary, maximum right boundary, and maximum bottom boundary after mesh matching meet the numerical range requirements of the container coordinate system; at the same time, verify whether the four values ​​in the inner margin parameter set are non-negative; normalize the boundary values ​​that pass the check, unify their coordinate reference system origin, and output the verified boundary value and inner margin combination pair. Subtract the left inner margin from the minimum left boundary value, subtract the top inner margin from the minimum top boundary value, add the right inner margin to the maximum right boundary value, and add the bottom inner margin to the maximum bottom boundary value; generate four temporary boundary values ​​and form a temporary quadruple in the order of left, top, right, and bottom, while attaching the current container group's identifier information, and output the temporary boundary value quadruple containing the container group identifier. Check if the left boundary is smaller than the right boundary and the top boundary is smaller than the bottom boundary to ensure that the compensated rectangle has a positive area; at the same time, normalize the boundary values ​​and align them to the decimal places or integer units of the container coordinate system; the boundary values ​​that pass the verification are re-encapsulated into a complete compensated boundary value quadruple and bound to the container group identifier.

9. The zero-code development method for enterprise-level application systems according to claim 8, characterized in that, The process of aligning boundary values ​​to the decimal places or integer units of the container coordinate system includes the following steps: Obtain the temporary boundary value quadruple and the configuration description of the container coordinate system. Parse the precision reference of the coordinate values ​​from the configuration description, including the minimum unit length. At the same time, read the preset rounding mode parameters and generate a set of normalization control parameters containing the precision reference and rounding mode. The left and upper boundaries are rounded to an integer multiple of the precision reference or a specified number of bits, while the right and lower boundaries are rounded to an integer multiple of the precision reference or a specified number of bits. The output is a quantized boundary value quadruple. Check if the left boundary is less than the right boundary and if the upper boundary is less than the lower boundary; if the boundaries are found to be equal or inverted, adjust them according to the preset boundary correction strategy; repackage the verified and corrected boundary values ​​into a normalized compensated boundary value quadruple, add a container group identifier, and output the normalized boundary values.

10. An enterprise application system zero-code development system applied to the enterprise application system zero-code development method of any one of claims 1 to 9, characterized in that, The enterprise-level application system zero-code development system includes: The Business Semantic Modeling and Metadata Configuration module takes forms, list files, and UI drag-and-drop prototypes submitted by business personnel as input, and transforms them into standardized JSON Schema metadata models and UI rendering descriptors through a semantic parsing engine and metadata modeling tools. It outputs structured configuration data for business requirements and persists it to the metadata database. The model-driven rendering and component-based assembly module takes the output structured configuration data as input, combines a pre-built component library and a custom script engine, and automatically completes data binding, permission registration and page route generation through the model-driven rendering pipeline, compiling and outputting a business system that can be deployed independently. The data asset accumulation and tagging system construction module is used to take the full amount of business data generated by the generated business system in runtime as input, clean, transform and integrate the data through ETL tools, and reconstruct the subject domain according to the dimensional modeling specifications of the data platform; at the same time, the tag extraction engine processes and calculates user behavior tags and business tags, and outputs standardized tagged data assets. The visualization configuration and data application presentation module is used to take the output tagged data assets as input and configure them through drag-and-drop using the configuration tools of the visualization development platform. It automatically generates enterprise decision-making dashboards and leadership cockpit data applications, completing a zero-code closed loop from business needs to data visualization.

Images