CN116991421A - Low-code platform event processing method, device, equipment and storage medium - Google Patents
Low-code platform event processing method, device, equipment and storage medium Download PDFInfo
- Publication number
- CN116991421A CN116991421A CN202310960508.5A CN202310960508A CN116991421A CN 116991421 A CN116991421 A CN 116991421A CN 202310960508 A CN202310960508 A CN 202310960508A CN 116991421 A CN116991421 A CN 116991421A
- Authority
- CN
- China
- Prior art keywords
- event
- block
- code
- code string
- current
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000003672 processing method Methods 0.000 title claims abstract description 10
- 238000000034 method Methods 0.000 claims abstract description 39
- 230000006870 function Effects 0.000 claims description 40
- 230000006399 behavior Effects 0.000 claims description 30
- 230000001960 triggered effect Effects 0.000 claims description 24
- 238000005516 engineering process Methods 0.000 claims description 23
- 238000012300 Sequence Analysis Methods 0.000 claims description 7
- 238000004458 analytical method Methods 0.000 claims description 5
- 230000000903 blocking effect Effects 0.000 description 7
- 238000004891 communication Methods 0.000 description 6
- 238000010586 diagram Methods 0.000 description 4
- 230000003993 interaction Effects 0.000 description 4
- 230000002085 persistent effect Effects 0.000 description 3
- 238000006243 chemical reaction Methods 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 1
- 125000004122 cyclic group Chemical group 0.000 description 1
- 238000013500 data storage Methods 0.000 description 1
- 238000012217 deletion Methods 0.000 description 1
- 230000037430 deletion Effects 0.000 description 1
- 238000002955 isolation Methods 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 230000000750 progressive effect Effects 0.000 description 1
- 238000000926 separation method Methods 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/42—Syntactic analysis
- G06F8/427—Parsing
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Abstract
The invention relates to the technical field of computers, and discloses a low-code platform event processing method, a device, equipment and a storage medium, wherein the method comprises the following steps: initializing a preset Blockly basic block, and pushing a page containing the preset Blockly basic block to a user; receiving a user behavior instruction, and determining a target block basic block in a preset block basic block through the user behavior instruction; obtaining block configuration parameters corresponding to a target block basic block, and generating a block module group of a current event; converting the Block ly module group into a code string of the current event, and executing the code string of the current event to complete event processing. According to the invention, the preset block basic blocks in the page are set in the jigsaw mode through the user instruction, so that the processing of different events is completed, compared with the existing interface input and flow connection modes, the method and the device can enable a user to intuitively and clearly set the solution of the event, and promote the expansibility of event processing based on a low-code platform in different scenes.
Description
Technical Field
The present invention relates to the field of computer technologies, and in particular, to a method, an apparatus, a device, and a storage medium for processing an event on a low-code platform.
Background
The current front-end platform is generally implemented by adopting modes such as interface configuration, flow connection configuration and the like for processing different behavior events. The interface configuration mode has two modes, namely a high code mode and a low code mode, wherein the high code mode needs a handwriting processing function of a user and cannot be oriented to a non-technical user; the low-code mode enables a user to select provided behaviors by providing a front-end interface, however, the flow of the selected behaviors is fixed, and the user can only set gradually according to the interface provided by a developer and cannot freely combine. The configuration mode of the flow connection has poor intuitiveness in the application of complex scenes, and cannot support the scenes needing to be recycled. Therefore, the above configuration event processing method requires not only a certain cost of the hands, but also a low degree of freedom and a high functional limit.
The foregoing is provided merely for the purpose of facilitating understanding of the technical scheme of the present invention and is not intended to represent an admission that the foregoing is related art.
Disclosure of Invention
The invention mainly aims to provide a method, a device, equipment and a storage medium for processing events of a low-code platform, and aims to solve the technical problems that the existing front-end low-code platform is low in configuration degree of freedom and high in functionality limitation because event processing is realized by adopting modes such as interface configuration, flow connection configuration and the like.
In order to achieve the above object, the present invention provides a low code platform event processing method, which includes the following steps:
initializing a preset Blockly basic block, and pushing a page containing the preset Blockly basic block to a user;
receiving a user behavior instruction, and determining a target block basic block in the preset block basic block through the user behavior instruction;
obtaining block configuration parameters corresponding to the target block basic blocks, and generating a block module group of a current event;
and converting the Blockly module group into a code string of the current event, and executing the code string of the current event to complete event processing.
Optionally, the obtaining the block configuration parameter corresponding to the target block basic block, and generating the block module group of the current event includes:
filling basic event sentences containing items to be filled in the target Blockly basic blocks according to the block configuration parameters to obtain each Blockly module of the current event;
and extracting block arrangement information in the user behavior instruction, and arranging all the block modules of the current event according to the block arrangement information to generate a block module group of the current event.
Optionally, the converting the block module group into a code string of the current event, executing the code string of the current event to complete event processing, including:
determining the corresponding language of the current technical stack, and converting the Blockly module group into codes in a corresponding language format to determine the code string of the current event;
transmitting the code string of the current event to a storage database;
when an event command is triggered, the code string of the current event is acquired from the storage database, and the code string is executed through an execution function to complete event processing.
Optionally, the current technology stack is VUE, the corresponding language of the current technology stack is JavaScript, the code string of the current event is a serialized code string, and the sending the code string of the current event to a storage database includes:
acquiring information of a Block module group;
and transmitting the code string of the current event and the information of the block module group in the serialization category to a storage database by adopting a JSON configuration form.
Optionally, when the event command is triggered, the code string of the current event is acquired from the storage database, and before the code string is executed by an execution function to complete event processing, the method includes:
binding the Blockly module group information with a preset interface to obtain interface binding information;
storing the interface binding information into a Blockly configuration information table;
correspondingly, when the event command is triggered, the code string of the current event is acquired from the storage database, and the code string is executed through an execution function to complete event processing, which comprises the following steps:
when an event command is triggered, a preset interface is determined through the Blockly configuration information table, a code string of the current event is obtained based on the preset interface, and the code string is executed through an execution function to complete event processing.
Optionally, when an event command is triggered, determining a preset interface through the block configuration information table, acquiring a code string of the current event based on the preset interface, and executing the code string through an execution function to complete event processing, where the method includes:
when an event command is triggered, determining a preset interface through the Blockly configuration information table;
acquiring a code string of the current event based on a preset interface, and performing anti-sequence analysis on the code string of the current event to obtain an analysis code;
the resolved code is executed by an execution function to complete event processing.
Optionally, before the executing the resolved code by the executing function to complete event processing, the method includes:
generating a code executable environment based on the current technology stack;
accordingly, the executing the resolved code by the execution function to complete event processing includes:
in the code executable environment, the resolved code is executed by an execution function to complete event processing.
In addition, to achieve the above object, the present invention also proposes a low code platform event processing apparatus, the apparatus comprising:
the page pushing module is used for initializing a preset block basic block and pushing a page containing the preset block basic block to a user;
the instruction receiving module is used for receiving a user behavior instruction, and determining a target block basic block in the preset block basic block through the user behavior instruction;
the block group generation module is used for acquiring block configuration parameters corresponding to the target block basic blocks and generating a block group of the current event;
and the event processing module is used for converting the Blockly module group into a code string of the current event and executing the code string of the current event to complete event processing.
In addition, to achieve the above object, the present invention also proposes a low code platform event processing apparatus, the apparatus comprising: a memory, a processor, and a low code platform event handler stored on the memory and executable on the processor, the low code platform event handler configured to implement the steps of the low code platform event handling method as described above.
In addition, to achieve the above object, the present invention also proposes a storage medium having stored thereon a low code platform event handler which, when executed by a processor, implements the steps of the low code platform event handling method as described above.
Firstly, initializing a preset block basic block, and pushing a page containing the preset block basic block to a user; receiving a user behavior instruction, and determining a target block basic block in the preset block basic block through the user behavior instruction; obtaining block configuration parameters corresponding to the target block basic blocks, and generating a block module group of a current event; and converting the Blockly module group into a code string of the current event, and executing the code string of the current event to complete event processing. Because the invention sets the preset block basic blocks in the page in the form of the jigsaw by the user instruction so as to finish the processing of different events, compared with the prior interface input and flow connection mode, the invention can lead the user to intuitively and clearly set the solution of the event, reduce the cost of hands of the non-technical user and promote the expansibility of processing the event in different scenes.
Drawings
FIG. 1 is a schematic diagram of a low code platform event handling device of a hardware runtime environment in accordance with an embodiment of the present invention;
FIG. 2 is a flowchart illustrating a first embodiment of a low code platform event handling method according to the present invention;
FIG. 3 is a flowchart illustrating a second embodiment of a low code platform event handling method according to the present invention;
FIG. 4 is a flowchart illustrating a third embodiment of a low code platform event handling method according to the present invention;
FIG. 5 is a block diagram illustrating a first embodiment of a low code platform event handler according to the present invention.
The achievement of the objects, functional features and advantages of the present invention will be further described with reference to the accompanying drawings, in conjunction with the embodiments.
Detailed Description
It should be understood that the specific embodiments described herein are for purposes of illustration only and are not intended to limit the scope of the invention.
Referring to fig. 1, fig. 1 is a schematic structural diagram of a low-code platform event processing device of a hardware running environment according to an embodiment of the present invention.
As shown in fig. 1, the low code platform event handling apparatus may include: a processor 1001, such as a central processing unit (Central Processing Unit, CPU), a communication bus 1002, a user interface 1003, a network interface 1004, a memory 1005. Wherein the communication bus 1002 is used to enable connected communication between these components. The user interface 1003 may include a Display, an input unit such as a Keyboard (Keyboard), and the optional user interface 1003 may further include a standard wired interface, a wireless interface. The network interface 1004 may optionally include a standard wired interface, a Wireless interface (e.g., a Wireless-Fidelity (WI-FI) interface). The Memory 1005 may be a high-speed random access Memory (Random Access Memory, RAM) or a stable nonvolatile Memory (NVM), such as a disk Memory. The memory 1005 may also optionally be a storage device separate from the processor 1001 described above.
Those skilled in the art will appreciate that the architecture shown in FIG. 1 is not limiting of a low code platform event handling apparatus and may include more or fewer components than shown, or certain components in combination, or a different arrangement of components.
As shown in fig. 1, an operating system, a network communication module, a user interface module, and a low code platform event handler may be included in the memory 1005 as one type of storage medium.
In the low code platform event handling device shown in fig. 1, the network interface 1004 is mainly used for data communication with a network server; the user interface 1003 is mainly used for data interaction with a user; the processor 1001 and the memory 1005 in the low code platform event handling apparatus of the present invention may be disposed in the low code platform event handling apparatus, which calls the low code platform event handling program stored in the memory 1005 through the processor 1001 and executes the low code platform event handling method provided by the embodiment of the present invention.
An embodiment of the present invention provides a low-code platform event processing method, and referring to fig. 2, fig. 2 is a flowchart of a first embodiment of the low-code platform event processing method of the present invention.
In this embodiment, the low code platform event processing method includes the following steps:
step S10: initializing a preset Blockly basic block, and pushing a page containing the preset Blockly basic block to a user.
It should be noted that, the execution body of the embodiment may be a computing service device with functions of data processing, network communication, screen display and program running, such as a mobile phone, a tablet computer, a personal computer, etc., or may be other electronic devices capable of implementing the low-code platform event processing method with the same or similar functions, which is not limited in this embodiment. Various embodiments of the low code platform event handling method of the present invention will be described herein using the low code platform event handling device (hereinafter referred to as the marketing device) as an example.
It should be noted that, blockly is a programming tool developed by google corporation, specifically, it is a programming tool that can be visualized based on pages. Because the command and the parameter forming the program are all the block basic blocks which are shaped like 'building blocks' and are patterned, a user only needs to drag different 'building blocks' on a page and combine the different 'building blocks' together according to a certain sequence, and then specific program codes of a specified language can be output.
It is understood that the preset block basic block may be a block that is set by a platform developer based on historical data and network related reference data and includes elements for composing a platform event. The elements forming the platform event can comprise logic, variables, functions, texts, custom and the like, and a user can process different platform events through configuration of the preset block basic block.
It should be noted that, the preset block basic block may be created on a web page, and the current marketing device may push the page including the preset block basic block to the user in a screen display manner.
It can be understood that the page may be partitioned, for example, a region on one side of the page may be listed with the preset Blockly basic block to be selected by the user, and a region on the other side may be used for executing subsequent block splicing and configuration for the user.
Step S20: and receiving a user behavior instruction, and determining a target Block basic block in the preset Block basic block through the user behavior instruction.
It should be noted that, the behavior instruction of the user may be an instruction that the user selects and adjusts the position of the preset block basic block.
It will be appreciated that the target Blockly basic block may be a user selected basic block that may be configured to implement current event processing.
In a specific implementation, the marketing device may receive a behavior instruction performed by a user on a page, for example, a specific preset block basic block selected by the user, to obtain a target block basic block, and may further obtain a block basic block in a combined form according to dragging performed by the user on different preset block basic blocks.
Step S30: and obtaining block configuration parameters corresponding to the target block basic block, and generating a block module group of the current event.
It can be understood that, since the target block basic block contains elements constituting the platform event and is displayed in the form of a text sentence, and the text sentence contains the item to be filled, the block configuration parameter may be a numerical value or a logic condition manually filled or selected by the user on the page, so as to be used for filling up the item to be filled in each text sentence of the block basic block.
It should be noted that, the block module group of the current event may be a module group selected by a user behavior instruction and including a specific parameter configuration of the basic block connection relation set. The set of modules may be stored for later direct invocation upon the same or similar event processing.
It should be understood that the marketing device may fill the basic event statement including the item to be filled in the target block basic block according to the block configuration parameter, so as to obtain each block module of the current event; and extracting block arrangement information in the user behavior instruction, and arranging all the block modules of the current event according to the block arrangement information to generate a block module group of the current event.
In a specific implementation, the marketing device fills text sentences of each basic event element in the target Blockly basic block according to block configuration parameters selected or input by a user to obtain each Blockly module of a current event; and determining the arrangement sequence and the combination mode of each basic block by combining the user behavior instructions to generate a block module group of the current event, wherein the block module group can contain all information for processing the current event.
Step 40: and converting the Blockly module group into a code string of the current event, and executing the code string of the current event to complete event processing.
It should be noted that, since the data processing implemented by the code platform is ultimately implemented to the execution of the code, the code platform can be converted into a corresponding language executable by the current code platform by using the blocking capability based on the language supported by the current low code platform and the specified language of the blocking.
In a specific implementation, the processing device converts the block module group determined by user combination connection into a corresponding language executable by the current code platform by using the block capability to obtain a code string of the current event so as to complete the processing of the current event by executing the code string.
Firstly, initializing a preset block basic block, and pushing a page containing the preset block basic block to a user; receiving a user behavior instruction, and determining a target block basic block in the preset block basic block through the user behavior instruction; obtaining block configuration parameters corresponding to the target block basic blocks, and generating a block module group of a current event; and converting the Blockly module group into a code string of the current event, and executing the code string of the current event to complete event processing. Because the invention sets the preset block basic blocks in the page in the form of the jigsaw by the user instruction so as to finish the processing of different events, compared with the prior interface input and flow connection mode, the invention can lead the user to intuitively and clearly set the solution of the event, reduce the cost of hands of the non-technical user and promote the expansibility of processing the event in different scenes.
Referring to fig. 3, fig. 3 is a flowchart illustrating a second embodiment of a low code platform event handling method according to the present invention.
Based on the above embodiment, in this embodiment, in order to achieve separation and interaction between front and rear ends, step S40 includes:
step S401: and determining the corresponding language of the current technical stack, and converting the Blockly module group into codes in a corresponding language format to determine the code string of the current event.
It should be noted that, the current platform may support different technology stacks, and different technology stacks have languages supported by the different technology stacks. When the current technology stack is a progressive frame VUE, the VUE is a JavaScript frame used to build the user interface. It is built based on standard hypertext markup language (HyperText Markup Language, HTML), cascading style sheets (Cascading Style Sheets, CSS) and JavaScript. Thus, the corresponding language of the current technology stack may be set as JavaScript.
In a specific implementation, when the processing device determines that the current technology stack is VUE and determines that the corresponding language of the current technology stack is JavaScript, the block module group obtained through user configuration can be converted into a Java format serialization code executable by the current platform by using the block capability, so as to determine a code string of the current event.
Step S402: and sending the code string of the current event to a storage database.
It should be noted that the storage database may be a back-end storage database, and the back-end does not need to pay attention to a specific structure in the configuration, and only needs to perform persistent storage, so that a subsequent user can directly call the content in the database when the same or similar event processing is required.
Further, step S402 includes:
step S4021: and acquiring the Blockly module group information.
The information of the block group may include each target block group of the block group, filling content of basic event sentences in each basic block determined by the user, and an arrangement sequence and a combination manner of each basic block formed by dragging each basic block by the user, and the information of the block group may reflect a specific structural configuration of the block group in a data form.
Step S4022: and transmitting the code string of the current event and the information of the block module group in the serialization category to a storage database by adopting a JSON configuration form.
It should be noted that, since the current platform adopts VUE as a technology stack and the executable corresponding language is JavaScript, and JSON is a standard format for representing structured data as JavaScript objects, and is generally used for representing and transmitting data on a website, the data storage can be performed in a JSON configuration form.
In a specific implementation, when a code string of an executable serialization category current event generated through the above-mentioned block function conversion and block module group information reflecting a specific structural configuration of a block module group are obtained, the generated executable serialization code and block module group information are stored in the form of JSON configuration and sent to a back-end storage database.
Step S403: when an event command is triggered, the code string of the current event is acquired from the storage database, and the code string is executed through an execution function to complete event processing.
It should be noted that, the event command may be triggered by the user performing the basic block configuration, or may be triggered by any user who needs to execute various events in the environment developed by the low-code platform.
It can be understood that, because the code string of the current event and the Blockly module group information are stored in the back-end storage database, the order of the back-end storage database is stored in a persistent manner, when an event command is triggered, the code string of the current event corresponding to the event command can be directly acquired from the back-end storage database, and the code string is executed by an honor executing function, so that event processing is completed.
The embodiment determines the code string of the current event by determining the corresponding language of the current technical stack and converting the Blockly module group into codes in the corresponding language format; transmitting the code string of the current event to a storage database; when an event command is triggered, the code string of the current event is acquired from the storage database, and the code string is executed through an execution function to complete event processing. In the embodiment, the code blocks are converted into the codes in the JavaScript format under the VUE technical stack through the Block function, so that the JavaScript capability can be re-carved, the JavaScript language can support expression theoretically, the flexibility of event processing in different scenes is improved, meanwhile, the block configuration information can be stored, and the cyclic use of the scenes can be supported.
Referring to fig. 4, fig. 4 is a flowchart illustrating a third embodiment of a low code platform event handling method according to the present invention.
Based on the above embodiment, in order to timely acquire the back-end storage content when the event command is triggered, before step S403, the method includes:
step S0403: binding the Blockly module group information with a preset interface to obtain interface binding information.
It should be noted that, the front-end platform and the back-end storage may perform information interaction based on a preset interface, so that the constructed block configuration may be called through the interface and stored in the block configuration information table of the back-end.
It can be understood that the blocking module block information can be bound with a preset interface for interaction, so that interface binding information is obtained, and data call can be performed from the preset interface when an event corresponding to the blocking module block information is executed subsequently.
Step S0403': and storing the interface binding information into a blocking configuration information table.
In a specific implementation, when interface binding information containing the block module group information of the block configuration is obtained, the interface binding information may be stored in a block configuration information table in a back-end storage database.
Accordingly, step S403 includes:
step S403': when an event command is triggered, a preset interface is determined through the Blockly configuration information table, a code string of the current event is obtained based on the preset interface, and the code string is executed through an execution function to complete event processing.
Further, considering that the code string of the current event is an executable serialized code string, step S403' includes:
step S4031: and when an event command is triggered, determining a preset interface through the Blockly configuration information table.
It should be noted that, because the current platform adopts VUE as a technology stack and the executable corresponding language is JavaScript, the data in the block configuration information table can be stored by adopting a JSON structure as well. The backend may be opened with CRUD interfaces for invoking the blocking configuration for performing creation, reading, updating and deletion.
Step S4032: and acquiring the code string of the current event based on a preset interface, and performing anti-sequence analysis on the code string of the current event to obtain an analysis code.
It can be appreciated that, since the code string obtained by the above-mentioned blocking conversion is an executable serialized code string, the code string of the current event needs to be subjected to anti-sequence analysis before the code string is executed.
Step S4033: the resolved code is executed by an execution function to complete event processing.
It can be understood that the executing function may be a function capable of executing code applied to the current platform, and since the current platform uses VUE as a technology stack and the executable corresponding language is JavaScript, the executing function may be eval, or other executing functions capable of executing java code, which is not limited in this embodiment.
It should be noted that, it is also considered that the current platform adopts VUE as a technology stack, so a context environment where code is executable may be generated based on the current technology stack VUE.
In a specific implementation, the running process can acquire a code string of a current event in the rear-end storage database based on a preset interface, perform anti-sequence analysis on the code string, form an executable context environment by combining with the VUE, execute codes by executing a function eval, and further complete event processing.
When an event command is triggered, the code string of the current event is acquired from the storage database, and before the execution of the code string by an execution function to complete event processing, the block module group information is bound with a preset interface to acquire interface binding information; storing the interface binding information into a Blockly configuration information table; when an event command is triggered, determining a preset interface through the Blockly configuration information table; acquiring a code string of the current event based on a preset interface, and performing anti-sequence analysis on the code string of the current event to obtain an analysis code; in the code executable environment, the resolved code is executed by an execution function to complete event processing. According to the embodiment, the fact that the rear end does not need to pay attention to a specific structure in the configuration can be considered, only persistent storage is needed, interfaces such as CRUD and the like of the block configuration are opened to the outside, front-rear end isolation is achieved, flexibility of executing processing events in different scenes can be improved, and the rate of solving similar behavior events based on the platform by a user is further improved.
In addition, in order to achieve the above object, the present invention also proposes a storage medium having stored thereon a low code platform event handler which, when executed by a processor, implements the steps of the low code platform event handling method as described above.
Because the storage medium adopts all the technical solutions of all the embodiments, at least all the beneficial effects brought by the technical solutions of the embodiments are not described in detail herein.
Referring to fig. 5, fig. 5 is a block diagram illustrating a first embodiment of a low code platform event handler according to the present invention.
The page pushing module 501 is configured to initialize a preset block basic block, and push a page containing the preset block basic block to a user;
the instruction receiving module 502 is configured to receive a user behavior instruction, and determine a target block basic block from the preset block basic blocks through the user behavior instruction;
a block group generating module 503, configured to obtain a block configuration parameter corresponding to the target block_basic block, and generate a block_ly module group of the current event;
and the event processing module 504 is configured to convert the block group into a code string of the current event, and execute the code string of the current event to complete event processing.
Firstly, initializing a preset block basic block, and pushing a page containing the preset block basic block to a user; receiving a user behavior instruction, and determining a target block basic block in the preset block basic block through the user behavior instruction; obtaining block configuration parameters corresponding to the target block basic blocks, and generating a block module group of a current event; and converting the Blockly module group into a code string of the current event, and executing the code string of the current event to complete event processing. Because the invention sets the preset block basic blocks in the page in the form of the jigsaw by the user instruction so as to finish the processing of different events, compared with the prior interface input and flow connection mode, the invention can lead the user to intuitively and clearly set the solution of the event, reduce the cost of hands of the non-technical user and promote the expansibility of processing the event in different scenes.
Based on the first embodiment of the low-code platform event handling device according to the present invention, a second embodiment of the low-code platform event handling device according to the present invention is provided.
In this embodiment, a block group generating module 503 is configured to fill a basic event statement including a to-be-filled item in the target block basic block according to the block configuration parameter, so as to obtain each block module of the current event; and extracting block arrangement information in the user behavior instruction, and arranging all the block modules of the current event according to the block arrangement information to generate a block module group of the current event.
An event processing module 504, configured to determine a corresponding language of the current technology stack, and convert the block module group into a code in a corresponding language format, so as to determine a code string of the current event; transmitting the code string of the current event to a storage database; when an event command is triggered, the code string of the current event is acquired from the storage database, and the code string is executed through an execution function to complete event processing.
Further, the event processing module 504 is further configured to obtain Blockly module group information; and transmitting the code string of the current event and the information of the block module group in the serialization category to a storage database by adopting a JSON configuration form, wherein the current technology stack is VUE, the corresponding language of the current technology stack is JavaScript, and the code string of the current event is the serialization code string.
Further, the event processing module 504 is further configured to bind the block_ly module group information with a preset interface to obtain interface binding information; storing the interface binding information into a Blockly configuration information table; when an event command is triggered, a preset interface is determined through the Blockly configuration information table, a code string of the current event is obtained based on the preset interface, and the code string is executed through an execution function to complete event processing.
Further, the event processing module 504 is further configured to determine, when an event command is triggered, a preset interface through the Blockly configuration information table; acquiring a code string of the current event based on a preset interface, and performing anti-sequence analysis on the code string of the current event to obtain an analysis code; the resolved code is executed by an execution function to complete event processing.
Further, the event processing module 504 is further configured to generate a code executable environment based on the current technology stack; in the code executable environment, the resolved code is executed by an execution function to complete event processing.
Other embodiments or specific implementation manners of the low-code platform event processing apparatus of the present invention may refer to the above method embodiments, and are not described herein again.
It should be noted that, in this document, the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or system that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or system. Without further limitation, an element defined by the phrase "comprising one … …" does not exclude the presence of other like elements in a process, method, article, or system that comprises the element.
The foregoing embodiment numbers of the present invention are merely for the purpose of description, and do not represent the advantages or disadvantages of the embodiments.
From the above description of the embodiments, it will be clear to those skilled in the art that the above-described embodiment method may be implemented by means of software plus a necessary general hardware platform, but of course may also be implemented by means of hardware, but in many cases the former is a preferred embodiment. Based on such understanding, the technical solution of the present invention may be embodied essentially or in a part contributing to the prior art in the form of a software product stored in a storage medium (e.g. read-only memory/random-access memory, magnetic disk, optical disk), comprising instructions for causing a terminal device (which may be a mobile phone, a computer, a server, an air conditioner, or a network device, etc.) to perform the method according to the embodiments of the present invention.
The foregoing description is only of the preferred embodiments of the present invention, and is not intended to limit the scope of the invention, but rather is intended to cover any equivalents of the structures or equivalent processes disclosed herein or in the alternative, which may be employed directly or indirectly in other related arts.
Claims (10)
1. A method of low code platform event handling, the method comprising:
initializing a preset Blockly basic block, and pushing a page containing the preset Blockly basic block to a user;
receiving a user behavior instruction, and determining a target block basic block in the preset block basic block through the user behavior instruction;
obtaining block configuration parameters corresponding to the target block basic blocks, and generating a block module group of a current event;
and converting the Blockly module group into a code string of the current event, and executing the code string of the current event to complete event processing.
2. The method for processing the low-code platform event according to claim 1, wherein the obtaining the block configuration parameter corresponding to the target block basic block to generate the block module group of the current event comprises:
filling basic event sentences containing items to be filled in the target Blockly basic blocks according to the block configuration parameters to obtain each Blockly module of the current event;
and extracting block arrangement information in the user behavior instruction, and arranging all the block modules of the current event according to the block arrangement information to generate a block module group of the current event.
3. The low code platform event handling method according to claim 2, wherein said converting said block group of modules into a code string of a current event, executing said code string of a current event to complete event handling, comprises:
determining the corresponding language of the current technical stack, and converting the Blockly module group into codes in a corresponding language format to determine the code string of the current event;
transmitting the code string of the current event to a storage database;
when an event command is triggered, the code string of the current event is acquired from the storage database, and the code string is executed through an execution function to complete event processing.
4. The low code platform event processing method according to claim 3, wherein the current technology stack is VUE, the corresponding language of the current technology stack is JavaScript, the code string of the current event is a serialized code string, and the sending the code string of the current event to a storage database comprises:
acquiring information of a Block module group;
and transmitting the code string of the current event and the information of the block module group in the serialization category to a storage database by adopting a JSON configuration form.
5. The low code platform event handling method according to claim 4, wherein said retrieving a code string of said current event from said stored database upon triggering an event command, before executing said code string by an execution function to complete event handling, comprises:
binding the Blockly module group information with a preset interface to obtain interface binding information;
storing the interface binding information into a Blockly configuration information table;
correspondingly, when the event command is triggered, the code string of the current event is acquired from the storage database, and the code string is executed through an execution function to complete event processing, which comprises the following steps:
when an event command is triggered, a preset interface is determined through the Blockly configuration information table, a code string of the current event is obtained based on the preset interface, and the code string is executed through an execution function to complete event processing.
6. The method for processing the event of the low-code platform according to claim 5, wherein the determining a preset interface through the block configuration information table when the event command is triggered, and acquiring the code string of the current event based on the preset interface, and executing the code string through an execution function to complete the event processing, comprises:
when an event command is triggered, determining a preset interface through the Blockly configuration information table;
acquiring a code string of the current event based on a preset interface, and performing anti-sequence analysis on the code string of the current event to obtain an analysis code;
the resolved code is executed by an execution function to complete event processing.
7. The low code platform event handling method according to claim 6, wherein before executing the resolved code by an execution function to complete event handling, comprising:
generating a code executable environment based on the current technology stack;
accordingly, the executing the resolved code by the execution function to complete event processing includes:
in the code executable environment, the resolved code is executed by an execution function to complete event processing.
8. A low code platform event handling apparatus, the apparatus comprising:
the page pushing module is used for initializing a preset block basic block and pushing a page containing the preset block basic block to a user;
the instruction receiving module is used for receiving a user behavior instruction, and determining a target block basic block in the preset block basic block through the user behavior instruction;
the block group generation module is used for acquiring block configuration parameters corresponding to the target block basic blocks and generating a block group of the current event;
and the event processing module is used for converting the Blockly module group into a code string of the current event and executing the code string of the current event to complete event processing.
9. A low code platform event handling device, the device comprising: a memory, a processor and a low code platform event handler stored on the memory and executable on the processor, the low code platform event handler configured to implement the steps of the low code platform event handling method of any one of claims 1 to 7.
10. A storage medium having stored thereon a low code platform event handler, which when executed by a processor, implements the steps of the low code platform event handling method according to any one of claims 1 to 7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202310960508.5A CN116991421A (en) | 2023-07-31 | 2023-07-31 | Low-code platform event processing method, device, equipment and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202310960508.5A CN116991421A (en) | 2023-07-31 | 2023-07-31 | Low-code platform event processing method, device, equipment and storage medium |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN116991421A true CN116991421A (en) | 2023-11-03 |
Family
ID=88531594
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202310960508.5A Pending CN116991421A (en) | 2023-07-31 | 2023-07-31 | Low-code platform event processing method, device, equipment and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN116991421A (en) |
-
2023
- 2023-07-31 CN CN202310960508.5A patent/CN116991421A/en active Pending
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US7721254B2 (en) | Programming interface for a computer platform | |
| RU2390834C2 (en) | Method and device for browsing and interacting with electronic worksheet from web-browser | |
| US8365144B1 (en) | Proxy graphical user interface generation | |
| US8201143B2 (en) | Dynamic mating of a modified user interface with pre-modified user interface code library | |
| US9274761B1 (en) | Dual programming interface | |
| US7707191B2 (en) | Synchronizing undo/redo operations between different document views | |
| US20020103902A1 (en) | Methods and apparatus for exchanging information between browser pages | |
| US20120110444A1 (en) | Help Document Animated Visualization | |
| US20060090138A1 (en) | Method and apparatus for providing DHTML accessibility | |
| WO2010036457A2 (en) | Editing 2d structures using natural input | |
| US20030140332A1 (en) | Method and apparatus for generating a software development tool | |
| US20180321831A1 (en) | Smart controls for user interface design and implementation | |
| US8082494B2 (en) | Rendering markup language macro data for display in a graphical user interface | |
| CN110941427A (en) | Code generation method and code generator | |
| CN112148356A (en) | Document generation method, interface development method, device, server and storage medium | |
| CN116069325A (en) | Front-end project construction method, device, equipment and computer readable storage medium | |
| CN100561472C (en) | Be used for the method and system that preserves unknown mark at the strongly-typed environment | |
| He et al. | Adaptive user interface generation for web services | |
| Pohja | Comparison of common XML-based web user interface languages | |
| CN116991421A (en) | Low-code platform event processing method, device, equipment and storage medium | |
| Haller et al. | RaUL: RDFa User Interface Language–A data processing model for web applications | |
| US20220284371A1 (en) | Method, device and medium for a business function page | |
| CN115081423A (en) | Document editing method and device, electronic equipment and storage medium | |
| JP6664536B1 (en) | Web form input support system | |
| CN113821209A (en) | Interactive data processing method and device, electronic equipment and storage medium |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |