Method and apparatus for using knowledge graph to generate web form, and computer device

Abstract

A method for using a knowledge graph to generate a web form, the method comprising: obtaining a knowledge graph; according to attribute information of nodes of the knowledge graph, generating front-end code used for creating a web form; and, according to the front-end code, generating a web form and loading the web form to obtain instance data.

Description

Method, device, and computer equipment for generating web page forms using knowledge graphs Technical Field

[0001] The present application relates to the industrial field, and specifically, to a method, apparatus, computer equipment, and storage medium for generating a web page form using a knowledge graph. Background Art

[0002] In existing solutions, it's often difficult to directly convert industry ontology knowledge graphs into web front-ends. For example, developers must first convert knowledge graph entities into database tables and then build the entire system's back-end application programming interface (API) and web front-end based on the industry ontology, limiting development speed. Furthermore, manufacturing applications use web front-ends to manage system data, which can create dependencies on industry process logic in other data forms, further limiting software development speed.

[0003] Summary of the Invention

[0004] This summary is provided to introduce some selected concepts in a simplified form, which will be further described in the detailed description below. This summary is not intended to identify any key features or essential features of the claimed subject matter, nor is it intended to be used to help determine the scope of the claimed subject matter.

[0005] Based on this, the present application discloses a method for generating a web page form using a knowledge graph, which includes: obtaining a knowledge graph; generating a front-end code for establishing a web page form based on the attribute information of the nodes of the knowledge graph; generating a web page form based on the front-end code, and loading the web page form to obtain instance data.

[0006] Through the above method, the knowledge graph can be quickly and efficiently converted into the corresponding web form, so that the background instance data can be obtained when the web form is loaded. This can greatly facilitate the reusability of the knowledge graph and provide a convenient way to generate web forms.

[0007] Furthermore, loading the form to obtain instance data further includes: receiving a mapping relationship between the attribute information of the form and the instance data in the background based on a mapping editing interface; and loading the web form to obtain the instance data in the background according to the mapping relationship.

[0008] Through the above method, a mapping editing page can be provided on the front end, which can quickly edit the mapping relationship between the attribute information in the form and the background instance data source. When the form loads the background instance data, it is more convenient and direct, and the background instance data loading is more direct and convenient.

[0009] Furthermore, it also includes: based on the subordinate editing interface, receiving the dependency relationship between the nodes of the knowledge graph.

[0010] Through the above method, a corresponding subordinate editing interface can be provided to facilitate editing of the subordinate relationship between attributes in the form, or the subordinate relationship between nodes, so that when the front-end code is generated, the corresponding front-end code will be generated in sequence.

[0011] Furthermore, based on the graphical relationship of the knowledge graph and the attribute information of the nodes, a front-end code for establishing a web page form is generated, including: based on the dependency relationship between the nodes of the knowledge graph, the front-end code corresponding to the attribute information of the nodes of the knowledge graph is called in sequence to generate the front-end code for establishing a web page form.

[0012] Through the above method, when establishing the overall front-end code of the web form, the front-end code corresponding to the attribute information can be called in sequence and in an orderly manner according to the corresponding provided subordinate relationships, so as to integrate and generate the code of the corresponding overall web form, which is conducive to the orderly establishment of the web form logic based on the subordinate relationships, in line with the industrial production logic and table attribute logic.

[0013] Furthermore, the present application also provides a device for generating a web page form using a knowledge graph, which includes: a knowledge graph acquisition module for acquiring a knowledge graph; a front-end code generation module for generating a front-end code for establishing a web page form based on the graphical relationship of the knowledge graph and the attribute information of the nodes; and a web page form generation module for generating a web page form based on the front-end code and loading the web page form to obtain instance data.

[0014] The present application also provides a computer device, comprising a memory and a processor, wherein the memory stores a computer program, and wherein the processor implements the above method when executing the computer program.

[0015] The present application also provides a computer-readable storage medium having a computer program stored thereon, and the computer program implements the above method when executed by a processor.

[0016] The present application also provides a computer program product, which is tangibly stored on a computer-readable medium and includes computer-executable instructions. When the computer-executable instructions are executed, the computer-executable instructions cause at least one processor to perform the method described above. BRIEF DESCRIPTION OF THE DRAWINGS

[0017] Implementations of the present disclosure are illustrated by way of example and not limitation in the figures of the accompanying drawings in which like references indicate the same or similar parts.

[0018] FIG1 is a schematic diagram of the process of a method for generating a web page form using a knowledge graph according to one embodiment of the present application.

[0019] FIG2 is a schematic diagram of an apparatus for generating a web page form using a knowledge graph according to an embodiment of the present application.

[0020] FIG3 is a schematic diagram of a computer device for generating a web page form using a knowledge graph according to an embodiment of the present application.

[0021] The reference numerals are as follows: S101-S103 Step 200: Apparatus 201: Module 202: Module 203: Module 204: Module 205: Module 300: Computer device 302: Processor 304: Memory DETAILED DESCRIPTION

[0022] In the following description, for the purpose of explanation, a large number of specific details are set forth. However, it is understood that the present invention can be implemented without these specific details. In other examples, well-known circuits, structures, and technologies are not shown in detail so as not to affect the understanding of the description.

[0023] References throughout this specification to "an implementation," "an implementation," "an exemplary implementation," "some implementations," "various implementations," etc., indicate that the implementations of the invention being described may include particular features, structures, or characteristics. However, it does not imply that every implementation must include those particular features, structures, or characteristics. Furthermore, some implementations may have some, all, or none of the features described for other implementations.

[0024] The implementation scenario of this application is: this application uses a front-end template engine to extract the front-end engineering code of a completed project (such as a factory production line system) and extract it into an editable web front-end mode, which can convert the modifiable knowledge graph into the form information of the front-end web page. This process is convenient and efficient. Subsequently, by further loading the web form, the corresponding instance data can be obtained from the background, and the complete web form can be displayed on the front end of the web page. The method as a whole utilizes the advantages of easy expansion and easy copying of the knowledge graph, making it convenient and fast to build a web form by utilizing the conversion method of the knowledge graph, thereby realizing the convenience and speed of displaying industrial data on the front end.

[0025] Based on this, this application discloses a method for generating a web form using a knowledge graph, which includes:

[0026] S101, obtain the knowledge graph;

[0027] Among them, the knowledge graph is a knowledge graph for the subsequent generation of web forms. The knowledge graph contains nodes and lines. The nodes and lines can be some attribute information in industrial production and the logical connections between some attribute information. Furthermore, the knowledge graph reflects more of an internal logic, which is an abstraction of the relationship between a type of substance or information and other substances or information. However, in subsequent industrial production, the knowledge graph can be adaptively filled and adjusted with attribute information based on the actual completed projects, so that the knowledge graph matches the current project, or matches the form information you want to generate, or matches the instance data in the corresponding database table. In short, the knowledge graph can be understood as a framework of information. In some embodiments, the nodes and lines in the knowledge graph are used as templates, so that the knowledge graph can be reused as a template for attribute information in multiple identical or similar project scenarios or industrial scenarios.

[0028] Specifically, the front-end template engine receives the knowledge graph, analyzes the knowledge graph, or reads the complex code of the knowledge graph, and can generate the front-end code of the web page form. In summary, in this application, the front-end template engine can directly connect to the name and attributes of the knowledge graph. The direct connection described here can be simply understood as the front-end template engine can match the attribute information in the knowledge graph with the attribute information in the front-end code or database table, or the front-end template engine has such ability. In short, the front-end template engine can analyze and deconstruct the knowledge graph, thereby making basic preparations for the subsequent generation of web page forms.

[0029] Furthermore, the front-end code is the code that can create a web form after the front-end template engine analyzes and parses the knowledge graph.

[0030] The nodes in the knowledge graph represent an attribute, such as nodes with words like equipment, devices, modules, etc., and then these nodes contain attribute information such as name and ID. There are connections between these nodes, but the connections are also based on the logic between macro concepts such as equipment, devices, and modules. In some embodiments, the knowledge graph does not contain specific instances, that is, it does not contain specific names and values. The instance data is stored in the background database in the format of a database table. The method disclosed in the present application can expand the knowledge graph with corresponding nodes and attribute information. The so-called node can be understood as the concept of a collection with multiple attribute information, or in some embodiments, the node can be understood as the concept of a table.

[0031] S102, generating a front-end code for establishing a web page form based on the graphical relationship of the knowledge graph and the attribute information of the nodes;

[0032] In this step, the front-end template engine can analyze the knowledge graph and generate the front-end code for creating the form based on the nodes, attribute information within the nodes, and connections in the knowledge graph.

[0033] For example, a node in the knowledge graph contains attribute information of general categories such as equipment, devices, age, name, and email address. The fronted template engine then parses and analyzes the knowledge graph, and assembles a form page that can edit the database table created by the knowledge graph based on the attribute information and logical relationships provided by the knowledge graph. In this way, it is possible to reduce or eliminate the need to develop front-end pages that adapt to the database table created by the knowledge graph. For example, instance information can be a row of specific data in the lathe status table generated by the lathe status node of the knowledge graph: lathe 1, axis 1, Zhang San, 33 years old, zhangsan@mail.com, which are instance information corresponding to the attribute information of the above-mentioned equipment, device, age, name, and email address.

[0034] In some embodiments, the nodes and connections in the knowledge graph are filled and constructed through an interactive interface. For example, in order to create and modify the instance information of "email address" in the final generated front-end form page, if there is no attribute information of "email address" in the knowledge graph, the attribute information of "email address" can be created in the node of the knowledge graph. The node is connected with other nodes to represent a parallel, subordinate, etc. relationship, which facilitates the subsequent parsing of the front-end template engine and the generation of the front-end code.

[0035] In this way, after obtaining the attribute information at the same time, the front-end template engine can directly generate the front-end form page. The steps are simple and fast, which reduces the time of front-end engineering development.

[0036] The focus of this step is that the front-end template engine can generate front-end codes one by one based on the graphical relationships of the knowledge graph and the attribute information in the nodes. In some embodiments, through integration and calling, the front-end codes generated by the nodes and attribute relationships of the knowledge graph extracted from the implemented projects can be completely converted into codes that conform to the web page form at one time. The method is convenient and fast.

[0037] Furthermore, the method can be completed by the front-end template engine. The method of using the front-end template engine to create page forms is different from the traditional front-end development model. It can directly map the user's attributes of the nodes in the knowledge graph and generate front-end form pages that can add and modify data. The front-end code is generated through the relationship between the nodes and attribute information and then assembled into a front-end web form that can be directly used. This makes it convenient to modify according to the knowledge graph at any time and quickly generate front-end web form projects to adapt to the needs of users and enterprises.

[0038] S103: Generate a web form according to the front-end code, and load the web form to obtain instance data.

[0039] The front-end code is the code generated by the front-end template engine based on the knowledge graph. The code can be understood as the code of the web form. Through the code, the web form can be displayed on the display end. According to the front-end code, generating a web form is a process of code conversion, which is relatively easy and direct. At this time, the web form only includes a table structure composed of attribute information transformed from the knowledge graph, and does not have instance data. Then, by loading the web form, the corresponding instance data is obtained from the background database through the database interface and the application programming interface (API). The instance data can also be stored in the database in the form of a database table structure.

[0040] In some of the web forms, or web forms that can add and delete instance data, the modified and created instance data are usually stored in a database. They may be in the form of database tables, with an unlimited number. In the case of multiple database tables, there will be subordinate relationships between the database tables due to the special physical relationship between the instance data.

[0041] Among them, after the front-end code is generated, the corresponding web form can be generated. The web form is a modifiable visual interactive interface. The web form has rows and columns, and each row or column has a specific meaning. Generally, attribute information precedes instance information, for example, it is used to indicate that a certain column is an instance of the same type of attribute information. The form information will also be equipped with add, modify, delete and other buttons to facilitate editing, adding and deleting knowledge graph instance information. In addition, there are functions such as query and page change to facilitate finding and viewing form information.

[0042] Through the above method, the knowledge graph can be quickly and efficiently converted into the corresponding form of the web page, which can greatly facilitate the reusability of the knowledge graph.

[0043] In some embodiments, when corresponding data needs to be managed in the industry, such as material management, order management, etc., the corresponding attributes and logical associations can be found in the knowledge graph, and then these corresponding attributes and logical associations can be checked and sent to the front-end template engine. The front-end template can generate corresponding form information based on the knowledge graph, which is conducive to presenting the information in the form of a form on the front end of the web page.

[0044] Furthermore, loading the form to obtain instance data also includes: receiving a mapping relationship between the attribute information of the node and the background instance data based on a mapping editing interface; and, according to the mapping relationship, loading the web form to obtain the background instance data.

[0045] Specifically, in the front-end template engine, you can configure the mapping relationship between the attribute information of the node in the knowledge graph and the instance data information in the back-end database. The configuration can be in the form of an interactive interface, such as a mapping editing interface, and can include the following configurations:

[0046] [Mapping config as data transform]

[0047] Data.person.age->age

[0048] Data.person.contact.email->email

[0049] Data.person.accountInfo.createDate->createDate

[0050] The Data.person.age, Data.person.contact.email, and Data.person.accountInfo.createDate fields on the left represent the specific location of the database instance information. Meanwhile, the age, email, and createDate fields on the right represent the attribute information of the node in the knowledge graph or in the front-end code. The goal is to conveniently, quickly, and directly map the instance data in the backend database to the corresponding attribute information. When loading a web form, simply querying this mapping information will quickly retrieve the backend instance data, saving steps and redirects.

[0051] Furthermore, it also includes: based on the subordinate editing interface, receiving the dependency relationship between the nodes of the knowledge graph.

[0052] Specifically, the dependency editing interface can allow adding dependencies, dependencies, or dependency chains to certain attribute information in the knowledge graph. For example, the interface can include a dependency knowledge graph ontology name and a dependency topic.

[0053] The name of the attribute-dependent knowledge graph ontology may be, for example, “Ontology 2.” The name of the attribute-dependent knowledge graph ontology represents information about a node.

[0054] The subordinate topic may be, for example, "Ontology1.Ontology2", indicating that Ontology 1 and Ontology 2 have a subordinate relationship in a sequential order. However, Ontology 1 and Ontology 2 are two different nodes.

[0055] The corresponding subordinate editing interface can be simply illustrated as follows:

[0056] Through the above method, the subordinate relationship of the corresponding data can be edited, or the subordinate relationship between data according to certain actual needs can be submitted, so that when generating web page data, it can be generated in sequence according to the above subordinate relationship, which is conducive to the subsequent display of data.

[0057] Furthermore, based on the graphical relationship of the knowledge graph and the attribute information of the nodes, a front-end code for establishing a web page form is generated, including: based on the dependency relationship between the nodes of the knowledge graph, the front-end code corresponding to the attribute information of the nodes of the knowledge graph is called in sequence to generate the front-end code for establishing a web page form.

[0058] Specifically, because some attribute information can only be obtained based on other attribute information, for example, a factory's temporary production schedule information needs to be determined based on order information, the front-end template engine will check its dependency chain after receiving the first attribute information. If the dependency chain shows that the first attribute information is related to the second attribute information, it will open the node containing the second attribute information first.

[0059] If we refer to the previous concept and the node can also be understood as a table, it is equivalent to opening the node table where the second attribute information is located. After the node table of the second attribute information is processed (for example, the front-end code of the node of the second attribute information is generated), return to the node table of the first attribute information, and continue to process the first attribute information based on the result of the processing of the second attribute information (for example, continue to generate the front-end code of the node table containing the first attribute information). In some embodiments, since the nodes in the knowledge graph can be disassembled or correspond to multiple attribute tables, such as attribute table 1, attribute table 2, and attribute table 3, and each attribute information can belong to or be located in a different attribute table, for example, attribute information 1 is located in attribute table 1, attribute information 2 is located in attribute table 2, and attribute information 3 is located in attribute table 3. When the front-end template engine generates the final front-end code, it analyzes and deconstructs attribute table 1. When it is found that the subordinate chain of attribute information 1 is related to attribute information 2, it first keeps attribute table 1, opens attribute table 2, and performs corresponding processing on attribute information 2 (if it is found that the subordinate chain of attribute information 2 is related to attribute information 3, it can also further keep attribute table 2 and open attribute table 3 for editing). When attribute table 2 is processed, all subordinate states are cleared and the process returns to attribute table 1 to continue processing attribute information 1 until all subordinate chains are processed, attribute 1 is closed, and all subordinate states are cleared.

[0060] In the above steps, the control capability of the routing in the front-end single page application (SPA) is used to implement the interruption mechanism, and there is a step of saving the subordinate status. After the subordinate relationship of the attribute information is processed, it is cleared and the code generation processing of the attribute information is continued in the next step.

[0061] Through the above method, the data format of the web page can be established in sequence and in an orderly manner according to the subordinate relationship of the corresponding data in the knowledge graph, so that the data of the web page after establishment is clearer and more logical.

[0062] Furthermore, it also includes: based on the attribute editing interface, receiving attribute information of the knowledge graph corresponding to the form information.

[0063] Specifically, in the attribute editing interface, the knowledge graph is displayed as a whole on the left side of the interface, and the right side allows the selection of certain specific nodes and their attribute information. Such attribute information includes, for example, ID and name. Because the entire knowledge graph contains many nodes, connection relationships, and node attribute information, it is possible to select the required attribute information and edit the front-end and back-end mapping relationship of node attributes according to project or industry requirements. This facilitates the adaptation of the form in the generated front-end page to the data structure of the back-end interface, so that when it is subsequently sent to the front-end template engine, the corresponding front-end code can be generated.

[0064] Through the above method, you can quickly edit the knowledge graph, generate the desired form information according to your needs, and flexibly and conveniently copy and expand the conversion and display of the knowledge graph on the web page.

[0065] In previous existing solutions, it is usually difficult to directly convert the knowledge graph of the industry ontology into the web front end, as follows:

[0066] a. Developers must first convert knowledge graph entities into data tables in the database, and then build the backend API and web front-end of the entire system based on the industry ontology, which limits the development speed.

[0067] b. Manufacturing applications use a web front-end to manage system data, which may rely on the industry process logic of other data tables, thus limiting the speed of software development.

[0068] The reasons for the above problems are:

[0069] a. The backend system keeps the business logic in the backend API, so the web frontend must adapt and wait, which means that the web frontend has no ability to directly modify the core system.

[0070] b. Factory systems usually have factory business processes. Even if the web front-end form can create / read / update / delete data tables through the back-end API, the flow of the process is still handled by the back-end.

[0071] Therefore, this application first establishes and uses a front-end template engine to fill in the corresponding web page code for the components of the web page front end.

[0072] In addition, a user interface (UI) for the knowledge graph editor is established, and the industry ontology properties generated into the web front-end code are marked as form pages, so that product managers can quickly respond to the expectations of the web front-end, modify the UI, or adjust the selection of knowledge graph properties for improvement.

[0073] Therefore, the front-end template engine can help users create form information, convert the knowledge graph into the form on the front end of the website, and spend less development time on automatic code programming and adjusting the application interface between the back end and the front end.

[0074] In some industry fields, if the form attribute editing is opened, the front-end template engine should design an interrupt mechanism, and then generate code according to the said subordinate relationship after receiving the subordinate relationship of the corresponding attribute information, so as to ensure the correct order of data information or attribute information when reading and editing.

[0075] Furthermore, a set of dependency triggers is configured in the front-end template engine to read dependency information and jump to the specified form page. The order in which pages or forms are opened is configured to read the attribute information of the corresponding dependencies. Therefore, the front-end template engine should adopt a mechanism to store the order and dependencies of the forms generated by the knowledge graph, so that the forms can be generated and saved in the order of their dependencies.

[0076] It should be understood that although the various steps in the flowchart of FIG1 are shown in sequence as indicated by the arrows, these steps are not necessarily executed in the order indicated by the arrows. Unless otherwise specified herein, there is no strict order restriction on the execution of these steps, and these steps can be executed in other orders. Moreover, at least a portion of the steps in FIG1 may include multiple steps or multiple stages, and these steps or stages are not necessarily executed at the same time, but can be executed at different times. The execution order of these steps or stages is not necessarily to be carried out in sequence, but can be executed in turn or alternately with other steps or at least a portion of steps or stages in other steps.

[0077] Figure 2 provides a device 200 for generating a web page form using a knowledge graph, which includes: a knowledge graph acquisition module 201 for acquiring a knowledge graph; a front-end code generation module 202 for generating a front-end code for establishing a web page form based on the graphical relationship of the knowledge graph and the attribute information of the nodes; a web page form generation module 203 for generating a web page form based on the front-end code and loading the web page form to obtain instance data.

[0078] The web form generating module 203 is configured to receive a mapping relationship between the attribute information of the node and the background instance data based on the mapping editing interface 204; and load the web form to obtain the background instance data according to the mapping relationship.

[0079] It also includes a dependent editing module 205 for receiving the dependency relationship between the nodes of the knowledge graph.

[0080] Among them, the front-end code generation module 202 is used to call the front-end code corresponding to the attribute information of the nodes of the knowledge graph in sequence according to the dependency relationship between the nodes of the knowledge graph, and generate the front-end code for establishing the web page form.

[0081] It should be noted that the apparatus may include more or fewer modules to implement the described functionality. For example, at least one module in FIG. 2 may be further divided into a plurality of different submodules, each of which is configured to perform at least a portion of the operations described herein in conjunction with the corresponding module. Furthermore, in some examples, the apparatus 200 may further include additional modules for performing other operations already described in the specification. Furthermore, those skilled in the art will appreciate that the exemplary apparatus 200 may be implemented using software, hardware, firmware, or any combination thereof.

[0082] Figure 3 provides a computer device. According to one embodiment, the computer device 300 may include a processor 302, which executes a computer program stored in a memory 304. When the computer program is executed by the processor, the above method is implemented.

[0083] Those skilled in the art will understand that the structure shown in Figure 3 is merely a block diagram of a portion of the structure related to the solution of the present application, and does not constitute a limitation on the computer device to which the present application is applied. The specific computer device may include more or fewer components than shown in the figure, or combine certain components, or have a different component arrangement.

[0084] Those skilled in the art will appreciate that all or part of the processes in the methods for implementing the above-mentioned embodiments can be accomplished by instructing the relevant hardware through a computer program, and the computer program can be stored in a non-volatile computer-readable storage medium. When the computer program is executed, it can include processes for the implementation of the above-mentioned methods. Among them, any reference to memory, storage, database or other media used in the various embodiments provided in this application may include at least one of non-volatile and volatile memory. Non-volatile memory may include read-only memory (ROM), magnetic tape, floppy disk, flash memory or optical memory, etc. Volatile memory may include random access memory (RAM) or external cache memory. As an illustration and not limitation, RAM can be in various forms, such as static random access memory (SRAM) or dynamic random access memory (DRAM).

[0085] The present application also provides a computer-readable storage medium having a computer program stored thereon, which implements the above steps when the computer program is executed by a processor.

[0086] The present application also provides a computer program product, which is tangibly stored on a computer-readable medium and includes computer-executable instructions. When the computer-executable instructions are executed, the computer-executable instructions cause at least one processor to perform the above method.

[0087] Furthermore, the computer program can be stored and run in the cloud to perform the method. Furthermore, the components of the program can be deployed on multiple devices and the cloud. For example, the corresponding steps can be deployed and run on a local or local computer, or run on different cloud devices, and transmit signals through a communication connection, or can also be deployed and run on a local or local computer. This application does not limit the manner or method, and the corresponding technology can be flexibly deployed to make full use of equipment and technologies such as the cloud, big data, and supercomputing capabilities to execute and complete the method.

[0088] Some implementations of the present disclosure may include articles of manufacture. Articles of manufacture may include storage media for storing logic. Examples of storage media may include one or more types of computer-readable storage media capable of storing electronic data, including volatile or non-volatile memory, removable or non-removable memory, erasable or non-erasable memory, writable or rewritable memory, and the like. Examples of logic may include various software units, such as software components, programs, applications, computer programs, application programs, system programs, machine programs, operating system software, middleware, firmware, software modules, routines, subroutines, functions, methods, processes, software interfaces, application program interfaces (APIs), instruction sets, computing codes, computer codes, code segments, computer code segments, words, values, symbols, or any combination thereof. In some implementations, for example, articles of manufacture may store executable computer program instructions that, when executed by a processor, cause the processor to perform the methods and / or operations described herein. Executable computer program instructions may include any suitable type of code, such as source code, compiled code, interpreted code, executable code, static code, dynamic code, and the like. Executable computer program instructions can be implemented according to a predefined computer language, method or syntax for commanding a computer to perform a specific function. The instructions can be implemented using any appropriate high-level, low-level, object-oriented, visual, compiled and / or interpreted programming language.

[0089] What has been described above includes examples of the disclosed architecture. It is, of course, not possible to describe every conceivable combination of components and / or methodologies, but those skilled in the art will appreciate that many other combinations and permutations are possible. Therefore, the novel architecture is intended to embrace all such alternatives, modifications, and variations that fall within the spirit and scope of the appended claims.

Claims

1. A method for generating a web page form using a knowledge graph, wherein: include: Get the knowledge graph; Generate front-end code for building a web form based on the attribute information of the nodes in the knowledge graph; A web page form is generated according to the front-end code, and the web page form is loaded to obtain instance data.

2. The method according to claim 1, wherein: Loading the form to obtain instance data also includes: Based on the mapping editing interface, receiving the mapping relationship between the attribute information of the node and the instance data of the background; and, According to the mapping relationship, the webpage form is loaded to obtain background instance data.

3. The method according to claim 1, wherein: Also includes: Based on the subordinate editing interface, the dependency relationship between the nodes of the knowledge graph is received.

4. The method according to claim 1, wherein: According to the attribute information of the nodes in the knowledge graph, the front-end code for establishing the web form is generated, including: According to the dependency relationship between the nodes of the knowledge graph, the front-end codes corresponding to the attribute information of the nodes of the knowledge graph are called in sequence to generate the front-end code for establishing the web page form.

5. A device (200) for generating a webpage form using a knowledge graph, wherein: include: A knowledge graph acquisition module (201), used to acquire a knowledge graph; A front-end code generation module (202) generates a front-end code for establishing a web page form according to the attribute information of the nodes of the knowledge graph; A web page form generation module (203) generates a web page form according to the front-end code, and loads the web page form to obtain instance data.

6. The device (200) according to claim 5, wherein: A webpage form generation module (203) is used to receive the mapping relationship between the attribute information of the node and the instance data in the background based on the mapping editing interface (204); And, according to the mapping relationship, the webpage form is loaded to obtain the instance data of the background.

7. The device (200) according to claim 5, wherein: Also includes: The dependent editing module (205) is used to receive the dependency relationship between the nodes of the knowledge graph.

8. The device (200) according to claim 5, wherein: The front-end code generation module (202) is used to call the front-end code corresponding to the attribute information of the nodes of the knowledge graph in sequence according to the dependency relationship between the nodes of the knowledge graph, and generate the front-end code for establishing the web page form.

9. A computer device comprising a memory and a processor, wherein the memory stores a computer program, wherein: When the processor executes the computer program, the steps of the method according to any one of claims 1 to 4 are implemented.

10. A computer-readable storage medium having a computer program stored thereon, wherein: When the computer program is executed by a processor, the steps of the method according to any one of claims 1 to 4 are implemented.

11. A computer program product tangibly stored on a computer readable medium and comprising computer executable instructions which, when executed, cause at least one processor to perform the method according to any one of claims 1 to 4.

Images