UI interface generation method of charging operation platform, electronic equipment and storage medium

Abstract

The invention relates to the technical field of charging operation platforms, in particular to a UI interface generation method of a charging operation platform, electronic equipment and a storage medium, and the method comprises the following steps: obtaining configuration information input by a user; determining a code generation rule according to the configuration information; according to the code generation rule, a pre-trained generative A I model is utilized to generate a target code, and the target code is matched with a technology stack adopted by the charging operation platform; and running the target code through a preset sandbox rendering module to generate a target U I interface. Based on the method, the complete U I interface can be generated according to the configuration information input by the user, the development process of the U I interface is remarkably simplified, a low-code template and a component library do not need to be additionally maintained, and dependence on a production and research team is reduced.

Description

Technical Field

[0001] Embodiments of the present invention relate to the technical field of charging operation platforms, and in particular to a method for generating a UI interface of a charging operation platform, an electronic device, and a storage medium. Background Art

[0002] There are hundreds of real-time data indicators that need to be monitored within the charging operation platform. Generally speaking, different users have personalized concerns about data in various dimensions (such as charging pile status data, charging pile utilization rate, failure rate, regional distribution, charging behavior data, etc.). Therefore, in order to meet users' customized monitoring needs for the charging operation platform, it is necessary to develop a user interface (UI) that supports customization for users to choose from.

[0003] Currently, commonly used UI interface development solutions mainly include manual development solutions and development solutions based on low-code tools. However, the application effects of these two solutions are not good, which affects the data monitoring effect of the charging operation platform. Specifically,

[0004] Manual development solutions require developers to manually write code to meet personalized user needs (such as custom data dashboards and interactive logic). Traditional development models typically involve organizing production and research teams through a series of communications and significant R&D investment, including requirements clarification, requirements discussions, product development, PRD writing, requirements reviews, UI design, UI reviews, department meetings, development and debugging, testing, deployment and rollout, regression verification, monitoring and maintenance. This results in high costs, long cycles, and difficulty in quickly responding to needs.

[0005] For development solutions that use low-code tools, current low-code tools can support users to configure the desired page layout by dragging and dropping, but there are still difficulties for non-technical personnel to operate low-code tools. For example, the development process requires reliance on professionals to adjust the layout, associate data, and bind events. Low-code tools are usually based on fixed templates and are difficult to support complex interactions (such as dynamic chart linkage, custom alarm rules, etc.). In addition, low-code tools need to maintain a large number of preset templates and component libraries. In order to adapt to different business scenarios, continuous investment in development resources is required, forming a hidden cost burden. Summary of the Invention

[0006] One purpose of an embodiment of the present invention is to provide a UI interface generation method, electronic device and storage medium for a charging operation platform, so as to solve the technical problem in the related technology that the manual development solution and the development solution based on low-code tools have poor application effects, which affects the data monitoring effect of the charging operation platform.

[0007] In a first aspect, an embodiment of the present invention provides a method for generating a UI interface of a charging operation platform, the method comprising:

[0008] Obtain configuration information input by the user, where the configuration information is used to indicate the configuration requirements of the UI interface to be generated; determine code generation rules based on the configuration information; generate target code using a pre-trained generative AI model based on the code generation rules, where the target code matches the technology stack used by the charging operation platform; run the target code through a preset sandbox rendering module to generate a target UI interface.

[0009] In conjunction with the first aspect, in one possible implementation, determining a code generation rule according to the configuration requirements includes:

[0010] The configuration information is parsed through a pre-built domain enhancement big model to obtain a parsing result; based on the parsing result, the structured parameters corresponding to the configuration requirements are determined, and the structured parameters are used to indicate the data indicators, screening conditions and interaction logic of the UI interface to be generated; based on the structured parameters, the code generation rules are determined.

[0011] In conjunction with the first aspect, in a possible implementation, determining the code generation rule according to the structured parameter includes:

[0012] Determine the API metadata corresponding to the structured parameters; determine, based on the API metadata, a target feature that matches the API I metadata in a feature library of a preset charging operation platform; and determine the code generation rule based on the matched target feature.

[0013] In conjunction with the first aspect, in a possible implementation, the feature library of the charging operation platform includes time features, device features, and user features of the charging operation platform;

[0014] The time characteristics include the peak charging period and peak-valley electricity price period of the charging operation platform; the equipment characteristics include the charging pile type and rated power of each charging pile in the charging operation platform; the user characteristics include the user level and historical credit score rate of the charging operation platform.

[0015] In conjunction with the first aspect, in one possible implementation, running the target code through a preset sandbox rendering module includes:

[0016] The target code is embedded in the sandbox rendering module so that the sandbox rendering module runs the target code. The sandbox rendering module communicates with the main application of the charging operation platform according to a preset application program interface. The sandbox rendering module controls the network requests and script execution permissions associated with the target code according to a preset security mechanism.

[0017] In conjunction with the first aspect, in a possible implementation, the method further includes:

[0018] The target code and corresponding configuration information are stored in a preset database, and the user's identity and version number are associated to record the current target code version; when it is detected that the user has modified the configuration information, the target code is updated according to the user's modified configuration information; the updated target code is re-embedded in the sandbox rendering module, so that the sandbox rendering module reloads the target code and runs.

[0019] In conjunction with the first aspect, in a possible implementation, the method further includes:

[0020] Determine whether the target UI interface meets the configuration requirements;

[0021] When the target UI interface meets the configuration requirements, saving and publishing the target code;

[0022] When the target UI interface does not meet the configuration requirements, the code generation rules are re-determined according to the configuration information input by the user.

[0023] In conjunction with the first aspect, in a possible implementation, the method further includes:

[0024] According to the re-determined code generation rules, the modified target code is determined, and the modified target code is run through the sandbox rendering module to generate a modified target UI interface; whether the modified target UI interface meets the configuration requirements is judged; if the modified target UI interface meets the configuration requirements, the modified target code is updated to the target code; if the modified target UI interface does not meet the configuration requirements, the target code is continued to be modified until the modified target UI interface meets the configuration requirements.

[0025] In a second aspect, an embodiment of the present invention further proposes an electronic device, comprising a memory and a processor, wherein the memory is connected to the processor, and the processor is used to execute one or more computer programs stored in the memory. When the processor executes the one or more computer programs, the electronic device implements the UI interface generation method of the charging operation platform as described in the first aspect.

[0026] In a third aspect, an embodiment of the present invention further proposes a computer-readable storage medium, wherein the computer-readable storage medium stores a computer program, wherein the computer program includes program instructions, and when the program instructions are executed by a processor, the processor executes the UI interface generation method of the charging operation platform as described in the first aspect.

[0027] The embodiments of the present invention can achieve the following technical effects:

[0028] An embodiment of the present invention proposes a method for generating a UI interface for a charging operation platform. The method first obtains configuration information input by the user and determines code generation rules based on the configuration information. Then, based on the code generation rules, the method outputs the target code using a pre-trained generative AI model. Finally, the target code is run through a preset sandbox rendering module to determine whether the generated UI interface meets the user's configuration requirements. Based on this method, users can generate complete pages through natural language descriptions without the intervention of developers, which is conducive to direct operation by non-technical personnel. Complex UIs can be generated through simple descriptions, and the generated code can automatically adapt to various terminal forms such as PC-side monitoring large screens, mobile APPs, and charging pile interactive screens, further improving the application effect of the UI interface development solution.

[0029] Compared with related technologies, since this method generates code through natural language input by the user, there is no need to maintain a huge template library, which significantly reduces the development and maintenance costs of low-code tools. While meeting user configuration requirements, the generated code can directly reuse the existing technology stack of the charging operation platform, reducing dependence on the production and research team. BRIEF DESCRIPTION OF THE DRAWINGS

[0030] In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the following briefly introduces the drawings required for use in the description of the embodiments of the present invention. Obviously, the drawings described below are only some embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying any creative labor.

[0031] Figure 1 A schematic diagram of a charging system provided by an embodiment of the present invention;

[0032] Figure 2 A flow chart of a method for generating a UI interface for a charging operation platform provided by an embodiment of the present invention;

[0033] Figure 3 A schematic diagram of generating target code using an AI model provided by an embodiment of the present invention;

[0034] Figure 4 A schematic diagram of a system architecture provided by an embodiment of the present invention;

[0035] Figure 5 A schematic diagram of the structure of a UI interface generation device for a charging operation platform provided by an embodiment of the present invention;

[0036] Figure 6 A schematic structural diagram of an electronic device provided by an embodiment of the present invention. DETAILED DESCRIPTION

[0037] In order to make the purpose, technical solutions and advantages of the present invention more clearly understood, the present invention is further described in detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are only used to explain the present invention and are not intended to limit the present invention. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without making creative work are within the scope of protection of the present invention.

[0038] It should be noted that, if there is no conflict, the various features in the embodiments of the present invention can be combined with each other and are all within the scope of protection of the present invention. In addition, although the functional modules are divided in the system schematic and the logical order is shown in the flow chart, in some cases, the steps shown or described can be executed in a different order than the module division in the system or the order in the flow chart. Furthermore, the words "first", "second", "third", etc. used in the present invention do not limit the data and execution order, but only distinguish between the same or similar items with basically the same functions and effects.

[0039] For a better explanation of this application, please refer to Figure 1 , Figure 1 The figure shows a schematic diagram of a charging system, which includes charging piles 101, 102, 123, 104, a charging operation platform 20 and a user management device 30. The charging piles 101, 102, 123, 104 are respectively connected to the charging operation platform 20 for communication. The charging piles 101, 102, 123, 104 are used to provide charging services for various types of vehicles and can send various charging data related to their working processes to the charging operation platform 20. The user can use the user management device 30 to monitor the various data of the charging operation platform 20 in real time, and then perform charging monitoring or data analysis on the charging piles 101, 102, 123, 104 connected to the charging operation platform 20.

[0040] It is easy to understand that Figure 1The charging piles 101, 102, 123, and 104 provide charging services for various vehicles such as electric vehicles and electric bicycles. According to their different working modes, they can support at least multiple charging modes such as DC fast charging and AC slow charging; the charging operation platform 20 serves as the data hub and processing center of the entire charging system. By establishing a two-way communication channel with the charging piles, it issues control instructions (such as start and stop charging) in real time. In addition, it can also receive and store the charging data uploaded by all charging piles to form a charging database. On this basis, it can also manage user accounts, charging orders, and fee settlement (such as docking with payment platforms) in the charging system, and support remote configuration of charging piles (such as upgrading firmware and adjusting rates). At the same time, by providing a unified API interface, each charging pile can be docked with a third-party platform (such as the car company's Internet of Vehicles system and the city's energy management platform).

[0041] The user management device 30 serves as the interactive terminal in this system. It can be a personal terminal device such as a mobile phone or computer, or a larger device such as a server. It provides users (such as charging operators and vehicle owners) with access to apps, PC-side management software, or a web interface. Through this user management device 30, users can view real-time data such as the online status, charging progress, and fault alarms of all charging piles, and generate charging trend charts (such as daily / monthly statistics on charging volume and revenue).

[0042] It's easy to understand that in order to monitor, view, and analyze various data within the charging operations platform and further meet the customized monitoring needs of different users for the charging operations platform, the user management device 30 needs to provide multiple user interfaces for operation. Users can use the interactive methods provided by each UI interface to achieve real-time monitoring or operation of the charging operations platform 20. On this basis, by providing users with customized UI interface development services, the personalized needs of different users can be better met, improving the user experience.

[0043] Furthermore, based on the above Figure 1 The charging system shown in the figure proposes a UI interface generation method for the charging operation platform, which can be applied to Figure 1 A user management device 30 in the charging system is shown.

[0044] For details, please refer to Figure 2 , the method comprising:

[0045] Step S10: obtaining configuration information input by the user, wherein the configuration information is used to indicate configuration requirements of the UI interface to be generated;

[0046] Specifically, the configuration information entered by the user mainly consists of the UI interface configuration requirements expressed by the user through natural language or interactive forms, which usually includes three core elements:

[0047] Data indicators: business data that needs to be displayed (such as failure rate, charging capacity);

[0048] Filter conditions: data filtering dimensions (such as region, time range, device type);

[0049] Interaction logic: behaviors triggered by user operations (such as click jump and data drill-down);

[0050] For example, users can enter natural language instructions through the web interface or text input box provided by the development tool. The natural language instructions are intended to limit the various components, functions, and meanings of the generated UI interface. For example, the user enters a natural language instruction in the web interface: "Generate a failure rate line chart of DC fast charging piles in Chaoyang District, Beijing during the evening peak period (18:00-20:00), and click on the column to view the failure details." After receiving the input instruction, the browser encapsulates the input into a JSON request body and transmits the JSON request body to the backend database as the input source for subsequent code generation.

[0051] Step S20, determining code generation rules based on the configuration information;

[0052] Among them, code generation rules refer to executable development rules converted from the configuration information input by the user during the UI interface development process. They can indicate the mapping relationship between the configuration requirements input by the user through natural language and the final program logic.

[0053] Those skilled in the art will understand that the development rules referred to in this embodiment include at least data binding rules, component matching rules, and interaction mapping rules, wherein the data binding rules are used to determine the associated platform APIs and parameters in the development process, the component matching rules are used to determine the adapted visual components, and the interaction mapping rules are used to define the relationship between user operations and system responses.

[0054] Specifically, in this embodiment, according to the configuration requirements, the code generation rules are determined, including:

[0055] The configuration information is parsed through a pre-built domain enhancement big model to obtain a parsing result; based on the parsing result, the structured parameters corresponding to the configuration requirements are determined, and the structured parameters are used to indicate the data indicators, screening conditions and interaction logic of the UI interface to be generated; based on the structured parameters, the code generation rules are determined.

[0056] The Domain-Enhanced Large Language Model in this embodiment can specifically adopt the LLaMA-7B architecture and be fine-tuned on 1 million charging industry work orders, operation and maintenance logs, and technical documents. It can perform deep semantic analysis on the configuration information input by the user, extract core demand elements, and convert them into structured parameters. Specifically, the model distinguishes between general language and domain-specific terms (i.e., the charging industry field), identifies implicit requirements in the form of natural language in the configuration information, and finally outputs the parsing results. For example, based on the LLaMA-7B architecture, it can be fine-tuned by injecting domain knowledge so that it can adapt to the entity library and business rules of the charging operation platform. In addition, a security constraint layer can be added on its basis to ensure that the user demand parsing process does not exceed the preset authority range.

[0057] More specifically, determining the code generation rules based on the structured parameters includes: determining the API metadata corresponding to the structured parameters; determining the target features that match the APII metadata in the feature library of a preset charging operation platform based on the API metadata; and determining the code generation rules based on the matched target features.

[0058] In this embodiment, the structured parameters are first mapped to the platform's predefined API interface specifications to ensure that the generated code can correctly access business data. The API metadata includes core information such as the interface address, request parameters, and response structure.

[0059] Afterwards, the target features associated with the API metadata are retrieved from the preset charging field feature library. The target features include but are not limited to business rules, device parameters, and security policies, etc., so as to combine the API metadata and target features to determine the front-end code rules that can guide the AI ​​model and ensure that the code complies with the technology stack specifications and meets business needs.

[0060] More specifically, the feature library of the charging operation platform includes the time characteristics, device characteristics and user characteristics of the charging operation platform; the time characteristics include the peak charging period and peak-valley electricity price period of the charging operation platform; the device characteristics include the charging pile type and rated power of each charging pile in the charging operation platform; the user characteristics include the user level and historical credit score rate of the charging operation platform.

[0061] For example, when matching target features, based on "device_type": "DC", the power range of DC fast charging piles matched in the feature library of the charging operation platform is 60kw-240kw.

[0062] Step S30: generating target code using a pre-trained generative AI model according to the code generation rules, wherein the target code matches the technology stack used by the charging operation platform;

[0063] Among them, the pre-trained generative AI model specifically refers to a pre-trained large model based on the Transformer architecture (such as GPT-4, etc.), which is used in this embodiment to automatically generate a UI interface (i.e., the above-mentioned target code) based on the output. It can support natural language interaction and dynamic layout adjustment without manual code writing. Its application in this embodiment can effectively lower the development threshold and simplify the development process.

[0064] Specifically, the input of the generative AI model includes but is not limited to the code generation rules in the above steps, the configuration information input by the user, the structured parameters after NLP parsing, and the historical generation records before the current task, etc., thereby forming multimodal input features and establishing semantic associations between natural language descriptions and code elements (such as component names, API parameters) through the cross-attention layer in the Transformer architecture.

[0065] For easier understanding, please refer to Figure 3 ,like Figure 3 The following is a schematic diagram of using a generative AI model to generate standardized code according to the platform technology stack (such as React+Ant Design). Figure 3 Some code snippets are shown in .

[0066] Step S40: running the target code through a preset sandbox rendering module to generate a target UI interface;

[0067] The sandbox rendering module in this embodiment refers to a sandbox rendering module built based on a sandbox rendering environment. Those skilled in the art will understand that the sandbox rendering environment is an isolated browser operating environment for safely executing dynamically generated code, ensuring that the generated code runs safely and seamlessly connects with the main platform, while preventing pollution to the main application of the charging operation platform.

[0068] Specifically, the sandbox rendering environment in this embodiment can be an iframe sandbox rendering environment, or a WebAssembly sandbox, etc., and this embodiment does not make too many restrictions on this.

[0069] Further, please refer to Figure 4 , Figure 4 The figure shows the system architecture diagram corresponding to the UI interface generation method in the above embodiment, wherein the system architecture includes:

[0070] User interaction layer: As the entry point for users to interact with the system, it provides users with necessary demand input and real-time feedback capabilities;

[0071] AI service layer: used to analyze user needs and generate executable code based on domain knowledge;

[0072] Runtime layer: used to dynamically execute target code and manage versions;

[0073] Business service layer: used to provide core business logic and data services for the charging industry;

[0074] Basic service layer: used to provide system-level infrastructure support to ensure high availability and security;

[0075] Database: including MySQL database, vector database and Redis database, used for persistent storage of core data generated by the entire system.

[0076] More specifically, in the above embodiment, when determining whether the target UI interface meets the configuration requirements, the target UI interface can be dynamically verified. For example, the target UI interface is firstly subjected to a layout compliance check to ensure that the element arrangement meets the configuration requirements, including the touch area size of the mobile terminal, the information density threshold of the PC terminal, etc.;

[0077] Afterwards, the target UI interface is tested for interactive behavior. By automatically simulating user clicks, sliding and other events, the integrity of the event response link is tracked, and whether there are any unhandled abnormal states in the current UI interface is detected. At the same time, by injecting test data sets, the deviation between the display value of the target UI interface and the expected calculation result is compared, and the effectiveness of the data refresh mechanism can be verified through timestamp tracking. In addition, the API request parameters can be checked to determine whether the interaction logic of the target UI interface complies with business rules, such as whether a certain area filtering condition is accurately mapped to the back-end query statement, etc.

[0078] Furthermore, the method in the above embodiment further includes:

[0079] Determine whether the target UI interface meets the configuration requirements;

[0080] When the target UI interface meets the configuration requirements, saving and publishing the target code;

[0081] When the target UI interface does not meet the configuration requirements, the code generation rules are re-determined according to the configuration information input by the user.

[0082] In this embodiment, after generating the target UI interface, the UI interface is further identified and judged to generate a judgment result on whether the target UI interface meets the configuration requirements. The judgment result may specifically include detection results of multiple dimensions, and the detection results of each dimension are used to characterize whether at least one key feature of the target UI interface meets the above-mentioned configuration requirements.

[0083] Specifically, in some embodiments, the method in the above embodiment further includes:

[0084] Determine the modified target code according to the re-determined code generation rule, and run the modified target code through the sandbox rendering module to generate a modified target UI interface;

[0085] Determine whether the modified target UI interface meets the configuration requirements;

[0086] If the modified target UI interface meets the configuration requirements, the modified target code is updated to the target code;

[0087] If the modified target UI interface does not meet the configuration requirements, continue to modify the target code until the modified target UI interface meets the configuration requirements.

[0088] In this embodiment, if it is determined that the current target UI interface cannot meet the user's configuration requirements, it means that the target code generated at this time is incorrect. Therefore, the code generation rules should be re-determined, and the target code should be modified according to the modified code generation rules, and the target UI interface should be reloaded, that is, the process in the above embodiment should be iteratively executed until the target UI interface meets the user's configuration requirements.

[0089] As an implementation method, for the detection results corresponding to multiple dimensions of the target UI interface, the detection results of all or part of the dimensions can be determined as restrictions to measure whether the target UI interface ultimately meets the configuration requirements. Finally, when the target UI interface meets the restrictions, the code version of the current target UI interface, that is, the final version of the target code corresponding to the target UI interface, is saved, and the target code is submitted as a release version to generate a UI interface that meets user needs.

[0090] Furthermore, in the above embodiment, running the target code through a preset sandbox rendering module includes:

[0091] The target code is embedded in the sandbox rendering module so that the sandbox rendering module runs the target code. The sandbox rendering module communicates with the main application of the charging operation platform according to a preset application program interface. The sandbox rendering module controls the network requests and script execution permissions associated with the target code according to a preset security mechanism.

[0092] This embodiment does not limit the above-mentioned application program interface and security mechanism. As a feasible implementation method, it can communicate with the main application through postMessage; and use Content-Security-Policy to limit network requests and script execution permissions.

[0093] More specifically, in the above embodiment, the method further includes:

[0094] The target code and corresponding configuration information are stored in a preset database, and the user's identity and version number are associated to record the current target code version; when it is detected that the user has modified the configuration information, the target code is updated according to the user's modified configuration information; the updated target code is re-embedded in the sandbox rendering module, so that the sandbox rendering module reloads the target code and runs.

[0095] In this embodiment, the generated target code and configuration information are first stored in the database, and the user ID and version number are associated at the same time, so as to facilitate rolling back to the historical version of the target code during later maintenance. In addition, when the user temporarily modifies the configuration information, the steps of the above embodiment are re-executed, that is, the sandbox rendering module is used to reload the target code to respond to the user's real-time needs.

[0096] It should be noted that, in each of the above-mentioned embodiments, there is not necessarily a certain order between the above-mentioned steps. A person skilled in the art can understand, based on the description of the embodiments of the present invention, that in different embodiments, the above-mentioned steps may have different execution orders, that is, they may be executed in parallel, or may be executed interchangeably, etc.

[0097] As another aspect of the present invention, an embodiment of the present invention provides a UI interface generation device for a charging operation platform. The UI interface generation device for the charging operation platform can be a software module, which includes several instructions stored in a memory. A processor can access the memory and call the instructions for execution to complete the UI interface generation method for the charging operation platform described in each of the above embodiments.

[0098] In some embodiments, the UI interface generation device of the charging operation platform can also be constructed by hardware devices. For example, the UI interface generation device of the charging operation platform can be constructed by one or more chips, and each chip can work in coordination with each other to complete the UI interface generation method of the charging operation platform described in each of the above embodiments. For another example, the UI interface generation device of the charging operation platform can also be constructed by various logic devices, such as a general-purpose processor, a digital signal processor (DSP), an application-specific integrated circuit (ASIC), a field-programmable gate array (FPGA), a single-chip microcomputer, an ARM (Acorn RISC Machine) or other programmable logic device, discrete gate or transistor logic, discrete hardware components, or any combination of these components.

[0099] For details, please refer to Figure 5 , Figure 5 The figure shows a schematic diagram of the structure of a UI interface generation device for a charging operation platform, which includes:

[0100] The data acquisition module 510 is used to acquire configuration information input by the user, where the configuration information is used to indicate the configuration requirements of the UI interface to be generated;

[0101] A rule injection module 520 is used to determine code generation rules based on the configuration information;

[0102] A code generation module 530 is configured to generate target code using a pre-trained generative AI model according to the code generation rules, wherein the target code matches the technology stack used by the charging operation platform;

[0103] The page rendering module 540 is used to run the target code through a preset sandbox rendering module to generate a target UI interface.

[0104] In one possible implementation, the rule injection module 520, when used to determine the code generation rule according to the configuration information, is specifically used to:

[0105] The configuration information is parsed through a pre-built domain enhancement big model to obtain a parsing result; based on the parsing result, the structured parameters corresponding to the configuration requirements are determined, and the structured parameters are used to indicate the data indicators, screening conditions and interaction logic of the UI interface to be generated; based on the structured parameters, the code generation rules are determined.

[0106] In a possible implementation, the rule injection module 520, when used to determine the code generation rule according to the structured parameter, is specifically configured to:

[0107] Determine the API metadata corresponding to the structured parameters; determine, based on the API metadata, a target feature that matches the API I metadata in a feature library of a preset charging operation platform; and determine the code generation rule based on the matched target feature.

[0108] In one possible implementation, the page rendering module 540, when used to run the target code through a preset sandbox rendering module, is specifically configured to:

[0109] The target code is embedded in the sandbox rendering module so that the sandbox rendering module runs the target code. The sandbox rendering module communicates with the main application of the charging operation platform according to a preset application program interface. The sandbox rendering module controls the network requests and script execution permissions associated with the target code according to a preset security mechanism.

[0110] In a possible implementation, the page rendering module 540 is further configured to:

[0111] The target code and corresponding configuration information are stored in a preset database, and the user's identity and version number are associated to record the current target code version; when it is detected that the user has modified the configuration information, the target code is updated according to the user's modified configuration information; the updated target code is re-embedded in the sandbox rendering module, so that the sandbox rendering module reloads the target code and runs.

[0112] In a possible implementation, the page rendering module 540 is further configured to:

[0113] Determine whether the target UI interface meets the configuration requirements;

[0114] When the target UI interface meets the configuration requirements, saving and publishing the target code;

[0115] When the target UI interface does not meet the configuration requirements, the code generation rules are re-determined according to the configuration information input by the user.

[0116] In a possible implementation, the page rendering module 540 is further configured to:

[0117] According to the re-determined code generation rules, the modified target code is determined, and the modified target code is run through the sandbox rendering module to generate a modified target UI interface; whether the modified target UI interface meets the configuration requirements is judged; if the modified target UI interface meets the configuration requirements, the modified target code is updated to the target code; if the modified target UI interface does not meet the configuration requirements, the target code is continued to be modified until the modified target UI interface meets the configuration requirements.

[0118] Based on this embodiment, a device for generating a UI interface for a charging operation platform is proposed. The device includes a data acquisition module, a rule injection module, a code generation module, a page rendering module, and a data storage module. Through the coordination between these modules, the method for generating a UI interface for a charging operation platform proposed in the above method embodiment is implemented. Based on this device, rule injection, code generation, and page rendering are integrated into each module. By analyzing user needs and combining domain knowledge to generate executable target code, the device is tested and run in a sandbox rendering environment, ultimately obtaining target code that meets the user's configuration requirements.

[0119] Since this device can execute the UI interface generation method of the charging operation platform provided by the above-mentioned method embodiment, it at least has all the technical effects of the above-mentioned method embodiment, and this device implements the functions of different modules according to the various steps of the method, so that the modules are isolated from each other, effectively reducing the overall coupling degree, and significantly improving the application effect of this device in the charging operation platform.

[0120] Further, see Figure 6 , Figure 6 1 is a schematic diagram of the structure of an electronic device provided by an embodiment of the present invention. The electronic device 60 includes one or more processors 61 and a memory 62. The memory 62 is connected to the one or more processors 61, for example, via a bus.

[0121] The processor 61 is configured to support the electronic device in executing the corresponding functions of the method in the above method embodiment. The processor 61 can be a central processing unit (CPU), a network processor (NP), a hardware chip, or any combination thereof. The above hardware chip can be an application specific integrated circuit (ASIC), a programmable logic device (PLD), or a combination thereof. The above PLD can be a complex programmable logic device (CPLD), a field-programmable gate array (FPGA), a generic array logic (GAL), or any combination thereof.

[0122] The memory 62 is used to store program code, etc. The memory 62 may include volatile memory (VM), such as random access memory (RAM); non-volatile memory (NVM), such as read-only memory (ROM), flash memory, hard disk drive (HDD), or solid-state drive (SSD); or a combination of the aforementioned types of memory.

[0123] Memory 62 can be used to store non-volatile software programs, non-volatile computer executable programs, and modules, such as the program instructions / modules corresponding to the method for generating a UI interface for a charging operation platform in the embodiments of the present invention. Processor 61 executes the non-volatile software programs, instructions, and modules stored in memory 62 to execute the various functional applications and data processing of the method for generating a UI interface for a charging operation platform and the system for generating a UI interface for a charging operation platform, thereby implementing the functions of the various modules or units of the method for generating a UI interface for a charging operation platform and the system for generating a UI interface for a charging operation platform provided in the aforementioned method embodiments.

[0124] The memory 62 may include a program storage area and a data storage area. The program storage area may store an operating system and applications required for at least one function. The data storage area may store data created based on the use of the UI interface generation system of the charging operation platform. In some embodiments, the memory 62 may optionally include a memory remote from the processor 61. These remote memories may be connected to the UI interface generation device of the charging operation platform via a network. Examples of such networks include, but are not limited to, the Internet, an intranet, a local area network, a mobile communication network, and combinations thereof.

[0125] One or more modules are stored in the memory 62. When executed by one or more processors 61, the UI interface generation method of the charging operation platform in any of the above method embodiments is executed, for example, the method steps described in the above method embodiments are executed to realize the functions of the modules described in the above system embodiments.

[0126] An embodiment of the present invention also provides a computer-readable storage medium, which stores a computer program. The computer program includes program instructions. When the program instructions are executed by a processor of an electronic device, the processor executes the UI interface generation method of the charging operation platform as described in the above embodiment.

[0127] Those skilled in the art will appreciate that all or part of the processes in the above-described method embodiments can be implemented by instructing related hardware through a computer program. The program can be stored in a computer-readable storage medium, and when executed, the program can include the processes in the above-described method embodiments. The storage medium can be a magnetic disk, an optical disk, a read-only memory (ROM), or a random access memory (RAM).

[0128] The above disclosure is merely a preferred embodiment of the present invention and certainly cannot be used to limit the scope of the present invention. Therefore, equivalent changes made according to the claims of the present invention are still within the scope of the present invention.

Claims

1. A method for generating a UI interface for a charging operation platform, characterized in that: The method comprises: Obtain configuration information input by the user, where the configuration information is used to indicate the configuration requirements of the UI interface to be generated; Determining code generation rules according to the configuration information; Generate target code using a pre-trained generative AI model according to the code generation rules, where the target code matches the technology stack used by the charging operation platform; The target code is run through a preset sandbox rendering module to generate a target UI interface.

2. The method for generating a UI interface of a charging operation platform according to claim 1, characterized in that: Determining code generation rules according to the configuration information includes: Parsing the configuration information using a pre-built domain enhancement model to obtain a parsing result; Determine, based on the analysis results, structured parameters corresponding to the configuration requirements, where the structured parameters are used to indicate data indicators, screening conditions, and interaction logic of the UI interface to be generated; The code generation rule is determined according to the structured parameters.

3. The method for generating a UI interface of a charging operation platform according to claim 2, characterized in that: Determining the code generation rule according to the structured parameters includes: Determining API metadata corresponding to the structured parameters; Determining, based on the API metadata, a target feature that matches the API metadata in a feature library of a preset charging operation platform; The code generation rule is determined according to the matched target features.

4. The method for generating a UI interface of a charging operation platform according to claim 3, characterized in that: The feature library of the charging operation platform includes the time features, device features and user features of the charging operation platform; The time characteristics include the peak charging period and peak and valley electricity price period of the charging operation platform; The equipment characteristics include the charging pile type and rated power of each charging pile in the charging operation platform; The user characteristics include the user level and historical credit score rate of the charging operation platform.

5. The method for generating a UI interface of a charging operation platform according to claim 1, characterized in that: Running the target code through a preset sandbox rendering module includes: The target code is embedded in the sandbox rendering module so that the sandbox rendering module runs the target code. The sandbox rendering module communicates with the main application of the charging operation platform according to a preset application program interface. The sandbox rendering module controls the network requests and script execution permissions associated with the target code according to a preset security mechanism.

6. The method for generating a UI interface of a charging operation platform according to claim 5, characterized in that: The method further comprises: Storing the target code and corresponding configuration information in a preset database and associating the user's identity and version number to record the current target code version; When it is detected that the user has modified the configuration information, the target code is updated according to the configuration information modified by the user; The updated target code is re-embedded into the sandbox rendering module, so that the sandbox rendering module reloads the target code and runs.

7. The method for generating a UI interface of a charging operation platform according to claim 1, characterized in that: The method further comprises: Determine whether the target UI interface meets the configuration requirements; When the target UI interface meets the configuration requirements, saving and publishing the target code; When the target UI interface does not meet the configuration requirements, the code generation rules are re-determined according to the configuration information input by the user.

8. The method for generating a UI interface of a charging operation platform according to claim 7, characterized in that: The method further comprises: Determine the modified target code according to the re-determined code generation rule, and run the modified target code through the sandbox rendering module to generate a modified target UI interface; Determine whether the modified target UI interface meets the configuration requirements; If the modified target UI interface meets the configuration requirements, the modified target code is updated to the target code; If the modified target UI interface does not meet the configuration requirements, continue to modify the target code until the modified target UI interface meets the configuration requirements.

9. An electronic device, characterized in that: The electronic device includes a memory and a processor, the memory is connected to the processor, and the processor is used to execute one or more computer programs stored in the memory. When the processor executes the one or more computer programs, the electronic device implements the UI interface generation method of the charging operation platform as described in any one of claims 1 to 8.

10. A computer-readable storage medium, characterized in that The computer-readable storage medium stores a computer program, which includes program instructions. When the program instructions are executed by a processor, the processor executes the UI interface generation method for the charging operation platform according to any one of claims 1 to 8.

Images