A low-code development method based on multi-person collaboration

Abstract

This application relates to a low-code file development method based on multi-person collaboration. It involves creating original files for different projects using a low-code platform; detecting and obtaining the original files to be edited, performing secondary editing to obtain secondary files, and submitting the secondary files; detecting whether there are conflicts between the secondary files and the original files, and resolving conflicts based on the Git conflict merging mechanism if conflicts exist. This method enables collaborative development of low-code applications on the same editing platform, allowing for editing of the developed application code before and after each node. It allows for version information matching checks and secondary editing, and after detecting conflicts between the secondary files and the original files, it uses the Git conflict merging mechanism to resolve conflicts. This method can quickly and effectively determine whether conflicts exist and alert users to resolve conflicts, thus avoiding conflicts in multi-person collaborative low-code development, ensuring consistency in code collaborative development, and improving usability.

Description

Technical Field

[0001] This disclosure relates to the field of software development technology, and in particular to a method, apparatus and control system for low-code file development based on multi-person collaboration. Background Technology

[0002] Low-code development refers to developing system applications using a small amount of code. In the field of low-code development, collaborative development by multiple people is often required.

[0003] Currently, collaboration solutions in the codebase field mainly include the following two types:

[0004] The first method is based on collaboration between different modules, with each person responsible for a different module, and the modules are finally assembled into an application. This method has the problem of lacking collaboration functions within the modules, which prevents multiple people from developing code in the same collaborative environment.

[0005] The second method is online document collaboration based on the OT algorithm. The advantage of this method is that it can display documents in real time; however, the disadvantages are that it is complex to implement, costly, has poor usability in the low-code domain, and still cannot enable multiple people to collaborate on the same page. Summary of the Invention

[0006] To address the aforementioned issues, this application proposes a low-code file development method, apparatus, and control system based on multi-user collaboration.

[0007] This application proposes a low-code file development method based on multi-person collaboration, including the following steps:

[0008] The low-code platform is used to create the original files for different projects and store these original files in a file management system.

[0009] The original file to be edited is detected and obtained, then edited to obtain a secondary file, which is then submitted.

[0010] The system checks whether there is a conflict between the secondary file and the original file. If there is a conflict, it resolves the conflict based on the Git conflict merging mechanism.

[0011] Once the problem is solved, the process will repeat until the project editing is complete.

[0012] As an optional implementation of this application, alternatively, original files for different projects are created through a low-code platform, and the original files are stored in a file management system, including:

[0013] Preset project creation rules;

[0014] According to the project creation rules, low-code source files for different projects are built through the VIS visual IoT development platform. The low-code source files of the projects contain the version information of the application.

[0015] Save the low-code source files of different projects to the file management system according to the preset file paths of different versions.

[0016] As an optional implementation of this application, optionally, the original file to be edited is detected and obtained, secondary editing is performed to obtain a secondary file, and the secondary file is submitted, including:

[0017] Identify the original file to be edited;

[0018] Based on the version information of the original file to be edited, detect whether a target file corresponding to the version information exists in the file management system:

[0019] If a target edit file corresponding to the version information exists, then the target edit file is obtained and parsed to obtain an edit parsing file;

[0020] The edited and parsed file is rendered and submitted to the editing page of the low-code platform on the front end;

[0021] Within the editing page, the file being edited is edited a second time to obtain a collaboratively edited secondary file, which is then submitted to the file management system.

[0022] As an optional implementation of this application, optionally, detecting and obtaining the original file to be edited, performing secondary editing to obtain a secondary file, and submitting the secondary file to the code layer, further includes:

[0023] Based on the version information of the original file to be edited, detect whether a target file corresponding to the version information exists in the file management system:

[0024] If the target edit file corresponding to the version information does not exist, the detection ends.

[0025] As an optional implementation of this application, optionally, a conflict is detected between the secondary file and the original file. If a conflict exists, the conflict is resolved based on the Git conflict merging mechanism, including:

[0026] Obtain the secondary file from the file management system;

[0027] Based on a conflict detection algorithm, the system detects whether there is a conflict between the secondary file and its corresponding original file.

[0028] If there is a conflict between the secondary file and its corresponding original file, the conflict is automatically merged using the Git conflict merging mechanism, and the resolved secondary file is committed and saved to the file management system.

[0029] As an optional implementation of this application, optionally, detecting whether there is a conflict between the secondary file and the original file, and if a conflict exists, resolving the conflict based on the Git conflict merging mechanism, further includes:

[0030] After automatic merging, check whether the aforementioned conflicts still exist:

[0031] If the conflict still exists, it will be reported to the front end and displayed for manual resolution. Once resolved, the user can return to the editing page to submit the changes.

[0032] As an optional implementation of this application, optionally, detecting whether there is a conflict between the secondary file and the original file, and if a conflict exists, resolving the conflict based on the Git conflict merging mechanism, further includes:

[0033] Based on a conflict detection algorithm, the system detects whether there is a conflict between the secondary file and its corresponding original file.

[0034] If there is no conflict between the secondary file and its corresponding original file, the detection ends and proceeds to the next step.

[0035] In another aspect, this application proposes an apparatus for implementing the aforementioned low-code file development method based on multi-user collaboration, comprising:

[0036] The VIS Visual IoT Development Module is used to create raw files for different projects through a low-code platform and store these raw files in a file management system.

[0037] The secondary editing module is used to detect and obtain the original file to be edited, perform secondary editing to obtain a secondary file, and submit the secondary file;

[0038] The conflict resolution module is used to detect whether there is a conflict between the secondary file and the original file. If there is a conflict, the conflict is resolved based on the Git conflict merging mechanism.

[0039] The collaborative loop module is used to cycle through the secondary editing steps after a problem is solved, until the project editing is completed.

[0040] In another aspect, this application also proposes a control system, comprising:

[0041] processor;

[0042] Memory used to store processor-executable instructions;

[0043] The processor is configured to implement the low-code file development method based on multi-user collaboration when executing the executable instructions.

[0044] Technical effects of the present invention:

[0045] Based on the implementation scheme of this application, this application uses a low-code platform to create original files for different projects and stores these original files in a file management system; it detects and retrieves the original files to be edited, performs secondary editing to obtain secondary files, and submits the secondary files; it detects whether there are conflicts between the secondary files and the original files, and if conflicts exist, it resolves the conflicts based on the Git conflict merging mechanism; after resolution, it loops through the secondary editing steps until the project editing is completed. This enables collaborative development of low-code applications on the same editing platform. The application code can be edited before and after each node, and matching checks and secondary editing can be performed based on version information. After detecting whether there are conflicts between the secondary files and the original files, the Git conflict merging mechanism is used to resolve conflicts, which can quickly and effectively determine whether there are conflicts and remind users to resolve the conflict points. This allows multiple people to collaborate on low-code development without conflicts, thereby ensuring the consistency of collaborative code development and improving usability.

[0046] Other features and aspects of this disclosure will become clear from the following detailed description of exemplary embodiments with reference to the accompanying drawings. Attached Figure Description

[0047] The accompanying drawings, which are included in and form part of this specification, illustrate exemplary embodiments, features, and aspects of this disclosure together with the specification and serve to explain the principles of this disclosure.

[0048] Figure 1 The diagram illustrates the implementation process of the low-code file development method based on multi-person collaboration according to the present invention.

[0049] Figure 2 The system shown is the application architecture of the present invention;

[0050] Figure 3 The diagram shows the timing steps of implementing the present invention. Detailed Implementation

[0051] Various exemplary embodiments, features, and aspects of this disclosure will now be described in detail with reference to the accompanying drawings. The same reference numerals in the drawings denote elements that have the same or similar functions. Although various aspects of the embodiments are shown in the drawings, they are not necessarily drawn to scale unless specifically indicated otherwise.

[0052] The term “exemplary” as used herein means “serving as an example, embodiment, or illustration.” Any embodiment illustrated herein as “exemplary” is not necessarily to be construed as superior to or better than other embodiments.

[0053] Furthermore, to better illustrate this disclosure, numerous specific details are set forth in the following detailed description. Those skilled in the art will understand that this disclosure can be practiced without certain specific details. In some instances, methods, means, components, and circuits well known to those skilled in the art have not been described in detail in order to highlight the main points of this disclosure.

[0054] Terminology Explanation:

[0055] Low-code: Developing system applications with minimal code;

[0056] DSL: Domain Design Language;

[0057] JSP files: JSP stands for Java Server Pages, a dynamic web page development technology;

[0058] VIS: VisualIOTStudio, is a low-level framework on an instruction set operating system and a tool for low-code tools (related information is provided in a separate patent).

[0059] Git: A code management tool.

[0060] Example 1

[0061] This application enables collaborative development of low-code applications on the same editing platform. The application code is edited before and after each node. It can perform matching detection and secondary editing based on version information. After detecting whether there are conflicts between the secondary file and the original file, the conflict merging mechanism of Git is used to resolve the conflict. This can quickly and effectively determine whether there are conflicts and remind the conflict points to be resolved. This allows multiple people to avoid conflicts in collaborative low-code development, thereby ensuring the consistency of code collaborative development and improving usability.

[0062] First, such as Figure 2 As shown, this application provides an application architecture for implementing this method.

[0063] The architecture includes:

[0064] 1. Components: Front-end components of the code designer, including multi-line text and single-line text, are the smallest units used to build code applications. In the visual editing page, such as the VIS visual IoT platform, several different functional components are configured. When editing code files for different projects, different functional components can be called to build and design the code files, depending on the configured components.

[0065] 2. Code layer, such as the JS layer: This describes the final generated file containing the underlying code, including types such as JS (meaning generated JavaScript code) and DSL (meaning the domain design language description document for the underlying code).

[0066] 3. File Management System: This system manages the files generated by the underlying code, including version control, path management, file management, and file storage. It is the main component for enabling multi-user collaboration within the underlying code. Applications built using the underlying code are ultimately stored as files, and multi-user collaboration is based on file-based conflict merging. The file management system can be an instruction set-based file management system.

[0067] Specifically, files are submitted through vis, which is a codebase tool. When the front-end is built with components, vis will directly convert the files into the corresponding file types. File submission is done by clicking the save button. The file is submitted to the backend via an HTTP RESTful API, and the backend will store and manage the file.

[0068] like Figure 1 As shown in this embodiment, collaborative editing of code from different projects is primarily performed within a visual low-code platform. The Git conflict merging mechanism is used to resolve conflicts detected between files before and after editing, allowing the next editing step to proceed. This method checks the edited work / files to ensure consistent usability of code files edited on the same editing page, avoiding inconsistencies in version / attributes between edited code files.

[0069] This application proposes a low-code file development method based on multi-person collaboration, including the following steps:

[0070] S1. Create original files for different projects using a low-code platform and store the original files in a file management system;

[0071] In this embodiment, the VIS visual IoT development platform is preferred for low-code file editing and application development.

[0072] All components can be converted into Javascript (JS) files, TypeScript (TS) files, CSS files, DSL description files, etc. via VIS. VIS is currently the self-developed low-code development tool for the instruction set.

[0073] As an optional implementation of this application, alternatively, original files for different projects are created through a low-code platform, and the original files are stored in a file management system, including:

[0074] Preset project creation rules;

[0075] According to the project creation rules, low-code source files for different projects are built through the VIS visual IoT development platform. The low-code source files of the projects contain the version information of the application.

[0076] Save the low-code source files of different projects to the file management system according to the preset file paths of different versions.

[0077] like Figure 3 As shown, firstly, before developing an application, programmers need to set the project creation principles for that application. Subsequent work will be carried out in accordance with these project creation principles. Therefore, the specific project creation principles are set according to the user's requirements for the application.

[0078] Secondly, programmers can utilize the above Figure 2 The VIS visual IoT development platform, as shown in the diagram, begins project creation, obtaining the original files for the first stage of the project. This involves editing the low-code files on the editing platform to obtain the original files for the first stage of the project. These original files are then stored in the file management system, with the storage path planned according to different version information.

[0079] The original code files obtained in the first stage of editing contain the application's development version information. This version information will be used for editing, testing, and verification in the next stage. Before the next stage of programming begins, this version information will be used to extract the corresponding file from the file management system, determine if a matching file (the file edited in the first stage) exists, and if so, extract it to the editing page for secondary editing, enabling collaborative programming and development.

[0080] S2. Detect and obtain the original file to be edited, perform secondary editing to obtain a secondary file, and submit the secondary file;

[0081] When a subsequent stage requires continuing the editing task from the previous step, the original file from the previous step needs to be retrieved from the file management system (database). This original file is the one to be edited. After retrieval, code development and editing for the next step can proceed. The original file to be edited is the file that the programmer determines needs to continue editing. This determination is based on the project type or application development project. Because application development requires assigning tasks to different application projects or modules simultaneously, once the original file to be edited is determined, the task will be retrieved from the database to continue editing.

[0082] As an optional implementation of this application, optionally, the original file to be edited is detected and obtained, secondary editing is performed to obtain a secondary file, and the secondary file is submitted, including:

[0083] Identify the original file to be edited;

[0084] Based on the version information of the original file to be edited, detect whether a target file corresponding to the version information exists in the file management system:

[0085] If a target edit file corresponding to the version information exists, then the target edit file is obtained and parsed to obtain an edit parsing file;

[0086] The edited and parsed file is rendered and submitted to the editing page of the low-code platform on the front end;

[0087] Within the editing page, the file being edited is edited a second time to obtain a collaboratively edited secondary file, which is then submitted to the file management system.

[0088] like Figure 3 As shown, once the original file to be edited is determined, which is the code project edited last time, this time we will continue to edit the original file for a second time. That is, the storage path is different for different projects and different application versions. We will check if the file exists. If it exists, we will parse the file and render the original file to the front end for a second edit.

[0089] Before editing, the system first checks whether the code file corresponding to the version information of the original file to be edited actually exists in the file management system to avoid code file loss. It also finds the correct editing code file from the file path corresponding to the version information and quickly locates the editing data package corresponding to the project in the file management system. Once the system detects the existence of the target editing file corresponding to the version information in the file management system, it parses and renders the target editing file and submits the parsed and rendered code file to the editing page of the low-code platform on the front end, ready for secondary editing.

[0090] At this point, programmers can perform secondary editing of the parsed file within the editing page, obtaining a collaboratively edited secondary file, which can then be submitted to the file management system. This completes one stage of file editing; after editing, the file can be saved for the next programming session, thus achieving collaborative development.

[0091] The specific implementation methods for the above parsing and rendering can be the same as those commonly used by programmers, and are not limited here.

[0092] As an optional implementation of this application, optionally, detecting and obtaining the original file to be edited, performing secondary editing to obtain a secondary file, and submitting the secondary file to the code layer, further includes:

[0093] Based on the version information of the original file to be edited, detect whether a target file corresponding to the version information exists in the file management system:

[0094] If the target edit file corresponding to the version information does not exist, the detection ends.

[0095] If, based on the version information, no corresponding original file is found in the file management system, it indicates that the previous programming file is missing, not saved, or not stored in the correct location in the file management system. In this case, the detection can be stopped and the current programming session can be abandoned.

[0096] S3. Detect whether there is a conflict between the secondary file and the original file. If there is a conflict, resolve the conflict based on the Git conflict merging mechanism.

[0097] After editing and submission, the page generates corresponding secondary files (JS, TS, CSS, etc.), and checks for conflicts between the secondary files and the original files.

[0098] If there is a conflict, the Git conflict merging mechanism will be used to resolve it, automatically merging the conflict; otherwise, the file version will be changed directly.

[0099] If conflicts persist after automatic merging, report them to the front-end page, resolve the conflicts manually, and then submit again.

[0100] like Figure 3 As shown, as an optional implementation of this application, optionally, a conflict is detected between the secondary file and the original file. If a conflict exists, the conflict is resolved based on the Git conflict merging mechanism, including:

[0101] Obtain the secondary file from the file management system;

[0102] Based on a conflict detection algorithm, the system detects whether there is a conflict between the secondary file and its corresponding original file.

[0103] If there is a conflict between the secondary file and its corresponding original file, the conflict is automatically merged using the Git conflict merging mechanism, and the resolved secondary file is committed and saved to the file management system.

[0104] The conflict detection algorithm is not limited in this embodiment. The Git conflict merging mechanism is existing technology, and can be found at: "https: / / blog.csdn.net / u011943534 / article / details / 83449402", which is not limited in this embodiment.

[0105] As an optional implementation of this application, optionally, detecting whether there is a conflict between the secondary file and the original file, and if a conflict exists, resolving the conflict based on the Git conflict merging mechanism, further includes:

[0106] After automatic merging, check whether the aforementioned conflicts still exist:

[0107] If the conflict still exists, it will be reported to the front end and displayed for manual resolution. Once resolved, the user can return to the editing page to submit the changes.

[0108] The conflict resolution solution using Git's conflict merging mechanism described above will not be repeated in this embodiment. The conflict handling process uses Git for both the conflict detection algorithm and the automatic conflict merging algorithm; however, the algorithm can be improved in the future.

[0109] For file conflicts detected after submission, the system will automatically resolve the conflicts. For conflicts that cannot be resolved automatically, the front end will display a message indicating that you should resolve them manually.

[0110] To ensure thorough conflict resolution, after automatic merging of conflicts, a second conflict check is performed. For conflicts that cannot be resolved automatically, the front end displays a prompt for manual resolution. Once resolved, the user returns to the editing page to submit.

[0111] As an optional implementation of this application, optionally, detecting whether there is a conflict between the secondary file and the original file, and if a conflict exists, resolving the conflict based on the Git conflict merging mechanism, further includes:

[0112] Based on a conflict detection algorithm, the system detects whether there is a conflict between the secondary file and its corresponding original file.

[0113] If there is no conflict between the secondary file and its corresponding original file, the detection ends and proceeds to the next step.

[0114] S4. Once the problem is solved, repeat the second editing step until the project editing is complete.

[0115] Using steps S2-S3 above, perform continuous collaborative programming and application code editing until the application / program project is completed.

[0116] Therefore, this application uses a low-code platform to create original files for different projects and stores these original files in a file management system. It detects and retrieves the original files to be edited, performs secondary editing to obtain secondary files, and submits these secondary files. It then checks for conflicts between the secondary files and the original files; if conflicts exist, they are resolved using the Git conflict merging mechanism. Once resolved, the process repeats until project editing is complete. This allows for collaborative development of low-code applications on the same editing platform. The application code can be edited before and after each node, and version information can be used for matching and secondary editing. After detecting conflicts between the secondary and original files, the Git conflict merging mechanism resolves the conflicts, quickly and effectively identifying and addressing them. This helps avoid conflicts in collaborative low-code development, ensuring consistency and improving usability.

[0117] Example 2

[0118] Based on the implementation principle of Embodiment 1, this application, in another aspect, proposes an apparatus for implementing the aforementioned low-code file development method based on multi-person collaboration, comprising:

[0119] The VIS Visual IoT Development Module is used to create raw files for different projects through a low-code platform and store these raw files in a file management system.

[0120] The secondary editing module is used to detect and obtain the original file to be edited, perform secondary editing to obtain a secondary file, and submit the secondary file;

[0121] The conflict resolution module is used to detect whether there is a conflict between the secondary file and the original file. If there is a conflict, the conflict is resolved based on the Git conflict merging mechanism.

[0122] The collaborative loop module is used to cycle through the secondary editing steps after a problem is solved, until the project editing is completed.

[0123] For details on the functions and application principles of each of the above modules, please refer to the description in Example 1. This example will not repeat them here.

[0124] Obviously, those skilled in the art should understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The program can be stored in a computer-readable storage medium, and when executed, it can include the processes of the embodiments of the control methods described above. The modules or steps of the present invention described above can be implemented using general-purpose computing devices. They can be centralized on a single computing device or distributed across a network of multiple computing devices. Optionally, they can be implemented using computer-executable program code, thereby storing them in a storage device for execution by a computing device, or fabricating them separately as individual integrated circuit modules, or fabricating multiple modules or steps into a single integrated circuit module. Thus, the present invention is not limited to any specific hardware and software combination.

[0125] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The program can be stored in a computer-readable storage medium, and when executed, it can include the processes of the embodiments of the control methods described above. The storage medium can be a magnetic disk, optical disk, read-only memory (ROM), random access memory (RAM), flash memory, hard disk drive (HDD), or solid-state drive (SSD), etc.; the storage medium can also include combinations of the above types of memory.

[0126] Example 3

[0127] Furthermore, this application also proposes a control system, comprising:

[0128] processor;

[0129] Memory used to store processor-executable instructions;

[0130] The processor is configured to implement the low-code file development method based on multi-user collaboration when executing the executable instructions.

[0131] This disclosure discloses an embodiment of a system including a processor and a memory for storing processor-executable instructions. The processor is configured to implement any of the preceding descriptions of a low-code file development method based on multi-user collaboration when executing the executable instructions.

[0132] It should be noted here that the number of processors can be one or more. Furthermore, the control system in this embodiment may also include input devices and output devices. The processors, memory, input devices, and output devices can be connected via a bus or other means, without specific limitations herein.

[0133] As a computer-readable storage medium, memory can be used to store software programs, computer-executable programs, and various modules, such as the program or module corresponding to the low-code file development method based on multi-user collaboration in this disclosure. The processor executes various functional applications and data processing of the control system by running the software programs or modules stored in the memory.

[0134] Input devices can be used to receive input digital numbers or signals. These signals can be key signals related to user settings and function control of the device / terminal / server. Output devices can include display devices such as screens.

[0135] The various embodiments of this disclosure have been described above. These descriptions are exemplary and not exhaustive, and are not limited to the disclosed embodiments. Many modifications and variations will be apparent to those skilled in the art without departing from the scope and spirit of the described embodiments. The terminology used herein is chosen to best explain the principles, practical applications, or technical improvements to the technology in the market, or to enable others skilled in the art to understand the embodiments disclosed herein.

Claims

1. A low-code file development method based on multi-user collaboration, characterized in that, Includes the following steps: The process involves creating source files for different projects using a low-code platform and storing these source files in a file management system. This includes: pre-setting project creation rules; building low-code source files for different projects using the VIS visual IoT development platform based on these rules, where each source file contains the application's version information; and saving the source files for different projects to the file management system according to preset file paths for different versions. Specifically: the first stage of low-code file editing begins on the editing platform, resulting in the source files for the first stage project, which are then stored in the file management system. During storage, paths are planned according to different version information. The source code files obtained in the first stage of editing contain the application's development version information, which will be used for editing detection and verification in the next stage. Before the next stage of programming begins, this version information is used to extract the corresponding file from the file management system, determine if a matching file (the first stage's edited file) exists, and if so, extract it to the editing page for secondary editing, enabling collaborative programming and development. The process of detecting and obtaining the original file to be edited, performing secondary editing to obtain a secondary file, and submitting the secondary file includes: determining the original file to be edited; detecting whether a target edit file corresponding to the version information of the original file to be edited exists in the file management system; if a target edit file corresponding to the version information exists, obtaining the target edit file and parsing it to obtain an edit parsing file; rendering the edit parsing file and submitting it to the editing page of the low-code platform on the front end; and performing secondary editing on the edit parsing file on the editing page to obtain a collaboratively edited secondary file. The secondary file is submitted to the file management system. Specifically, before editing, the version information of the original file to be edited is used to check whether the code file corresponding to the version information actually exists in the file management system, so as to avoid the loss of the code file. The correct editing code file is found from the file path corresponding to the version information. The editing data package corresponding to the project is quickly found in the file management system. That is, after detecting that the target editing file corresponding to the version information exists in the file management system, the target editing file is parsed and rendered, and the parsed and rendered code file is submitted to the editing page of the low-code platform on the front end for secondary editing. The system checks whether there is a conflict between the secondary file and the original file. If there is a conflict, it resolves the conflict based on the Git conflict merging mechanism. Once the problem is solved, the process will repeat until the project editing is complete.

2. The low-code file development method based on multi-person collaboration according to claim 1, characterized in that, The process includes detecting and obtaining the original file to be edited, performing secondary editing to obtain a secondary file, and submitting the secondary file to the code layer. Based on the version information of the original file to be edited, detect whether a target file corresponding to the version information exists in the file management system: If the target edit file corresponding to the version information does not exist, the detection ends.

3. The low-code file development method based on multi-person collaboration according to claim 1, characterized in that, The system checks whether there is a conflict between the secondary file and the original file. If a conflict exists, it resolves the conflict based on the Git conflict merging mechanism, including: Obtain the secondary file from the file management system; Based on a conflict detection algorithm, the system detects whether there is a conflict between the secondary file and its corresponding original file. If there is a conflict between the secondary file and its corresponding original file, the conflict is automatically merged using the Git conflict merging mechanism, and the resolved secondary file is committed and saved to the file management system.

4. The low-code file development method based on multi-person collaboration according to claim 3, characterized in that, Detection If the secondary file conflicts with the original file, and if so, the conflict is resolved based on the Git conflict merging mechanism, including: After automatic merging, check whether the aforementioned conflicts still exist: If the conflict still exists, it will be reported to the front end and displayed for manual resolution. Once resolved, the user can return to the editing page to submit the changes.

5. The low-code file development method based on multi-person collaboration according to claim 4, characterized in that, The process includes detecting whether the secondary file conflicts with the original file. If a conflict exists, it is resolved using the Git conflict merging mechanism, and further includes: Based on a conflict detection algorithm, the system detects whether there is a conflict between the secondary file and its corresponding original file. If there is no conflict between the secondary file and its corresponding original file, the detection ends and proceeds to the next step.

6. An apparatus for implementing the low-code file development method based on multi-person collaboration as described in any one of claims 1-5, characterized in that, include: The VIS Visual IoT Development Module is used to create raw files for different projects through a low-code platform and store these raw files in a file management system. The secondary editing module is used to detect and obtain the original file to be edited, perform secondary editing to obtain a secondary file, and submit the secondary file; The conflict resolution module is used to detect whether there is a conflict between the secondary file and the original file. If there is a conflict, the conflict is resolved based on the Git conflict merging mechanism. The collaborative loop module is used to cycle through the secondary editing steps after a problem is solved, until the project editing is completed.

7. A control system, characterized in that, include: processor; Memory used to store processor-executable instructions; The processor is configured to implement, when executing the executable instructions, a low-code file development method based on multi-person collaboration as described in any one of claims 1 to 5.

Images