A low-code development method, storage medium and electronic device

Abstract

The application relates to a low-code development method, a storage medium and an electronic device, and the low-code development method comprises the following steps: receiving a code compilation request sent by a first client and carrying a first storage path of a to-be-compiled code file; based on the code compilation request, generating, through an interaction program, notification information for notifying of pulling the to-be-compiled code file, and sending the notification information to the client, so that the client feeds back a code pulling request carrying a second storage path of the to-be-compiled code file; receiving the code pulling request sent by the client, and based on the second storage path, finding the to-be-compiled code file from a file system through the interaction program, and sending the to-be-compiled code file to the client through the interaction program, so that the first client compiles the to-be-compiled code file to obtain a compiled code file, and the compiled code file is synchronized to a database and a file system through a plug-in program, thereby improving development efficiency in an automatic manner.

Description

Technical Field

[0001] This invention relates to the field of software code management technology, and more particularly to a low-code development method, storage medium, and electronic device. Background Technology

[0002] On entity configuration code development platforms, with the increasingly diversified product forms, the number of business APP modules for different industrial fields is rapidly increasing. The business volume with multiple versions and multiple requirements places higher demands on the efficiency of business development using entity configuration.

[0003] Currently, developing custom code using low-code development tools in IDEs and debugging it locally on the server requires a high level of skill. The most common way to verify code is to manually copy parts of the custom code to the entity configuration server after local development, compile and start it for verification. Updating the server-side code to the local machine is also done by manually copying the code files, resulting in a lot of unnecessary work in synchronizing local and server code, thus reducing development efficiency. Summary of the Invention

[0004] (a) Technical problems to be solved

[0005] In view of the above-mentioned shortcomings and deficiencies of the prior art, the present invention provides a low-code development method, storage medium and electronic device, which solves the technical problem of low development efficiency in the prior art.

[0006] (II) Technical Solution

[0007] To achieve the above objectives, the main technical solutions adopted by the present invention include:

[0008] In a first aspect, embodiments of the present invention provide a low-code development method. The low-code development method is applied to a server, and the server is configured with a file system and an interactive program capable of fetching code. The low-code development method includes: receiving a code compilation request sent by a first client, carrying a first storage path containing a code file to be compiled; wherein the first client has a low-code development tool (IDE) installed, enabling the first client to compile code in the IDE environment, and the low-code development tool is configured with a plugin program capable of code synchronization; based on the code compilation request, generating notification information through the interactive program to notify the first client to fetch the code file to be compiled, and sending the notification message to the client, so that the client can respond with a code fetch request carrying a second storage path containing the code file to be compiled; receiving the code fetch request sent by the client, and based on the second storage path, searching for the code file to be compiled in the file system through the interactive program, and sending the code file to be compiled to the client through the interactive program, so that the first client can compile the code file to be compiled, obtain the compiled code file, and synchronize the compiled code file to the database and file system through the plugin program.

[0009] Therefore, this application embodiment uses a plug-in program configured on the first client and an interactive program configured on the server to enable business developers to conveniently synchronize development tools and code on the server during the process, thereby replacing the method of developers manually copying code files and improving development efficiency. That is, it improves development efficiency through automatic uploading and automatic downloading.

[0010] In one possible embodiment, the first storage path is the storage path of the code file to be compiled in the database; wherein, based on the code compilation request, generating notification information to notify the first client to pull the code file to be compiled includes: based on the first storage path, determining through an interactive program whether the code file to be compiled is occupied by a client other than the first client; if it is determined that the code file to be compiled is not occupied by a client other than the first client, then generating a notification message through the interactive program.

[0011] In one possible embodiment, the low-code development method further includes: if it is determined that the code file to be compiled is occupied by another client, sending a request failure message to the first client through an interactive program to inform the first client that the code retrieval failed.

[0012] In one possible embodiment, the low-code development method further includes: determining the latest version number of the compiled code file through an interactive program, and storing the latest version number in a database.

[0013] Secondly, embodiments of the present invention provide a low-code development method. This method is applied to a first client equipped with a low-code development tool, enabling the first client to compile code in an IDE environment. The low-code development tool is configured with a plugin program capable of code synchronization. The low-code development method includes: generating a code compilation request carrying a first storage path of the code file to be compiled, and sending the code compilation request to a server, so that the server, based on the code compilation request, generates notification information to notify the first client to retrieve the code file to be compiled via an interactive program; wherein the server is configured with a file system and an interactive program; receiving the notification information sent by the server; based on the notification information, sending a code retrieval request carrying a second storage path to the server, so that the server, based on the second storage path, locates the code file to be compiled in the file system via the interactive program; receiving the code file to be encoded sent by the server, compiling the code file to be encoded to obtain a compiled code file, and synchronizing the compiled code file to a database and a file system via a plugin program.

[0014] In one possible embodiment, the first storage path is the storage path of the code file to be compiled in the database, and the notification message is generated by the server through an interactive program after determining that the code file to be compiled is not occupied by any client other than the first client.

[0015] In one possible embodiment, the low-code development method further includes: receiving request failure information sent by the server to determine that code retrieval failed; wherein the request failure information is generated by the server through an interactive program when the code file to be compiled is occupied by another client.

[0016] In one possible embodiment, during the process of synchronizing the compiled code file to the database via the plug-in program, the interactive program determines the latest version number of the compiled code file and updates the latest version number to the database.

[0017] Thirdly, embodiments of this application provide a storage medium storing a computer program, which, when executed by a processor, performs the method described in the first aspect or any optional implementation thereof.

[0018] Fourthly, embodiments of this application provide a storage medium storing a computer program, which, when executed by a processor, performs the method described in the second aspect or any optional implementation thereof.

[0019] Fifthly, embodiments of this application provide an electronic device, including: a processor, a memory, and a bus. The memory stores machine-readable instructions executable by the processor. When the electronic device is running, the processor communicates with the memory via the bus. When the machine-readable instructions are executed by the processor, they perform the method described in the first aspect or any optional implementation of the first aspect.

[0020] In a sixth aspect, embodiments of this application provide an electronic device, including: a processor, a memory, and a bus. The memory stores machine-readable instructions executable by the processor. When the electronic device is running, the processor communicates with the memory via the bus. When the machine-readable instructions are executed by the processor, they perform the method described in the second aspect or any optional implementation of the second aspect.

[0021] To make the above-mentioned objectives, features and advantages to be achieved by the embodiments of this application more apparent and understandable, preferred embodiments are described below in detail with reference to the accompanying drawings. Attached Figure Description

[0022] To more clearly illustrate the technical solutions of the embodiments of this application, the accompanying drawings used in the embodiments of this application will be briefly introduced below. It should be understood that the following drawings only show some embodiments of this application and should not be regarded as a limitation of the scope. For those skilled in the art, other related drawings can be obtained based on these drawings without creative effort.

[0023] Figure 1 A schematic diagram illustrating an application scenario provided by an embodiment of this application is shown;

[0024] Figure 2 A flowchart of a low-code development method provided in an embodiment of this application is shown;

[0025] Figure 3 A flowchart of another low-code development method provided in an embodiment of this application is shown. Detailed Implementation

[0026] To better explain and facilitate understanding of the present invention, the present invention will be described in detail below with reference to the accompanying drawings and specific embodiments.

[0027] Currently, in addition to the low development efficiency caused by manually uploading or downloading code, the inability to manage and trace different versions of original and custom code, which requires writing duplicate code multiple times to achieve the same functionality on different versions of module packages, also greatly reduces development efficiency.

[0028] Based on this, this application ingeniously proposes a low-code development solution. By using a plugin program configured on the first client and an interactive program configured on the server, business developers can easily synchronize development tools and code on the server during the process. This replaces the manual copying of code files by developers, improving development efficiency through automatic uploading and downloading. Furthermore, during code submission, the server program records relevant version information for different versions of custom code in the database and file system to achieve concise version tracking, thereby improving development efficiency.

[0029] To better understand the above technical solutions, exemplary embodiments of the present invention will be described in more detail below with reference to the accompanying drawings. Although exemplary embodiments of the present invention are shown in the drawings, it should be understood that the present invention can be implemented in various forms and should not be limited to the embodiments set forth herein. Rather, these embodiments are provided so that the present invention can be understood more clearly and thoroughly, and that the scope of the present invention can be fully conveyed to those skilled in the art.

[0030] To facilitate understanding of the embodiments of this application, some terms involved in this application are explained below:

[0031] "Integrated Development Environment (IDE)": It is an application that provides a program development environment, which generally includes tools such as code editors, compilers, debuggers and graphical user interfaces;

[0032] "IDEA (IntelliJ IDEA)": It can refer to an integrated development environment (IDE) for Java language development, but it can also be used for other languages.

[0033] "Plug-in Program": It can be a plugin that is installed on IDEA and developed based on IDEA and Gradle. It enables right-click menus in different areas of the IDEA interface to operate on the code in different areas and to perform bidirectional synchronization with the code in the server files.

[0034] For example, after installing this plugin on the corresponding version of IDEA, it provides a series of menu options (such as right-click menu options) for IDEA operations. The main function of these menu options is to initiate requests to the server for different areas of code through the code logic in the plugin, so as to achieve interaction with the server's interactive modules and complete the logic of mutual synchronization and version control between the code in the current IDEA and the server code. Specific right-click menu options include PackProject (package the current code into a ZIP), PullAllCodeFromADP (pull all code from the current server and overwrite the local code), PullCustomCodeFromADP (pull all custom code from the server and overwrite the local code; if the current file does not exist locally, it will be added), and PushCustomCodeToADP (push all custom code from the local code to the ADP server), etc.

[0035] It should be understood that the specific program of the plug-in program can be set according to actual needs, and the embodiments of this application are not limited thereto.

[0036] For example, a plugin could be CDS-Plugin, etc.

[0037] "Interactive program": It can be a server program that interacts with the plug-in program running on the ADS platform server. Its main functions include manipulating server code files and performing version control.

[0038] For example, the interactive program's role is to accept and process requests from the plugin program, the operatetools service, and the configuration service, and to interact with the plugin program to synchronize different code files, as well as to interact with the operatetools service, the configuration service, and the data to record custom code version information.

[0039] It should also be understood that the specific program of the interactive program can be set according to actual needs, and the embodiments of this application are not limited thereto.

[0040] For example, the interactive program could be a CDS-Server, etc.

[0041] The "operatetools service" can be one of the main applications of a low-code development platform, enabling operations such as generating, compiling, and starting business module code. It can also compile the original code based on the configuration information dragged and dropped from the configuration service. The code compiled based on the configuration information is called the generated code, while the code written by the developers themselves can be called custom code (for example, it could be a single file containing only custom code, or it could be a generated file containing some code written by the developers interspersed within the original code).

[0042] For example, the operatetools service can compile and run the corresponding business module code. During the compilation process, a unique identifier is added to the custom files and code and then stored in the server's file system for version control information recording. The main function of the current service is to compile and run module APPs developed from low-code code.

[0043] It should also be understood that the original code can also be called the generated code. The original code can be code generated based on the dragged elements and configuration.

[0044] For example, the source code could be code pre-set by business developers.

[0045] It should also be understood that custom code can also be called business code, and the business code section can contain corresponding target code tags so that it can be determined whether custom code is included.

[0046] "Configuration Service": This can be one of the main applications of a low-code development platform, providing visual operations such as business entity model views. Additionally, it can be used to add identifiers to different code files and custom code section files for version control information recording during the module upload process, tailored to the current service within this tool. Furthermore, its main functions include creating new modules, dragging and dropping elements for development, and writing small amounts of code on a web interface.

[0047] "File system": It refers to the source code information files of all business modules on the low-code development platform. That is, after the low-code development platform software system is deployed, it can be stored on the machine as a file plus directory containing the code files of all modules.

[0048] It should also be understood that the specific system of the file system can be set according to actual needs, and the embodiments of this application are not limited thereto.

[0049] For example, the file system could be a Code-File, etc.

[0050] "Database": It can store code and its version number.

[0051] "First Client": It can be equipped with a low-code development tool IDE, which means that business developers can perform low-code development in the IDE environment.

[0052] It should also be understood that the first client can also be called the IDE client.

[0053] "Second Client": It can write code through the web interface of the low-code development platform. That is, business developers can perform low-code development in the WEB environment, and interact with the entity configuration service during the process of saving and adding custom code, which will update the corresponding custom code and version information.

[0054] It should also be understood that the second client can also be called the first client.

[0055] Please see Figure 1 , Figure 1 A schematic diagram illustrating an application scenario provided by an embodiment of this application is shown. For example... Figure 1 As shown, this application scenario may include a first client, a second client, a server, and a database.

[0056] The first client can be configured with plug-in programs; the second client can be configured with web pages; and the server can be configured with interactive programs, configuration services, operatortools services, and a file system.

[0057] It should be noted here that, although Figure 1 Specific application scenarios are illustrated, but those skilled in the art should understand that they can be set according to actual needs, and the embodiments of this application are not limited thereto.

[0058] Please see Figure 2 , Figure 2 A flowchart illustrating a low-code development method provided in an embodiment of this application is shown. Figure 2 As shown, this low-code development method includes:

[0059] In step S210, the first client generates a code compilation request carrying the first storage path of the code file to be compiled, and sends the code compilation request to the server. Correspondingly, the server receives the code compilation request sent by the first client.

[0060] Specifically, after the first client installs the plug-in program, the first client can obtain the IP and port information of the server with the interactive program, and detect whether the interactive program is deployed on the server based on the IP and port information.

[0061] If the detection determines that an interactive program is deployed on the server, the first client generates a code compilation request carrying the first storage path of the code file to be compiled, where the first storage path is the storage path of the file to be compiled in the database, and sends the code compilation request to the server; if the detection determines that no interactive program is deployed on the server, a prompt message can be issued to inform the business personnel that no interactive program is deployed on the server.

[0062] It should be noted that the code file to be compiled can be any one of multiple code files, or it can be a collection of multiple code files. This application embodiment is not limited to this.

[0063] In step S220, the server generates notification information through an interactive program based on the code compilation request to notify the first client to pull the code file to be compiled.

[0064] Specifically, based on the first storage path in the code compilation request, the server uses an interactive program to determine whether the code file to be compiled is being used by any client other than the first client. If it is determined that the code file is not being used by any other client, a notification message is generated through the interactive program; if it is determined that the code file is being used by any other client, a request failure message is sent to the first client through the interactive program to inform the first client that the code retrieval failed. The other client can be either the second client or another first client.

[0065] For example, when another client uses a file to compile, a usage flag can be stored first, thus determining whether the file to be compiled has a usage flag. If it is determined that the file to be compiled has a usage flag, a notification message is generated through the interactive program; if it is determined that the file to be compiled does not have a usage flag, a request failure message is sent to the first client through the interactive program.

[0066] In step S230, the server sends the notification message to the first client through an interactive program. Correspondingly, the first client receives the notification message sent by the server.

[0067] In step S240, the first client sends a code retrieval request carrying the second storage path to the server based on the notification information. The second storage path represents the storage path of the file to be compiled in the file system.

[0068] Specifically, upon receiving the notification message, the first client can obtain the second storage path of the file to be compiled and generate a code fetch request carrying the second storage path. Furthermore, the first client sends this code fetch request to the server through a plugin program.

[0069] In step S250, the server locates the code file to be compiled in the file system through an interactive program based on the second storage path.

[0070] In step S260, the server sends the code file to be compiled to the first client. Correspondingly, the first client receives the code file to be compiled sent by the server.

[0071] In step S270, the first client compiles the code file to be encoded, obtains the compiled code file, and synchronizes the compiled code file to the database and file system through the plugin program.

[0072] Specifically, after the first client obtains the code file to be encoded, it can be displayed locally on the first client. After the code is displayed, the business developers can identify which part of the displayed code has problems, and then compile the problematic part (for example, it may include adding, deleting, and modifying data) to obtain the compiled code file. The compiled code file can also be synchronized to the database and file system through the plugin program.

[0073] It's important to note that during the process of synchronizing compiled code files to the file system via the plugin, the compiled code files can completely overwrite the previous uncompiled code files; that is, the uncompiled code files are deleted, and only the latest compiled code files are retained. Furthermore, during the process of synchronizing compiled code files to the database via the plugin, the previous uncompiled files can be retained, and the compiled code files carrying revision marks (including compilation marks from business developers) can be saved to the database.

[0074] In addition, during the process of synchronizing the compiled code files to the database through the plugin program, the interactive program can determine the latest version of the compiled code files (for example, by adding 1 to the version number of the code file to be compiled, the latest version number can be obtained), and the latest version number can also be stored in the database.

[0075] Therefore, by utilizing the above technical solutions, this application embodiment, through the use of a plug-in program configured on the first client and an interactive program configured on the server, enables business developers to conveniently synchronize development tools and code on the server during the process. This replaces the manual copying of code files by developers, improving development efficiency through automatic uploading and downloading. Furthermore, during code submission, the server program records relevant version information for different versions of custom code in the database and file system to achieve concise version recording for traceability, thereby improving development efficiency.

[0076] To facilitate understanding of the embodiments of this application, the following can also be used... Figure 3This describes the process by which business developers perform low-code development through a second client.

[0077] It should be noted here that... Figure 3 The process can occur before step S210 or after step S270, and Figure 2 and Figure 3 The difference is that, Figure 2 This describes the interaction process between the first client and the server. Figure 3 It describes the interaction process between the second client and the server.

[0078] It should also be noted that, in cases where other clients are secondary clients, please refer to [link / reference needed]. Figure 3 For related descriptions, see below if other clients are the primary clients. Figure 2 Related descriptions.

[0079] Please see Figure 3 , Figure 3 A flowchart illustrating another low-code development method provided in an embodiment of this application is shown. Figure 3 As shown, this low-code development method includes:

[0080] In step S310, after the code upload service is started on the web interface of the second client, the server receives the code file uploaded by the second client.

[0081] It should be understood that the specific file of the code uploaded by the second client can be set according to actual needs, and the embodiments of this application are not limited thereto.

[0082] For example, the code file uploaded by the second client can be entirely original code, entirely custom code, or a combination of original and custom code.

[0083] In step S320, the server stores the code file uploaded by the second client into the file system and database through the corresponding service.

[0084] Optionally, the server may detect whether the code file uploaded by the second client contains target code tags.

[0085] If the server determines through detection that the code file uploaded by the second client does not contain target code markers, then it determines that the code file uploaded by the second client is entirely raw code. The server can obtain the filename of the code file uploaded by the second client and its storage path in the database. Based on the filename and storage path, the server generates a fixed-length first string, which can be used as the latest version number of the code file uploaded by the second client. For example, a fixed-length first string can be generated by hashing the filename and storage path of the code file uploaded by the second client. Furthermore, the operatetools service can send the latest version number of the code file uploaded by the second client to the interactive program (e.g., CDS-Server), and the interactive program can update the latest version number of the code file uploaded by the second client in the database. The interactive program can also update the database and file system with the latest version number of the code file uploaded by the second client.

[0086] If the server determines through detection that the code file uploaded by the second client contains target code markers, and the start code marker of the target code markers is set at the beginning of the code file uploaded by the second client, and a corresponding end code marker is present at the end of the code file uploaded by the second client, then it can be determined that the code file uploaded by the second client is entirely custom code. Furthermore, the server can determine the methods (e.g., method1 and method2, etc.) and filename of the code file uploaded by the second client, and generate a fixed-length second string based on these two strings. This second string can be used as the latest version number of the code file uploaded by the second client. For example, a fixed-length second string can be generated by hashing the methods and filename of the code file uploaded by the second client. Additionally, the configuration service can send the latest version number of the code file uploaded by the second client to the interactive program (e.g., CDS-Server, etc.), and the interactive program can update the latest version number of the code file uploaded by the second client in the database, and the interactive program can also update the code file uploaded by the second client in both the database and the file system.

[0087] Furthermore, if the server determines through detection that the code file uploaded by the second client contains object code markers, and the start and end code markers of the object code markers are located in the middle of the code file uploaded by the second client, then it can be determined that the code file uploaded by the second client contains not only original code but also custom code. Also, since the original code portion of the code file may have a corresponding version number, and the custom code portion of the code file may also have a corresponding version number, the server can determine the latest version number of the original code portion and the latest version number of the custom code portion using the method described above for determining the two version numbers. Furthermore, the server can store the file and its version number in the file system and database using the storage update method described above.

[0088] Therefore, the embodiments of this application can perform code version management for custom code areas that cannot be managed by code, which facilitates historical backtracking.

[0089] It should be understood that the above low-code development method is merely exemplary, and those skilled in the art can make various modifications based on the above method, and the modified solutions also fall within the protection scope of this application.

[0090] This application provides a storage medium storing a computer program, which is executed by a processor to perform the methods described in the embodiments.

[0091] For example, in the case where the storage medium is the storage medium on the first client, the storage medium stores a computer program that is executed by the processor. Figure 2 The method related to the first client; for example, in the case where the storage medium is the storage medium on the second client, the storage medium stores a computer program that is executed by the processor. Figure 3 Methods related to the second client.

[0092] This application also provides a computer program product that, when run on a computer, causes the computer to perform the method described in the method embodiment.

[0093] Correspondingly, this computer program product is similar to the storage medium, as detailed in the relevant description of the storage medium.

[0094] Those skilled in the art will understand that embodiments of the present invention can be provided as methods, systems, or computer program products. Therefore, the present invention can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, the present invention can take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0095] This invention is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and / or block diagrams, as well as combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions.

[0096] It should be noted that any reference numerals placed between parentheses in the claims should not be construed as limiting the claims. The word "comprising" does not exclude the presence of components or steps not listed in the claims. The word "a" or "an" preceding a component does not exclude the presence of a plurality of such components. The invention can be implemented by means of hardware comprising several different components and by means of a suitably programmed computer. In claims that enumerate several means, several of these means may be embodied by the same hardware. The use of the terms first, second, third, etc., is merely for convenience of expression and does not indicate any order. These terms can be understood as part of the component names.

[0097] Furthermore, it should be noted that in the description of this specification, the terms "one embodiment," "some embodiments," "embodiment," "example," "specific example," or "some examples," etc., refer to specific features, structures, materials, or characteristics described in connection with that embodiment or example, which are included in at least one embodiment or example of the present invention. In this specification, the illustrative expressions of the above terms do not necessarily refer to the same embodiment or example. Moreover, the specific features, structures, materials, or characteristics described may be combined in any suitable manner in one or more embodiments or examples. Furthermore, without contradiction, those skilled in the art can combine and integrate the different embodiments or examples described in this specification, as well as the features of different embodiments or examples.

[0098] Although preferred embodiments of the invention have been described, those skilled in the art, upon learning the basic inventive concept, can make other changes and modifications to these embodiments. Therefore, the claims should be interpreted to include both the preferred embodiments and all changes and modifications falling within the scope of the invention.

[0099] Obviously, those skilled in the art can make various modifications and variations to this invention without departing from its spirit and scope. Therefore, if these modifications and variations fall within the scope of the claims of this invention and their equivalents, then this invention should also include these modifications and variations.

Claims

1. A low-code development method, characterized in that, The low-code development method is applied to a server, and the server is configured with a file system and an interactive program that can be used to pull code. The low-code development method includes: The system receives a code compilation request from a first client, which carries a first storage path for the code file to be compiled. The first client has a low-code development tool (IDE) installed, which allows the first client to compile code in the IDE environment. The low-code development tool is configured with a plugin program that can perform code synchronization. The first storage path is the storage path of the code file to be compiled in the database. The code file to be compiled is either a raw code file or a custom code file. The custom code file is a code file written by the developer. Based on the code compilation request, the interactive program generates a notification message to notify the first client to pull the code file to be compiled, and sends the notification message to the client so that the client can respond with a code pull request carrying the second storage path of the code file to be compiled. The system receives the code retrieval request sent by the client, and based on the second storage path, searches for the code file to be compiled in the file system through the interactive program, and sends the code file to be compiled to the client through the interactive program, so that the first client can compile the code file to be compiled to obtain the compiled code file, and synchronizes the compiled code file to the database and the file system through the plug-in program; The plug-in program provides menu options for the user interface, allowing requests to the server to be initiated through these menu options. This enables bidirectional synchronization and version control between the code in the first client and the code on the server. The menu options include fetching all custom code from the server to overwrite the local code and pushing all custom code from the local code to the server.

2. The low-code development method according to claim 1, characterized in that, The first storage path is the storage path of the code file to be compiled in the database; The step of generating a notification message based on the code compilation request to notify the first client to pull the code file to be compiled includes: Based on the first storage path, the interactive program determines whether the code file to be compiled is occupied by a client other than the first client. If it is determined that the code file to be compiled is not occupied by the other client, the notification message is generated through the interactive program.

3. The low-code development method according to claim 2, characterized in that, The low-code development method further includes: If it is determined that the code file to be compiled is occupied by another client, a request failure message is sent to the first client through the interactive program to inform the first client that the code retrieval failed.

4. The low-code development method according to claim 1, characterized in that, The low-code development method further includes: The latest version number of the compiled code file is determined through the interactive program, and the latest version number is stored in the database.

5. A low-code development method, characterized in that, The low-code development method is applied to a first client with a low-code development tool installed, so that the first client can compile code in an IDE environment, and the low-code development tool is configured with a plugin program that can perform code synchronization; The low-code development method includes: A code compilation request carrying a first storage path of the code file to be compiled is generated and sent to the server, so that the server can generate a notification message to notify the first client to pull the code file to be compiled based on the code compilation request through an interactive program; wherein, the server is configured with a file system and the interactive program; Receive the notification message sent by the server; Based on the notification message, a code retrieval request carrying a second storage path is sent to the server, so that the server can locate the code file to be compiled from the file system through the interactive program based on the second storage path; The system receives the code file to be compiled sent by the server, compiles the code file to obtain the compiled code file, and synchronizes the compiled code file to the database and the file system through the plugin program. The plug-in program provides menu options for the user interface, allowing requests to the server to be initiated through these menu options. This enables bidirectional synchronization and version control between the code in the first client and the code on the server. The menu options include fetching all custom code from the server to overwrite the local code and pushing all custom code from the local code to the server.

6. The low-code development method according to claim 5, characterized in that, The first storage path is the storage path of the code file to be compiled in the database, and the notification message is generated by the server through the interactive program after determining that the code file to be compiled is not occupied by any client other than the first client.

7. The low-code development method according to claim 6, characterized in that, The low-code development method further includes: The server receives a request failure message to determine if the code retrieval failed; wherein the request failure message is generated by the server through the interactive program when the code file to be compiled is occupied by the other client.

8. The low-code development method according to claim 5, characterized in that, During the process of synchronizing the compiled code file to the database through the plugin program, the interactive program determines the latest version number of the compiled code file and updates the latest version number to the database.

9. A storage medium having a computer program stored thereon, characterized in that, The computer program is executed by the processor to perform the low-code development method as described in any one of claims 1-8.

10. An electronic device comprising a processor, a memory, and a computer program stored in the memory, characterized in that, The processor executes the computer program to implement the low-code development method as described in any one of claims 1-8.

Images