CN113656028A - UI component code generation method, CRUD page generation method, device and equipment - Google Patents
UI component code generation method, CRUD page generation method, device and equipment Download PDFInfo
- Publication number
- CN113656028A CN113656028A CN202110920849.0A CN202110920849A CN113656028A CN 113656028 A CN113656028 A CN 113656028A CN 202110920849 A CN202110920849 A CN 202110920849A CN 113656028 A CN113656028 A CN 113656028A
- Authority
- CN
- China
- Prior art keywords
- interface
- model
- target
- api
- generating
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
- 238000000034 method Methods 0.000 title claims abstract description 73
- 238000004573 interface analysis Methods 0.000 claims abstract description 121
- 230000004044 response Effects 0.000 claims abstract description 65
- 230000000977 initiatory effect Effects 0.000 claims abstract description 10
- 230000000694 effects Effects 0.000 claims description 25
- 238000012790 confirmation Methods 0.000 claims description 23
- 239000000126 substance Substances 0.000 claims description 2
- 238000011161 development Methods 0.000 abstract description 14
- 238000012827 research and development Methods 0.000 abstract description 9
- 230000000875 corresponding effect Effects 0.000 description 121
- 238000004458 analytical method Methods 0.000 description 6
- 238000010586 diagram Methods 0.000 description 6
- 230000008569 process Effects 0.000 description 6
- 238000004590 computer program Methods 0.000 description 4
- 230000000007 visual effect Effects 0.000 description 4
- 230000006870 function Effects 0.000 description 3
- 238000012986 modification Methods 0.000 description 3
- 230000004048 modification Effects 0.000 description 3
- 230000003287 optical effect Effects 0.000 description 3
- 230000003068 static effect Effects 0.000 description 3
- 230000009286 beneficial effect Effects 0.000 description 2
- 238000013461 design Methods 0.000 description 2
- 230000003993 interaction Effects 0.000 description 2
- 239000013307 optical fiber Substances 0.000 description 2
- 238000012545 processing Methods 0.000 description 2
- 230000000644 propagated effect Effects 0.000 description 2
- 238000009877 rendering Methods 0.000 description 2
- 238000004088 simulation Methods 0.000 description 2
- 238000010200 validation analysis Methods 0.000 description 2
- 230000009471 action Effects 0.000 description 1
- 238000006243 chemical reaction Methods 0.000 description 1
- 238000004891 communication Methods 0.000 description 1
- 230000002596 correlated effect Effects 0.000 description 1
- 238000007405 data analysis Methods 0.000 description 1
- 238000013500 data storage Methods 0.000 description 1
- 238000012217 deletion Methods 0.000 description 1
- 230000037430 deletion Effects 0.000 description 1
- 238000010295 mobile communication Methods 0.000 description 1
- 230000008707 rearrangement Effects 0.000 description 1
- 238000007670 refining Methods 0.000 description 1
- 230000003252 repetitive effect Effects 0.000 description 1
- 239000004065 semiconductor Substances 0.000 description 1
- 239000007787 solid Substances 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
- 239000013589 supplement Substances 0.000 description 1
- 238000012546 transfer Methods 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/38—Creation or generation of source code for implementing user interfaces
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Human Computer Interaction (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Stored Programmes (AREA)
Abstract
The embodiment of the invention discloses a method, a device and equipment for generating UI component codes and CRUD pages. The method comprises the following steps: acquiring interface information of an API corresponding to the UI component, initiating a local interface request according to the interface information, and acquiring response data corresponding to the local interface request; generating API interface analysis data according to the interface information and the response data, and determining a target UI model matched with the API interface in a preset UI model set according to the API interface analysis data; generating a UI configuration tree according to the API interface analysis data and the original configuration information corresponding to the target UI model; and generating UI component codes according to the interface code template, the logic code template and the API interface analysis data corresponding to the UI configuration tree. The technical scheme of the embodiment of the invention can generate the dynamic code containing the logical relationship, thereby reducing the threshold of front-end development and improving the research and development efficiency.
Description
Technical Field
The embodiment of the invention relates to the technical field of computers, in particular to a method, a device and equipment for generating UI component codes and CRUD pages.
Background
In project development, a front-end system typically needs to communicate with a back-end service. For example, the front-end system may obtain data filled by a user through an Application Programming Interface (API), and submit the data to the back-end service through the API Interface. Therefore, in project development, a front-end developer is required to write a large amount of code to enable communication with a back-end service.
In the prior art, codes are generally generated by a manual writing mode, or codes are generated by configuration data or visual draft data. However, generating code by manual writing requires a lot of manpower, and requires a developer to have a high level of skill. And the code is generated by the configuration data or the visual draft data, only the code of the static page can be generated, and the dynamic code needs to be supplemented manually when the code is communicated with the back-end service, so that the code is inconvenient to use, and the research and development efficiency is low.
Disclosure of Invention
The embodiment of the invention provides a method, a device and equipment for generating UI component codes and CRUD pages, which can generate dynamic codes containing logical relations according to analysis of API interfaces, thereby reducing the threshold of front-end development and improving the research and development efficiency.
In a first aspect, an embodiment of the present invention provides a UI component code generation method, including:
acquiring interface information of an API corresponding to a UI component, initiating a local interface request according to the interface information, and acquiring response data corresponding to the local interface request;
generating API interface analysis data according to the interface information and the response data, and determining a target UI model matched with the API interface in a preset UI model set according to the API interface analysis data;
generating a UI configuration tree according to the API interface analysis data and original configuration information corresponding to the target UI model;
and generating the UI component code according to the interface code template, the logic code template and the API interface analysis data corresponding to the UI configuration tree.
In a second aspect, an embodiment of the present invention further provides a method for generating a CRUD page, including:
generating a user interface UI component code corresponding to a target application program interface API related to a CRUD page by adopting a UI component code generation method provided by any embodiment of the invention;
determining the parameter corresponding relation between target API interfaces, constructing the incidence relation between UI component codes corresponding to the target API interfaces according to the parameter corresponding relation, and generating CRUD page codes;
and generating the CRUD page according to the CRUD page code.
In a third aspect, an embodiment of the present invention further provides a UI component code generating apparatus, including:
the response data acquisition module is used for acquiring interface information of an API corresponding to the UI component, initiating a local interface request according to the interface information and acquiring response data corresponding to the local interface request;
the target UI model determining module is used for generating API interface analysis data according to the interface information and the response data and determining a target UI model matched with the API interface in a preset UI model set according to the API interface analysis data;
the UI configuration tree generation module is used for generating a UI configuration tree according to the API interface analysis data and the original configuration information corresponding to the target UI model;
and the UI component code generating module is used for generating the UI component code according to the interface code template, the logic code template and the API interface analysis data corresponding to the UI configuration tree.
In a fourth aspect, an embodiment of the present invention further provides a CRUD page generation apparatus, including:
the UI component code generating module is used for generating a user interface UI component code corresponding to a target application program interface API related to the CRUD page by adopting the UI component code generating method provided by any embodiment of the invention;
the CRUD page code generating module is used for determining the parameter corresponding relation between the target API interfaces, constructing the incidence relation between the UI component codes corresponding to the target API interfaces according to the parameter corresponding relation and generating CRUD page codes;
and the CRUD page generating module is used for generating the CRUD page according to the CRUD page code.
In a fifth aspect, an embodiment of the present invention further provides a computer device, where the computer device includes:
one or more processors; and
a memory communicatively coupled to the at least one processor; wherein the content of the first and second substances,
the memory stores instructions executable by the at least one processor, the instructions being executable by the at least one processor to enable the at least one processor to perform a UI component code generation method according to any of the embodiments of the present invention, or to perform a CRUD page generation method according to any of the embodiments of the present invention.
In a sixth aspect, an embodiment of the present invention further provides a computer-readable storage medium, on which a computer program is stored, which, when executed by a computer, implements a UI component code generation method provided in any embodiment of the present invention, or executes a CRUD page generation method provided in any embodiment of the present invention.
According to the technical scheme of the embodiment of the invention, the interface information of the API corresponding to the UI component is obtained, and the local interface request is initiated according to the interface information, so that the response data corresponding to the local interface request is obtained; generating API interface analysis data according to the interface information and the response data, and determining a target UI model matched with the API interface in a preset UI model set according to the API interface analysis data; generating a UI configuration tree according to the API interface analysis data and the original configuration information corresponding to the target UI model; and generating UI component codes according to the interface code template, the logic code template and the API interface analysis data corresponding to the UI configuration tree. According to the technical scheme of the embodiment of the invention, the dynamic code containing the logical relationship can be generated by analyzing the API interface, so that the threshold of front-end development is reduced, and the research and development efficiency is improved.
Drawings
FIG. 1 is a flowchart of a method for generating UI component code according to an embodiment of the present invention;
FIG. 2a is a flowchart of a UI component code generation method according to a second embodiment of the invention;
FIG. 2b is a flowchart of a method for generating UI component code according to a second embodiment of the present invention;
FIG. 3 is a flowchart of a CRUD page generation method according to a third embodiment of the present invention;
FIG. 4 is a schematic structural diagram of a UI component code generation apparatus according to a fourth embodiment of the invention;
fig. 5 is a schematic structural diagram of a CRUD page generation device in the fifth embodiment of the present invention;
fig. 6 is a schematic structural diagram of a computer device according to a sixth embodiment of the present invention.
Detailed Description
The present invention will be described in further detail with reference to the accompanying drawings and examples. It is to be understood that the specific embodiments described herein are merely illustrative of the invention and are not limiting of the invention. It should be further noted that, for the convenience of description, only some of the structures related to the present invention are shown in the drawings, not all of the structures.
It should be further noted that, for the convenience of description, only some but not all of the relevant aspects of the present invention are shown in the drawings. Before discussing exemplary embodiments in more detail, it should be noted that some exemplary embodiments are described as processes or methods depicted as flowcharts. Although a flowchart may describe the operations (or steps) as a sequential process, many of the operations can be performed in parallel, concurrently or simultaneously. In addition, the order of the operations may be re-arranged. The process may be terminated when its operations are completed, but may have additional steps not included in the figure. The processes may correspond to methods, functions, procedures, subroutines, and the like.
Example one
Fig. 1 is a flowchart of a UI component code generation method according to an embodiment of the present invention, which is applicable to a case where corresponding front-end component codes are quickly generated according to analysis of API interface information. The method may be performed by a UI component code generating apparatus, which may be implemented by software and/or hardware, and may be generally integrated in a computer device (e.g., various intelligent terminals or servers, etc.). As shown in fig. 1, the method includes:
and step 110, acquiring interface information of an API corresponding to the UI component, initiating a local interface request according to the interface information, and acquiring response data corresponding to the local interface request.
The User Interface (UI) may be a human-computer Interface of software. Specifically, the UI in the embodiment of the present invention refers to interface design in a front-end system. The UI component may be a view element in a user interface. The API interfaces are some predefined Protocol interfaces such as hypertext Transfer Protocol (HTTP). The front-end system generally communicates with the back-end service through an associated API interface, such as obtaining data for presentation or submitting user data. The UI component may be implemented through calls of an API interface. Therefore, the UI component may have a certain correspondence with the API interface, which is also the basis for the front-end developer to design the interface.
In the embodiment of the invention, the interface information of the API is information required when the API is called. For example, the interface information of the API interface may include an interface address, interface parameters, and the like. When generating the UI component code, a simulation request of the API interface may be performed, that is, a local interface request may be initiated according to the interface information, and the corresponding response data may be determined. For example, the response data may be obtained by an HTTP request of the local Node (an operating environment) service initiation interface according to the interface address and the interface parameter. The response data may include data content and data type of the specific response, and the like.
And 120, generating API interface analysis data according to the interface information and the response data, and determining a target UI model matched with the API interface in a preset UI model set according to the API interface analysis data.
The API interface analysis data may be all information data of the API interface, for example, the API interface analysis data may include interface information and response data. Specifically, the API interface analysis data may include an interface address, an interface request method, a request parameter type, request data, a response parameter type, response data, and the like.
In the embodiment of the present invention, the preset UI model may be a model in a UI component library. Specifically, the preset UI model set may include some common models exposed through an API interface. For example, the set of pre-set UI models may include one or more of a form model, a pop-up window model, and a menu model.
In this step, there may be various ways to determine the matching target UI model with the API interface. For example, the UI model may be matched with the API interface analysis data according to the interface features of the UI model, and if the matching is successful, the UI model is determined to be the target UI model corresponding to the API interface analysis data. Specifically, one or more items of an interface request method, a request parameter type, quantity information or format information of request data, a response parameter type, quantity information or format information of response data, and the like in the API interface analysis data may be matched with the interface characteristics of the UI model. When the interface characteristics of the API interface analysis data and the UI model are successfully matched, it may be determined that the UI model is a target UI model of the API interface corresponding to the API interface analysis data.
And step 130, generating a UI configuration tree according to the API interface analysis data and the original configuration information corresponding to the target UI model.
In the preset UI model set, each UI model may have preset original configuration information. And different UI models have different corresponding original configuration information. The UI configuration tree may be a concrete representation of the API interface analysis data and the original configuration information of the target UI model. For example, the UI configuration tree may record the type of UI model, the original configuration information of the UI model, and data information generated by analyzing specific data in the data according to the API interface, etc. When the data types (request parameter types or response parameter types) in the API interface analysis data are different, the generated item items of the UI model tree are different. In the embodiment of the present invention, the item items of the generated UI model tree may be determined according to the determined data type in the API interface analysis data. For example, when the data type in the API interface analysis data is a request parameter type, the item of the UI model tree may be an entry result. For another example, when the data type in the API interface analysis data is a response parameter type, the item of the UI model tree may be a response result.
And 140, generating a UI component code according to the interface code template, the logic code template and the API interface analysis data corresponding to the UI configuration tree.
The UI model has an original code template, and can comprise an original interface code template and a logic code template. The original code template of the UI model corresponding to the UI configuration tree may be adjusted according to the configuration information in the UI configuration tree. For example, parameter modification may be performed on the original code template to generate an interface code template and a logic code template corresponding to the UI configuration tree.
In the embodiment of the present invention, the UI configuration tree corresponds to the API interface, that is, the generation of the UI component can be realized only by calling the API interface. Therefore, the interface code template and the logic code template corresponding to the UI configuration tree need to be added with API interface analysis data to generate UI component codes.
Specifically, the UI component code generated in the embodiment of the present invention is generated based on analysis of data information of the API interface, and the UI component code includes not only the interface code but also a specific logic code when the API interface is called, so that the UI component code is a dynamic code. The dynamic UI component code can meet the actual requirements of business, so that in the actual business, the back end can independently generate a front end system matched with back end service without depending on front end developers. Compared with static codes generated in the prior art, the dynamic UI component codes can be generated without the need of a front-end developer to supplement the dynamic codes, so that the front-end development threshold is reduced, and the research and development efficiency is improved.
According to the technical scheme of the embodiment of the invention, the interface information of the API corresponding to the UI component is obtained, and the local interface request is initiated according to the interface information, so that the response data corresponding to the local interface request is obtained; generating API interface analysis data according to the interface information and the response data, and determining a target UI model matched with the API interface in a preset UI model set according to the API interface analysis data; generating a UI configuration tree according to the API interface analysis data and the original configuration information corresponding to the target UI model; and generating UI component codes according to the interface code template, the logic code template and the API interface analysis data corresponding to the UI configuration tree. The technical scheme of the embodiment of the invention solves the problem of quick generation of the front-end component code, and can generate the dynamic code containing the logical relation according to the analysis of the API interface information, thereby reducing the threshold of front-end development and improving the research and development efficiency.
Example two
Fig. 2a is a flowchart of a UI component code generation method in a second embodiment of the present invention, which is further detailed based on the above-mentioned embodiment, in this embodiment, a manner of determining a target UI model matching an API interface in a preset UI model set according to API interface analysis data is further detailed. And further refining the characteristics of generating the UI configuration tree according to the API interface analysis data and the original configuration information corresponding to the target UI model. And the mode of generating UI component codes is further refined according to the interface code template, the logic code template and the API interface analysis data corresponding to the UI configuration tree.
Specifically, in an optional implementation manner of the embodiment of the present invention, generating the UI configuration tree according to the API interface analysis data and the original configuration information corresponding to the target UI model includes: generating an information item list according to the API interface analysis data and original configuration information corresponding to the target UI model; responding to the selection operation of the user on the information item list, and determining configuration information corresponding to the UI configuration tree; and generating the UI configuration tree according to the configuration information.
In an optional implementation manner of the embodiment of the present invention, generating UI component codes according to an interface code template, a logic code template, and API interface analysis data corresponding to a UI configuration tree includes: updating parameter information in an interface code template corresponding to the UI configuration tree according to the configuration information corresponding to the UI configuration tree, and generating a target interface code; updating interface calling logic information in a logic code template corresponding to the UI configuration tree according to the API interface analysis data to generate a target logic code; and generating UI component codes according to the target interface codes and the target logic codes.
As shown in fig. 2a, the method of the present embodiment may include:
And step 220, generating API interface analysis data according to the interface information and the response data, and determining a target UI model matched with the API interface in a preset UI model set according to the API interface analysis data.
In an optional implementation manner of the embodiment of the present invention, the UI model set is a set formed by one or more items of a table model, a form model, a popup model, and a menu model.
In an optional implementation manner of the embodiment of the present invention, determining, according to API interface analysis data in a preset UI model set, a target UI model matching an API interface includes: when determining that the API interface analysis data is request type data and the API interface analysis data contains paging information, determining a table model as a target UI model matched with an API interface in a preset UI model set; when determining that the API interface analysis data is request type data and the API interface analysis data does not contain paging information, determining a form model and a menu model as a target UI model matched with the API interface in a preset UI model set; when determining that the API interface analysis data is submission type data and the API interface analysis data is single identification type data, determining a popup window model as a target UI model matched with the API interface in a preset UI model set; when determining that the API interface analysis data is submission type data and the API interface analysis data is multiple submission data, determining a form model as a target UI model matched with the API interface in a preset UI model set; and when determining that the API interface analysis data is submission type data and the API interface analysis data is single non-identification type data, determining the form model and the popup window model as a target UI model matched with the API interface in a preset UI model set.
Specifically, the interface characteristics of the table model may include making a data request through the interface, returning multiple pieces of response data, and the response data having paging information. The paging information is specific information of the table model. The interface features of the menu model may include making a data request over the interface, returning one or more data, etc. The interface features of the pop-up window model may include submitting data through the interface, submitting a parameter with an identification type, and the like. Wherein, the identification type is the specific information of the popup model. The identification type may be identification number (ID) information of the parameter. The form model may have interface features that may include submitting data through an interface, submitting one or more data, and so on.
When the API interface analyzes the data type in the data as request type data, that is, makes a data request through the API interface, and requests to return the data, it may be determined that the target UI model may be a table model or a menu model. When the response data corresponding to the request type data includes paging information, it may be determined that the target UI model is a table model. And when the response data corresponding to the request type data does not include paging information, it may be determined that the target UI model may be a table model or a menu model.
When the API interface analyzes the data type in the data as submission type data, that is, submits the data in response to an operation of inputting the data by a user through the API interface, it may be determined that the target UI model may be a form model or a pop-up window model. When the submitted type data is single identification type data, for example, when data corresponding to a certain identification is deleted, the target UI model can be determined to be a popup model. When the submission-type data is a plurality of data, the target UI model may be determined to be a form model. When the submission-type data is a single non-identification-type data, the target UI model may be determined to be a form model or a pop-up window model.
In order to improve the accuracy of determining the target UI model, in an optional implementation manner of the embodiment of the present invention, after determining, in a preset UI model set according to API interface analysis data, a target UI model matching the API interface, the method further includes: when the number of the determined models in the target UI model is more than 1, generating a UI model confirmation list according to the target UI model; and updating the target UI model in response to the confirmation operation of the user on the single model in the UI model confirmation list.
The UI model confirmation list may include target UI models with the currently determined number of models greater than 1, that is, the UI model confirmation list may include at least 2 UI models. For example, UI model validation List
May be a confirmation list of form models and menu models; alternatively, the UI model validation list may be a table schema
Confirmation list of types and pop-up models. The UI model confirmation list can be displayed to a user through a display interface of the electronic equipment, and the user can perform model confirmation operation on the display interface. For example, the user may determine a certain UI model in the UI model confirmation list as the target UI model by clicking or touching on the display interface.
According to the technical scheme of the embodiment of the invention, the single target UI model can be accurately determined by responding to the model confirmation operation of the user, the single target UI model corresponds to the API interface which is currently analyzed, and the accurate UI component code can be generated.
And step 230, generating an information item list according to the API interface analysis data and the original configuration information corresponding to the target UI model.
The information item list may be a specific presentation of the API interface analysis data and the original configuration information corresponding to the target UI model. The list of information items may be selectable. For example, one or more items of information in the information item list may be selected by clicking or touching.
Specifically, the information item list may display the API interface analysis data and the original configuration information corresponding to the target UI model according to the type of the target UI model. For example, the target UI model is a form model, and a corresponding form may be generated according to the original configuration information of the form model, and the API interface analysis data is filled in the items of the form as parameters.
Wherein the user may select the information that the user wishes to generate from the list of information items. Specifically, all the information in the information item list may be selected by default, the user may cancel the information that is not desired to be generated by canceling the check operation, and the remaining information that is not canceled may be used as the configuration information corresponding to the UI configuration tree. For example, the user may cancel one or more items in the form and determine the remaining items as configuration information corresponding to the UI configuration tree.
And step 250, generating a UI configuration tree according to the configuration information.
The embodiment of the invention can confirm the secondary parameters of the UI model through the user. For example, for a table model, paging information associated with the table data needs to be identified; as another example, the form model requires identifying a list of parameters for generating form entries; as another example, which parameters in the interface represent results, which parameters represent project names, etc. After the secondary parameters are confirmed, the UI configuration tree is generated according to the configuration information, the configuration information can be intervened, the generated UI configuration tree is enabled to be more consistent with an actual service scene, the format correctness of the UI configuration tree is improved, and the accuracy of the subsequent UI component code generation is further improved.
And step 260, generating a preview effect graph of the UI according to the UI configuration tree.
Wherein, the preview effect picture is an editable effect picture. The preview effect graph may be a UI effect graph generated by performing front-end rendering according to the type of the UI model and the configuration information of the UI configuration tree and simulating the UI effect graph. The preview effect graph is set as an editable effect graph, so that a user can conveniently visually adjust based on the effect graph, and the final UI configuration tree is ensured to be matched with the service requirement.
And 270, acquiring editing information aiming at the preview effect picture, and updating the UI configuration tree according to the editing information.
The editing information may be information generated by modifying the preview effect image by the user. For example, the editing information may be title modification information for a form item or title modification information for a form column, or the like. The UI configuration tree is updated through the editing information, so that the default parameter information in the UI configuration tree can be modified into specific parameters corresponding to the service, the content correctness of the UI configuration tree is improved, and the accuracy of the subsequent generation of the UI component codes is further improved.
And step 280, updating parameter information in the interface code template corresponding to the UI configuration tree according to the configuration information corresponding to the UI configuration tree, and generating a target interface code.
The step may be to update specific parameters in the configuration information corresponding to the UI configuration tree to an original interface code template of the UI model. Specifically, the step may specifically generate the configuration information in the corresponding UI configuration tree according to a predefined conversion rule of each UI model, and may generate a code displayed on the interface of the UI component, that is, a target interface code.
The target interface code may be understood as static code for the UI component code. For example, the target interface code may be a code of a table, and may specifically include information such as row and column data, a title, and a table request interface of the table in the UI interface.
And 290, updating interface calling logic information in the logic code template corresponding to the UI configuration tree according to the API interface analysis data, and generating a target logic code.
Wherein, this step may be to generate a basic code, i.e. an original logic code template, based on a basic logic interaction template (interface call logic information) predefined by the UI model. The API interface analysis data comprises information such as interface addresses, request methods, request parameters, response data and the like when the interface is mobilized, and can be updated to a basic logic interaction template predefined by the UI model to generate a target logic code.
In particular, logic code may be understood as dynamic code, which is associated with calls to the API interface. Illustratively, operations on the UI model may be included in the logic code. For example, deletion or editing of a single piece of data in a table; in another example, a row data delete or edit action of the table; for another example, a pop-up window may appear after a button is clicked.
Wherein the target interface code and the target logic code may be combined to generate the UI component code. The UI component code comprises view (interface) related code and view operation logic code, and is dynamic code capable of carrying out real business operation. For example, the generated UI code of the form may include interface code when the form is displayed and also include logic code of a form submission button. In the specific application, the form can be displayed according to the generated UI component codes, a user can edit the form and the like, and can also submit the form, namely the UI component codes are complete and specific business processing can be performed.
According to the technical scheme of the embodiment of the invention, the interface information of the API corresponding to the UI component is obtained, and the local interface request is initiated according to the interface information, so that the response data corresponding to the local interface request is obtained; generating API interface analysis data according to the interface information and the response data, and determining a target UI model matched with the API interface in a preset UI model set according to the API interface analysis data; generating an information item list according to the API interface analysis data and original configuration information corresponding to the target UI model; responding to the selection operation of the user on the information item list, and determining configuration information corresponding to the UI configuration tree; generating a UI configuration tree according to the configuration information; generating a preview effect graph of the UI according to the UI configuration tree; acquiring editing information aiming at the preview effect picture, and updating a UI configuration tree according to the editing information; updating parameter information in an interface code template corresponding to the UI configuration tree according to the configuration information corresponding to the UI configuration tree, and generating a target interface code; updating interface calling logic information in a logic code template corresponding to the UI configuration tree according to the API interface analysis data to generate a target logic code; according to the target interface code and the target logic code, the UI component code is generated, the problem of quick generation of the front-end component code is solved, and the dynamic code containing the logic relation can be generated according to analysis of the API interface information, so that the threshold of front-end development is reduced, and the research and development efficiency is improved; and the accuracy of code generation can be improved through a visual interface, so that the generated code is more suitable for the real business requirement.
Fig. 2b is a flowchart of another UI component code generation method according to the second embodiment of the present invention. As shown in fig. 2b, the specific generation process of UI component code may be: and identifying the API interface and analyzing the data. For example, the API interface includes an interface address and an interface parameter, and the interface identification stage may initiate a local interface request through the interface address and the interface parameter, and obtain response data of the interface. In the data analysis stage, the request method of the API interface, the interface parameters (each parameter type, data, and the like), and the interface response data (each response data, type, and the like) may be specifically analyzed in sequence to generate API interface analysis data. According to the API interface analysis data, built-in UI models (tables, forms, popup windows, menus and the like) can be matched, target UI models which can be generated by the API interface are identified, and confirmation is carried out through a user. After the user confirms the UI model, the user may perform secondary parameter confirmation on the configuration information (API interface analysis data and original configuration information of the target UI model), thereby generating the UI configuration tree. And generating a corresponding preview effect picture by performing front-end simulation on the UI model tree. And providing partial data for secondary editing by the user in the preview effect picture, and updating the UI configuration tree according to the editing information of the user on the preview effect picture. According to the updated UI configuration tree, the configuration information of the UI configuration tree can be converted into UI component codes, and specifically generation of target interface codes and target logic codes is included. Through the process, dynamic codes containing logical relations can be generated according to analysis of API interface information, so that the threshold of front-end development is reduced, and the research and development efficiency is improved; and the accuracy of code generation can be improved through a visual interface, so that the generated code is more suitable for the real business requirement.
EXAMPLE III
Fig. 3 is a flowchart of a method for generating a CRUD page in a third embodiment of the present invention, which is added based on the above embodiment, and in this embodiment, a flow for implementing the method for generating the CRUD page is specifically defined. As shown in fig. 3, the method of this embodiment may include:
Wherein, the Create Delete Update Delete (CRUD) may be an operation that is common to some data in a service scene by the middle back end. The CRUD page relates to four API interfaces, namely a new interface, a delete interface, an update interface and a retrieval interface. In the embodiment of the invention, the corresponding UI component codes can be respectively generated by adopting a UI component code generation method according to the specific API interface related to the CRUD interface.
And step 320, determining the parameter corresponding relation among the target API interfaces, constructing the incidence relation among the UI component codes corresponding to the target API interfaces according to the parameter corresponding relation, and generating CRUD page codes.
The generated UI component code can be built into a code corresponding to the CRUD interface according to the specific configuration of the CRUD interface. The specific configuration of the CRUD interface can be generated according to the parameter correspondence between the API interfaces. The parameter correspondence between the API interfaces may be determined by a specific call relationship between the API interfaces or a usage relationship of API interface data in a specific service. According to the parameter corresponding relation between the API interfaces, the corresponding UI component codes can be correlated, so that the logical relation of the UI component codes is realized, and the codes corresponding to the CRUD interface are built.
And step 330, generating a CRUD page according to the CRUD page code.
And performing page rendering according to the CRUD page code to generate a CRUD page. The CRUD page generation mode can greatly reduce the repetitive work of front-end developers, namely, the front-end developers do not need to generate UI component codes repeatedly and perform code association, the research and development efficiency can be improved, and the front-end developers can be released from conventional service requests.
In an optional implementation manner of the embodiment of the present invention, determining a parameter correspondence between target API interfaces includes: according to the response data of the current target API interface, performing data matching with the interface information of each remaining target API interface; and determining the parameter corresponding relation between the target response data successfully matched with the data and the target interface information.
And performing data matching with the interface information of each remaining target API according to the response data of the current target API, namely determining whether the response data of the current target API is the request parameter required by the remaining target API. For example, the current target API interface may be read data, an associated API interface for updating or editing the read data exists in the remaining target API interfaces, and it may be determined that there is a parameter correspondence between response data of the current target API interface and request parameters of the associated API interface, so that the current target API interface may be associated with the associated API interface.
In the specific application of this step, the determined parameter correspondence may be submitted to a user for confirmation. For example, a parameter correspondence confirmation list may be generated according to the parameter correspondence between API interfaces; and updating the parameter corresponding relation in response to the adjustment operation of the user on the parameter corresponding relation confirmation list. The generated parameter corresponding relation can be determined to be reliable, and the correlation relation between UI component codes is ensured to be correct, so that the generated CRUD page is ensured to be in accordance with expectation.
According to the technical scheme of the embodiment of the invention, the UI component code generation method provided by any embodiment of the invention is adopted to generate the UI component code of the user interface corresponding to the target application program interface API related to the CRUD page; determining the parameter corresponding relation between target API interfaces, constructing the incidence relation between UI component codes corresponding to the target API interfaces according to the parameter corresponding relation, and generating CRUD page codes; according to the CRUD page code, the CRUD page is generated, the problem that the CRUD page is built according to the front end component code is solved, the threshold of front end development can be reduced, personnel who are not familiar with the front end development can build a conventional CRUD page, the rear end development can be independent of front end development personnel, a matched front end system can be built independently, and therefore the development efficiency is improved.
Example four
Fig. 4 is a schematic structural diagram of a UI component code generation apparatus in the fourth embodiment of the present invention. As shown in fig. 4, the UI component code generating apparatus includes: in response to the data acquisition module 410, the target UI model determination module 420, the UI configuration tree generation module 430, and the UI component code generation module 440. Wherein:
a response data obtaining module 410, configured to obtain interface information of an API corresponding to the UI component, initiate a local interface request according to the interface information, and obtain response data corresponding to the local interface request;
a target UI model determining module 420, configured to generate API interface analysis data according to the interface information and the response data, and determine a target UI model matching the API interface in a preset UI model set according to the API interface analysis data;
the UI configuration tree generating module 430 is configured to generate a UI configuration tree according to the API interface analysis data and the original configuration information corresponding to the target UI model;
the UI component code generating module 440 is configured to generate UI component codes according to the interface code template, the logic code template and the API interface analysis data corresponding to the UI configuration tree.
Optionally, the UI model set is a set formed by one or more items of a form model, a popup model and a menu model;
a target UI model determination module 420 comprising:
the first target UI model determining unit is used for determining the form model as a target UI model matched with the API in a preset UI model set when the API interface analysis data is determined to be request type data and the API interface analysis data contains paging information;
the second target UI model determining unit is used for determining the form model and the menu model as target UI models matched with the API in a preset UI model set when the API interface analysis data is determined to be request type data and does not contain paging information;
a third target UI model determining unit, configured to determine, when it is determined that the API interface analysis data is the submission-type data and the API interface analysis data is the single identification-type data, a popup model as a target UI model matching the API interface in a preset UI model set;
a fourth target UI model determining unit, configured to determine, when it is determined that the API interface analysis data is submission-type data and the API interface analysis data is multiple submission data, the form model as a target UI model that matches the API interface in a preset UI model set;
and the fifth target UI model determining unit is used for determining the form model and the popup window model as target UI models matched with the API in a preset UI model set when the API interface analysis data is determined to be the submission type data and the API interface analysis data is determined to be single non-identification type data.
Optionally, the apparatus further includes:
the UI model confirmation list generation module is used for determining a target UI model matched with the API in a preset UI model set according to the API interface analysis data and generating a UI model confirmation list according to the target UI model when the number of the determined models in the target UI model is more than 1;
and the target UI model updating module is used for responding to the confirmation operation of the user on the single model in the UI model confirmation list and updating the target UI model.
Optionally, the UI configuration tree generating module 430 includes:
the information item list generating unit is used for generating an information item list according to the API interface analysis data and the original configuration information corresponding to the target UI model;
the configuration information determining unit is used for responding to the selection operation of the user on the information item list and determining the configuration information corresponding to the UI configuration tree;
and the UI configuration tree generating unit is used for generating the UI configuration tree according to the configuration information.
Optionally, the apparatus further includes:
the preview effect graph generating module is used for generating a preview effect graph of the UI according to the UI configuration tree before analyzing data according to the interface code template, the logic code template and the API corresponding to the UI configuration tree and generating UI component codes, wherein the preview effect graph is an editable effect graph;
and the UI configuration tree updating module is used for acquiring the editing information aiming at the preview effect picture and updating the UI configuration tree according to the editing information.
Optionally, the UI component code generating module 440 includes:
the target interface code generating unit is used for updating the parameter information in the interface code template corresponding to the UI configuration tree according to the configuration information corresponding to the UI configuration tree and generating a target interface code;
the target logic code generating unit is used for updating interface calling logic information in a logic code template corresponding to the UI configuration tree according to the API interface analysis data and generating a target logic code;
and the UI component code generating unit is used for generating the UI component code according to the target interface code and the target logic code.
The UI component code generation device provided by the embodiment of the invention can execute the UI component code generation method provided by any embodiment of the invention, and has corresponding functional modules and beneficial effects of the execution method.
EXAMPLE five
Fig. 5 is a schematic structural diagram of a CRUD page generation apparatus in the fifth embodiment of the present invention. As shown in fig. 5, the CRUD page generation device includes: a UI component code generating module 510, a CRUD page code generating module 520, and a CRUD page generating module 530. Wherein:
a UI component code generating module 510, configured to generate a user interface UI component code corresponding to a target API interface related to a CRUD page by using a UI component code generating method provided in any embodiment of the present invention;
a CRUD page code generating module 520, configured to determine a parameter correspondence between target API interfaces, and construct an association between UI component codes corresponding to the target API interfaces according to the parameter correspondence, so as to generate a CRUD page code;
and a CRUD page generating module 530, configured to generate a CRUD page according to the CRUD page code.
Optionally, the CRUD page code generating module 520 includes:
the data matching unit is used for performing data matching with the interface information of each remaining target API according to the response data of the current target API;
and the parameter corresponding relation determining unit is used for determining the parameter corresponding relation between the target response data with successful data matching and the target interface information.
The CRUD page generation device provided by the embodiment of the invention can execute the CRUD page generation method provided by any embodiment of the invention, and has corresponding functional modules and beneficial effects of the execution method.
EXAMPLE six
Fig. 6 is a schematic structural diagram of a computer apparatus according to a sixth embodiment of the present invention, as shown in fig. 6, the computer apparatus includes a processor 60, a memory 61, an input device 62, and an output device 63; the number of processors 60 in the computer device may be one or more, and one processor 60 is taken as an example in fig. 6; the processor 60, the memory 61, the input device 62 and the output device 63 in the computer apparatus may be connected by a bus or other means, and the connection by the bus is exemplified in fig. 6.
The memory 61 is a computer-readable storage medium that can be used to store software programs, computer-executable programs, and modules, such as program instructions/modules corresponding to the UI component code generation method or the CRUD page generation method in the embodiment of the present invention (for example, the response data acquisition module 410, the target UI model determination module 420, the UI configuration tree generation module 430, and the UI component code generation module 440 shown in fig. 4, or the UI component code generation module 510, the CRUD page code generation module 520, and the CRUD page generation module 530 shown in fig. 5). The processor 60 executes various functional applications and data processing of the computer device by running software programs, instructions, and modules stored in the memory 61, that is, implements the above-described UI component code generation method or CRUD page generation method:
acquiring interface information of an API (application program interface) corresponding to a UI (user interface) component, initiating a local interface request according to the interface information, and acquiring response data corresponding to the local interface request;
generating API interface analysis data according to the interface information and the response data, and determining a target UI model matched with the API interface in a preset UI model set according to the API interface analysis data;
generating a UI configuration tree according to the API interface analysis data and original configuration information corresponding to the target UI model;
and generating the UI component code according to the interface code template, the logic code template and the API interface analysis data corresponding to the UI configuration tree.
Alternatively, the first and second electrodes may be,
generating a user interface UI component code corresponding to a target API related to a CRUD page by adopting a UI component code generation method provided by any embodiment of the invention;
determining the parameter corresponding relation between target API interfaces, constructing the incidence relation between UI component codes corresponding to the target API interfaces according to the parameter corresponding relation, and generating CRUD page codes;
and generating the CRUD page according to the CRUD page code.
The memory 61 may mainly include a program storage area and a data storage area, wherein the program storage area may store an operating system, an application program required for at least one function; the storage data area may store data created according to the use of the terminal, and the like. Further, the memory 61 may include high speed random access memory, and may also include non-volatile memory, such as at least one magnetic disk storage device, flash memory device, or other non-volatile solid state storage device. In some examples, the memory 61 may further include memory located remotely from the processor 60, which may be connected to a computer device over a network. Examples of such networks include, but are not limited to, the internet, intranets, local area networks, mobile communication networks, and combinations thereof.
The input device 62 may be used to receive input numeric or character information and to generate key signal inputs relating to user settings and function controls of the computer apparatus. The output device 63 may include a display device such as a display screen.
EXAMPLE seven
The seventh embodiment of the present invention further discloses a computer storage medium, on which a computer program is stored, where the computer program, when executed by a processor, implements the UI component code generating method or the CRUD page generating method described above:
acquiring interface information of an API (application program interface) corresponding to a UI (user interface) component, initiating a local interface request according to the interface information, and acquiring response data corresponding to the local interface request;
generating API interface analysis data according to the interface information and the response data, and determining a target UI model matched with the API interface in a preset UI model set according to the API interface analysis data;
generating a UI configuration tree according to the API interface analysis data and original configuration information corresponding to the target UI model;
and generating the UI component code according to the interface code template, the logic code template and the API interface analysis data corresponding to the UI configuration tree.
Alternatively, the first and second electrodes may be,
generating a user interface UI component code corresponding to a target API related to a CRUD page by adopting a UI component code generation method provided by any embodiment of the invention;
determining the parameter corresponding relation between target API interfaces, constructing the incidence relation between UI component codes corresponding to the target API interfaces according to the parameter corresponding relation, and generating CRUD page codes;
and generating the CRUD page according to the CRUD page code.
Computer storage media for embodiments of the invention may employ any combination of one or more computer-readable media. The computer readable medium may be a computer readable signal medium or a computer readable storage medium. The computer-readable storage medium may be, for example, but is not limited to: an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination thereof. More specific examples (a non-exhaustive list) of the computer readable storage medium would include the following: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the context of this document, a computer readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device.
A computer readable signal medium may include a propagated data signal with computer readable program code embodied therein, for example, in baseband or as part of a carrier wave. Such a propagated data signal may take many forms, including, but not limited to, electro-magnetic, optical, or any suitable combination thereof. A computer readable signal medium may also be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device.
Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to wireless, wireline, optical fiber cable, RF, etc., or any suitable combination of the foregoing.
Computer program code for carrying out operations for aspects of the present invention may be written in any combination of one or more programming languages, including an object oriented programming language such as Java, Smalltalk, C + +, or the like, as well as conventional procedural programming languages, such as the "C" programming language or similar programming languages. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the case of a remote computer, the remote computer may be connected to the user's computer through any type of network, including a Local Area Network (LAN) or a Wide Area Network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet service provider).
It is to be noted that the foregoing is only illustrative of the preferred embodiments of the present invention and the technical principles employed. It will be understood by those skilled in the art that the present invention is not limited to the particular embodiments illustrated herein, but is capable of various obvious changes, rearrangements and substitutions as will now become apparent to those skilled in the art without departing from the scope of the invention. Therefore, although the present invention has been described in greater detail by the above embodiments, the present invention is not limited to the above embodiments, and may include other equivalent embodiments without departing from the spirit of the present invention, and the scope of the present invention is determined by the scope of the appended claims.
Claims (12)
1. A UI component code generation method, comprising:
acquiring interface information of an Application Program Interface (API) corresponding to a User Interface (UI) component, initiating a local interface request according to the interface information, and acquiring response data corresponding to the local interface request;
generating API interface analysis data according to the interface information and the response data, and determining a target UI model matched with the API interface in a preset UI model set according to the API interface analysis data;
generating a UI configuration tree according to the API interface analysis data and original configuration information corresponding to the target UI model;
and generating the UI component code according to the interface code template, the logic code template and the API interface analysis data corresponding to the UI configuration tree.
2. The method of claim 1, wherein the UI model set is a set of one or more of a table model, a form model, a pop-up window model, and a menu model;
determining a target UI model matched with the API interface in a preset UI model set according to the API interface analysis data, wherein the target UI model comprises the following steps:
when the API interface analysis data is determined to be request type data and the API interface analysis data contains paging information, determining a table model as a target UI model matched with an API interface in a preset UI model set;
when the API interface analysis data is determined to be request type data and the API interface analysis data does not contain paging information, determining a form model and a menu model as a target UI model matched with an API interface in a preset UI model set;
when the API interface analysis data are determined to be the submission type data and the API interface analysis data are the single identification type data, determining a popup window model as a target UI model matched with the API interface in a preset UI model set;
when the API interface analysis data are determined to be submission type data and the API interface analysis data are multiple submission data, determining a form model as a target UI model matched with an API interface in a preset UI model set;
and when determining that the API interface analysis data is submission type data and the API interface analysis data is single non-identification type data, determining the form model and the popup window model as a target UI model matched with the API interface in a preset UI model set.
3. The method of claim 2, after determining a target UI model matching an API interface from the API interface analysis data in a preset UI model set, further comprising:
when the number of the determined models in the target UI model is larger than 1, generating a UI model confirmation list according to the target UI model;
and updating the target UI model in response to the confirmation operation of the user on the single model in the UI model confirmation list.
4. The method of claim 1, wherein generating a UI configuration tree based on the API interface analysis data and raw configuration information corresponding to the target UI model comprises:
generating an information item list according to the API interface analysis data and original configuration information corresponding to the target UI model;
responding to the selection operation of the user on the information item list, and determining the configuration information corresponding to the UI configuration tree;
and generating the UI configuration tree according to the configuration information.
5. The method of claim 1, further comprising, before generating the UI component code according to the interface code template, the logic code template, and the API interface analysis data corresponding to the UI configuration tree, further:
generating a preview effect graph of the UI according to the UI configuration tree, wherein the preview effect graph is an editable effect graph;
and acquiring editing information aiming at the preview effect picture, and updating the UI configuration tree according to the editing information.
6. The method of claim 1, wherein generating the UI component code according to the interface code template, the logic code template and the API interface analysis data corresponding to the UI configuration tree comprises:
updating parameter information in an interface code template corresponding to the UI configuration tree according to the configuration information corresponding to the UI configuration tree to generate a target interface code;
updating interface calling logic information in a logic code template corresponding to the UI configuration tree according to the API interface analysis data to generate a target logic code;
and generating the UI component code according to the target interface code and the target logic code.
7. A CRUD page generation method is characterized by comprising the following steps:
generating User Interface (UI) component codes corresponding to target Application Program Interfaces (APIs) involved in the adding, deleting, modifying and checking of CRUD pages by adopting the UI component code generation method of any one of claims 1-6;
determining the parameter corresponding relation between target API interfaces, constructing the incidence relation between UI component codes corresponding to the target API interfaces according to the parameter corresponding relation, and generating CRUD page codes;
and generating the CRUD page according to the CRUD page code.
8. The method of claim 7, wherein determining a parameter correspondence between target API interfaces comprises:
according to the response data of the current target API interface, performing data matching with the interface information of each remaining target API interface;
and determining the parameter corresponding relation between the target response data successfully matched with the data and the target interface information.
9. A UI component code generating apparatus, comprising:
the response data acquisition module is used for acquiring interface information of an Application Program Interface (API) corresponding to a User Interface (UI) component, initiating a local interface request according to the interface information and acquiring response data corresponding to the local interface request;
the target UI model determining module is used for generating API interface analysis data according to the interface information and the response data and determining a target UI model matched with the API interface in a preset UI model set according to the API interface analysis data;
the UI configuration tree generation module is used for generating a UI configuration tree according to the API interface analysis data and the original configuration information corresponding to the target UI model;
and the UI component code generating module is used for generating the UI component code according to the interface code template, the logic code template and the API interface analysis data corresponding to the UI configuration tree.
10. An apparatus for generating a CRUD page, comprising:
a UI component code generating module, configured to generate, by using the UI component code generating method according to any one of claims 1 to 6, UI component codes corresponding to target Application Program Interfaces (APIs) involved in the adding, deleting, modifying and checking of the CRUD page;
the CRUD page code generating module is used for determining the parameter corresponding relation between the target API interfaces, constructing the incidence relation between the UI component codes corresponding to the target API interfaces according to the parameter corresponding relation and generating CRUD page codes;
and the CRUD page generating module is used for generating the CRUD page according to the CRUD page code.
11. A computer device, comprising:
at least one processor; and
a memory communicatively coupled to the at least one processor; wherein the content of the first and second substances,
the memory stores instructions executable by the at least one processor to enable the at least one processor to perform the UI component code generation method of any of claims 1-6 or to perform the CRUD page generation method of any of claims 7-8.
12. A non-transitory computer readable storage medium storing computer instructions for causing the computer to execute the UI component code generation method according to any one of claims 1 to 6 or the CRUD page generation method according to any one of claims 7 to 8.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110920849.0A CN113656028B (en) | 2021-08-11 | 2021-08-11 | UI component code generation method, device and equipment, and CRUD page generation method, device and equipment |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110920849.0A CN113656028B (en) | 2021-08-11 | 2021-08-11 | UI component code generation method, device and equipment, and CRUD page generation method, device and equipment |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN113656028A true CN113656028A (en) | 2021-11-16 |
| CN113656028B CN113656028B (en) | 2023-11-14 |
Family
ID=78491437
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202110920849.0A Active CN113656028B (en) | 2021-08-11 | 2021-08-11 | UI component code generation method, device and equipment, and CRUD page generation method, device and equipment |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN113656028B (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN114579112A (en) * | 2022-02-25 | 2022-06-03 | 北京圣博润高新技术股份有限公司 | Method, device, equipment and storage medium for assisting system development |
Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20190340230A1 (en) * | 2018-05-07 | 2019-11-07 | Web.Com Group, Inc. | System and method for generating websites from predefined templates |
| CN110580189A (en) * | 2019-09-06 | 2019-12-17 | 深圳前海环融联易信息科技服务有限公司 | method and device for generating front-end page, computer equipment and storage medium |
| CN110727429A (en) * | 2019-09-18 | 2020-01-24 | 东软集团股份有限公司 | Front-end page generation method, device and equipment |
| CN112416363A (en) * | 2020-12-09 | 2021-02-26 | 锐捷网络股份有限公司 | Method and device for generating front-end and back-end CRUD codes |
-
2021
- 2021-08-11 CN CN202110920849.0A patent/CN113656028B/en active Active
Patent Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20190340230A1 (en) * | 2018-05-07 | 2019-11-07 | Web.Com Group, Inc. | System and method for generating websites from predefined templates |
| CN110580189A (en) * | 2019-09-06 | 2019-12-17 | 深圳前海环融联易信息科技服务有限公司 | method and device for generating front-end page, computer equipment and storage medium |
| CN110727429A (en) * | 2019-09-18 | 2020-01-24 | 东软集团股份有限公司 | Front-end page generation method, device and equipment |
| CN112416363A (en) * | 2020-12-09 | 2021-02-26 | 锐捷网络股份有限公司 | Method and device for generating front-end and back-end CRUD codes |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN114579112A (en) * | 2022-02-25 | 2022-06-03 | 北京圣博润高新技术股份有限公司 | Method, device, equipment and storage medium for assisting system development |
| CN114579112B (en) * | 2022-02-25 | 2023-10-20 | 北京圣博润高新技术股份有限公司 | Method, device, equipment and storage medium for assisting system development |
Also Published As
| Publication number | Publication date |
|---|---|
| CN113656028B (en) | 2023-11-14 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN111310934B (en) | Model generation method and device, electronic equipment and storage medium | |
| US20220004705A1 (en) | Personalization of content suggestions for document creation | |
| CN1828526A (en) | Automatic user interface updating in business processes | |
| TWI661349B (en) | Method and system for generating conversational user interface | |
| CN110941467A (en) | Data processing method, device and system | |
| CN110968305A (en) | Applet visualization generation method, device, equipment and storage medium | |
| CN111813409A (en) | Code generation method, device, equipment and storage medium of interactive interface | |
| CN114328276A (en) | Test case generation method and device, and test case display method and device | |
| CN117057318A (en) | Domain model generation method, device, equipment and storage medium | |
| CN113656028A (en) | UI component code generation method, CRUD page generation method, device and equipment | |
| US20220143825A1 (en) | Automated process robotic system, method, non transitory computer readable recording medium and computer program product with integrated process and automated data analysis | |
| CN114201144A (en) | Micro service system construction method, device and medium based on domain-driven design | |
| CN113419711A (en) | Page guiding method and device, electronic equipment and storage medium | |
| CN113238739A (en) | Plug-in development and data acquisition method, device, electronic equipment and medium | |
| CN111061522B (en) | Method, device, equipment and storage medium for generating front-end card assembly based on back end | |
| CN114072787A (en) | System and method for fast data entry to facilitate document review | |
| US20210055928A1 (en) | Integration test framework | |
| US11663199B1 (en) | Application development based on stored data | |
| CN108763066A (en) | A kind of natural language test script edit methods of word slot design and test machine people | |
| CN114928566A (en) | Client function testing method and device, storage medium and electronic equipment | |
| US11328018B2 (en) | System and method for state dependency based task execution and natural language response generation | |
| CN114090436A (en) | Test method and device | |
| CN113296912A (en) | Task processing method, device and system, storage medium and electronic equipment | |
| CN113779117A (en) | Data monitoring method and device, storage medium and electronic equipment | |
| JP7241201B2 (en) | Sampling target identification method, device, electronic device and computer readable storage medium |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |