Logic checking method and device based on low-code platform and computer equipment

Abstract

The invention relates to the technical field of low-code development, in particular to a logic checking method and device based on a low-code platform and computer equipment. The method comprises the steps that a target language text corresponding to target logic is acquired, and the target logic is created in a low-code platform; analyzing the target language text to obtain a node type and a node attribute of each executable node in the target logic; according to the node type and the node attribute of the executable node, obtaining a node limitation check item of the executable node; and performing logic check on the executable node through the description rule in the node limitation check item of the executable node to obtain a check result of the target logic. According to the technical scheme provided by one or more implementation methods, detection of low-code logic can be achieved without invading codes, and the safety of the codes is guaranteed while logic detection is achieved.

Description

Technical Field

[0001] The present disclosure relates to the field of low-code development technology, and specifically to a logic checking method, apparatus, and computer equipment based on a low-code platform. Background Art

[0002] Low-code development is a method for rapidly building applications through a visual interface and pre-built modules. It allows developers to build application interfaces and business logic by dragging and dropping components and configuring parameters, significantly reducing the development threshold and cycle time for computer applications.

[0003] At present, although low-code development can simplify the application development process, its own logical complexity is also constantly increasing, which puts the security of low-code logic under tremendous pressure. Summary of the Invention

[0004] In view of this, one or more embodiments of the present disclosure provide a logic inspection method, apparatus, and computer equipment based on a low-code platform, which can detect low-code logic without intruding into the code, thereby ensuring the security of the code while achieving logic detection.

[0005] In the first aspect, the present disclosure provides a logic checking method based on a low-code platform, the method comprising: obtaining a target language text corresponding to a target logic, the target logic being created in a low-code platform, the target logic comprising at least one executable node; parsing the target language text to obtain the node type and node attributes of each executable node in the target logic; obtaining node restriction check items of the executable node according to the node type and node attributes of the executable node, the node restriction check items comprising description rules of the executable node in the target language text; performing a logic check on the executable node through the description rules in the node restriction check items of the executable node to obtain an inspection result of the target logic.

[0006] In the second aspect, the present disclosure provides a logic checking device based on a low-code platform, the device including: a text acquisition unit, used to obtain a target language text corresponding to a target logic, the target logic is created in a low-code platform, and the target logic includes at least one executable node; a text parsing unit, used to parse the target language text, and obtain the node type and node attributes of each executable node in the target logic; a first checking unit, used to obtain a node restriction check item of the executable node according to the node type and node attributes of the executable node, the node restriction check item including a description rule of the executable node in the target language text; a second checking unit, used to perform a logic check on the executable node through the description rule in the node restriction check item of the executable node, and obtain an inspection result of the target logic.

[0007] In a third aspect, the present disclosure provides a computer device comprising a memory and a processor, wherein the memory is used to store a computer program, and when the computer program is executed by the processor, the above-mentioned logic checking method based on the low-code platform is implemented.

[0008] In a fourth aspect, the present disclosure provides a computer-readable storage medium for storing a computer program, which, when executed by a processor, implements the above-mentioned logic checking method based on a low-code platform.

[0009] In a fifth aspect, the present disclosure provides a computer program product, including computer instructions, which are used to enable a computer to execute the above-mentioned logic checking method based on the low-code platform.

[0010] The technical solution provided by one or more embodiments of the present disclosure can obtain the node type and node attributes of executable nodes by parsing the target language text corresponding to the target logic. Based on this information, node restriction check items can be obtained, thereby performing a logical level check on the executable nodes. This allows for the detection of low-code logic without intrusion into the code, ensuring code security while achieving logical detection.

[0011] The technical solution provided by one or more embodiments of the present disclosure realizes efficient analysis of low-code logic, improves inspection efficiency, reduces inspection costs, and helps low-code logic to quickly form usable program products.

[0012] The technical solution provided by one or more embodiments of the present disclosure can automatically check for possible problems in the low-code logic after obtaining the target language text corresponding to the target logic, greatly reducing the time and effort of manual troubleshooting, avoiding possible omissions in manual inspection, improving the accuracy and reliability of logic inspection, and helping to improve the quality of applications developed based on the low-code platform and ensure the stable operation of applications developed on the low-code platform. BRIEF DESCRIPTION OF THE DRAWINGS

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

[0014] Figure 1 A schematic diagram of the steps of a logic checking method based on a low-code platform in one embodiment of the present disclosure is shown; Figure 2 An application diagram of a logic checking method based on a low-code platform in one embodiment of the present disclosure is shown; Figure 3 A flow chart of a logic checking method based on a low-code platform in one embodiment of the present disclosure is shown; Figure 4 A schematic diagram showing node restriction check items of an executable node in one embodiment of the present disclosure is shown; Figure 5 A schematic diagram of the functional modules of a logic checking device based on a low-code platform in one embodiment of the present disclosure is shown; Figure 6 A schematic structural diagram of a computer device in one embodiment of the present disclosure is shown. DETAILED DESCRIPTION

[0015] To make the purpose, technical solutions, and advantages of the embodiments of the present disclosure more clear, the technical solutions in the embodiments of the present disclosure will be clearly and completely described below in conjunction with the drawings in the embodiments of the present disclosure. Obviously, the described embodiments are part of the embodiments of the present disclosure, not all of the embodiments. Based on the embodiments of the present disclosure, all other embodiments obtained by those skilled in the art without making creative efforts shall fall within the scope of protection of the present disclosure.

[0016] In related technologies, applications developed for code development platforms can use code checkers to check the underlying code of the application, or the code checker can be parsed and converted into corresponding code logic to perform logic-level checks on the application. However, code checkers rely on the underlying code of the application, making it difficult to directly perform logic-level checks on low-code logic. In addition, code checkers generally require users to edit positive and negative example code snippets, which means that the underlying code of the application needs to be edited, which is an intrusion into the underlying code.

[0017] In view of this, the logic inspection method based on the low-code platform provided by one or more embodiments of the present disclosure can directly perform logic-level inspection on the low-code logic without obtaining or running the underlying code of the low-code logic, thereby improving inspection efficiency and ensuring detection security.

[0018] See also Figure 1 , a logic inspection method based on a low-code platform provided in one embodiment of the present disclosure may include the following steps.

[0019] S101: Obtain target language text corresponding to target logic, where the target logic is created in a low-code platform and includes at least one executable node.

[0020] In this implementation, the low-code logic that users build in the low-code platform's visual interface by dragging components and configuring parameters is called target logic. This target logic can be a complete application or a subset of an application's functionality. When the target logic is executed, it manifests as a series of executable steps, executed according to the user-programmed logic.

[0021] In this embodiment, the target logic may have one or more logical nodes, each of which may include one or more executable steps. Executable nodes are the nodes within these logical nodes that actually need to be checked. For example, a target logic may have three logical nodes: data reception, data processing, and data output. Of these, the data processing and data output logical nodes need to be checked, while the data reception logical nodes do not.

[0022] In this embodiment, the target language text is primarily used to describe the interface layout, component configuration, and behavioral logic of the target logic. The target language text is generally created and saved by the low-code platform. Generally speaking, after a user builds a target logic on a low-code platform, they can issue a command to the low-code platform to obtain the target language text, thereby receiving the target language text created by the low-code platform that corresponds to the target logic. The target language text can be a logical DSL (Domain-Specific Language).

[0023] In a practical application example, a user can drag a "Send Message" node into the process canvas of a low-code platform and set parameters such as the message recipient, message routing, and message frequency. The low-code platform can translate these "drag and drop" and "configuration" operations into a structured description that can be recognized internally by the platform, that is, text in the target language (such as a logical DSL).

[0024] In a practical application example, when users add nodes, delete nodes, connect lines, modify properties, and perform other operations on the process canvas of a low-code platform, the low-code platform can serialize these operations into logical DSL in JSON, XML, or a custom format.

[0025] S102: Parse the target language text to obtain the node type and node attributes of each executable node in the target logic.

[0026] In this implementation, logic checking of the target logic requires node-by-node processing to ensure comprehensiveness and accuracy. Therefore, it is necessary to parse the target language text, filter out the executable nodes of the target logic, and determine the node types and node attributes of these executable nodes.

[0027] It should be noted that this method parses the target language text. It does not require obtaining or running the underlying code of the target logic, nor does it require modifying the target logic itself. It will not cause additional logical changes to the target logic, thus ensuring detection security.

[0028] In this implementation, a node type defines the overall structure and behavior of a node. Node types may include, but are not limited to, assignment operations, function definitions, function calls, conditional statements, and loop statements. Node attributes describe the local structure or content of a node. Node attributes may include, but are not limited to, node names, node values, and node parameter lists.

[0029] In an actual application example, the node type of the executable node is "variable assignment", and its node attributes may include "variable name" and "variable assignment content".

[0030] In an actual application example, the node type of the executable node is "function definition", and its node attributes may include "function name" and "function parameter list".

[0031] In an actual application example, the node type of the executable node is "conditional statement", and its node attributes may include "conditional expression" and "execution code block".

[0032] In an actual application example, the node type of the executable node is a "loop statement", and its node attributes may include a "loop condition" and a "loop body".

[0033] S103: Obtain node restriction check items of the executable node according to the node type and node attributes of the executable node, where the node restriction check items include description rules of the executable node in the target language text.

[0034] In this embodiment, each type of node should have standardized description rules, and each node's node attributes should also have standardized description rules. During the logic check of each executable node, if the current description content of an executable node in the target language text is found to not conform to the standardized description rules, the executable node can be considered to have a logical error and needs to be modified and corrected.

[0035] In this embodiment, the description rules can be predetermined. For example, according to the editing rules of the low-code platform, a description rule library is pre-established to include description rules for various node types and description rules for various node attributes. After determining the executable node to be checked in the target logic, the description rules related to the executable node can be filtered out from the pre-created description rule library based on the node type and node attributes of the executable node. Optionally, the description rule library can update the description rules with version iteration or daily maintenance.

[0036] In a node or node attribute, description rules may include, but are not limited to, the following: the first parameter must be defined; the variable type of the second parameter must be within a type range; the value of the third parameter must be within a numerical interval; the fourth and fifth parameters must satisfy a specific logical relationship (for example, when one is enabled, the other must be disabled); and the sixth parameter must conform to a specific format specification, such as the "YYYY-MM-DD" format.

[0037] In some embodiments, the node restriction check item further includes description information corresponding to the description rule. Performing a logic check on the executable node to obtain a target logic check result includes: if the executable node does not satisfy the description rule, returning the description information corresponding to the description rule.

[0038] Specifically, the node restriction check item can be a collection of many description rules, so as to facilitate the efficient and orderly inspection of each executable node. For example, a specific description rule among the many description rules can be "parameter A must be defined." The description rules can include but are not limited to missing variables, incorrect variable definitions, incorrect variable values, variable conflicts, etc. The description information can correspond to the description rules one by one, clearly indicating which description rule a node or a node attribute in a node has violated, which helps users quickly locate errors and correct the target logic in a timely manner.

[0039] In some embodiments, the node restriction check items include at least one set of restriction combinations, each of which includes description rules and description information. Obtaining the node restriction check items for the executable node based on the node type and node attributes of the executable node includes: filtering a set of restriction items from a check item list based on the node type of the executable node; and filtering at least one set of restriction combinations from the set of restriction items based on the node attributes of the executable node.

[0040] Specifically, the check item list is similar to the description rule base described above, and is used to include description rules for various node types and various node attributes. After determining the executable node to be checked in the target logic, you can first filter out a part of the description rules, that is, the restriction item set, from the pre-created check item list based on the node type of the executable node. Then, based on the node attributes of the executable node, you can further filter out at least one set of restriction combinations in the restriction item set. Each restriction combination can include a specific description rule and the description information corresponding to the specific description rule. In this way, by filtering the restriction item set and restriction combination in steps, you can accurately match the description rules related to the executable node, and even to the attributes of each node in the executable node, thereby improving the pertinence and accuracy of the logic check.

[0041] In some embodiments, different attribute types of the same node attribute in the restriction item set have respective corresponding restriction combinations. Filtering at least one set of restriction combinations from the restriction item set based on the node attribute of the executable node includes filtering at least one set of restriction combinations from the restriction item set based on the node attribute and attribute type of the executable node.

[0042] Specifically, the attribute type represents the specific data type of the node attribute. The attribute type may include but is not limited to strings, variables, expressions (such as arithmetic expressions or logical expressions), statements (such as assignment statements or conditional statements), code blocks (such as function bodies or loop bodies), etc.

[0043] By considering different attribute types for the same node attribute and setting independent restriction combinations for each attribute type, further refined references to the description rules related to executable nodes are achieved. This makes the inspection process of the target logic more nuanced and can more accurately discover potential logical problems in the target logic. In addition, different attribute types can have their own restriction combinations, which can better adapt to the diversity of node attributes in the low-code platform. As the functions of the low-code platform continue to expand and the node attributes become increasingly complex, this refined inspection mechanism can flexibly respond to various situations and ensure the accuracy and reliability of logic inspections.

[0044] S104: Performing a logic check on the executable node according to the description rules in the node restriction check item of the executable node to obtain a target logic check result.

[0045] In this embodiment, the node restriction check item is used to perform a logic check on the executable node, that is, to check whether the current description content of the executable node in the target language text complies with the description rules of the node restriction check item.

[0046] In some implementations, the low-code platform also includes a prompt list, which is used to record descriptive information corresponding to the description rule. Performing a logic check on the executable node includes: querying the descriptive information corresponding to the description rule from the prompt list corresponding to the target logic; if the descriptive information corresponding to the description rule does not exist in the prompt list, returning a prompt indicating that the logic check was successful; if the descriptive information corresponding to the description rule exists in the prompt list, returning a prompt indicating that the logic check failed, along with the descriptive information corresponding to the description rule.

[0047] Specifically, the low-code platform can have a prompt list function or component for storing the returned inspection results, especially the descriptive information in the inspection results, when performing a logical check on the target logic. For example, the low-code platform pre-stores a certain number of prompt lists. When performing a logical check on the target logic, one can be randomly selected from these pre-stored prompt lists as a prompt list dedicated to the target logic. For another example, when performing a logical check on the target logic, the low-code platform can create a new prompt list dedicated to the target logic based on a pre-stored prompt list template.

[0048] The prompt list stores the descriptive information returned when the target logic fails the logic check, clearly providing users with feedback on the target logic check results. Users can intuitively understand whether the target logic has any logic problems, as well as the specific descriptions of the logic problems, allowing them to quickly locate and fix the problems.

[0049] If a logical error is found in an executable node, the user can be notified not only of the logical error in the target logic, but also of the specific logical error in the target logic. If no logical error is found in any executable node, the user can be notified that there is no logical error in the target logic.

[0050] Judging whether an inspection has passed or failed based on the presence of description information in the prompt list is both concise and clear, and easy to implement and maintain. This approach also ensures the efficiency of the inspection process, avoids complex logical judgments and redundant operations, and reduces operating costs.

[0051] In some embodiments, a logical check is performed on the executable node through the node restriction check item of the executable node, including: performing a logical check on the executable node in turn according to each description rule in the node restriction check item; if the logical check corresponding to the target description rule in each description rule fails, the description information corresponding to the target description rule is added to the prompt list.

[0052] Specifically, by sequentially checking each description rule, every possible problem point is verified. Once an executable node is found to have failed the logic check corresponding to a target description rule, the corresponding description information is immediately added to the prompt list, making the problem record more detailed and specific. Users can clearly understand each description rule that failed the check and the reasons, making it easier to quickly locate and fix the problem.

[0053] This step-by-step approach avoids omissions or confusion that might result from checking multiple description rules at once. By verifying each description rule one by one, issues can be more accurately identified, improving the overall accuracy and reliability of logic checking.

[0054] In some implementations, if the logic check corresponding to the target description rule fails, the next description rule of the target description rule is selected to perform a logic check on the executable node.

[0055] Specifically, even if a target description rule fails the check, the system continues to check subsequent description rules, ensuring a comprehensive check of all executable nodes. This allows all possible problems to be discovered at once, rather than just focusing on the first error, providing more comprehensive inspection results.

[0056] In some implementations, if the logic check corresponding to the target description rule fails, the logic check on the target logic is stopped.

[0057] Specifically, if a critical logic error is found to have failed the check, the check stops immediately, allowing the key issue to be quickly located. This allows developers to quickly focus on the key issue, reducing time wasted on checking a large amount of irrelevant content and improving the development and testing efficiency of the target logic.

[0058] By stopping the inspection immediately after detecting a critical issue, unnecessary subsequent inspections are avoided, saving computing resources and time. This is especially important for large-scale low-code logic inspections, significantly reducing operating costs.

[0059] See also Figure 2 , a logic checking method based on a low-code platform is provided in one embodiment of the present disclosure, which standardizes the method ontology, method input information, and method output results. For example, a logic checking method based on a low-code platform can be run on Figure 2 The logic checker is used in the target language to check the method input (that is, the target language text in the form of a logic DSL). After receiving the method input (that is, the target language text in the form of a logic DSL), the logic checker parses the logic DSL and identifies the executable nodes in the target logic. The logic checker then checks each executable node against the rules described in the DSL, determining whether each executable node contains any logical errors. Finally, the logic checker outputs the overall check results.

[0060] It's important to note that since no changes are made to the original logic DSL (that is, no modifications are made to the target logic), the entire checking process can be considered a static analysis of the logic DSL. The final output of the logic checker can also be called the static analysis result.

[0061] See also Figure 3 , a logic inspection method based on a low-code platform provided in one embodiment of the present disclosure may include the following process.

[0062] Process 1: Create a checklist. This checklist can include descriptive rules for various node types and node attributes. The checklist can be indexed by node type to form different sets of restrictions. The checklist can also be sub-indexed by node attribute and attribute type to form different restriction combinations.

[0063] The restricted combinations in the check item lists of Process 2 and Process 1 support combination expansion.

[0064] Each restriction combination in process 3 and process 1 consists of a restriction type (equivalent to a specific description rule) and prompt information (equivalent to the description information corresponding to the description rule).

[0065] Process 4: Parse the logical DSL generated by the low-code platform, which corresponds to the target logic.

[0066] Process 5: Get the executable node of the target logic and parse the node type and node attributes of the executable node.

[0067] Process 6: Based on the node type and node attributes obtained in process 5, obtain the restriction combination related to the feasible execution node from the check item list created in process 1.

[0068] Process 7, please refer to Figure 4 ,According to the attribute type of the node attribute, the restriction combination is further ,screened to form the node restriction check items of the ,executable node.

[0069] Process 8: Perform restriction checks (logical checks) on executable nodes based on each restriction type of the node restriction check item.

[0070] Process 9: When the restriction check corresponding to a restriction type in process 8 is determined to be failed, the node information, node attribute information and prompt information are stored in the prompt queue, and the next restriction type is determined.

[0071] Process 10: After all executable nodes have been checked, if the prompt queue is empty, a prompt indicating that the logic check is successful is returned.

[0072] Process 11: If the prompt queue is not empty, return the logic check failure prompt and return to the prompt queue at the same time.

[0073] It should be noted that the above steps 1 to 3 represent the preliminary preparation phase of the method. During this preliminary preparation phase, the restriction type and prompt information can be pre-set by the developer. In other words, description rules and description information for violations of the description rules are pre-set for different executable nodes. Steps 4 to 11 represent the actual execution phase of the method. The specific execution logic can be found in steps S101 to S104 and will not be further described here.

[0074] The technical solution provided by one or more embodiments of the present disclosure can obtain the node type and node attributes of executable nodes by parsing the target language text corresponding to the target logic. Based on this information, node restriction check items can be obtained, thereby performing a logical level check on the executable nodes. This achieves efficient analysis of low-code logic, improves inspection efficiency, reduces inspection costs, and helps low-code logic quickly form usable program products.

[0075] The technical solution provided by one or more embodiments of the present disclosure does not require obtaining or running the underlying code of the low-code logic, nor does it require modifying the low-code logic itself. It will not cause additional logical changes to the original code logic, thereby ensuring detection security.

[0076] The technical solution provided by one or more embodiments of the present disclosure can automatically check for possible problems in the low-code logic after obtaining the target language text corresponding to the target logic, greatly reducing the time and effort of manual troubleshooting, avoiding possible omissions in manual inspection, improving the accuracy and reliability of logic inspection, and helping to improve the quality of applications developed based on the low-code platform and ensure the stable operation of applications developed on the low-code platform.

[0077] See also Figure 5 The present disclosure also provides a logic inspection device based on a low-code platform, the device comprising: A text acquisition unit 100 is used to acquire a target language text corresponding to a target logic, where the target logic is created in a low-code platform and includes at least one executable node; The text parsing unit 200 is used to parse the target language text and obtain the node type and node attributes of each executable node in the target logic; A first checking unit 300 is configured to obtain node restriction check items of the executable node according to the node type and node attributes of the executable node, wherein the node restriction check items include description rules of the executable node in the target language text; The second checking unit 400 is configured to perform a logic check on the executable node according to the description rules in the node restriction check item of the executable node, and obtain a target logic check result.

[0078] In one embodiment, the node restriction check item further includes description information corresponding to the description rule. The second checking unit 400 is specifically configured to return the description information corresponding to the description rule if the executable node does not satisfy the description rule.

[0079] In one embodiment, the node restriction check items include at least one set of restriction combinations; the restriction combinations include description rules and description information; the first inspection unit 300 is specifically used to filter out a set of restriction items in the inspection item list according to the node type of the executable node; and filter out at least one set of restriction combinations in the restriction item set according to the node attributes of the executable node.

[0080] In one embodiment, in a restriction item set, different attribute types of the same node attribute have respective corresponding restriction combinations. The first checking unit 300 includes an attribute checking subunit. The attribute checking subunit is configured to filter out at least one set of restriction combinations from the restriction item set based on the node attribute and attribute type of the executable node.

[0081] In one embodiment, the low-code platform further includes a prompt list for recording description information corresponding to the description rule. The second check unit 400 includes a result feedback subunit. The result feedback subunit is configured to query the description information corresponding to the description rule from the prompt list corresponding to the target logic. If the description information corresponding to the description rule does not exist in the prompt list, a logic check success prompt is returned. If the description information corresponding to the description rule exists in the prompt list, a logic check failure prompt and the description information corresponding to the description rule are returned.

[0082] In one embodiment, the second checking unit 400 includes a checking execution subunit. The checking execution subunit is configured to sequentially perform logic checks on executable nodes according to the description rules in the node restriction check item; if the logic checks corresponding to the target description rules in the description rules fail, the description information corresponding to the target description rule is added to a prompt list.

[0083] In one embodiment, the check execution subunit is further configured to select the next description rule of the target description rule and perform a logic check on the executable node if the logic check corresponding to the target description rule fails.

[0084] In one embodiment, the check execution subunit is further configured to stop the logic check on the target logic if the logic check corresponding to the target description rule fails.

[0085] The various units described in the above embodiments can be implemented by computer chips or products with certain functions. A typical implementation device is a computer. Specifically, the computer can be, for example, a personal computer, a laptop computer, a cellular phone, a camera phone, a smartphone, a personal digital assistant, a media player, a navigation device, an email device, a game console, a tablet computer, a wearable device, or a combination of any of these devices.

[0086] For the convenience of description, the above devices are described as being divided into various units according to their functions. Of course, when implementing this application, the functions of each unit can be implemented in the same or multiple software and / or hardware.

[0087] See also Figure 6 The present disclosure also provides a computer device, which includes a memory and a processor, wherein the memory is used to store a computer program, and when the computer program is executed by the processor, the above-mentioned logic inspection method based on the low-code platform is implemented.

[0088] The present disclosure also provides a computer-readable storage medium, which is used to store a computer program. When the computer program is executed by a processor, it implements the above-mentioned logic inspection method based on the low-code platform.

[0089] The processor may be a central processing unit (CPU). The processor may also be other general-purpose processors, digital signal processors (DSP), application-specific integrated circuits (ASIC), field-programmable gate arrays (FPGA), other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, or a combination of the above chips.

[0090] Memory, as a non-transitory computer-readable storage medium, can be used to store non-transitory software programs, non-transitory computer executable programs, and modules, such as the program instructions / modules corresponding to the methods in the embodiments of the present disclosure. The processor executes the non-transitory software programs, instructions, and modules stored in the memory to perform various processor functions and data processing, thereby implementing the methods in the aforementioned method embodiments.

[0091] The memory may include a program storage area and a data storage area, wherein the program storage area may store an operating system, an application required for at least one function; the data storage area may store data created by the processor, etc. In addition, the memory may include a high-speed random access memory, and may also include a non-transitory memory, such as at least one disk storage device, a flash memory device, or other non-transitory solid-state storage device. In some embodiments, the memory may optionally include a memory remotely located relative to the processor, and these remote memories may be connected to the processor via a network. Examples of the above-mentioned network include, but are not limited to, the Internet, an intranet, a local area network, a mobile communication network, and combinations thereof.

[0092] 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 the relevant hardware through a computer program. The program can be stored in a computer-readable storage medium. 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), a random access memory (RAM), a flash memory, a hard disk drive (HDD), or a solid-state drive (SSD). The storage medium can also include a combination of the above-mentioned types of memory.

[0093] Part of the present disclosure may also be applied as a computer program product, such as a computer program instruction, which, when executed by a computer, can call or provide all or part of the steps of the logic inspection method based on the low-code platform of the present disclosure through the operation of the computer. Those skilled in the art should understand that the existence of computer program instructions in computer-readable media includes but is not limited to source files, executable files, installation package files, etc. Accordingly, the way in which computer program instructions are executed by a computer includes but is not limited to: the computer directly executes the instruction, or the computer compiles the instruction and then executes the corresponding compiled program, or the computer reads and executes the instruction, or the computer reads and installs the instruction and then executes the corresponding installed program. Here, the computer-readable medium can be any available computer-readable storage medium or communication medium that can be accessed by the computer.

[0094] The various embodiments in this specification are described in a progressive manner. Similar portions between the various embodiments can be referenced to each other, and each embodiment focuses on the differences between the other embodiments. In particular, the embodiments of the apparatus, computing device, computer storage medium, and computer program product are generally similar to the method embodiments, so their descriptions are relatively simplified. For relevant portions, reference can be made to the descriptions of the method embodiments.

[0095] The foregoing is merely an embodiment of the present application and is not intended to limit the present application. For those skilled in the art, the present application may have various changes and variations. Any modifications, equivalent replacements, improvements, etc. made within the spirit and principles of the present application should all be included within the scope of the claims of the present application.

[0096] Although the embodiments of the present disclosure have been described with reference to the accompanying drawings, those skilled in the art may make various modifications and variations without departing from the spirit and scope of the present disclosure, and such modifications and variations are all within the scope defined by the appended claims.

Claims

1. A logic inspection method based on a low-code platform, characterized in that: The method comprises: Obtaining a target language text corresponding to a target logic, where the target logic is created in a low-code platform and includes at least one executable node; Parsing the target language text to obtain the node type and node attributes of each executable node in the target logic; Acquire node restriction check items of the executable node according to the node type and node attributes of the executable node, wherein the node restriction check items include description rules of the executable node in the target language text; The executable node is logically checked according to the description rules in the node restriction check item of the executable node to obtain the target logic check result.

2. The method according to claim 1, characterized in that The node restriction check item further includes description information corresponding to the description rule; The performing a logic check on the executable node to obtain a check result of the target logic includes: If the executable node does not satisfy the description rule, the description information corresponding to the description rule is returned.

3. The method according to claim 2, characterized in that The node restriction check item includes at least one set of restriction combinations; the restriction combination includes the description rule and the description information; The acquiring, according to the node type and node attributes of the executable node, node restriction check items of the executable node includes: Filtering a set of restriction items from a check item list according to the node type of the executable node; At least one set of restriction combinations is screened out from the restriction item set according to the node attributes of the executable node.

4. The method according to claim 3, characterized in that In the restriction item set, different attribute types of the same node attribute have their own corresponding restriction combinations; The step of screening out at least one set of restriction combinations from the restriction item set according to the node attributes of the executable node includes: At least one set of restriction combinations is screened out from the restriction item set according to the node attributes and attribute types of the executable node.

5. The method according to claim 4, characterized in that The low-code platform also includes a prompt list, which is used to record the description information corresponding to the description rule; the logical check of the executable node includes: Querying description information corresponding to the description rule from a prompt list corresponding to the target logic; If the description information corresponding to the description rule does not exist in the prompt list, a prompt indicating that the logic check is successful is returned; If the description information corresponding to the description rule exists in the prompt list, a prompt indicating that the logic check has failed and the description information corresponding to the description rule are returned.

6. The method according to claim 3, characterized in that The performing a logic check on the executable node through the node restriction check item of the executable node includes: Performing logic checks on the executable nodes in sequence according to the description rules in the node restriction check items; If the logic check corresponding to the target description rule in each description rule fails, the description information corresponding to the target description rule is added to the prompt list.

7. The method according to claim 6, characterized in that The method further comprises: If the logic check corresponding to the target description rule fails, selecting the next description rule of the target description rule and performing a logic check on the executable node; Alternatively, if the logic check corresponding to the target description rule fails, the logic check on the target logic is stopped.

8. A logic inspection device based on a low-code platform, characterized in that: The device comprises: A text acquisition unit, configured to acquire a target language text corresponding to a target logic, wherein the target logic is created in a low-code platform and includes at least one executable node; A text parsing unit, configured to parse the target language text and obtain the node type and node attributes of each executable node in the target logic; a first checking unit, configured to obtain node restriction check items of the executable node according to the node type and node attributes of the executable node, wherein the node restriction check items include description rules of the executable node in the target language text; The second checking unit is configured to perform a logic check on the executable node according to the description rules in the node restriction check item of the executable node, and obtain a check result of the target logic.

9. A computer device, characterized in that: The computer device includes a memory and a processor, the memory is used to store a computer program, and when the computer program is executed by the processor, the method according to any one of claims 1 to 7 is implemented.

10. A computer-readable storage medium, characterized in that The computer-readable storage medium is used to store a computer program, and when the computer program is executed by a processor, the method according to any one of claims 1 to 7 is implemented.

11. A computer program product, characterized in that The method comprises computer instructions for causing a computer to execute the method according to any one of claims 1 to 7.

Images