Low-code online project debugging method and device, storage medium and terminal

Abstract

The invention discloses a low-code online project debugging method and device, a storage medium and a terminal, relates to the technical field of low-code online page development, and mainly aims to solve the problem of low efficiency of low-code online project debugging. The method mainly comprises the following steps: in response to a loading instruction of any page in a browser window of a target low-code online project, querying a page configuration adjustment file of a matched page from a client local database under a low-code platform through an inline framework homologous with the low-code platform, the page configuration adjustment file comprises configuration modification content of a to-be-debugged page; if the page configuration adjustment file matched with the page is queried, determining that the page is a to-be-debugged page, and pulling the page configuration adjustment file; and rendering a view page of the page in the browser window according to the page configuration adjustment file so as to execute page debugging operation in the production environment of the target low-code online project. The method and the device are mainly used for debugging published low-code online projects.

Description

Technical Field

[0001] The present invention relates to the technical field of low-code online page development, and in particular to a low-code online project debugging method and device, storage medium, and terminal. Background Art

[0002] Low-code page development is a method of creating online browsing system pages through a graphical interface and a small amount of coding. This method aims to lower the threshold of programming and allow non-professional developers to participate in the page development process, thereby improving development efficiency and reducing development costs. Although low-code page development brings a lot of convenience to development, it also poses challenges to the repair and debugging of low-code projects after they are launched.

[0003] Currently, after a low-code project goes online, if there is a problem, it needs to be repaired and tested in the development or test environment, and then released to the production environment after the test is completed. However, since the troubleshooting process is usually complicated, especially when the problem only occurs in specific scenarios and data conditions, the problem is difficult to show in the development and test environment. Therefore, the troubleshooting and repair of the problem often requires repeated release and online verification, and the verification process may cause more user-visible problems, which greatly reduces the efficiency of project problem debugging. Summary of the invention

[0004] In view of this, the present invention provides a low-code online project debugging method and device, storage medium, and terminal, the main purpose of which is to solve the problem of low efficiency of existing low-code online project debugging.

[0005] According to one aspect of the present invention, a low-code online project debugging method is provided, comprising:

[0006] In response to a loading instruction of any page in a browser window of a target low-code online project, a page configuration adjustment file matching the page is queried from a local database of a client under the low-code platform through an inline frame of the same origin as the low-code platform, wherein the inline frame shares a browser domain name with the low-code platform, and the page configuration adjustment file includes configuration modification content of the page to be debugged;

[0007] If a page configuration adjustment file matching the page is found, the page is determined to be a page to be debugged, and the page configuration adjustment file is retrieved;

[0008] The view page of the page is rendered in the browser window according to the page configuration adjustment file to perform debugging operations on the page in the production environment of the target low-code online project.

[0009] Furthermore, before querying a page configuration adjustment file matching the page from a local database of a client under the low-code platform through an inline frame homologous to the low-code platform, the method further includes:

[0010] Build HTML static resource files in the low-code platform server;

[0011] During the initialization process of the target low-code online project, an initial inline framework is constructed;

[0012] The properties of the initial inline frame are configured according to the file information of the HTML static resource file to obtain an inline frame that shares the browser domain name with the low-code platform, so that during the page loading process, the page configuration adjustment file in the client local database of the low-code platform can be called through the inline frame.

[0013] Furthermore, in response to a loading instruction of any page in the browser window of the target low-code online project, before querying a page configuration adjustment file matching the page from a client local database under the low-code platform through an inline frame homologous to the low-code platform, the method further includes:

[0014] Obtain the operation content of adjusting the page configuration of the page to be debugged in the target low-code online project in the low-code platform page designer;

[0015] Parsing the operation content, and generating a page configuration adjustment file according to the parsing result of the operation content;

[0016] The page configuration adjustment file is stored in the client local database under the low-code platform, so that when the browser window of the target low-code online project loads the page to be debugged, it retrieves the page configuration adjustment file that matches the page to be debugged.

[0017] Furthermore, after rendering the view page of the page in the browser window according to the page configuration adjustment file, the method further includes:

[0018] Monitoring the page configuration adjustment file in the client local database of the low-code platform through the inline frame;

[0019] If the page configuration adjustment file is updated, the updated page configuration adjustment file is pulled from the client local database;

[0020] According to the updated page configuration adjustment file, the updated debugging result of the page is rendered in the browser window.

[0021] Furthermore, before monitoring the page configuration adjustment file in the client local database of the low-code platform through the inline frame, the method further includes:

[0022] In response to an update configuration storage instruction in the low-code platform page designer, an updated page configuration adjustment file is generated according to the page configuration update operation content;

[0023] The updated page configuration adjustment file is updated and stored in the client local database, so that the target low-code online project refreshes the page according to the updated configuration adjustment file of the page to be debugged.

[0024] Furthermore, the method further comprises:

[0025] If the page configuration adjustment file is not found, the page is determined to be a non-debugging page, and a deployed page configuration file matching the page is pulled from the low-code platform server;

[0026] The loading result of the page is rendered in the browser window according to the deployed page configuration file.

[0027] Furthermore, after rendering the view page of the page in the browser window according to the page configuration adjustment file, the method further includes:

[0028] In response to a page configuration cancellation instruction, deleting the page configuration adjustment file from the client local database; or,

[0029] In response to the page configuration publishing instruction, the page configuration adjustment file is deployed to the low-code platform server, and the page configuration adjustment file is deleted from the client local database.

[0030] According to another aspect of the present invention, a low-code online project debugging device is provided, comprising:

[0031] A query module, for responding to a loading instruction of any page in a browser window of a target low-code online project, querying a page configuration adjustment file matching the page from a client local database under the low-code platform through an inline frame homologous to the low-code platform, wherein the inline frame shares a browser domain name with the low-code platform, and the page configuration adjustment file includes configuration modification content of the page to be debugged;

[0032] A pulling module, configured to determine that the page is a page to be debugged and pull the page configuration adjustment file if a page configuration adjustment file matching the page is found;

[0033] A rendering module is used to render the view page of the page in the browser window according to the page configuration adjustment file, so as to perform debugging operations on the page in the production environment of the target low-code online project.

[0034] Furthermore, the device also includes:

[0035] The first building module is used to build HTML static resource files in the low-code platform server;

[0036] A second construction module is used to construct an initial inline framework during the initialization process of the target low-code online project;

[0037] A configuration module is used to configure the properties of the initial inline frame according to the file information of the HTML static resource file, and obtain an inline frame that shares a browser domain name with the low-code platform, so that during the page loading process, the page configuration adjustment file in the client local database of the low-code platform can be called through the inline frame.

[0038] Furthermore, the device also includes:

[0039] An acquisition module is used to obtain the operation content of adjusting the page configuration of the page to be debugged in the target low-code online project in the low-code platform page designer;

[0040] A first generating module, used for parsing the operation content, and generating a page configuration adjustment file according to the parsing result of the operation content;

[0041] The first storage module is used to store the page configuration adjustment file in the client local database under the low-code platform, so that when the browser window of the target low-code online project loads the page to be debugged, it calls the page configuration adjustment file that matches the page to be debugged.

[0042] Furthermore, the device also includes a monitoring module;

[0043] A monitoring module, used to monitor the page configuration adjustment file in the client local database of the low-code platform through the inline frame;

[0044] The pulling module is used to pull the updated page configuration adjustment file from the client local database if the page configuration adjustment file is updated;

[0045] The rendering module is further used to render the updated debugging result of the page in the browser window according to the updated page configuration adjustment file.

[0046] Furthermore, the device also includes:

[0047] A second generation module is used to generate an updated page configuration adjustment file according to the page configuration update operation content in response to the update configuration storage instruction in the low-code platform page designer;

[0048] The second storage module updates and stores the updated page configuration adjustment file in the client local database, so that the target low-code online project refreshes the page according to the updated page configuration adjustment file to be debugged.

[0049] Furthermore, the pulling module is also used to determine that the page is a non-debugging page if the page configuration adjustment file is not found, and pull a deployed page configuration file matching the page from the low-code platform server;

[0050] The rendering module is further used to render the loading result of the page in the browser window according to the deployed page configuration file.

[0051] Furthermore, the device also includes:

[0052] a deleting module, configured to delete the page configuration adjustment file from the client local database in response to a page configuration revocation instruction; or

[0053] A deployment module is used to deploy the page configuration adjustment file to the low-code platform server in response to a page configuration publishing instruction, and delete the page configuration adjustment file from the client local database.

[0054] According to another aspect of the present invention, a storage medium is provided, in which at least one executable instruction is stored, and the executable instruction enables a processor to perform operations corresponding to the above-mentioned low-code online project debugging method.

[0055] According to another aspect of the present invention, there is provided a terminal, comprising: a processor, a memory, a communication interface and a communication bus, wherein the processor, the memory and the communication interface communicate with each other via the communication bus;

[0056] The memory is used to store at least one executable instruction, and the executable instruction enables the processor to perform operations corresponding to the above-mentioned low-code online project debugging method.

[0057] By means of the above technical solution, the technical solution provided by the embodiment of the present invention has at least the following advantages:

[0058] The present invention provides a low-code online project debugging method and device, storage medium, and terminal. The embodiment of the present invention responds to a loading instruction of any page in a browser window of a target low-code online project, and queries a page configuration adjustment file matching the page from a client local database under a low-code platform through an inline frame homologous to the low-code platform, wherein the inline frame shares a browser domain name with the low-code platform, and the page configuration adjustment file includes configuration modification content of the page to be debugged; if a page configuration adjustment file matching the page is queried, the page is determined to be a page to be debugged, and the page configuration adjustment file is pulled; the view page of the page is rendered in the browser window according to the page configuration adjustment file, so as to perform debugging operations on the page in the production environment of the target low-code online project, and on the basis that the debugging process page is invisible to external users, page debugging in the production environment of the low-code online project is realized, the accuracy of project debugging is improved, and the time of project debugging is greatly reduced. At the same time, the accuracy of project debugging is ensured, thereby greatly improving the efficiency of project debugging.

[0059] The above description is only an overview of the technical solution of the present invention. In order to more clearly understand the technical means of the present invention, it can be implemented in accordance with the contents of the specification. In order to make the above and other purposes, features and advantages of the present invention more obvious and easy to understand, the specific implementation methods of the present invention are listed below. BRIEF DESCRIPTION OF THE DRAWINGS

[0060] Various other advantages and benefits will become apparent to those of ordinary skill in the art by reading the detailed description of the preferred embodiments below. The accompanying drawings are only for the purpose of illustrating the preferred embodiments and are not to be considered as limiting the present invention. Moreover, the same reference symbols are used throughout the accompanying drawings to represent the same components. In the accompanying drawings:

[0061] Figure 1 A flow chart of a low-code online project debugging method provided by an embodiment of the present invention is shown;

[0062] Figure 2 Another flow chart of a low-code online project debugging method provided by an embodiment of the present invention is shown;

[0063] Figure 3 A schematic diagram of a process of debugging an application example of a low-code online project provided by an embodiment of the present invention is shown;

[0064] Figure 4 A block diagram of a low-code online project debugging device provided by an embodiment of the present invention is shown;

[0065] Figure 5 A schematic diagram of the structure of a terminal provided by an embodiment of the present invention is shown. DETAILED DESCRIPTION

[0066] The exemplary embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. Although exemplary embodiments of the present disclosure are shown in the accompanying drawings, it should be understood that the present disclosure can be implemented in various forms and should not be limited by the embodiments set forth herein. On the contrary, these embodiments are provided to enable a more thorough understanding of the present disclosure and to fully convey the scope of the present disclosure to those skilled in the art.

[0067] Aiming at the problem of low debugging efficiency of existing low-code online projects. The embodiment of the present invention provides a low-code online project debugging method, such as Figure 1 As shown, the method includes:

[0068] 101. In response to a loading instruction of any page in the browser window of the target low-code online project, a page configuration adjustment file matching the page is queried from the client local database under the low-code platform through an inline frame homologous to the low-code platform.

[0069] In the embodiment of the present invention, the target low-code online project is a low-code online project that needs to be debugged, and the browser page contained therein is based on the low-code platform and is designed by low-code configuration. The business scope involved in the low-code online project can be any business in the field of insurance, finance, enterprise management, etc., and the embodiment of the present invention does not make specific limitations. The inline frame of the same origin as the low-code platform shares the browser domain name with the low-code platform, that is, the homologous object of the inline frame is the low-code platform, and this inline frame shares the client local database (IndexedDB) under the same domain name browser with the low-code platform. Among them, IndexedDB is a transactional (non-relational) database implemented by the browser, allowing web scripts to be created and operated, and is used to store a large amount of structured data (including files / binary large objects blobs) on the client, supporting GB-level storage capacity, and supporting transaction operations and indexing, making data query more efficient. The page configuration adjustment file includes the configuration modification content of the page to be debugged, that is, when the operation and maintenance personnel debug a page in the target low-code online project, the page configuration of this page is modified and adjusted by the low-code platform to obtain the file.

[0070] It should be noted that the client's local database complies with the same-origin policy. Only under the same domain name (including subdomains) can the IndexedDB under the domain name be accessed and operated. If the Uniform Resource Locators (URLs) of two web pages have the same protocol, domain name, and port, the pages can share the same IndexedDB. The inline frame is equivalent to embedding a component for sharing the client's local database under the low-code platform in the target low-code online project, so that when the target low-code online project loads a page, it can call the page configuration adjustment file configured by the low-code platform and run it in the production environment of the target low-code online project, thereby realizing page debugging in the online production environment.

[0071] 102. If a page configuration adjustment file matching the page is found, the page is determined to be a page to be debugged, and the page configuration adjustment file is retrieved.

[0072] In an embodiment of the present invention, the target low-code online project consists of multiple pages, and project problems may only appear in individual pages, that is, not all pages in the project are pages that need to be modified and debugged. However, as a complete online project, the project testing process needs to test all pages in the project. The page loaded in the browser window may be a page to be debugged, or it may not be a page to be debugged, that is, a non-debugging page, and the page to be debugged is a corresponding page configuration adjustment file stored in the client local database. Therefore, when the page is loaded, it is necessary to first query the client local database whether there is a matching page configuration adjustment file for the current page. If so, pull the page configuration adjustment file out from the client local database. Among them, the page configuration adjustment file can be stored in a sub-database in the client local database. For example, a sub-database named "lowcodeLocalJson" is created in advance under IndexedDB, and the generated page configuration adjustment files are all stored in this sub-database.

[0073] 103. Render the view page of the page in the browser window according to the page configuration adjustment file, so as to perform debugging operations on the page in the production environment of the target low-code online project.

[0074] In an embodiment of the present invention, the essence of the page configuration adjustment file is a json file. In the process of rendering the page to the browser window according to the page configuration adjustment file, the rendering engine consumes the corresponding component materials of the component material center under the low-code platform according to the json string in the page configuration adjustment file to render a view page corresponding to the content configured in the page configuration adjustment file. Among them, the component materials contained in the component material center include but are not limited to "Button", "GridContainer", "Image", "Form", "Searchs", "Input", "Text", "Select", "Table", etc. After displaying this view page, the operation and maintenance personnel can debug the relevant functions of the page in this view page. Since the browser window of the target low-code online project is the production environment of the target low-code online project, page debugging in this environment can make the debugging environment of the page consistent with the actual operating environment of the page, which is more convenient to quickly and accurately discover page problems, greatly reducing the debugging time of the project, thereby improving the debugging efficiency of the project.

[0075] It should be noted that by using inline frames to pull page configuration adjustment files that have not been deployed online in the low-code platform environment, and loading the adjustment content of the current page configuration into the production environment of the target low-code online project, the page modification content in the test phase can be run in the production environment of the low-code online project. At the same time, since the page configuration adjustment file has not been deployed online, the view page corresponding to the current page configuration adjustment file is only displayed in the browser window of the current client of the operation and maintenance personnel. When other clients display this page to be debugged, they can only load the page configuration file version of this page to be debugged that has been deployed online from the low-code platform server. That is, the view page corresponding to the page configuration adjustment file is invisible to users other than those who submitted the page configuration adjustment file, and will not have any impact on the browsing experience of users other than the operation and maintenance personnel. On the basis of meeting the needs of page debugging in the production environment, the debugging process is invisible to users, ensuring the user's project usage experience.

[0076] In an embodiment of the present invention, for further explanation and limitation, as Figure 2 As shown, in step 101, in response to a loading instruction of any page in the browser window of the target low-code online project, before querying a page configuration adjustment file matching the page from a client local database under the low-code platform through an inline frame homologous to the low-code platform, the method further includes:

[0077] 201. Build HTML static resource files in the low-code platform server.

[0078] 202. During the initialization process of the target low-code online project, an initial inline framework is constructed.

[0079] 203. Configure the properties of the initial inline frame according to the file information of the HTML static resource file to obtain an inline frame that shares the browser domain name with the low-code platform, so that during the page loading process, the page configuration adjustment file in the client local database of the low-code platform can be called through the inline frame.

[0080] In an embodiment of the present invention, in order to achieve the same origin as the target low-code online project and the low-code platform. Create an HTML (HyperText Markup Language) static resource file in the low-code platform server, for example, store an HTML static resource file named localDebugChannel.html. And when the target low-code online project is initialized, create an initial inline frame, and set the HTML static resource file as the attribute of the initial inline frame. Specifically, the initial inline frame can be an iframe (Inline Frame). Iframe is an element (tag) in HTML, that is, an inline frame, and its src attribute is used to specify the address of the page to be embedded. By configuring the src attribute of the iframe as the HTML static resource file of the low-code platform, the target low-code online project and the low-code platform can share the IndexedDB database under the browser with the same domain name.

[0081] It should be noted that in the prior art, the page configuration files loaded by the browser window of the target low-code online project are all published files deployed in the low-code platform server. By configuring an inline frame with the same origin as the low-code platform in the target low-code online project, the page configuration adjustment file that has not been deployed during the debugging phase is retrieved, so that the view page after the page configuration adjustment is displayed in the production environment of the target low-code online project, and the operation and maintenance personnel can perform page debugging in the view page.

[0082] In one embodiment of the present invention, for further explanation and limitation, before the step of responding to a loading instruction of any page in the browser window of the target low-code online project, querying a page configuration adjustment file matching the page from a client local database under the low-code platform through an inline frame homologous to the low-code platform, the method further includes:

[0083] Obtain the operation content of adjusting the page configuration of the page to be debugged in the target low-code online project in the low-code platform page designer;

[0084] Analyzing the operation content, and generating a page configuration adjustment file according to the analysis result of the operation content;

[0085] The page configuration adjustment file is stored in the client local database under the low-code platform, so that when the browser window of the target low-code online project loads the page to be debugged, it retrieves the page configuration adjustment file that matches the page to be debugged.

[0086] In an embodiment of the present invention, the project operation and maintenance personnel configure and modify the page (to be debugged page) that needs to be debugged in the target low-code online project through the low-code platform page designer. Specifically, the project operation and maintenance personnel can modify and adjust the original configuration of the page to be adjusted by dragging, pulling, and dragging the components in the configuration page or component tree in the visual interface of the low-code platform page designer, and after completing the adjustment, click the "Save" button of the low-code platform page designer. In response to the save instruction, the configuration content of the modification and adjustment represented by the operation content is parsed, and a page configuration adjustment file is generated according to the modified and adjusted configuration content, and the page configuration adjustment file is stored in the client local database, that is, the local database corresponding to the client that currently configures and adjusts the debugging page through the low-code platform page designer, and this local database can only be accessed through the current client. Among them, the client can be a desktop computer, a laptop computer, a smart mobile device, etc., which is not specifically limited in the embodiment of the present invention. By configuring and modifying the debugging page through the low-code platform page designer, the professional level requirements of the personnel who modify the page can be greatly reduced, and the convenience and efficiency of page configuration modification can be improved.

[0087] In one embodiment of the present invention, for further explanation and limitation, after rendering the view page of the page in the browser window according to the page configuration adjustment file, the method further includes:

[0088] Monitoring the page configuration adjustment file in the client local database of the low-code platform through the inline frame;

[0089] If the page configuration adjustment file is updated, the updated page configuration adjustment file is pulled from the client local database;

[0090] According to the updated page configuration adjustment file, the updated debugging result of the page is rendered in the browser window.

[0091] In an embodiment of the present invention, the client local database is also configured with a monitoring component for monitoring data changes in the database. Taking IndexedDB as an example, IndexedDB is configured with an encapsulation library "Dexie" and an extension library "Dexie-Observable" of "Dexie". The specific monitoring process includes: monitoring the page configuration adjustment file in the client local database through "Dexie" and "Dexie-Observable". Once the page configuration adjustment file is detected to have changed, window.parent.postMessage is called to send an event of type "updatePage" to the browser window where the target low-code online project is located. The root component App.vue of the target low-code online project will monitor the "message" event of window when loading. If the "message" event is received, the page configuration adjustment file stored in the client local database is obtained, and the page configuration adjustment file is sent to the target low-code online project through an event of type "replyLocalJson" to refresh the page to be debugged to a page that matches the updated page configuration adjustment file, so as to achieve hot update of the page to be debugged. By configuring the monitoring function, the page to be debugged can be hot updated, so that the project operation and maintenance personnel can automatically load and refresh the current page to be debugged after adjusting the page configuration file, greatly improving the debugging efficiency of the page.

[0092] In one embodiment of the present invention, for further explanation and limitation, before the step of monitoring the page configuration adjustment file in the client local database of the low-code platform through the inline frame, the method further includes:

[0093] In response to an update configuration storage instruction in the low-code platform page designer, an updated page configuration adjustment file is generated according to the page configuration update operation content;

[0094] The updated page configuration adjustment file is updated and stored in the client local database, so that the target low-code online project refreshes the page according to the updated configuration adjustment file of the page to be debugged.

[0095] In an embodiment of the present invention, project operation and maintenance personnel can update the configuration content in the configuration page corresponding to the page configuration adjustment file through the low-code platform page designer, for example, changing the original "Input" in the configuration page to "Select". After completing the configuration update, generate an update configuration storage instruction by clicking the "Save" or "Update" button. In response to the update configuration storage instruction, obtain the page configuration update operation content, and parse the page configuration update operation content to obtain the configuration page update content, and generate an updated page configuration adjustment file based on the configuration page update content. After the updated page configuration adjustment file is generated, it is stored in the client local database to update and replace the page configuration adjustment file.

[0096] It should be noted that the page configuration often needs to be adjusted repeatedly during page debugging. By configuring the page content through the low-code platform page designer, the convenience of page configuration adjustment can be improved. In addition, the automatic update of the page configuration adjustment file stored in the client's local database, combined with the database monitoring function, can realize the automatic refresh of the page after the page configuration adjustment, thereby greatly reducing the operation of the operation and maintenance personnel and improving the efficiency of page debugging.

[0097] In an embodiment of the present invention, for further explanation and limitation, the method further includes:

[0098] If the page configuration adjustment file is not found, the page is determined to be a non-debugging page, and a deployed page configuration file matching the page is pulled from the low-code platform server;

[0099] The loading result of the page is rendered in the browser window according to the deployed page configuration file.

[0100] In the embodiment of the present invention, if the page configuration adjustment file is not found in the local database of the client, that is, the page configuration of the current page has not been adjusted, it indicates that the current page is a non-debugging page. At this time, in order to display this page, it is necessary to pull the deployed page configuration file (deployed page configuration file) matching the current page from the low-code platform server, and render the components contained in the deployed page configuration file through the rendering engine to obtain the loading result of the current page.

[0101] In one embodiment of the present invention, for further explanation and limitation, after rendering the view page of the page in the browser window according to the page configuration adjustment file, the method further includes:

[0102] In response to a page configuration cancellation instruction, deleting the page configuration adjustment file from the client local database; or,

[0103] In response to the page configuration publishing instruction, the page configuration adjustment file is deployed to the low-code platform server, and the page configuration adjustment file is deleted from the client local database.

[0104] In an embodiment of the present invention, after the view page of the current page is displayed in the browser window, the project operation and maintenance personnel perform page debugging, and the results of the debugging include meeting expectations and not meeting expectations. If after debugging, it is considered that the current configuration adjustment content meets expectations, you can choose to publish this page configuration adjustment file to be deployed in the low-code platform server; if after debugging, it is considered that the current configuration adjustment content does not meet expectations, you can delete this page configuration adjustment file. The page configuration undo instruction can be triggered by options or buttons such as "Undo", "Return", and "Cancel Save"; the page configuration publish instruction can be triggered by options or buttons such as "Submit" and "Publish", which are not specifically limited in the embodiment of the present invention.

[0105] It should be noted that when the page configuration adjustment file is deployed to the low-code platform server, the page configuration adjustment file is also deleted from the client's local database to avoid the page configuration adjustment file of the successfully debugged page when the page is loaded next time, and the client's local database stores too many useless files, resulting in unnecessary consumption of storage resources and waste of running resources in the file query process.

[0106] In an application example of the present application, Figure 3 As shown, on the low-code platform side, users can edit the configuration page of the page through the page designer, and through the "Save", "Submit" and "Undo" buttons, choose to store the page configuration adjustment file in the client local database (IndexedDB) under the low-code platform domain name, delete the page configuration adjustment file from this IndexedDB, and push the page configuration adjustment file to the low-code platform server. On the low-code online project side, an inline frame (Iframe) is created according to the build strategy in the entry file (main.js), and when the page needs to be loaded, the page configuration adjustment file is obtained from the client local database through Iframe according to the execution strategy in the entry file, or the deployed page configuration file is pulled from the low-code platform server, and the page configuration adjustment file or the deployed page configuration file is transferred to the project root component to render the page. In addition, the project root component (App.vue) also listens for messages indicating that files in the client local database have been updated. When this message is listened, the updated page configuration adjustment file is obtained from the client local database through Iframe for hot page updates.

[0107] The present invention provides a low-code online project debugging method. An embodiment of the present invention responds to a loading instruction of any page in a browser window of a target low-code online project, and queries a page configuration adjustment file matching the page from a client local database under the low-code platform through an inline frame homologous to the low-code platform, wherein the inline frame shares a browser domain name with the low-code platform, and the page configuration adjustment file includes configuration modification content of the page to be debugged; if a page configuration adjustment file matching the page is queried, the page is determined to be a page to be debugged, and the page configuration adjustment file is pulled; the view page of the page is rendered in the browser window according to the page configuration adjustment file, so as to perform debugging operations on the page in the production environment of the target low-code online project, and on the basis that the debugging process page is invisible to external users, page debugging in the production environment of the low-code online project is implemented, thereby improving the accuracy of project debugging, greatly reducing the time of project debugging, and at the same time ensuring the accuracy of project debugging, thereby greatly improving the efficiency of project debugging. Further, as an improvement to the above Figure 1 The implementation of the method shown in the figure, the embodiment of the present invention provides a low-code online project debugging device, such as Figure 4 As shown, the device comprises:

[0108] A query module 31 is used to respond to a loading instruction of any page in a browser window of a target low-code online project, and query a page configuration adjustment file matching the page from a client local database under the low-code platform through an inline frame of the same origin as the low-code platform, wherein the inline frame shares a browser domain name with the low-code platform, and the page configuration adjustment file includes configuration modification content of the page to be debugged;

[0109] A pulling module 32, configured to determine that the page is a page to be debugged and pull the page configuration adjustment file if a page configuration adjustment file matching the page is found;

[0110] The rendering module 33 is used to render the view page of the page in the browser window according to the page configuration adjustment file, so as to perform debugging operations on the page in the production environment of the target low-code online project.

[0111] Furthermore, the device also includes:

[0112] The first building module is used to build HTML static resource files in the low-code platform server;

[0113] A second construction module is used to construct an initial inline framework during the initialization process of the target low-code online project;

[0114] A configuration module is used to configure the properties of the initial inline frame according to the file information of the HTML static resource file, and obtain an inline frame that shares a browser domain name with the low-code platform, so that during the page loading process, the page configuration adjustment file in the client local database of the low-code platform can be called through the inline frame.

[0115] Furthermore, the device also includes:

[0116] An acquisition module is used to obtain the operation content of adjusting the page configuration of the page to be debugged in the target low-code online project in the low-code platform page designer;

[0117] A first generating module, used for parsing the operation content, and generating a page configuration adjustment file according to the parsing result of the operation content;

[0118] The first storage module is used to store the page configuration adjustment file in the client local database under the low-code platform, so that when the browser window of the target low-code online project loads the page to be debugged, it calls the page configuration adjustment file that matches the page to be debugged.

[0119] Furthermore, the device also includes a monitoring module;

[0120] A monitoring module, used to monitor the page configuration adjustment file in the client local database of the low-code platform through the inline frame;

[0121] The pulling module 32 is used to pull the updated page configuration adjustment file from the client local database if the page configuration adjustment file is updated;

[0122] The rendering module 33 is further configured to render the updated debugging result of the page in the browser window according to the updated page configuration adjustment file.

[0123] Furthermore, the device also includes:

[0124] A second generation module is used to generate an updated page configuration adjustment file according to the page configuration update operation content in response to the update configuration storage instruction in the low-code platform page designer;

[0125] The second storage module updates and stores the updated page configuration adjustment file in the client local database, so that the target low-code online project refreshes the page according to the updated page configuration adjustment file to be debugged.

[0126] Furthermore, the pulling module is also used to determine that the page is a non-debugging page if the page configuration adjustment file is not found, and pull a deployed page configuration file matching the page from the low-code platform server;

[0127] The rendering module is further used to render the loading result of the page in the browser window according to the deployed page configuration file.

[0128] Furthermore, the device also includes:

[0129] a deleting module, configured to delete the page configuration adjustment file from the client local database in response to a page configuration revocation instruction; or

[0130] A deployment module is used to deploy the page configuration adjustment file to the low-code platform server in response to a page configuration publishing instruction, and delete the page configuration adjustment file from the client local database.

[0131] The present invention provides a low-code online project debugging device. An embodiment of the present invention responds to a loading instruction of any page in a browser window of a target low-code online project, and queries a page configuration adjustment file matching the page from a client local database under a low-code platform through an inline frame homologous to the low-code platform, wherein the inline frame shares a browser domain name with the low-code platform, and the page configuration adjustment file includes configuration modification content of the page to be debugged; if a page configuration adjustment file matching the page is queried, the page is determined to be a page to be debugged, and the page configuration adjustment file is pulled; the view page of the page is rendered in the browser window according to the page configuration adjustment file, so as to perform debugging operations on the page in the production environment of the target low-code online project, and on the basis that the debugging process page is invisible to external users, page debugging in the production environment of the low-code online project is realized, the accuracy of project debugging is improved, and the time of project debugging is greatly reduced. At the same time, the accuracy of project debugging is ensured, thereby greatly improving the efficiency of project debugging.

[0132] According to one embodiment of the present invention, a storage medium is provided, wherein the storage medium stores at least one executable instruction, and the computer executable instruction can execute the low-code online project debugging method in any of the above method embodiments.

[0133] Figure 5 A schematic diagram of the structure of a terminal provided according to an embodiment of the present invention is shown. The specific embodiment of the present invention does not limit the specific implementation of the terminal.

[0134] like Figure 5As shown, the terminal may include: a processor (processor) 402 , a communication interface (Communications Interface) 404 , a memory (memory) 406 , and a communication bus 408 .

[0135] The processor 402 , the communication interface 404 , and the memory 406 communicate with each other via a communication bus 408 .

[0136] The communication interface 404 is used for network communication with other devices such as a client or other servers.

[0137] Processor 402 is used to execute program 410, and can specifically execute the relevant steps in the above-mentioned low-code online project debugging method embodiment.

[0138] Specifically, the program 410 may include program codes, which include computer operation instructions.

[0139] The processor 402 may be a central processing unit (CPU), or an application-specific integrated circuit (ASIC), or one or more integrated circuits configured to implement the embodiment of the present invention. The one or more processors included in the terminal may be processors of the same type, such as one or more CPUs; or processors of different types, such as one or more CPUs and one or more ASICs.

[0140] The memory 406 is used to store the program 410. The memory 406 may include a high-speed RAM memory, and may also include a non-volatile memory (non-volatile memory), such as at least one disk memory.

[0141] The program 410 may be specifically configured to enable the processor 402 to perform the following operations:

[0142] In response to a loading instruction of any page in a browser window of a target low-code online project, a page configuration adjustment file matching the page is queried from a local database of a client under the low-code platform through an inline frame of the same origin as the low-code platform, wherein the inline frame shares a browser domain name with the low-code platform, and the page configuration adjustment file includes configuration modification content of the page to be debugged;

[0143] If a page configuration adjustment file matching the page is found, the page is determined to be a page to be debugged, and the page configuration adjustment file is retrieved;

[0144] The view page of the page is rendered in the browser window according to the page configuration adjustment file to perform debugging operations on the page in the production environment of the target low-code online project.

[0145] Obviously, those skilled in the art should understand that the above modules or steps of the present invention can be implemented by a general computing device, they can be concentrated on a single computing device, or distributed on a network composed of multiple computing devices, and optionally, they can be implemented by a program code executable by a computing device, so that they can be stored in a storage device and executed by the computing device, and in some cases, the steps shown or described can be executed in a different order than here, or they can be made into individual integrated circuit modules, or multiple modules or steps therein can be made into a single integrated circuit module for implementation. Thus, the present invention is not limited to any specific combination of hardware and software.

[0146] The above description is only a preferred embodiment of the present invention and is not intended to limit the present invention. For those skilled in the art, the present invention may have various modifications and variations. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present invention shall be included in the protection scope of the present invention.

Claims

1. A low-code online project debugging method, characterized in that: include: In response to a loading instruction of any page in a browser window of a target low-code online project, a page configuration adjustment file matching the page is queried from a local database of a client under the low-code platform through an inline frame of the same origin as the low-code platform, wherein the inline frame shares a browser domain name with the low-code platform, and the page configuration adjustment file includes configuration modification content of the page to be debugged; If a page configuration adjustment file matching the page is found, the page is determined to be a page to be debugged, and the page configuration adjustment file is retrieved; The view page of the page is rendered in the browser window according to the page configuration adjustment file to perform debugging operations on the page in the production environment of the target low-code online project.

2. The method according to claim 1, characterized in that Before responding to a loading instruction of any page in a browser window of a target low-code online project and querying a page configuration adjustment file matching the page from a client local database under the low-code platform through an inline frame homologous to the low-code platform, the method further includes: Build HTML static resource files in the low-code platform server; During the initialization process of the target low-code online project, an initial inline framework is constructed; The properties of the initial inline frame are configured according to the file information of the HTML static resource file to obtain an inline frame that shares the browser domain name with the low-code platform, so that during the page loading process, the page configuration adjustment file in the client local database of the low-code platform can be called through the inline frame.

3. The method according to claim 2, characterized in that Before responding to a loading instruction of any page in a browser window of a target low-code online project and querying a page configuration adjustment file matching the page from a client local database under the low-code platform through an inline frame homologous to the low-code platform, the method further includes: Obtain the operation content of adjusting the page configuration of the page to be debugged in the target low-code online project in the low-code platform page designer; Parsing the operation content, and generating a page configuration adjustment file according to the parsing result of the operation content; The page configuration adjustment file is stored in the client local database under the low-code platform, so that when the browser window of the target low-code online project loads the page to be debugged, it retrieves the page configuration adjustment file that matches the page to be debugged.

4. The method according to claim 1, characterized in that: After rendering the view page of the page in the browser window according to the page configuration adjustment file, the method further includes: Monitoring the page configuration adjustment file in the client local database of the low-code platform through the inline frame; If the page configuration adjustment file is updated, the updated page configuration adjustment file is pulled from the client local database; According to the updated page configuration adjustment file, the updated debugging result of the page is rendered in the browser window.

5. The method according to claim 4, characterized in that Before monitoring the page configuration adjustment file in the client local database of the low-code platform through the inline frame, the method further includes: In response to an update configuration storage instruction in the low-code platform page designer, an updated page configuration adjustment file is generated according to the page configuration update operation content; The updated page configuration adjustment file is updated and stored in the client local database, so that the target low-code online project refreshes the page according to the updated configuration adjustment file of the page to be debugged.

6. The method according to claim 1, characterized in that The method further comprises: If the page configuration adjustment file is not found, the page is determined to be a non-debugging page, and a deployed page configuration file matching the page is pulled from the low-code platform server; The loading result of the page is rendered in the browser window according to the deployed page configuration file.

7. The method according to any one of claims 1 to 6, characterized in that After rendering the view page of the page in the browser window according to the page configuration adjustment file, the method further includes: In response to a page configuration cancellation instruction, deleting the page configuration adjustment file from the client local database; or, In response to the page configuration publishing instruction, the page configuration adjustment file is deployed to the low-code platform server, and the page configuration adjustment file is deleted from the client local database.

8. A low-code online project debugging device, characterized in that: include: A query module, for responding to a loading instruction of any page in a browser window of a target low-code online project, querying a page configuration adjustment file matching the page from a client local database under the low-code platform through an inline frame homologous to the low-code platform, wherein the inline frame shares a browser domain name with the low-code platform, and the page configuration adjustment file includes configuration modification content of the page to be debugged; A pulling module, configured to determine that the page is a page to be debugged and pull the page configuration adjustment file if a page configuration adjustment file matching the page is found; A rendering module is used to render the view page of the page in the browser window according to the page configuration adjustment file, so as to perform debugging operations on the page in the production environment of the target low-code online project.

9. A storage medium, wherein at least one executable instruction is stored in the storage medium, and the executable instruction enables a processor to perform operations corresponding to the low-code online project debugging method described in any one of claims 1-7.

10. A terminal, comprising: A processor, a memory, a communication interface and a communication bus, wherein the processor, the memory and the communication interface communicate with each other via the communication bus; The memory is used to store at least one executable instruction, and the executable instruction enables the processor to perform operations corresponding to the low-code online project debugging method described in any one of claims 1-7.

Images