Construction method, device and equipment of project engineering and storage medium

Abstract

The application discloses a project engineering construction method and device, equipment and a storage medium, and relates to the technical field of project engineering construction. The method comprises the following steps: in response to a template selection instruction, determining a target engineering template identifier and an associated baseline version number according to the template selection instruction; generating a target seed engineering compressed package according to the target engineering template identifier and the associated baseline version number; dynamically loading the latest component version corresponding to the target engineering template according to a version upgrade topology graph and the target seed engineering compressed package; configuring target environment parameters according to the latest component version, and constructing a target project engineering. The project engineering construction method eliminates the process of repeatedly building an engineering framework. The latest component version is loaded through a topology graph, thereby reducing the manual maintenance cost. The target environment parameters are independently configured according to the latest component version, thereby preventing running errors caused by environment differences and improving the efficiency and reliability of project engineering construction.

Description

Technical Field

[0001] This application relates to the technical field of project engineering construction, and in particular to methods, apparatus, equipment and storage media for constructing project engineering. Background Technology

[0002] As software development becomes increasingly complex, the project engineering process faces numerous challenges. In modern software development, project engineering refers to the process of organizing source code, dependency libraries, configuration files, and other resources into a runnable application.

[0003] Traditional project engineering processes require manually importing software development kits (SDKs), which is complex, error-prone, and leads to low development efficiency.

[0004] Therefore, how to improve the efficiency and reliability of project construction is an urgent problem to be solved. Summary of the Invention

[0005] The main purpose of this application is to provide a method, apparatus, equipment and storage medium for constructing project engineering, aiming to solve the technical problem of how to improve the efficiency and reliability of project engineering construction.

[0006] To achieve the above objectives, this application proposes a method for constructing a project engineering process, the method comprising:

[0007] In response to the template selection instruction, the target project template identifier and associated baseline version number are determined according to the template selection instruction;

[0008] Generate a target seed project compressed package based on the target project template identifier and the associated baseline version number seed project;

[0009] Based on the version upgrade topology diagram and the target seed project compressed package, dynamically load the latest component version corresponding to the target project template;

[0010] Configure the target environment parameters according to the latest component version and build the target project.

[0011] In one embodiment, prior to the step of responding to the template selection instruction, the method further includes:

[0012] Configure multiple types of project template sets and generate a set of seed project compressed packages;

[0013] Extract the association mapping relationship between the baseline version and the module version from the project template set and the seed project compressed package set;

[0014] A version upgrade topology diagram is generated based on the association mapping relationship between the baseline version and the module version.

[0015] In one embodiment, the step of configuring a set of multiple types of project templates and generating a set of seed project compressed packages includes:

[0016] Create metadata description files for multi-tab templates and blank templates;

[0017] Define the project directory structure rules based on the metadata description file;

[0018] The original project is compressed and packaged according to the project directory structure rules to generate a set of seed project compressed packages with digital signatures.

[0019] In one embodiment, the step of generating a version upgrade topology map based on the association mapping relationship between the baseline version and the module version includes:

[0020] Create the root node of the version upgrade topology graph based on the baseline version;

[0021] Analyze the version dependencies of each module and generate a module version tree structure based on the root node;

[0022] Set constraints for the baseline version and module version, including a mandatory upgrade flag and an optional upgrade flag;

[0023] The constraints are added to the module version tree structure to obtain the version upgrade topology diagram.

[0024] In one embodiment, the step of dynamically loading the latest component version corresponding to the target project template based on the version upgrade topology map and the target seed project compressed package includes:

[0025] Traverse the tree structure of module versions associated with the target project template in the version upgrade topology graph;

[0026] Based on the target seed project compressed package, the latest component version that satisfies the constraints is extracted from the module version tree structure.

[0027] In one embodiment, the step of configuring the target environment parameters according to the latest component version and constructing the target project includes:

[0028] Based on the latest version of the component, dependency resolution is performed on the version components with dependencies to generate a set of target components that are compatible with the version.

[0029] Inject the dependency configuration of the target component set into the project description file containing the target environment parameters;

[0030] The target project is constructed based on the project description file.

[0031] In one embodiment, after the step of constructing the target project project based on the project description file, the method further includes:

[0032] Based on the project description file and project directory structure rules, the component injection process, directory generation events and version conflict handling results are recorded in real time, and a process log file is generated.

[0033] Monitor the error logs in the process log file and determine the exception type by matching regular expressions.

[0034] Based on the anomaly type, a remediation plan is retrieved from the solution knowledge base and executed to obtain the remediation plan execution result;

[0035] The results of the repair solution are recorded in the experience database, and the solution knowledge base is updated.

[0036] Furthermore, to achieve the above objectives, this application also proposes a project construction apparatus, which includes:

[0037] The version determination module is used to respond to the template selection instruction and determine the target project template identifier and associated baseline version number according to the template selection instruction;

[0038] The project compression module is used to generate a target seed project compressed package based on the target project template identifier and the associated baseline version number seed project;

[0039] The component loading module is used to dynamically load the latest component version corresponding to the target project template based on the version upgrade topology diagram and the target seed project compressed package;

[0040] The project construction module is used to configure the target environment parameters according to the latest component version and construct the target project project.

[0041] In addition, to achieve the above objectives, this application also proposes a project engineering construction device, the device comprising: a memory, a processor, and a computer program stored in the memory and executable on the processor, the computer program being configured to implement the steps of the project engineering construction method as described above.

[0042] In addition, to achieve the above objectives, this application also proposes a storage medium, which is a computer-readable storage medium, on which a computer program is stored, and when the computer program is executed by a processor, it implements the steps of the project construction method as described above.

[0043] One or more technical solutions proposed in this application have at least the following technical effects:

[0044] Responding to template selection instructions, the system determines the target project template identifier and associated baseline version number based on these instructions. It then generates a target seed project compressed package based on the target project template identifier and associated baseline version number. The system dynamically loads the latest component version corresponding to the target project template based on the version upgrade topology diagram and the target seed project compressed package. Finally, it configures the target environment parameters based on the latest component version and constructs the target project. By parsing the template selection instructions, the target template and baseline version can be directly determined, avoiding the time-consuming manual search and configuration. Generating a seed project compressed package based on the template identifier and version number, and reusing predefined templates, eliminates the need to repeatedly build the project framework, ensuring the consistency of the initial project architecture. Loading the latest component version through the topology diagram enables automated dependency upgrades, reducing manual maintenance costs. Independently configuring target environment parameters based on the latest component version isolates the build process from the environment, preventing runtime errors caused by environmental differences. Automating tedious compilation and packaging tasks saves developers' time and effort, improving development efficiency while ensuring the accuracy of integrated products and the convenience of project construction. Attached Figure Description

[0045] The accompanying drawings, which are incorporated in and form part of this specification, illustrate embodiments consistent with this application and, together with the description, serve to explain the principles of this application.

[0046] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, for those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0047] Figure 1 This is a schematic diagram of the system architecture of an embodiment of this application;

[0048] Figure 2 This is a flowchart illustrating the first embodiment of the construction method for the project in this application.

[0049] Figure 3 A schematic diagram of the interface for setting project engineering parameters in an embodiment of this application;

[0050] Figure 4 This is a flowchart illustrating the second embodiment of the construction method for the project in this application.

[0051] Figure 5 This is a flowchart illustrating the third embodiment of the construction method for the project in this application.

[0052] Figure 6 This is a schematic diagram of the modular structure of the construction device for the project engineering of the embodiment of this application;

[0053] Figure 7 This is a schematic diagram of the hardware operating environment involved in the construction method of the project in this application embodiment.

[0054] The purpose, features, and advantages of this application will be further explained in conjunction with the embodiments and with reference to the accompanying drawings. Detailed Implementation

[0055] It should be understood that the specific embodiments described herein are merely illustrative of the technical solutions of this application and are not intended to limit this application.

[0056] To better understand the technical solution of this application, a detailed description will be provided below in conjunction with the accompanying drawings and specific implementation methods.

[0057] Existing project build methods lack systematic management of the relationship between project templates and component versions. In actual development, different project templates often need to match specific component versions, and existing technologies struggle to effectively handle such complex version dependencies, leading to frequent version incompatibility issues during the build process. Secondly, upgrading a component version often requires manually adjusting the versions of multiple related components, which is not only cumbersome but also prone to errors. This is especially true in mobile application development, where different development tools (such as Xcode for Apple and Android Studio for Android) are used for building, making the process even more cumbersome. Furthermore, various anomalies frequently occur during project builds, such as component version conflicts and missing dependencies, and existing technologies lack automated anomaly detection and handling capabilities, forcing developers to spend significant time troubleshooting and resolving these issues.

[0058] This application provides a solution that responds to a template selection instruction and determines the target project template identifier and associated baseline version number based on the instruction; generates a target seed project compressed package based on the target project template identifier and associated baseline version number; dynamically loads the latest component version corresponding to the target project template based on the version upgrade topology diagram and the target seed project compressed package; and configures the target environment parameters based on the latest component version to build the target project project. By parsing the template selection instruction, the target template and baseline version can be directly determined, avoiding the time-consuming manual search and configuration. Generating a seed project compressed package based on the template identifier and version number, and reusing predefined templates, eliminates the process of repeatedly building the project framework, ensuring the consistency of the initial architecture of the project project. Loading the latest component version through the topology diagram enables automated upgrades of dependencies, reducing manual maintenance costs. Independently configuring the target environment parameters based on the latest component version isolates the build process from the environment, preventing runtime errors caused by environmental differences, saving developers' time and effort, and improving the efficiency and reliability of project construction.

[0059] It should be noted that the execution entity of the project engineering construction method provided in this application can be a project engineering construction system. For example, the system architecture diagram is as follows: Figure 1 As shown, in terms of technical architecture, the front-end pages of the backend management system are developed using Vue and Element UI, the client-side uses Electron, and the backend uses Java. The control center layer is divided into two parts: the backend management system and the client-side. The main functions of the backend management system include template management, baseline management, module management, component management, and project management; the client-side includes creating new projects, editing projects, basic tools, and frequently asked questions. The application side supports mobile applications including iOS, Android, HarmonyOS, H5, and mini-programs.

[0060] Based on this, the embodiments of this application provide a method for constructing a project engineering, referring to... Figure 2 , Figure 2 This is a flowchart illustrating the first embodiment of the construction method for the project in this application.

[0061] In this embodiment, the method for constructing the project includes steps S10 to S40:

[0062] Step S10: In response to the template selection instruction, determine the target project template identifier and associated baseline version number according to the template selection instruction.

[0063] For example, the system first receives a template selection command from the user via a graphical interface or command line. This command includes the type of project template the user wishes to use, such as a "multi-tab template" or a "blank template." The system then parses the target project template identifier based on this command, such as a unique identifier like "multi-tab-template" or "blank-template." Simultaneously, the system automatically associates the template with its corresponding baseline version number, such as "v1.0.0" or "v2.1.3," which represent the basic feature set version of the template.

[0064] Step S20: Generate a target seed project compressed package based on the target project template identifier and the associated baseline version number seed project.

[0065] For example, after determining the target project template identifier and associated baseline version number, the system retrieves the corresponding seed project from the pre-configured seed project library. A seed project is a minimal project template containing the basic project structure and core dependencies. Based on the target project template identifier and associated baseline version number, the system extracts the corresponding seed project from the seed project library and compresses it into a target seed project compressed package. This compressed package typically uses ZIP or TAR format and contains the project's basic directory structure, core configuration files, and necessary dependency declarations. The configuration file may include information such as tenant ID, application ID, gateway address, package name, and key. The gateway address can be understood as a preset path; for example, submitting API calls, loading images, and loading offline package resources will all involve concatenating the gateway address, and the address will differ depending on the environment. The tenant ID (TencendID) is used to distinguish different workspaces. The application ID (appID) distinguishes different applications, such as mobile banking applications, corporate banking applications, and mini-program applications; the package name and key are necessary parameters for the application. This configuration file is used to distinguish different application projects, outputting different applications for different customers and different projects.

[0066] Step S30: Dynamically load the latest component version corresponding to the target project template based on the version upgrade topology diagram and the target seed project compressed package.

[0067] For example, the system first loads a pre-generated version upgrade topology graph. This topology graph is a directed graph structure describing the version dependencies of each component, where nodes represent component versions and edges represent dependencies. Based on the baseline version information in the target seed project package, the system locates the starting node in the version upgrade topology graph, then traverses the graph structure to identify the latest compatible versions of all components associated with the target project template.

[0068] Step S40: Configure the target environment parameters according to the latest component version and build the target project.

[0069] For example, the target environment parameters are configured based on the characteristics and requirements of these components. These parameters include, but are not limited to, compilation options, runtime configurations, and dependency management settings. The system will automatically adjust these parameters according to the characteristics of the component versions to ensure that the project can build and run correctly. Specifically, the system will generate or update project description files (such as package.json, pom.xml, or build.gradle), injecting the dependency configurations of the latest component versions into them. Simultaneously, the system will also configure the corresponding environment variables, build scripts, and runtime parameters according to the component requirements. Figure 3 As shown, the system can construct the target project based on pre-set parameters.

[0070] In this embodiment, by parsing the template selection instruction, the target template and baseline version can be directly determined, avoiding the time-consuming process of manual searching and configuration. A seed project compressed package is generated based on the template identifier and version number. By reusing predefined templates, the process of repeatedly building the project framework is eliminated, ensuring the consistency of the initial project architecture. The latest component version is loaded through the topology graph, achieving automated dependency upgrades and reducing manual maintenance costs. Target environment parameters are configured independently according to the latest component version, achieving isolation between the build process and the environment, preventing runtime errors caused by environmental differences, saving developers' time and effort, and improving the efficiency and reliability of project construction.

[0071] Reference Figure 4 , Figure 4 This is a flowchart illustrating the second embodiment of the construction method for the project in this application, based on the above. Figure 2 The first embodiment shown presents a second embodiment of the construction method for the project of this application.

[0072] In the second embodiment, before step S10, the method further includes:

[0073] Step S010: Configure a collection of multiple types of project templates and generate a collection of seed project compressed packages.

[0074] It's important to note that system administrators or development teams will first configure various types of project templates based on project requirements. These templates may include, but are not limited to, multi-tab application templates, single-page application templates, microservice application templates, and mobile application templates. For each template type, the system will create a corresponding basic project structure, including directory structure, basic code files, and configuration files. For example, these project templates can be compressed and packaged to generate a collection of seed project archives. Each archive contains the complete project structure and basic dependency configurations for the corresponding template type. These archives will be stored in the system's seed project library for later use.

[0075] Step S020: Extract the association mapping relationship between the baseline version and the module version from the project template set and the seed project compressed package set.

[0076] It's important to note that after configuring the project template set and generating the seed project compressed package set, the system analyzes the dependency configurations in each template and compressed package, extracting the mapping relationship between the baseline version and the versions of each module. The baseline version refers to the overall version of the project template, while the module version refers to the specific version of each component or library. The system parses the dependency configuration files (such as package.json, pom.xml, etc.) in each seed project compressed package, extracting all declared dependencies and their version information. Then, the system establishes a mapping table to record the module versions corresponding to each baseline version. For example, the baseline version "v1.0.0" might correspond to the UI component library version "v2.3.1", the network request library version "v1.5.0", etc.

[0077] Step S030: Generate a version upgrade topology diagram based on the association mapping relationship between the baseline version and the module version.

[0078] It should be noted that step S030 includes: creating the root node of the version upgrade topology graph based on the baseline version; parsing the version dependencies of each module and generating a module version tree structure in combination with the root node; setting constraints on the baseline version and module versions, including mandatory upgrade flags and optional upgrade flags; and adding the constraints to the module version tree structure to obtain the version upgrade topology graph.

[0079] For example, after obtaining the mapping relationship between the baseline version and the module version, the system generates a version upgrade topology graph based on these relationships. This topology graph is a directed graph structure used to describe the dependencies and upgrade paths between versions. Specifically, the system first creates the root node of the topology graph based on the baseline version. Then, the system parses the version dependencies of each module, creates a corresponding node for each module version, and establishes directed edges between nodes based on the dependencies. In addition, the system sets constraints between the baseline version and the module version, including mandatory upgrade flags and optional upgrade flags. A mandatory upgrade flag indicates that the module must be upgraded to a specified version, while an optional upgrade flag indicates that the module can be upgraded selectively. Finally, the system adds these constraints to the module version tree structure to form a complete version upgrade topology graph. The topology graph can be used in the subsequent dynamic loading process of component versions. For example, a mandatory upgrade flag indicates that the module must be upgraded to a specified version, typically used for versions that fix serious bugs or security vulnerabilities. An optional upgrade flag indicates that the module can be upgraded selectively, typically used for versions that enhance functionality or optimize performance.

[0080] This embodiment describes a method for generating a version upgrade topology graph, including creating a root node, resolving dependencies, setting constraints, and forming a complete topology graph, providing important version management support for project construction.

[0081] In one implementation, step S010 includes: creating metadata description files for multi-tab templates and blank templates; defining project directory structure rules based on the metadata description files; and compressing and packaging the original project according to the project directory structure rules to generate a set of seed project compressed packages with digital signatures.

[0082] For example, the system can create a corresponding metadata description file for each project template. The metadata description file is typically in JSON or YAML format and describes the template's basic information and characteristics. For multi-tab templates, the metadata description file contains the following information: template identifier (e.g., "multi-tab-template"), template name, template description, applicable scenarios, baseline version, core dependency list, recommended plugin list, etc. For blank templates, the metadata description file structure is similar, but the content is simplified, containing only the most basic dependencies and configurations. After creating the metadata description files, the system defines project directory structure rules based on these files. These rules describe which directories and files the project should contain, and their organizational relationships. For multi-tab templates, the project directory structure rules may include: configuration files in the root directory (e.g., package.json, tsconfig.json, etc.), source code directory (src), resource directory (assets), component directory (components), page directory (pages), route configuration directory (routes), state management directory (store), utility function directory (utils), etc. The system defines the purpose and file types contained in each directory. For blank templates, the project directory structure is relatively simple, containing only the most basic directories and files.

[0083] It's important to note that after defining the project directory structure rules, the system will create native projects based on these rules. A native project refers to a project template that conforms to the directory structure rules and contains basic code and configuration. The system will create a corresponding native project for each template type, including creating the required directory structure, adding basic code files, and configuring dependencies. For example, the native projects can be compressed and packaged to generate a collection of seed project archives containing various template types, each archive bearing a unique digital signature. These digital signatures are typically generated using asymmetric encryption algorithms such as RSA or ECDSA and can be used to verify the origin and integrity of the archives.

[0084] Based on the above embodiments and implementation methods, this application proposes an implementation method in which step S30 includes: traversing the module version tree structure associated with the target project template in the version upgrade topology graph; and extracting the latest component version that meets the constraints from the module version tree structure based on the target seed project compressed package.

[0085] For example, the system first locates the corresponding root node in the version upgrade topology graph based on the target project template identifier, and then traverses the entire module version tree structure associated with the target project template, starting from the root node. Depth-first search (DFS) or breadth-first search (BFS) algorithms can be used to visit each node in the tree structure, starting from the root node. During the traversal, the system records all available versions of each module and their dependencies. After traversing the module version tree structure, the system parses the dependency configuration in the target seed project package to obtain the currently used component version information. Then, the system compares this information with the data in the module version tree structure and selects the latest version that meets the constraints for each component.

[0086] Reference Figure 5 , Figure 5 This is a flowchart illustrating the third embodiment of the construction method for the project in this application, based on the above. Figure 4 The second embodiment shown presents a third embodiment of the construction method for the project of this application.

[0087] In the third embodiment, step S40 includes:

[0088] Step S401: Based on the latest version of the component, perform dependency resolution on the version components with dependencies to generate a set of target components that are compatible with the version.

[0089] For example, the system constructs a dependency graph, where nodes represent component versions and edges represent dependencies. The system then checks the dependency graph for conflicts, such as circular dependencies or version incompatibilities. If a conflict is found, the system attempts to adjust the component versions to resolve it. After dependency resolution, the system generates a set of version-compatible target components, containing all the components that need to be loaded and their versions, ensuring that these component versions are compatible with each other.

[0090] Step S402: Inject the dependency configuration of the target component set into the project description file containing the target environment parameters.

[0091] It's important to note that project description files (or project description files) describe the project structure, dependencies, and build configurations, such as package.json, pom.xml, and build.gradle. Specifically, the system selects the appropriate project description file format based on the project type and then adds each component in the target component collection, along with its version information, to the dependency list. For example, for a Node.js project, the system updates the dependencies and devDependencies fields in the package.json file; for a Java project, the system updates the dependencies field in the pom.xml file.

[0092] Step S403: Construct the target project project based on the project description file.

[0093] It's important to note that after configuring the project description file, the system will build the target project based on that file. The build process includes, but is not limited to, dependency installation, code compilation, resource handling, and packaging optimization. For example, the system can select appropriate build tools and commands based on the project type. For instance, for a Node.js project, the system might use npm or yarn to install dependencies, and then use webpack or rollup for packaging; for a Java project, the system might use maven or gradle for building.

[0094] In this embodiment, the configuration content in the seed project is modified by scripts on each end, and a project packaging script is provided to realize project construction, which ensures the accuracy of the integrated product and the convenience of project construction.

[0095] In one implementation, based on the third embodiment described above, after the step of constructing the target project project based on the project description file, the method further includes: recording the component injection process, directory generation events, and version conflict handling results in real time according to the project description file and project directory structure rules, and generating a process log file; monitoring the error logs in the process log file, and determining the exception type through regular expression matching; retrieving and executing a repair solution from the solution knowledge base according to the exception type, and obtaining the repair solution execution result; recording the repair solution execution result in the experience database, and updating the solution knowledge base.

[0096] For example, a structured format (such as JSON or XML) can be used to record the component injection process, directory generation events, and version conflict handling results. The component injection process can be understood as recording the injection time, version information, and dependencies of each component; directory generation events can be understood as recording the creation and modification of the project directory structure; and version conflict handling results can record the discovery and resolution process of version conflicts. After generating the process log file, the system continuously monitors the error logs in that file. Error logs are log entries that record errors, warnings, or exceptions that occur during the build process. The system uses predefined regular expression patterns to match and analyze the log content to determine the exception type. Through regular expressions, the system can extract key information from the error logs, such as error type, error location, and related components, providing a basis for subsequent error repair. After determining the exception type, the system retrieves applicable repair solutions from a pre-built solution knowledge base. The solution knowledge base is a database containing various common errors and their solutions, typically built based on past experience and best practices. The system searches the knowledge base for matching repair solutions based on the exception type and related information. After obtaining the results of the remediation plan execution, the system records these results in the experience database. The experience database stores historical remediation experiences, used to accumulate and analyze problems and solutions encountered during the project development process. The system also updates the solution knowledge base based on the remediation plan execution results. If a remediation plan successfully solves the problem, the system increases its weight or priority; if a remediation plan fails or is ineffective, the system decreases its weight or marks it as needing improvement. Furthermore, the system generates new remediation plans or optimizes existing plans based on new experience data, continuously enriching and improving the solution knowledge base.

[0097] This implementation describes error handling and repair methods during the project construction process, including log recording, anomaly identification, solution execution, and knowledge updating. This enables the system to automatically discover and resolve problems during the construction process, improve the success rate and efficiency of project construction, and continuously accumulate experience to optimize solutions.

[0098] It should be noted that the above examples are only for understanding this application and do not constitute a limitation on the construction method of the project of this application. Any simple modifications based on this technical concept are within the protection scope of this application.

[0099] This application also provides a construction apparatus for a project, please refer to... Figure 6 The construction apparatus for the project includes:

[0100] Version determination module 10 is used to respond to template selection instructions and determine the target project template identifier and associated baseline version number according to the template selection instructions;

[0101] Project compression module 20 is used to generate a target seed project compressed package based on the target project template identifier and the associated baseline version number seed project;

[0102] Component loading module 30 is used to dynamically load the latest component version corresponding to the target project template according to the version upgrade topology diagram and the target seed project compressed package;

[0103] Project construction module 40 is used to configure the target environment parameters according to the latest component version and construct the target project project.

[0104] The project construction apparatus provided in this application, employing the project construction method described in the above embodiments, can solve the technical problem of how to improve the efficiency and reliability of project construction. Compared with the prior art, the beneficial effects of the project construction apparatus provided in this application are the same as those of the project construction method described in the above embodiments, and other technical features in the project construction apparatus are the same as those disclosed in the methods of the above embodiments, and will not be repeated here.

[0105] This application provides a project construction device, which includes: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, which are executed by the at least one processor to enable the at least one processor to execute the project construction method in Embodiment 1 above.

[0106] The following is for reference. Figure 7 The diagram illustrates a structural schematic of a construction device suitable for implementing the project engineering of the embodiments of this application. The construction device for the project engineering in the embodiments of this application may include, but is not limited to, mobile terminals such as mobile phones, laptops, digital broadcast receivers, PDAs (Personal Digital Assistants), PADs (Portable Application Description), PMPs (Portable Media Players), in-vehicle terminals (e.g., in-vehicle navigation terminals), and fixed terminals such as digital TVs and desktop computers. Figure 7 The construction equipment shown for the project is merely an example and should not impose any limitations on the functionality and scope of use of the embodiments of this application.

[0107] like Figure 7As shown, the construction equipment for the project may include a processing unit 1001 (e.g., a central processing unit, a graphics processing unit, etc.), which can perform various appropriate actions and processes according to a program stored in a read-only memory (ROM) 1002 or a program loaded from a storage device 1003 into a random access memory (RAM) 1004. The RAM 1004 also stores various programs and data required for the operation of the construction equipment for the project. The processing unit 1001, ROM 1002, and RAM 1004 are interconnected via a bus 1005. An input / output (I / O) interface 1006 is also connected to the bus. Typically, the following systems can be connected to the I / O interface 1006: input devices 1007 including, for example, a touchscreen, touchpad, keyboard, mouse, image sensor, microphone, accelerometer, gyroscope, etc.; output devices 1008 including, for example, a liquid crystal display (LCD), speaker, vibrator, etc.; storage devices 1003 including, for example, magnetic tape, hard disk, etc.; and communication devices 1009. Communication device 1009 allows the construction equipment of the project to communicate wirelessly or wiredly with other devices to exchange data. Although Figure 7 The project engineering setup shown includes various systems; however, it should be understood that implementation or possession of all the systems shown is not required. More or fewer systems may be implemented alternatively.

[0108] Specifically, according to the embodiments disclosed in this application, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, embodiments disclosed in this application include a computer program product comprising a computer program carried on a computer-readable medium, the computer program containing program code for performing the methods shown in the flowcharts. In such embodiments, the computer program can be downloaded and installed from a network via a communication device, or installed from storage device 1003, or installed from ROM 1002. When the computer program is executed by processing device 1001, it performs the functions defined in the methods of the embodiments disclosed in this application.

[0109] The project construction equipment provided in this application, employing the project construction method described in the above embodiments, can solve the technical problem of how to improve the efficiency and reliability of project construction. Compared with the prior art, the beneficial effects of the project construction equipment provided in this application are the same as those of the project construction method described in the above embodiments, and other technical features of the project construction equipment are the same as those disclosed in the previous embodiment method, and will not be repeated here.

[0110] It should be understood that the various parts disclosed in this application can be implemented using hardware, software, firmware, or a combination thereof. In the description of the above embodiments, specific features, structures, materials, or characteristics can be combined in any suitable manner in one or more embodiments or examples.

[0111] The above description is merely a specific embodiment of this application, but the scope of protection of this application is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in this application should be included within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the scope of the claims.

[0112] This application provides a computer-readable storage medium having computer-readable program instructions (i.e., a computer program) stored thereon, the computer-readable program instructions being used to execute the project construction method of the above embodiments.

[0113] The computer-readable storage medium provided in this application may be, for example, a USB flash drive, but is not limited to, electrical, magnetic, optical, electromagnetic, infrared, or semiconductor systems, devices, or any combination thereof. More specific examples of computer-readable storage media may include, but are not limited to: electrical connections having one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fibers, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination thereof. In this embodiment, the computer-readable storage medium may be any tangible medium containing or storing a program that can be used by or in conjunction with an instruction execution system, system, or device. The program code contained on the computer-readable storage medium may be transmitted using any suitable medium, including but not limited to: wires, optical cables, RF (Radio Frequency), etc., or any suitable combination thereof.

[0114] The aforementioned computer-readable storage medium may be included in the construction equipment of the project; or it may exist independently and not be assembled into the construction equipment of the project.

[0115] The aforementioned computer-readable storage medium carries one or more programs that, when executed by the project's construction device, cause the project's construction device to: respond to a template selection instruction and determine a target project template identifier and associated baseline version number based on the template selection instruction; generate a target seed project compressed package based on the target project template identifier and associated baseline version number; dynamically load the latest component version corresponding to the target project template based on the version upgrade topology diagram and the target seed project compressed package; configure target environment parameters based on the latest component version, and construct the target project.

[0116] Computer program code for performing the operations of this application can be written in one or more programming languages ​​or a combination thereof, including object-oriented programming languages ​​such as Java, Smalltalk, and C++, as well as conventional procedural programming languages ​​such as "C" or similar programming languages. The program code can be executed entirely on the user's computer, partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In cases involving remote computers, the remote computer can be connected to the user's computer via any type of network—including a Local Area Network (LAN) or a Wide Area Network (WAN)—or can be connected to an external computer (e.g., via the Internet using an Internet service provider).

[0117] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of this application. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of code containing one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions indicated in the blocks may occur in a different order than those indicated in the drawings. For example, two consecutively indicated blocks may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, can be implemented using a dedicated hardware-based system that performs the specified function or operation, or using a combination of dedicated hardware and computer instructions.

[0118] The modules described in the embodiments of this application can be implemented in software or hardware. The names of the modules do not necessarily limit the functionality of the unit itself.

[0119] The readable storage medium provided in this application is a computer-readable storage medium that stores computer-readable program instructions (i.e., a computer program) for executing the construction method of the above-described project, and can solve the technical problem of how to improve the efficiency and reliability of project construction. Compared with the prior art, the beneficial effects of the computer-readable storage medium provided in this application are the same as the beneficial effects of the project construction method provided in the above embodiments, and will not be repeated here.

[0120] The above description is only a part of the embodiments of this application and does not limit the patent scope of this application. All equivalent structural transformations made under the technical concept of this application and using the contents of the specification and drawings of this application, or direct / indirect applications in other related technical fields, are included in the patent protection scope of this application.

Claims

1. A method for constructing a project engineering, characterized in that, The method includes: Configure multiple types of project template sets and generate a set of seed project compressed packages; Extract the association mapping relationship between the baseline version and the module version from the project template set and the seed project compressed package set; Create the root node of the version upgrade topology graph based on the baseline version; Analyze the version dependencies of each module and generate a module version tree structure based on the root node; Set constraints for the baseline version and module version, including a mandatory upgrade flag and an optional upgrade flag; The constraints are added to the module version tree structure to obtain the version upgrade topology diagram; In response to a template selection instruction, the target project template identifier and associated baseline version number are determined based on the template selection instruction; the baseline version number represents the basic function set version of the template. A target seed project compressed package is generated based on the target project template identifier and the associated baseline version number seed project; the seed project is a minimal project template containing the basic project structure and core dependencies, and the target seed project compressed package contains the project's basic directory structure, core configuration files, and dependency declarations; the core configuration files include tenant ID, application ID, gateway address, package name, and key information; Traverse the tree structure of module versions associated with the target project template in the version upgrade topology graph; Based on the target seed project compressed package, the latest component version that satisfies the constraints is extracted from the module version tree structure; the version upgrade topology graph is a directed structure graph describing the dependency relationship between the versions of each component. Configure the target environment parameters according to the latest component version, and build the target project. The steps of configuring the target environment parameters according to the latest component version and building the target project include: Based on the latest component version, perform dependency resolution on the version components with dependencies to generate a set of target components that are compatible with the version. Inject the dependency configuration of the target component set into the project description file containing the target environment parameters; The target project is constructed based on the project description file.

2. The method as described in claim 1, characterized in that, The step of configuring a set of multiple types of project templates and generating a set of seed project compressed packages includes: Create metadata description files for multi-tab templates and blank templates; Define the project directory structure rules based on the metadata description file; The original project is compressed and packaged according to the project directory structure rules to generate a set of seed project compressed packages with digital signatures.

3. The method as described in claim 1, characterized in that, Following the step of constructing the target project project based on the project description file, the method further includes: Based on the project description file and project directory structure rules, the component injection process, directory generation events and version conflict handling results are recorded in real time, and a process log file is generated. Monitor the error logs in the process log file and determine the exception type by matching regular expressions. Based on the anomaly type, a remediation plan is retrieved from the solution knowledge base and executed to obtain the remediation plan execution result; The results of the repair solution are recorded in the experience database, and the solution knowledge base is updated.

4. A construction device for a project, characterized in that, The device includes: A topology building module is used to configure multiple types of project template sets and generate a set of seed project compressed packages. From the project template sets and the seed project compressed package sets, the module version and module version association mapping relationship is extracted. A root node for the version upgrade topology graph is created based on the baseline version. The version dependencies of each module are parsed, and a module version tree structure is generated based on the root node. Constraints are set between the baseline version and the module version, including a mandatory upgrade flag and an optional upgrade flag. These constraints are added to the module version tree structure to obtain the version upgrade topology graph. The version determination module is used to respond to the template selection instruction and determine the target project template identifier and associated baseline version number according to the template selection instruction; the baseline version number represents the basic function set version of the template; The project compression module is used to generate a target seed project compressed package based on the target project template identifier and the associated baseline version number seed project; the seed project is a minimal project template containing the basic project structure and core dependencies, and the target seed project compressed package contains the project's basic directory structure, core configuration files, and dependency declarations; the core configuration files include tenant ID, application ID, gateway address, package name, and key information; The component loading module traverses the module version tree structure associated with the target project template in the version upgrade topology graph; based on the target seed project compressed package, it extracts the latest component version that satisfies the constraints from the module version tree structure; the version upgrade topology graph is a directed structure graph describing the dependency relationships between component versions; The project construction module is used to configure the target environment parameters according to the latest component version and construct the target project. The project construction module is also used for: Based on the latest component version, perform dependency resolution on the version components with dependencies to generate a set of target components that are compatible with the version. Inject the dependency configuration of the target component set into the project description file containing the target environment parameters; The target project is constructed based on the project description file.

5. A construction device for a project, characterized in that, The device includes: a memory, a processor, and a computer program stored in the memory and executable on the processor, the computer program being configured to implement the steps of the method for constructing the project engineering as described in any one of claims 1 to 3.

6. A storage medium, characterized in that, The storage medium is a computer-readable storage medium, and a computer program is stored on the storage medium. When the computer program is executed by a processor, it implements the steps of the project construction method as described in any one of claims 1 to 3.

Images