Application generation method, device, readable storage medium and program product applied to low-code platform

Abstract

The method comprises the following steps: according to a preset trigger instruction received in a session area of an application program editing interface, displaying a component list, the component list comprising information of at least one component of the application program, and the application program editing interface presenting an application program in an editing state; in response to a selection operation in the component list and an instruction of performing a target operation on the selected component, calling an intelligent assistant to generate code; and generating an editing result of the application program according to the code. The matching degree between the obtained application program editing result and the actual demand of the user is improved, and the accuracy of the obtained application program editing result is improved.

Description

Technical Field

[0001] This disclosure relates to the field of computer technology, and in particular to a method, apparatus, readable storage medium, and program product for generating applications on a low-code platform. Background Technology

[0002] Low-code platforms, such as Application Platform as a Service (aPaaS), provide users with rapid application development services. Low-code platforms allow users to quickly build applications that meet their needs with little or no code development.

[0003] Furthermore, with the development of artificial intelligence technology, users are increasingly using code editing models to generate code. Users can provide context and design requirements, which the code editing model then generates. This allows users to develop complete applications simply by inputting natural language. In low-code platforms, users can also build or maintain applications by inputting natural language.

[0004] Currently, when users develop applications by inputting context and design requirements through natural language input, problems arise such as inaccurate expression of requirements and inaccurate description of context, resulting in the generated code not matching the user's actual needs when generating application pages. Summary of the Invention

[0005] This disclosure provides an application generation method, device, readable storage medium, and application product to improve travel rates.

[0006] In a first aspect, embodiments of this disclosure provide an application generation method for a low-code platform, comprising:

[0007] Based on a preset trigger command received in the session area of ​​the application editing interface, a component list is displayed, which includes information on at least one component of the application, and the application in editing mode is displayed on the application editing interface;

[0008] In response to a selection operation in the component list and an instruction to perform a target operation on the selected component, the intelligent assistant is invoked to generate code;

[0009] The edited result of the application is generated based on the code.

[0010] Secondly, embodiments of this disclosure provide an application generation apparatus for a low-code platform, comprising:

[0011] The display unit is used to display a component list according to a preset trigger command received in the session area of ​​the application editing interface. The component list includes information on at least one component of the application, and the application in the editing state is displayed on the application editing interface.

[0012] The calling unit is used to call the intelligent assistant to generate code in response to a selection operation in the component list and an instruction to perform a target operation on the selected component;

[0013] The generation unit is used to generate the edited result of the application based on the code.

[0014] Thirdly, embodiments of this disclosure provide an electronic device, including: a processor and a memory;

[0015] The memory stores computer-executed instructions;

[0016] The processor executes computer execution instructions stored in the memory, causing the at least one processor to perform the method described in the first aspect above and various possible designs of the first aspect.

[0017] Fourthly, embodiments of this disclosure provide a computer-readable storage medium storing computer-executable instructions, which, when executed by a processor, implement the methods described in the first aspect and various possible designs of the first aspect.

[0018] Fifthly, embodiments of this disclosure provide a computer program product, including a computer program that, when executed by a processor, implements the method described in the first aspect above and various possible designs of the first aspect.

[0019] This embodiment provides an application generation method, device, readable storage medium, and program product for a low-code platform. The method displays a component list based on a preset trigger command received in the session area of ​​the application editing interface. The component list includes information about at least one component of the application, and the application editing interface displays the application in an editing state. In response to a selection operation in the component list and a command to perform a target operation on the selected component, a smart assistant is invoked to generate code. The edited result of the application is generated based on the code. This method achieves the display of an available component list based on a trigger, allowing the user to select a target component from the list. Compared to interaction solely through natural language, this operation allows for precise selection of application components requiring further editing, avoiding inaccurate descriptions by the user using natural language. This improves the matching degree between the obtained application editing result and the user's actual needs, as well as the accuracy of the obtained application editing result. Attached Figure Description

[0020] To more clearly illustrate the technical solutions in the embodiments of this disclosure or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of this disclosure. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0021] Figure 1 A flowchart illustrating the application generation method for low-code platforms provided in this embodiment of the disclosure. Figure 1 ;

[0022] Figure 2 A flowchart illustrating the application generation method for low-code platforms provided in this embodiment of the disclosure. Figure 2 ;

[0023] Figure 3A This is a schematic diagram of an application scenario provided by an embodiment of the present disclosure;

[0024] Figure 3B This is a schematic diagram of an application scenario provided by an embodiment of the present disclosure;

[0025] Figure 3C This is a schematic diagram of an application scenario provided by an embodiment of the present disclosure;

[0026] Figure 3D This is a schematic diagram of an application scenario provided by an embodiment of the present disclosure;

[0027] Figure 3E This is a schematic diagram of an application scenario provided by an embodiment of the present disclosure;

[0028] Figure 4 A structural block diagram of an application generation apparatus for a low-code platform provided in an embodiment of this disclosure;

[0029] Figure 5 This is a schematic diagram of the hardware structure of an electronic device provided in an embodiment of this disclosure. Detailed Implementation

[0030] To make the objectives, technical solutions, and advantages of the embodiments of this disclosure clearer, the technical solutions of the embodiments of this disclosure will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this disclosure, and not all embodiments. Based on the embodiments of this disclosure, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this disclosure.

[0031] When users generate code using a code editing model, and when developing applications using natural language, they describe the requirements and context in natural language. The complexity of application development necessitates a high information density that natural language must convey. For example, users need to describe the layout of the entire page, specifying the placement of content. For instance, describing the left-hand relative position of content 'a' compared to 'b', and the distance between them. In data processing, complex data calculation logic also needs to be described. On the one hand, the efficiency of the above descriptions is relatively low; on the other hand, natural language descriptions are prone to inaccurate expression and contextual descriptions. Therefore, the efficiency of application development using a code editing model needs improvement, and the degree of matching between applications developed using this model and actual user needs also needs to be enhanced.

[0032] This disclosure provides a function that presents component information for editing an application to the user through a trigger command. Components can be selected from this component information as input text for the application component. This simplifies user input, improves message accuracy, and facilitates the model's accurate understanding of the message, thereby increasing the accuracy of the generated code and improving the match between the application editing results generated by the code and the user's needs.

[0033] Please refer to Figure 1 , Figure 1 A flowchart illustrating the application generation method for low-code platforms provided in this disclosure. Figure 1 ,like Figure 1 As shown, the method includes the following steps:

[0034] S101: Display the application editing interface based on user operation, where the application editing interface displays information about the smart assistant.

[0035] In this disclosure, the execution entity of the application generation method applied to the low-code platform can be a low-code platform application development client running on various electronic devices. These electronic devices can be user terminal devices or servers.

[0036] The aforementioned applications can be either applications under development or applications that have been released but are yet to be maintained.

[0037] Users can open applications under development or awaiting maintenance, and the aforementioned execution entity displays the application editing interface. This application editing interface can be the main interface, through which users can also access the editing interface of any page within the application. In some examples, this editing interface can display a list of the application's existing pages. Furthermore, this editing interface can also display information about the smart assistant, such as the smart assistant's identifier.

[0038] S102: In response to receiving a session trigger operation with the smart assistant, display the session area.

[0039] In one example, a user can issue the aforementioned session triggering operation. Upon receiving the session instruction, the executing entity displays a session area for interacting with the smart assistant. This session area includes a message input box. Illustratively, the session operation could be, for example, a triggering operation performed on the smart assistant's identifier.

[0040] S103: Based on the preset trigger command received in the session area of ​​the application editing interface, display the component list, which includes information on at least one component of the application, and display the application in editing mode on the application editing interface.

[0041] Text content can be entered in the message input box via voice or text input. Preset trigger commands can also be issued in the message input box. Upon receiving the preset trigger command, the executing entity can display the component list. The preset trigger command can be any predefined type of command used to invoke the component list. The preset trigger command can be set according to different application scenarios; no restrictions are imposed here.

[0042] S104: In response to a selection operation in the component list and an instruction to perform a target operation on the selected component, invoke the intelligent assistant to generate code.

[0043] As an example, the aforementioned execution entity can automatically write the information of the target component after the cursor in the message input box based on the selection operation. The information of the target component could be, for example, its identifier. Upon completion of the input operation in the message input box, the execution entity can retrieve the message entered in the message input box, and then invoke the intelligent assistant to generate code based on the message.

[0044] In one example, the aforementioned intelligent assistant can be associated with various code editing models. When the aforementioned execution entity calls the intelligent assistant, the intelligent assistant can interact with its associated code editing model and use the code editing model to generate code based on the aforementioned message.

[0045] S105: Generate the application's editing results based on the code.

[0046] Specifically, it can load the application's page layout, component tree, component properties and styles, as well as data objects, the logical relationships between data objects, page-related logic (event handlers), and processes based on the code. Based on the page layout, component tree, component properties and styles, data objects, the logical relationships between data objects, and page-related logic (event handlers), it renders the application's user interface, thus obtaining the application's editing results.

[0047] In this embodiment, a component list is displayed based on a preset trigger command received in the session area of ​​the application editing interface. The component list includes information on at least one component of the application, and the application in editing mode is displayed on the application editing interface. In response to a selection operation in the component list and a command to perform a target operation on the selected component, the intelligent assistant is invoked to generate code. The editing result of the application is generated based on the code. This achieves the display of an available component list based on a trigger. The user can select the target component to be entered in the component list. Compared with the interaction method based solely on natural language, this operation can accurately select the application component that needs further editing, avoiding the problem of inaccurate descriptions by the user using natural language. This improves the matching degree between the obtained application editing result and the user's actual needs, as well as the accuracy of the obtained application editing result.

[0048] In some embodiments, step S104 above includes the following steps:

[0049] First, generate a prompt message that includes information about the target component.

[0050] Secondly, the intelligent assistant is invoked based on the prompt information, so that the intelligent assistant can generate code according to the prompt information.

[0051] In one example, a prompt template can be pre-built, which can include multiple pre-defined components such as the task, input data, context, and output requirements. The information from this target template can be written into the input data section to obtain the prompt message.

[0052] In these embodiments, the intelligent assistant is invoked to generate code through the aforementioned prompt information. The prompt information helps the intelligent assistant understand the task requirements and context, enabling it to efficiently generate code that matches the user's needs.

[0053] The aforementioned intelligent assistant can edit the code based on the prompts provided. Finally, it outputs the code generated based on the prompts.

[0054] In some implementations, the above-mentioned invocation of the smart assistant based on the prompt information, so that the smart assistant generates code according to the prompt information, includes:

[0055] Obtain the target component's metadata through a preset interface, and generate new prompt information based on the metadata;

[0056] Send the new prompt to the smart assistant, which will then generate code based on the new prompt.

[0057] In order for the intelligent assistant to generate accurate code, the target component's metadata needs to be provided to the intelligent assistant.

[0058] The aforementioned preset interface can be a preset interface provided by the database. The database can store the identifiers and metadata of multiple components in association. The executing entity can obtain the metadata of the target component through the database interface and edit the original prompt message based on the metadata to obtain a new prompt message with the added metadata of the target component.

[0059] In one example, the target component mentioned above is a page layout, and the metadata of the target component includes a rule description of the page layout.

[0060] In one example, the target component is a form, and the metadata of the target component includes UI layout, field attributes, data binding to business logic, and behavior.

[0061] In one example, the target component mentioned above is a function. The metadata of the target component includes: function identifier (function ID, name, and function description), input specifications (parameter name, type, whether it is required, and description), output definition (declaring the data type and meaning of the return value), execution configuration (specifying the runtime environment, code location, and entry function), triggering method (specifying what kind of event (such as HTTP request, timer, database operation) calls the function), and permissions and resources (setting the memory required for the function to run, timeout, and access permissions).

[0062] In one example, the target component described above is an automated processing flow. The metadata of the target component includes: flow identifier (flow ID, name, and description), triggers (defining the conditions for the flow to start automatically (such as "form submission", "timed arrival", or "API call"), node sequence (describing the steps of the flow (such as "approval", "sending email", and "updating data"), and the flow order and logic between each node (branching, looping, parallelism)), node configuration (the specific settings of each node (such as who approves, email content template, and data fields to be updated)), participants and permissions (which can define who (human, system role, or automated robot) performs each step, and their operation permissions), data mapping (which can specify how data is transferred and transformed between different steps of the flow), and exception handling (such as defining the handling rules for flow timeout, failure, or error (such as retrying, notifying the administrator, and executing a backup plan)).

[0063] In these implementations, by acquiring the metadata of the target construction and updating the prompt information based on the metadata, the intelligent assistant can obtain more accurate component information from the new prompt information, thereby making the code generated by the intelligent assistant based on the new prompt information more accurate.

[0064] Please refer to Figure 2 , Figure 2 A flowchart illustrating the application generation method for low-code platforms provided in this disclosure. Figure 1 ,like Figure 2 As shown, the method includes the following steps:

[0065] S201: Display a list of component categories based on the first preset operation received in the session area of ​​the application editing interface; the list of component categories includes identifiers for multiple component categories.

[0066] Users can input text content via voice or text input in the message input box, and can also issue a preset first preset operation at the cursor position in the message input box, such as inputting a preset character. The character can be predefined text or symbols. For example, the preset character could be "@". Based on the received first preset operation, the executing entity can display a list of component sets. Component category identifiers can include text and symbols, etc. Different component category identifiers are used to distinguish components of different categories.

[0067] In some implementations, the component categories indicated by the identifiers of multiple component categories include at least one of the following:

[0068] Application-related data objects, application-related functions, application page components, preset layout styles, processes, and interactive actions.

[0069] It is understood that the aforementioned data objects may include at least one data object associated with the application, such as forms, fields, etc. The aforementioned function categories may include at least one function associated with the application. The aforementioned page component categories may be at least one page component of the application, and may also include at least one page component that the application can navigate to. The aforementioned process categories may be at least one process associated with the application, and may also include at least one process provided by the low-code platform. The aforementioned interaction action categories may include at least one interaction action associated with the application, and may also include interaction actions provided by the low-code platform. The aforementioned layout style categories may include at least one layout style provided by the low-code platform.

[0070] S202: Based on receiving a second preset operation on the target component category in the component category list, display a list of components belonging to the target component category.

[0071] The second preset operation mentioned above can be a click, touch, or other similar operation.

[0072] The list of components belonging to the target component category may include at least one component. Taking the target component as a layout style as an example, the above component list includes at least one preset layout style.

[0073] S203: In response to a selection operation in the component list and an instruction to perform a target operation on the selected component, invoke the intelligent assistant to generate code.

[0074] For example, in response to a selection operation in the component list, information about the target component selected by the selection operation is written to a message input box. This target component information may include, for example, the identifier of the target component.

[0075] In some implementations, the target component is a data object associated with an application, and step S202 above includes the following steps:

[0076] First, based on the triggering operation performed on the object category, display the identifier of at least one data object;

[0077] Secondly, in response to the triggered operation performed on the identifier of the target data object, the list of fields of the target data object is displayed.

[0078] Further, step S203 includes: based on the selection operation on at least one field in the field list, invoking the smart assistant to generate code based on the at least one field selected by the selection operation.

[0079] Specifically, based on a selection operation on at least one field in the field list, the selected field is written into a message input box. The fields written into the message input box have accurate contextual information. By invoking the intelligent assistant based on the contextualized message, the intelligent assistant can be provided with the fields and their context, which helps improve the accuracy of the generated code.

[0080] S204: Generate the application's edit results based on the code.

[0081] This embodiment describes a component list displayed in a multi-level display manner. This facilitates the management of different types of components and improves the speed at which users can find the components they need. When editing an application, the method described above allows for precise selection of the context through the chosen method of the component list, which improves the accuracy of the generated code.

[0082] Please refer to Figure 3A , 3B And 3C, Figure 3A This is a schematic diagram of an application scenario provided in this disclosure. Figure 3B This is a schematic diagram of an application scenario provided in this disclosure. Figure 3C This is a schematic diagram illustrating an application scenario provided in this disclosure. For example... Figure 3A As shown, the application graph editing interface 30 is displayed on the low-code development platform client. This editing interface can include a list of application pages, such as page 1, page 2, and page 3. Users can edit existing page content or create new pages in the application editing interface. The following explanation uses editing page 1 as an example. Users can perform session triggering operations with the smart assistant in the application editing interface, displaying a message input box 301. Users can enter the text "Please use the following component" in the message input box 301, and then enter the preset trigger command "@" 302 after "Component", such as... Figure 3A As shown.

[0083] Upon receiving a preset trigger command, a component collection list 303 can be displayed. The component collection list 303 may include the following component collections: data object collection, process collection, function collection, layout collection, and interaction collection. Users can perform selection operations within these component collection lists; for example, a selection operation can be performed on the layout collection. Figure 3B As shown.

[0084] After receiving a selection from the user regarding the layout collection, a list of layouts can be displayed, such as... Figure 3CThe layouts shown are 1, 2, 3, and 4. Users can select from layout 1. After receiving the user's selection of layout 1, the aforementioned execution entity can write the information of layout 1 into message input box 301, such as... Figure 3C The message entered in message input box 301 is "Please use the following layout 1".

[0085] Understandably, users can also enter other content in the message input box. The message input operation can be considered complete after the user sends the message. The aforementioned execution entity can obtain the message entered by the user in the message input box and send the prompt information generated based on the message to the intelligent assistant. The intelligent assistant then generates the code for this edit based on the prompt information. The low-code platform can then generate the application editing result corresponding to this edit based on the code.

[0086] As can be seen from the above application scenarios, this solution can change the process of users inputting application component information to selecting component information from a list. This can improve the accuracy of the requirements sent to the intelligent assistant, thereby improving the accuracy of the generated code and ultimately increasing the matching degree between the generated application and the user's actual needs.

[0087] In some embodiments, Figure 1 and Figure 2 In some optional implementations of the method shown, the application editing interface also includes a message display window;

[0088] The message display window shows the session messages, which include information about the target component displayed in a rich text style.

[0089] By displaying a message window, users can easily query the history of their interactions with the smart assistant.

[0090] exist Figure 1 and Figure 2 In some alternative implementations of the method shown, the method further includes the following steps:

[0091] In response to a triggered action performed on information about the target component in a session message, a details window for the target component is displayed.

[0092] For example, details of the target component can be displayed in the form of a pop-up or floating window based on user trigger actions. Taking the target component as a form as an example, the details of the target component can include multiple fields in the form, as well as the data in the fields.

[0093] In these implementations, the details of the target component can be viewed in the message window through the above-described interactive operations, which helps improve the efficiency of users in obtaining information and further improves the efficiency of application editing.

[0094] In some embodiments of the application generation method for low-code platforms provided in this disclosure, information on multiple components can be displayed based on a preset identifier input in the aforementioned conversation area. Based on the user's selection of a target component, the target component's information is presented in capsule form in the conversation area. Based on the user's click on the capsule, details of the target component are presented. The natural language and components input by the user in the conversation area can be sent as prompts to the intelligent assistant, which then generates the application editing result based on the prompts.

[0095] Please refer to Figure 3D and Figure 3E , Figure 3D This is a schematic diagram of an application scenario. Figure 3E This is a diagram illustrating an application scenario. For example... Figure 3D As shown, users can enter "Create a user" in the message input box (conversation area) 301 and select from a list of components by entering a preset identifier. Then, they can enter the text "Click on a table row" and select the "Open Page" component from the list again by entering a preset identifier. The "Open Page" component is displayed as a capsule in the conversation area 301. Triggering operations on the "Open Page" capsule can display the page list "Page 1", "Page 2", and "Page 3", as shown below. Figure 3D As shown. Users can perform trigger operations on the page, displaying the interaction action configuration window 305 for page 2. The interaction action configuration window 305 allows configuration of actions, page selection, and opening methods, such as... Figure 3E As shown. After the input ends, prompts can be generated based on this information, and the intelligent assistant can then generate code based on these prompts.

[0096] Corresponding to the application generation method for low-code platforms described in the above embodiments, Figure 4 This is a structural block diagram of an application generation apparatus for a low-code platform provided in an embodiment of this disclosure. For ease of explanation, only the parts relevant to the embodiments of this disclosure are shown. (Refer to...) Figure 4 The application generation device for low-code platforms includes a display unit 401, a writing unit 402, a calling unit 403, and a generation unit 404.

[0097] Display unit 401 is used to display a component list according to a preset trigger command received in the session area of ​​the application editing interface. The component list includes information on at least one component of the application, and the application in the editing state is displayed on the application editing interface.

[0098] Calling unit 402 is used to call the intelligent assistant to generate code in response to a selection operation in the component list and an instruction to perform a target operation on the selected component.

[0099] The generation unit 403 is used to generate the editing results of the application based on the code.

[0100] This embodiment of the disclosure provides a method to display a component list based on a preset trigger command received in a message input box of the application editing interface. The component list includes information about at least one component of the application. In response to a selection operation in the component list, information about the selected target component is written into the message input box. In response to the end of the input operation in the message input box, a smart assistant is invoked to generate code based on the message entered in the message input box. The message includes information about the target component. The application editing result is generated based on the code. This method enables the display of an available component list based on a trigger. Users can select the target component from the component list. Compared with interaction methods based solely on natural language, this method can accurately select the application component that needs further editing, avoiding the problem of inaccurate descriptions by users using natural language. This improves the matching degree between the obtained application editing result and the user's actual needs, as well as the accuracy of the obtained application editing result.

[0101] In one embodiment of this disclosure, the calling unit 402 is further configured to:

[0102] Generate a prompt message containing information about the target component based on the message;

[0103] The system invokes the smart assistant based on the prompt information, and the smart assistant generates code based on the prompt information.

[0104] In one embodiment of this disclosure, the calling unit 402 is further configured to:

[0105] Obtain the target component's metadata through a preset interface, and generate new prompt information based on the metadata;

[0106] Send the new prompt to the smart assistant, which will then generate code based on the new prompt.

[0107] In one embodiment of this disclosure, the display unit 401 is further configured to:

[0108] Based on the first preset operation received in the message input box of the application editing interface, display the component collection list; the component collection list includes the identifiers of multiple component collections;

[0109] Based on the received second preset operation on the target component set in the set list, display the component list belonging to the target component set.

[0110] In one embodiment of this disclosure, the multiple component category sets include:

[0111] A collection of data objects, functions, pages, layout styles, processes, and interactive actions.

[0112] In one embodiment of this disclosure, the target component is a data object, the data object is a target field in the target form, and the display unit 401 is further configured to:

[0113] Based on the triggering operation performed on the data object collection, display the identifier of at least one form;

[0114] In response to a triggering operation performed on the identifier of a target form in at least one form, the information of the target form is written to a message input box;

[0115] Based on the triggered action performed on the information in the target form in the message input box, display information about the list of fields in the target form, including the target field.

[0116] In one embodiment of this disclosure, the calling unit 403 is further configured to:

[0117] Based on the selection operation of at least one field in the field list, the intelligent assistant is invoked to generate code based on the at least one field selected by the selection operation.

[0118] In one embodiment of this disclosure, the application editing interface further includes a message display window;

[0119] The message display window shows the session messages, which include information about the target component displayed in a rich text style.

[0120] In one embodiment of this disclosure, the display unit 401 is further configured to:

[0121] In response to a triggered action performed on information about the target component in a session message, a details window for the target component is displayed.

[0122] To implement the above embodiments, this disclosure also provides an electronic device.

[0123] refer to Figure 5The diagram illustrates a structural schematic of an electronic device 500 suitable for implementing embodiments of the present disclosure. The electronic device 500 can be a terminal device or a server. The terminal device can include, but is not limited to, mobile terminals such as mobile phones, laptops, digital broadcast receivers, personal digital assistants (PDAs), tablet computers, portable media players (PMPs), and in-vehicle terminals (e.g., in-vehicle navigation terminals), as well as fixed terminals such as digital TVs and desktop computers. Figure 5 The electronic device shown is merely an example and should not be construed as limiting the functionality and scope of the embodiments disclosed herein.

[0124] like Figure 5 As shown, the electronic device 500 may include a processing unit (e.g., a central processing unit, a graphics processing unit, etc.) 501, which can perform various appropriate actions and processes according to a program stored in a read-only memory (ROM) 502 or a program loaded from a storage device 508 into a random access memory (RAM) 503. The RAM 503 also stores various programs and data required for the operation of the electronic device 500. The processing unit 501, ROM 502, and RAM 503 are interconnected via a bus 504. An input / output (I / O) interface 505 is also connected to the bus 504.

[0125] Typically, the following devices can be connected to I / O interface 505: input devices 506 including, for example, touchscreens, touchpads, keyboards, mice, cameras, microphones, accelerometers, gyroscopes, etc.; output devices 507 including, for example, liquid crystal displays (LCDs), speakers, vibrators, etc.; storage devices 508 including, for example, magnetic tapes, hard disks, etc.; and communication devices 509. Communication device 509 allows electronic device 500 to communicate wirelessly or wiredly with other devices to exchange data. Although Figure 5 An electronic device 500 with various devices is shown; however, it should be understood that it is not required to implement or possess all of the devices shown. More or fewer devices may be implemented or possessed alternatively.

[0126] In particular, according to embodiments of this disclosure, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, embodiments of this disclosure include a computer program product comprising a computer program carried on a computer-readable storage medium, the computer program containing program code for performing the methods shown in the flowcharts. In such embodiments, the computer program can be downloaded and installed from a network via a communication device 509, or installed from a storage device 508, or installed from a ROM 502. When the computer program is executed by the processing device 501, it performs the functions defined in the methods of embodiments of this disclosure.

[0127] It should be noted that the computer-readable storage medium described in this disclosure can be a computer-readable signal medium, a computer-readable storage medium, or any combination thereof. A computer-readable storage medium can be, for example,—but not limited to—an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination thereof. More specific examples of a computer-readable storage medium may include, but are not limited to: an electrical connection having one or more wires, a portable computer disk, a hard disk, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage device, magnetic storage device, or any suitable combination thereof. In this disclosure, a computer-readable storage medium can be any tangible medium containing or storing a program that can be used by or in conjunction with an instruction execution system, apparatus, or device. In this disclosure, a computer-readable signal medium can include a data signal propagated in baseband or as part of a carrier wave, carrying computer-readable program code. Such propagated data signals can take various forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination thereof. A computer-readable signal medium may also be any computer-readable storage medium other than a computer-readable storage medium, which can send, propagate, or transmit a program for use by or in connection with an instruction execution system, apparatus, or device. The program code contained on the computer-readable storage medium can be transmitted using any suitable medium, including but not limited to: wires, optical fibers, RF (radio frequency), etc., or any suitable combination thereof.

[0128] The aforementioned computer-readable storage medium may be included in the aforementioned electronic device; or it may exist independently and not assembled into the electronic device.

[0129] The aforementioned computer-readable storage medium carries one or more programs, which, when executed by the electronic device, cause the electronic device to perform the methods shown in the above embodiments.

[0130] Computer program code for performing the operations of this disclosure can be written in one or more programming languages ​​or a combination thereof, including object-oriented programming languages ​​such as Java, Smalltalk, and C++, and conventional procedural programming languages ​​such as the "C" language or similar programming languages. The program code can be executed entirely on the user's computer, partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In cases involving remote computers, the remote computer can be connected to the user's computer via any type of network—including a Local Area Network (LAN) or a Wide Area Network (WAN)—or can be connected to an external computer (e.g., via the Internet using an Internet service provider).

[0131] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of this disclosure. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of code containing one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions indicated in the blocks may occur in a different order than those indicated in the drawings. For example, two consecutively indicated blocks may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, can be implemented using a dedicated hardware-based system that performs the specified function or operation, or using a combination of dedicated hardware and computer instructions.

[0132] The units described in the embodiments of this disclosure can be implemented in software or in hardware. The name of a unit does not necessarily limit the unit itself; for example, the first acquisition unit can also be described as "a unit that acquires at least two Internet Protocol addresses".

[0133] The functions described above in this document can be performed, at least in part, by one or more hardware logic components. For example, exemplary types of hardware logic components that can be used, without limitation, include: Field Programmable Gate Arrays (FPGAs), Application-Specific Integrated Circuits (ASICs), Application Standard Products (ASSPs), System-on-Chip (SoCs), Complex Programmable Logic Devices (CPLDs), and so on.

[0134] The electronic device, computer-readable storage medium, and computer program product provided in this disclosure display a component list based on a preset trigger instruction received in a message input box of the application editing interface. The component list includes information about at least one component of the application. In response to a selection operation in the component list, information about the selected target component is written into the message input box. In response to the end of the input operation in the message input box, a smart assistant is invoked to generate code based on the message entered in the message input box. The message includes information about the target component. The application editing result is generated based on the code. This achieves the display of an available component list based on a trigger. Users can select the target component from the component list. Compared with interaction methods based solely on natural language, this operation can accurately select the application component that needs further editing, avoiding the problem of inaccurate descriptions by users using natural language. This improves the matching degree between the obtained application editing result and the user's actual needs, as well as the accuracy of the obtained application editing result.

[0135] The above description is merely a preferred embodiment of this disclosure and an explanation of the technical principles employed. Those skilled in the art should understand that the scope of this disclosure is not limited to technical solutions formed by specific combinations of the above-described technical features, but should also cover other technical solutions formed by arbitrary combinations of the above-described technical features or their equivalents without departing from the above-described concept. For example, technical solutions formed by substituting the above features with (but not limited to) technical features disclosed in this disclosure that have similar functions.

[0136] Furthermore, while the operations are described in a specific order, this should not be construed as requiring these operations to be performed in the specific order shown or in a sequential order. In certain environments, multitasking and parallel processing may be advantageous. Similarly, while several specific implementation details are included in the above discussion, these should not be construed as limiting the scope of this disclosure. Certain features described in the context of individual embodiments may also be implemented in combination in a single embodiment. Conversely, various features described in the context of a single embodiment may also be implemented individually or in any suitable sub-combination in multiple embodiments.

[0137] Although the subject matter has been described using language specific to structural features and / or methodological logic, it should be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or actions described above. Rather, the specific features and actions described above are merely illustrative examples of implementing the claims.

[0138] The above description is merely a preferred embodiment of this disclosure and an explanation of the technical principles employed. Those skilled in the art should understand that the scope of this disclosure is not limited to technical solutions formed by specific combinations of the above-described technical features, but should also cover other technical solutions formed by arbitrary combinations of the above-described technical features or their equivalents without departing from the above-described concept. For example, technical solutions formed by substituting the above features with (but not limited to) technical features disclosed in this disclosure that have similar functions.

[0139] Furthermore, while the operations are described in a specific order, this should not be construed as requiring these operations to be performed in the specific order shown or in a sequential order. In certain environments, multitasking and parallel processing may be advantageous. Similarly, while several specific implementation details are included in the above discussion, these should not be construed as limiting the scope of this disclosure. Certain features described in the context of individual embodiments may also be implemented in combination in a single embodiment. Conversely, various features described in the context of a single embodiment may also be implemented individually or in any suitable sub-combination in multiple embodiments.

[0140] Although the subject matter has been described using language specific to structural features and / or methodological logic, it should be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or actions described above. Rather, the specific features and actions described above are merely illustrative examples of implementing the claims.

Claims

1. A method for generating applications for low-code platforms, characterized in that, include: Display a list of component categories based on the first preset action received in the session area of ​​the application editing interface; The component category list includes identifiers for multiple component categories; Based on receiving a second preset operation on a target component category in the component category list, a list of components belonging to the target component category is displayed. The component list includes information on at least one component of the application, and the application in edit mode is displayed on the application editing interface. In response to a selection operation in the component list and an instruction to perform a target operation on the selected target component, the intelligent assistant is invoked to generate code; The edited result of the application is generated based on the code; The target component is a data object associated with the application. The step of displaying a list of components belonging to the target component category based on a second preset operation received from the component category list includes: Based on the trigger operation performed on the object category, display the identifier of at least one data object; In response to a triggered operation performed on the identifier of the target data object, a list of fields of the target data object is displayed; Based on a selection operation on at least one field in the field list, the smart assistant is invoked to generate code based on the at least one field selected by the selection operation.

2. The method according to claim 1, characterized in that, The code generated by calling the smart assistant includes: Generate a prompt message that includes information about the target component; The smart assistant is invoked based on the prompt information, so that the smart assistant generates the code according to the prompt information.

3. The method according to claim 2, characterized in that, The step of invoking the smart assistant based on the prompt information, so that the smart assistant generates the code according to the prompt information, includes: The target component's metadata is obtained through a preset interface, and new prompt information is generated based on the metadata; The new prompt message is sent to the smart assistant, which then generates the code based on the new prompt message.

4. The method according to claim 1, characterized in that, The component categories indicated by the identifiers of the plurality of component categories include at least one of the following: The application's associated data objects, functions associated with the application, page components of the application, preset layout styles, processes, and interactive actions.

5. The method according to claim 1, characterized in that, The application editing interface also includes a message display window; The message display window displays session messages, which include information about the target component displayed in a rich text style.

6. The method according to claim 5, characterized in that, The method further includes: displaying a details window of the target component in response to a triggering operation performed on information of the target component in the session message.

7. An application generation apparatus for a low-code platform, characterized in that, include: The display unit is used to display a list of component categories based on a first preset operation received in the session area of ​​the application editing interface; The component category list includes identifiers for multiple component categories; Based on receiving a second preset operation on a target component category in the component category list, a list of components belonging to the target component category is displayed. The component list includes information on at least one component of the application, and the application in edit mode is displayed on the application editing interface. The calling unit is used to call the intelligent assistant to generate code in response to a selection operation in the component list and an instruction to perform a target operation on the selected target component; A generation unit is used to generate the edited result of the application based on the code; The target component is a data object associated with the application, and the display unit is further used for: Based on the trigger operation performed on the object category, display the identifier of at least one data object; In response to a triggering operation performed on the identifier of the target data object, a list of fields of the target data object is displayed; Based on a selection operation on at least one field in the field list, the smart assistant is invoked to generate code based on the at least one field selected by the selection operation.

8. An electronic device, characterized in that, include: Processor and memory; The memory stores computer-executed instructions; The processor executes computer execution instructions stored in the memory, causing the processor to perform the method as described in any one of claims 1 to 6.

9. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores computer-executable instructions, which, when executed by a processor, implement the method as described in any one of claims 1 to 6.

10. A computer program product, comprising a computer program, characterized in that, When the computer program is executed by a processor, it implements the method as described in any one of claims 1 to 6.

Images