WO2023109074A1

WO2023109074A1 - Method and apparatus for implementing linkage function, device, storage medium, and program

Info

Publication number: WO2023109074A1
Application number: PCT/CN2022/100726
Authority: WO
Inventors: 郑荣东; 江旻; 王大飞; 陈秋雁; 黎联成
Original assignee: 深圳前海微众银行股份有限公司
Priority date: 2021-12-17
Filing date: 2022-06-23
Publication date: 2023-06-22
Also published as: CN114385148A

Abstract

Embodiments of the present application provide a method and apparatus for implementing a linkage function, an electronic device, a computer storage medium, and a computer program product, applied to a low-code core class of a Formily framework. The method comprises: receiving JSON Schema configuration sent from a user page, the JSON Schema configuration being obtained by the user page from a page designer, the JSON Schema configuration comprising linkage configuration information for describing a plurality of component nodes of the user page, and the linkage configuration information of different component nodes corresponding to the same data structure specification; traversing the JSON Schema configuration to obtain the linkage configuration information of each of the plurality of component nodes; performing linkage parsing on the linkage configuration information of each component node according to the data structure specification to obtain a linkage function code after the linkage parsing; and implementing a linkage function of each component node by using the linkage function code after the linkage parsing.

Description

A method, device, equipment, storage medium and program for realizing linkage function

Cross References to Related Applications

This application is based on a Chinese patent application with application number 202111552350.5 and an application date of December 17, 2021. The applicant is Shenzhen Qianhai WeBank Co., Ltd., and the application name is "A Method, Device, and Equipment for Realizing Linkage Functions" and storage medium” and claim the priority of this Chinese patent application, the entire content of this Chinese patent application is hereby incorporated into this application as a reference.

technical field

This application relates to the technical field of cloud computing in financial technology (Fintech), and involves but is not limited to a method, device, electronic device, computer storage medium and computer program product for realizing linkage functions.

Background technique

With the development of computer technology, more and more technologies are applied in the financial field, and the traditional financial industry is gradually transforming into financial technology. However, due to the security and real-time requirements of the financial industry, higher requirements are also placed on technology.

Among related technologies, the linked development of Formily, a high-performance form solution, has limitations in generalization and high cost in iterative development. For example, an expression string is used when writing a linkage function on the Schema, and an error will be reported due to the lack of a correct execution context when the variables in the expression string are executed elsewhere. Furthermore, for example, when using the function method to develop complex linkage functions on Formily's effect application programming interface (application programming interface, api), it is necessary to hand-write code blocks related to complex linkage functions every time; further, it affects Formily's linkage development process ability.

Contents of the invention

The present application provides a method, device, electronic equipment, computer storage medium and computer program product for realizing the linkage function, which can solve the problems of limited generalization and high cost in iterative development of Formily linkage development in the related art.

The technical scheme of the present application is realized like this:

The embodiment of the present application provides a method for realizing the linkage function, which is applied to the low-code core class of the Formily framework, and the method includes:

Receive the JSON Schema configuration sent from the user page; the JSON Schema configuration is obtained by the user page from the page designer; the JSON Schema configuration includes linkage configuration information for describing multiple component nodes of the user page , and the linkage configuration information of different component nodes corresponds to the same data structure specification;

By traversing the JSON Schema configuration, the linkage configuration information of each component node in the plurality of component nodes is obtained; according to the data structure specification, the linkage configuration information of each component node is subjected to linkage analysis processing, and the linkage analysis is obtained. The processed linkage function code;

The linkage function code for each component node is realized by using the linkage function code after the linkage analysis and processing.

Exemplarily, the component node includes multiple pieces of linkage configuration information, and each piece of linkage configuration information in the multiple pieces of linkage configuration information includes: the final setting result of the component node and linkage conditions; the linkage conditions include condition node paths and Condition component node type;

The linkage function code after the linkage analysis and processing is used to perform the following steps:

In the current linkage configuration information included in the current component node, according to the condition node path and the condition component node type in the linkage condition, find out the component nodes from the remaining component nodes; the current component node represents the plurality of component nodes Among the component nodes that currently need linkage analysis and processing, the remaining component nodes represent component nodes in the plurality of component nodes except the current component node;

Determine whether the found component nodes meet the linkage conditions;

When it is determined that the found component node satisfies the linkage condition, it is determined that the current piece of linkage configuration information satisfies the linkage condition, and the final setting result in the current piece of linkage configuration information is set to the current component node on the results.

Exemplarily, the linkage condition further includes a condition node value and a condition node value type, and the judging whether the found component node satisfies the linkage condition includes:

performing type conversion on the condition node value of the found component node according to the condition node value type in the linkage condition, to obtain a type-converted condition value;

When the condition value after the type conversion is the same as the condition node value in the linkage condition, determine that the found component node satisfies the linkage condition;

If the condition value after the type conversion is different from the condition node value in the linkage condition, it is determined that the found component node does not satisfy the linkage condition.

Exemplarily, using the linkage function code after the linkage analysis and processing to realize the linkage function for each component node includes:

Registering the linkage function code after the linkage analysis and processing in the linkage function application programming interface api of the Formily framework;

When it is determined that the user page triggers linkage for each component node, the linkage function code is invoked through the linkage function api to realize the linkage function for each component node.

Exemplarily, the method also includes:

Perform verification and analysis processing on the linkage configuration information of each component node according to the data structure specification, and obtain the verification function code after the verification and analysis processing;

The verification function code for each component node is realized by using the verification function code after the verification analysis.

The verification function code after the linkage analysis and processing is used to perform the following steps:

Determine whether the found component nodes meet the linkage conditions;

When determining that the found component node satisfies the linkage condition, determine that the current linkage configuration information satisfies the linkage condition, continue to judge whether the result of the current component node passes the verification, and obtain the verification result; After the verification result determines that the current component node has passed the verification, continue to judge whether the next component node of the current component node has passed the verification until all the component nodes that need linkage analysis and processing are judged; or,

When it is determined that the found component node does not meet the linkage condition, determine that the current component node has passed the verification; continue to judge whether the next component node of the current component node has passed the verification, until the component node that needs linkage analysis processing All judgments are complete.

Exemplarily, according to the condition node path and condition component node type in the linkage condition, finding the component node from other component nodes includes:

determining a part of component nodes corresponding to the condition node path in the linkage condition from the remaining component nodes;

A component node of the same type as the conditional component node in the linkage condition is found from the partial component nodes.

Exemplarily, said verifying and parsing the processed verifying function code to realize the verifying function of each component node includes:

Register the verification function code after the linkage analysis and processing into the submission function of the low-code core class;

When it is determined that the user page is performing a data recovery or submission operation, the verification function for each component node is realized by executing the verification function code.

Exemplarily, after executing the verification function code, the method further includes:

Perform type conversion on the output data of the verification function code according to the data type of the condition node in the linkage condition of the current component node.

The embodiment of the present application also proposes a device for realizing the linkage function, the device includes a receiving module, an obtaining module and a linkage module, wherein,

The receiving module is configured to receive the JSON Schema configuration sent from the user page; the JSON Schema configuration is obtained by the user page from the page designer; the JSON Schema configuration includes multiple components for describing the user page The linkage configuration information of the node, and the linkage configuration information of different component nodes corresponds to the same data structure specification;

Obtaining a module configured to obtain the linkage configuration information of each component node in the plurality of component nodes by traversing the JSON Schema configuration; performing linkage analysis on the linkage configuration information of each component node according to the data structure specification processing to obtain the linkage function code after linkage analysis and processing;

The linkage module is configured to realize the linkage function of each component node by using the linkage function code after the linkage analysis and processing.

An embodiment of the present application provides an electronic device, the device includes a memory, a processor, and a computer program stored on the memory and operable on the processor, and the processor implements one or more of the aforementioned technologies when executing the program The method provided by the scheme to realize the linkage function.

An embodiment of the present application provides a computer storage medium, and the computer storage medium stores a computer program; after the computer program is executed, the method for realizing the linkage function provided by the aforementioned one or more technical solutions can be implemented.

The embodiment of the present application also provides a computer program product, including computer readable code, when the computer readable code is run in the electronic device, the processor in the electronic device executes to implement the aforementioned one or more The method for realizing the linkage function provided by the technical solution.

The embodiment of the present application proposes a method, device, electronic device, computer storage medium, and computer program product for realizing the linkage function, which are applied to the low-code core class of the Formily framework, and the method includes: receiving the JSON sent from the user page Schema configuration; the JSON Schema configuration is obtained by the user page from the page designer; the JSON Schema configuration includes linkage configuration information for describing multiple component nodes of the user page, and the linkage of different component nodes The configuration information corresponds to the same data structure specification; by traversing the JSON Schema configuration, the linkage configuration information of each component node in the plurality of component nodes is obtained; the linkage configuration of each component node according to the data structure specification The information is subjected to linkage analysis and processing to obtain a linkage function code after linkage analysis and processing; using the linkage function code after linkage analysis and processing to realize the linkage function of each component node.

It can be seen that in the embodiment of this application, since each component node included in the JSON Schema configuration corresponds to the same data structure specification, when it is necessary to perform linkage development on each component node included in the JSON Schema configuration, you can Based on a generalized data structure specification, these component nodes are linked and analyzed. In this way, the problem of limited generalization of linked development can be solved; further, when these component nodes are linked and analyzed according to the data structure specification , by combing the rules of each protocol field in the data structure specification, the function code for realizing the linkage function can be automatically generated, so that developers do not need to hand-write code blocks related to complex linkage functions every time, and solve the cost of linkage functions in iterative development high question.

Description of drawings

FIG. 1A is a schematic flow diagram of a method for realizing a linkage function in an embodiment of the present application;

Fig. 1B is a schematic flow diagram of executing linkage function codes in the embodiment of the present application;

FIG. 1C is a schematic diagram of a data structure specification in the embodiment of the present application;

FIG. 2A is a schematic diagram of a scenario for implementing a linkage verification function according to an embodiment of the present application;

FIG. 2B is a schematic flow diagram of performing linkage analysis processing and verification analysis processing according to an embodiment of the present application;

FIG. 2C is another schematic flow diagram of linkage analysis processing according to the embodiment of the present application;

FIG. 2D is another schematic flowchart of verification and analysis processing according to the embodiment of the present application;

Fig. 3 is a schematic diagram of the composition and structure of the device for realizing the linkage function according to the embodiment of the present application;

FIG. 4 is a schematic structural diagram of an electronic device provided by an embodiment of the present application.

Detailed ways

The present application will be described in further detail below in conjunction with the accompanying drawings and embodiments. It should be understood that the embodiments provided here are only used to explain the present application, and are not intended to limit the present application. In addition, the embodiments provided below are some embodiments for implementing the application, rather than providing all the embodiments for implementing the application. In the case of no conflict, the technical solutions described in the embodiments of the application can be combined in any manner implement.

It should be noted that, in the embodiments of the present application, the term "comprising", "comprising" or any other variation thereof is intended to cover a non-exclusive inclusion, so that a method or device comprising a series of elements not only includes the explicitly stated elements, but also include other elements not explicitly listed, or also include elements inherent in implementing the method or apparatus. Without further limitations, an element defined by the phrase "comprising a..." does not exclude the presence of additional related elements (such as steps in the method or A unit in an apparatus, for example, a unit may be part of a circuit, part of a processor, part of a program or software, etc.).

The term "and/or" in this article is just an association relationship describing associated objects, which means that there can be three kinds of relationships, for example, I and/or J, which can mean: I exists alone, I and J exist at the same time, and I exist alone J these three situations. In addition, the term "at least one" herein means any one of a variety or any combination of at least two of the more, for example, including at least one of I, J, R, may mean including from I, Any one or more elements selected from the set formed by J and R.

For example, the method for realizing the linkage function provided by the embodiment of the present application includes a series of steps, but the method for realizing the linkage function provided by the embodiment of the present application is not limited to the steps described. Similarly, the method for realizing the linkage function provided by the embodiment of the present application The functional device includes a series of modules, but the device for realizing the linkage function provided by the embodiment of the application is not limited to include the modules explicitly recorded, and may also include the required settings for obtaining relevant task data or processing based on task data module.

The embodiments of the present application can be applied to a computer system composed of servers, and can operate together with many other general-purpose or special-purpose computing system environments or configurations. Here, the server may be a distributed cloud computing technology environment including a small computer system, a large computer system, and so on.

Electronic devices such as the server can realize corresponding functions through the execution of program modules. Generally, program modules may include routines, programs, objects, components, logic, data structures, etc., that perform particular tasks or implement particular abstract data types. The computer system/server can be practiced in distributed cloud computing environments where tasks are performed by remote processing devices that are linked through a communications network. In a distributed cloud computing environment, program modules may be located in both local and remote computing system storage media including storage devices.

At present, Formily has three ways of using Markup Schema, JSON Schema, and JSX; the embodiment of this application can be aimed at the way of using JSON Schema.

The JSON Schema protocol data type used by Formily is not rich enough. The JSON Schema used by Formily is a JSON string, which is generated by the page designer. In the page designer, because the value corresponding to the JSON string is mostly entered manually by the user through the input box, the obtained value is a string type. And because Formily's schema type (type) only supports string, object, array, number, boolean, void, date and datetime. Therefore, when encountering basic types such as Boolean values (true, false), the input box of string type cannot correctly convert the string type value into a Boolean type value. Moreover, when encountering complex types such as the occupation type structure: {jobcode:1234}, Formily's schema type cannot be converted correctly through string type values. In addition, Formily's linkage development has limitations in generalization and high cost in iterative development.

In view of the above technical problems, the following embodiments are proposed.

In some embodiments of the present application, the method for realizing the linkage function can be implemented by using a processor in a device for realizing the linkage function, and the above-mentioned processor can be an application specific integrated circuit (Application Specific Integrated Circuit, ASIC), a digital signal processor ( Digital Signal Processor, DSP), Digital Signal Processing Device (Digital Signal Processing Device, DSPD), Programmable Logic Device (Programmable Logic Device, PLD), Field Programmable Logic Gate Array (Field Programmable Gate Array, FPGA), CPU At least one of (Central Processing Unit, CPU), controller, microcontroller, microprocessor.

Fig. 1A is a schematic flowchart of a method for realizing linkage function in the embodiment of the present application. As shown in Fig. 1A, the method includes the following steps:

Step 100: Receive the JSON Schema configuration sent from the user page; the JSON Schema configuration is obtained by the user page from the page designer; the JSON Schema configuration includes linkage configuration information for describing multiple component nodes of the user page, and different component nodes The linkage configuration information corresponds to the same data structure specification.

Exemplarily, the method for realizing the linkage function can be applied to the low-code core class of the Formily framework; here, the Formily framework includes not only the low-code core class, but also a user page and a page designer; wherein, the user page can be the World Wide Web ( The WEB interface corresponding to the World Wide Web (WEB) application can also be other human-computer interaction interfaces; the page designer is a page design platform developed by low-code, which can finally output a JSON data conforming to the JSON Schema protocol.

In the embodiment of this application, the low-code core class receives the JSON Schema configuration sent from the user page; as an example, the implementation process can be as follows, when the user page is opened, a data request for obtaining the JSON Schema configuration is sent to the page designer through the user page , when the page designer receives the data request, it returns the JSON Schema configuration to the user page, and sends the JSON Schema configuration to the low-code core class. At this time, the low-code core class receives the JSON Schema configuration sent from the user page .

Exemplarily, the JSON Schema configuration can be represented by a tree data structure in JSON format, where the tree data structure is composed of multiple component nodes describing the user page; here, the component node representation is used to describe the user page The node corresponding to the data information of the component. Exemplarily, the component node can be an abstract data type of view plus interactive logic, and can include hypertext markup language (hypertext markup language, html) templates, cascading style sheets (cascading style sheets, css) styles and js (javascript) Logical code snippets.

Step 101: By traversing the JSON Schema configuration, obtain the linkage configuration information of each component node among multiple component nodes; perform linkage analysis processing on the linkage configuration information of each component node according to the data structure specification, and obtain the linkage function after linkage analysis processing code.

Exemplarily, after the low-code core class receives the JSON Schema configuration sent from the user page, first, obtain the linkage configuration information of each component node by traversing the JSON Schema configuration; then, unify the linkage configuration information of each component node Save to the linkage configuration array; in this way, the linkage configuration array saves the linkage configuration information from all component nodes in the JSON Schema configuration; here, the linkage configuration array is located in the cache of the low-code core class.

Exemplarily, in the process of saving the linkage configuration information of each component node to the linkage configuration array, the linkage configuration information can be saved according to the format [{"key", "data structure specification"}]; here "key" represents the component node identity number (identity document, id). By saving the component node id to the linkage configuration array, it is convenient to search for each component node in the linkage analysis process.

Here, before the low-code core class needs to analyze and process the linkage configuration information of each component node, first obtain the linkage configuration array, and then obtain the linkage configuration information of each component node from the linkage configuration array, and then follow the steps shown in Figure 1C The data structure specification shown in the following table performs linkage analysis processing on the linkage configuration information of each component node; here, the linkage analysis processing is equivalent to declaring the code blocks corresponding to each protocol field in the linkage configuration information. After the linkage analysis processing, it can be automated. Generate subsequent function codes required to realize the linkage function of each component node. It can be seen that in this process, there is no need for developers to write code blocks related to linkage functions by hand, so the problem of high cost in iterative development of linkage functions can be solved.

Step 102: Realize the linkage function for each component node by using the linkage function code after linkage analysis and processing.

Exemplarily, a component node may include multiple pieces of linkage configuration information, wherein each piece of linkage configuration information in the multiple pieces of linkage configuration information may include the final setting result of the component node and linkage conditions; wherein, the linkage conditions may include condition node paths and Condition component node type.

In some embodiments, referring to FIG. 1B , the linkage function code after linkage analysis and processing is used to perform the following steps:

Step 1021: In the current linkage configuration information included in the current component node, according to the condition node path and the condition component node type in the linkage condition, find out the component node from other component nodes;

Step 1022: Determine whether the found component nodes meet the linkage condition;

Step 1023: When it is determined that the found component node satisfies the linkage condition, determine that the current linkage configuration information satisfies the linkage condition, and set the final setting result in the current linkage configuration information to the result of the current component node.

Here, the current component node represents a component node among the multiple component nodes that needs to be analyzed and processed currently; the rest of the component nodes represent component nodes among the multiple component nodes except the current component node.

In some embodiments, according to the condition node path and the condition component node type in the linkage condition, finding the component node from the remaining component nodes may include: determining the part corresponding to the condition node path in the linkage condition from the remaining component nodes Component nodes; find component nodes of the same type as the conditional component nodes in the linkage condition from some component nodes.

Exemplarily, in the case of determining the linkage condition of the current component node, first, according to the condition node path in the linkage condition of the current component node, find out some component nodes under the condition node path from the remaining component nodes; Traverse each component node in some component nodes to find out the component node with the same type as the conditional component node in the linkage condition.

In the embodiment of this application, in the current linkage configuration information included in the current component node, if the component node is found according to the condition node path and condition component node type in the linkage condition, it is necessary to further judge whether the found component node is Linkage conditions are met.

Exemplarily, if it is determined that the found component node satisfies the linkage condition, it means that the current linkage configuration information satisfies the linkage condition. At this time, the final setting result in the current linkage configuration information can be set to the result of the current component node On the contrary, if it is determined that the found component node does not meet the linkage condition, it means that the current linkage configuration information does not meet the linkage condition, that is, the current component node does not match this linkage configuration information. In the next linkage configuration information included in the component node, check whether the found component node satisfies the linkage condition until the linkage configuration information matching the current component node is found; If the linkage configuration information matching the current component node is found, it means that the current component node does not need to trigger linkage.

In some embodiments, the linkage condition may also include a condition node value and a condition node value type, and judging whether the found component node satisfies the linkage condition may include: pairing the searched component node according to the condition node value type in the linkage condition Convert the condition node value to get the condition value after type conversion; if the condition value after type conversion is the same as the condition node value in the linkage condition, it is determined that the found component node meets the linkage condition; after the type conversion If the condition value is not the same as the condition node value in the linkage condition, it is determined that the found component node does not satisfy the linkage condition.

Here, if it is determined that the found component node meets the linkage condition, it means that the current linkage configuration information contained in the current component node meets the linkage condition; otherwise, if it is determined that the found component node does not meet the linkage condition, it means that the current component node includes The current linkage configuration information for does not meet the linkage conditions.

Exemplarily, the linkage configuration information of each component node in the JSON Schema configuration corresponds to the same data structure specification; here, the data structure specification is a generalized protocol specification newly defined in this application; FIG. A schematic diagram of a data structure specification, as shown in Figure 1C, the data structure specification "includeAttributeValues" can be expressed in the form of {values, condition{key, values, formType, valueType}, errorMsg}; below, the data structure Each attribute (that is, the protocol field) in the specification is described.

Here, the values attribute represents the final setting result of the component node that needs to be analyzed and processed in conjunction; it should be noted that for different types of component nodes, the types of corresponding values can be different. For example, when the component node is an Input component, values The value represents the type of linkage condition; when the component node is a Select component, the values value represents the range of options; the condition attribute defines the conditions required for the linkage judgment of the component node, and the purpose of setting the judgment conditions in the condition attribute is to facilitate The code core class performs code analysis for linkage condition judgment.

Furthermore, condition.key (the key in the condition attribute) represents the path of the condition node that needs to be observed, specifically how to observe the implementation of the linkage function code obtained by subsequent analysis. condition.values (values in the condition attribute) represents the condition node value, which defines the specific value of the judgment condition. condition.formType (formType in the condition attribute) represents the condition component node type, and each component node encapsulates its own linkage analysis method. condition.valueType (valueType in the condition attribute) defines the data type of the condition node; here, condition.values and condition.valueType appear in pairs; errorMsg represents the error message. Finally, in the process of judging the linkage condition, the component node corresponding to condition.formType will first perform type conversion according to condition.valueType, and then judge the condition node value of the component node corresponding to condition.formType to determine Whether the current component node that requires linkage parsing and processing meets the linkage conditions.

Exemplarily, the various attributes included in the data structure specification are sorted out through actual business, and they describe the key data information related to the linkage of component nodes. Corresponding linkage parsing and processing of linkage configuration information can solve the problem that linkage development is limited in generalization.

Exemplarily, in the process of judging whether the found component node satisfies the linkage condition according to the current linkage configuration information included in the current component node, it may be traversed according to the component node id of each component node in the found component node , judge one by one whether the value of the condition node after the type conversion of each component node is the same as the value of the condition node in the linkage condition of the current component node. The linkage configuration information satisfies the linkage condition. At this time, the final setting result in the current linkage configuration information can be set to the result of the current component node. On the contrary, if it is determined that they are not the same, it means that the found component node does not meet the linkage condition, that is, the current linkage configuration information does not meet the linkage condition. At this time, continue to judge whether the next linkage configuration information included in the current component node satisfies the linkage condition Linkage conditions until the linkage configuration information matching the current component node is found; if the linkage configuration information matching the current component node cannot be found among the multiple linkage configuration information included in the current component node, it means that the current component node does not need to trigger linkage.

It can be seen that in the embodiment of the present application, the linkage configuration information matching the current component node can be found from the multiple pieces of linkage configuration information included in the current component node, and the linkage configuration information can be used for subsequent implementation of the current component node. linkage.

In some embodiments, using the linkage function code after linkage analysis and processing to realize the linkage function to each component node may include: registering the linkage function code after linkage analysis and processing into the linkage function api of the Formily framework; When the user page triggers linkage for each component node, the linkage function code is called through the linkage function api to realize the linkage function for each component node.

Exemplarily, taking the current component node as an example, after the low-code core class determines each component node that realizes linkage with the current component node according to the above steps, the corresponding linkage function code can be obtained, and the linkage function code can be registered in the Formily framework In the linkage function api, here, the linkage function api is located in the user interface; later, when the user triggers linkage to the current component node through the user page, the corresponding linkage function code can be called according to the linkage function api, and by executing the linkage function code, you can Realize the linkage function of the current component node.

It can be seen that in the embodiment of the present application, by registering the linkage function code to the linkage function api of the Formily framework, it is convenient to quickly execute the linkage function code related to the component node when the linkage of the component node is triggered later, so as to ensure the execution of the linkage operation. effectiveness.

The embodiment of the present application proposes a method, device, electronic device, computer storage medium, and computer program product for realizing the linkage function, which are applied to the low-code core class of the Formily framework, and the method includes: receiving the JSON Schema configuration sent from the user page ;JSON Schema configuration is obtained by the user page from the page designer; JSON Schema configuration includes the linkage configuration information used to describe multiple component nodes of the user page, and the linkage configuration information of different component nodes corresponds to the same data structure specification; Traverse the JSON Schema configuration to obtain the linkage configuration information of each component node among multiple component nodes; perform linkage analysis and processing on the linkage configuration information of each component node according to the data structure specification, and obtain the linkage function code after linkage analysis and processing; use linkage Parse the processed linkage function code to realize the linkage function of each component node. It can be seen that in the embodiment of this application, since each component node included in the JSON Schema configuration corresponds to the same data structure specification, when it is necessary to perform linkage development on each component node included in the JSON Schema configuration, you can Based on a generalized data structure specification, these component nodes are linked and analyzed. In this way, the problem of limited generalization of linked development can be solved; further, when these component nodes are linked and analyzed according to the data structure specification , by combing the rules of each protocol field in the data structure specification, the function code for realizing the linkage function can be automatically generated. In this way, developers do not need to manually write code blocks related to complex linkage functions every time, and solve the cost of linkage functions in iterative development. high question.

In some embodiments, the above method may further include: performing verification and analysis processing on the linkage configuration information of each component node according to the data structure specification to obtain the verification function code after the verification and analysis processing; The verification function code realizes the verification function of each component node.

Here, the data structure specification for performing verification analysis processing is the same as the above-mentioned data structure specification for performing linkage analysis processing, and will not be repeated here.

Exemplarily, the linkage configuration information of each component node is verified and analyzed according to the same data structure specification as the linkage analysis process, which can improve the accuracy of the verification result of the component node.

In some embodiments, the verification function code after linkage analysis and processing is used to perform the following steps: in the current linkage configuration information included in the current component node, according to the condition node path and condition component node type in the linkage condition, Find the component nodes from the rest of the component nodes; the current component node represents the component node that needs to be analyzed and processed currently among the multiple component nodes, and the remaining component nodes represent the component nodes other than the current component node among the multiple component nodes; judge the found one Whether the component node meets the linkage condition;

When it is determined that the found component node meets the linkage condition, determine that the current linkage configuration information meets the linkage condition, continue to judge whether the result of the current component node passes the verification, and obtain the verification result; after determining that the current component node passes the verification result After the verification, continue to judge whether the next component node of the current component node passes the verification until all the component nodes that need linkage analysis and processing are judged; or, when it is determined that the found component nodes do not meet the linkage conditions, determine the current component node Pass the verification; continue to judge whether the next component node of the current component node passes the verification until all the component nodes that need linkage analysis and processing are judged.

Exemplarily, the implementation manner of determining whether the found component node satisfies the linkage condition has been described in the above embodiment, and will not be repeated here.

In one embodiment, if it is determined that the found component node satisfies the linkage condition, continue to judge whether the current component node passes the verification; here, passing the verification shows that the result of the current component node is consistent with the final The setting results are the same; if the verification fails, it means that the result of the current component node is different from the final setting result in the current linkage configuration information.

Exemplarily, if it is determined that the current component node passes the verification, continue to judge whether the next component node of the current component node passes the verification, until the judgment of all the component nodes requiring linkage analysis processing is completed.

In another implementation, if it is determined that the current component node does not meet the linkage conditions, no verification judgment is required, but the current component node is directly defaulted to pass the verification; then, continue to judge whether the next component node of the current component node satisfies the Linkage conditions, if satisfied, continue to verify and judge; if not satisfied, directly pass the verification by default.

Here, in the current linkage configuration information included in the current component node, only when the found component nodes pass the verification, it means that the verification function of the current component node has passed; otherwise, it means that the verification function of the current component node is passed. Function failed.

It can be seen that after each component node that needs to be linked with the current component node is determined, further verification of these component nodes can ensure the reliability of the component node linkage function.

In some embodiments, the verification function code of each component node is realized by using the verification function code after the verification analysis processing, which may include: registering the verification function code after the linkage analysis processing to the submission of the low-code core class In function; when the data recovery or submission operation is determined on the user page, the verification function of each component node is realized by executing the verification function code.

In the implementation of this application, taking the current component node as an example, after obtaining the verification function code of the current component node, register the verification function code in the submission function of the low-code core class; When restoring or submitting an operation, by executing the verification function code, the verification function of the current component node can be realized.

It can be seen that in the embodiment of this application, by registering the verification function code in the submission function of the low-code core class, it is convenient to quickly execute the verification function code related to the component node during subsequent data recovery or submission operations. Ensure the validity of the performed check operation.

In some embodiments, after the verification function code is executed, the above method may further include: performing type conversion on the output data of the verification function code according to the condition node data type in the linkage condition of the current component node.

Exemplarily, after the verification function code is executed, the output data of the verification function code related to the current component node can be type-converted according to the condition node data type in the linkage condition of the current component node to obtain the verification function code final output.

It can be seen that by converting the output data of the conditional node data type, the JSON Schema protocol data type can be enriched, and the problem that some data types cannot be correctly converted through the string type in related technologies can be solved.

In order to better reflect the purpose of the present application, further description will be made on the basis of the above-mentioned embodiments of the present application.

Fig. 2A is a schematic diagram of a scenario for realizing the linkage verification function according to an embodiment of the present application. As shown in Fig. 2A, the figure includes: a user page, a low code core class (LowcodeCore) and a page designer; the specific implementation process can be as follows :

First, the user page sends a data request to the page designer to obtain the JSON Schema configuration; when the page designer receives the data request, it returns the JSON Schema configuration to the user page; after receiving the JSON Schema configuration, the user page sends the JSON Schema configuration Configuration is sent to low-code core classes.

Then, the low-code core class finds out the linkage configuration information of each component node under each level of node tree by traversing the tree data structure configured by JSON Schema and saves it in the linkage configuration array; the low-code core class performs linkage configuration according to the data structure specification The linkage configuration information of each component node in the configuration array is analyzed for linkage and verification, and the linkage function code and verification function code are automatically generated.

Finally, register the linkage function code to the linkage function api of the Formily framework for use, and register the verification function code to the submit function of the low-code core class, which will be executed when the page performs data recovery or submission.

Fig. 2B is a schematic flow diagram of a linkage analysis process and verification analysis process according to an embodiment of the present application. As shown in Fig. 2B, the process includes the following steps:

Step A1: Obtain the linkage configuration array.

Exemplarily, the low-code core class obtains a linkage configuration array from its own cache, and the linkage configuration array includes linkage configuration information of all component nodes in the JSON Schema configuration.

Step A2: Determine the work type as linkage type.

Exemplarily, after the low-code core class obtains the linkage configuration array, it will judge the current work type; here, the work type includes two types: linkage type and verification type.

Step A3: Carry out linkage parsing and processing according to the data structure specification.

Exemplarily, after determining that the current work type is a linkage type, the low-code core class performs linkage analysis and processing on multiple pieces of linkage configuration information in the linkage configuration array corresponding to the current component node according to the data structure specification.

Step A4: Find the linkage configuration information that meets the linkage conditions by traversing the linkage configuration array.

Exemplarily, if it is determined that the current piece of linkage configuration information contained in the current component node meets the linkage condition by traversing each piece of linkage configuration information in the linkage configuration array corresponding to the current component node, it means that the current piece of linkage configuration information is found out The component nodes of all meet the linkage conditions; the specific implementation has been described in the above-mentioned embodiments, and will not be repeated here.

Step A5: Set the values in the linkage configuration information to the current component node.

Exemplarily, the values value corresponds to the final setting result in the above-mentioned current linkage configuration information; after traversing the linkage configuration array to determine that all component nodes in the current linkage configuration information meet the linkage conditions, the current linkage configuration information The values (final setting result) in are set to the current component node; at this time, the linkage analysis processing for the current component node is completed, and the linkage function code after the linkage analysis processing is obtained.

Step A2': Determine the work type as the verification type.

Step A3': Perform verification and parsing processing according to the data structure specification.

Exemplarily, after the low-code core class determines that the current work type is the verification type, it performs verification analysis processing on multiple pieces of linkage configuration information in the linkage configuration array corresponding to the current component node according to the data structure specification.

Step A4': find the linkage configuration information satisfying the linkage condition by traversing the linkage configuration array.

Exemplarily, specific implementation manners have been described in the foregoing embodiments, and details are not repeated here.

Step A5': Judging whether it is equal to the result of the current component node.

Exemplarily, in the linkage configuration information that satisfies the linkage condition, it is judged whether the values (final setting result) in the linkage configuration information is equal to the result of the current component node; if yes, it means that the verification function of the current component node is passed. , the verification is successful; otherwise, it indicates that the verification function of the current component node has failed, and at this time, the verification failure is returned.

Below, the above-mentioned linkage analysis process and verification analysis process will be described in conjunction with a specific flow chart; FIG. 2C is another schematic flow diagram of the linkage analysis process according to the embodiment of the present application. As shown in FIG. 2C, the process includes the following steps :

Step B1: Obtain the linkage configuration array.

Step B2: Obtain the current linkage configuration information of the current component node.

Exemplarily, the current piece of linkage configuration information of the current component node can be acquired from the linkage configuration array in a traversal manner. Here, the current component node represents the JSON description of one of the user interface (User Interface, UI) components in the JSON Schema tree configuration describing the current user page.

Step B3: Determine whether the current component node has changed.

Exemplarily, it is judged whether the current linkage configuration information of the current component node has changed; if yes, proceed to the following steps. Component nodes do not need to be relinked.

Step B4: Determine some component nodes according to the conditional node path in the linkage condition.

Exemplarily, in the current piece of linkage configuration information of the current component node, some component nodes are determined according to the path of the conditional node in the linkage condition.

Step B5: Obtain the ComponentSchema component instance of the found component node according to the conditional component node type in the linkage condition.

Exemplarily, after part of the component nodes are determined, according to the type of the conditional component node in the linkage condition, continue to find out from the part of the component nodes the component node of the same type as the conditional component node in the linkage condition; obtain the found component node ComponentSchema component instance.

Step B6: Pass the condition node value type and condition node value in the linkage condition to the ComponentSchema component instance of the found component node.

Exemplarily, after passing the condition node value type and condition node value in the linkage condition to the ComponentSchema component instance of the found component node, the ComponentSchema component instance will match the found component node according to the condition node value type in the linkage condition Perform type conversion on the condition node value of each component node in , and obtain the condition value after type conversion; judge the condition value after type conversion and the condition node value in the linkage condition, and determine whether the found component nodes satisfy the linkage condition .

Step B7: Judging whether the linkage condition is met. If yes, execute step B8, otherwise, execute step B4 for determining whether the next piece of linkage configuration information included in the current component node satisfies the linkage condition.

Exemplarily, it is judged whether the found component node satisfies the linkage condition, and when it is determined that the type-converted condition value corresponding to the found component node is the same as the condition node value in the linkage condition, it is determined that the found component node satisfies The linkage condition, that is, the current linkage configuration information satisfies the linkage condition; otherwise, it is determined that the current linkage configuration information does not meet the linkage condition.

Step B8: Obtain the ComponentSchema component instance of the current component node, and transfer the values in the current linkage configuration information to the ComponentSchema component instance of the current component node for setting.

Exemplarily, when it is determined that the current linkage configuration information satisfies the linkage condition, the ComponentSchema component instance of the current component node can be obtained, and the values in the current linkage configuration information can be transferred to the ComponentSchema component instance of the current component node for further processing. The setting of the linkage result, that is, setting the values (final setting result) in the current linkage configuration information to the ComponentSchema component instance of the current component node.

Exemplarily, when starting to execute the generated linkage function code, the linkage configuration array relationConfigArr including the linkage configuration information of all component nodes is taken out from the low-code core class. Exemplarily, the current component node in the linkage configuration array can represent For: '[{"key":"detail.identity","includeAttributeValues":[{"values":[{"regex":"\\S","errorRemind":""}],"condition": [{"key":"detail.identityType","values":[{"label":"ID card","value":"0"}],"formType":"select","valueType":" 2"}]}]}]'; relationConfigArr.*.key represents the current component node id, and relationConfigArr.*.includeAttributeValues represents the linkage configuration information of the current component node.

Then traverse the linkage configuration array relationConfigArr; perform linkage analysis processing for each component node of relationConfigArr according to the data structure specification. Among them, the linkage configuration information relationConfig of the current component node is as follows: ({"includeAttributeValues":[{"values":[{"regex":"\\S","errorRemind":""}],"condition":[ {"key":"detail.identityType","values":[{"label":"ID card","value":"0"}],"formType":"select","valueType":"2 "}]}]}) and Formily's data source ({detail:{identity,identityType}}) for parsing instructions.

In the linkage analysis process, configure the condition node of relationConfig as the linkage judgment condition, use the value of condition.key as "detail.identityType" as the dependency path, and then call Formily's API onFieldValueChange with the condition.key path as detail. The data of identityType monitors and registers a callback function. In the callback function, when the detail.identityType changes, get the result of detail.identityType from the formal parameter of the callback function. Then obtain the corresponding ComponentSchema component instance according to the condition.formType component type, pass the range values of the detail.identityType and condition.values judgment conditions to the ComponentSchema component instance and call validate for verification. If the condition condition check passes, it means that the linkage condition of the current component is satisfied, otherwise it is not satisfied. Then use Array.some to traverse, verify and analyze the component nodes in the linkage configuration array. If there is a condition condition in the linkage configuration array that passes the verification of the ComponentSchema component instance, set the linkage result includeAttributeValues.*.values to the configuration relationConfig. On the component corresponding to key, the component corresponding to relationConfig.key will call Formily API setFieldState according to the current component rules to set the linkage result includeAttributeValues.*.values to the correct attribute.

Fig. 2D is another schematic flow diagram of verification analysis processing according to the embodiment of the present application. As shown in Fig. 2D, the flow includes the following steps:

Step C1: Obtain the linkage configuration array.

Step C2: Obtain the linkage configuration information of the component nodes that need to be parsed and processed in linkage.

Exemplarily, linkage configuration information of all component nodes requiring linkage parsing and processing may be acquired from the linkage configuration array in a traversal manner.

Step C3: Verify according to the linkage configuration information of the current component node.

Here, the current component node is a component node among all component nodes that need to be linked and parsed.

Step C4: Judging whether all checks are passed.

Exemplarily, it is judged whether all the component nodes that need to be linked and parsed pass the verification. If yes, execute step C12 and step C13 in sequence, otherwise, execute step C5.

Step C5: Obtain the ComponentSchema component instance of the found component node according to the conditional component node type in the linkage condition.

Step C6: Pass the condition node value type and condition node value in the linkage condition of the current component node to the ComponentSchema component instance of the found component node.

Exemplarily, steps C5 to C6 are implemented in the same way as the above steps B5 to B6, and will not be repeated here.

Step C7: Judging whether the linkage condition is met. If yes, execute step C8, otherwise, execute step C4 to determine whether all the component nodes that require linkage analysis and processing pass the verification, if not, follow the steps below to continue the linkage verification of the next component node of the current component node ; At this point, the default current component node check is passed.

Step C8: Get the ComponentSchema component instance of the current component node.

Exemplarily, when it is determined that the current linkage configuration information satisfies the linkage condition, the ComponentSchema component instance of the current component node can be obtained,

Step C9: Transfer the values in the current linkage configuration information to the ComponentSchema component instance of the current component node for verification.

Exemplarily, after passing the values in the current linkage configuration information included in the current component node to the ComponentSchema component instance of the current component node, by comparing the actual result of the ComponentSchema component instance of the current component node with the current linkage configuration information The values in the value are verified.

Step C10: Judging whether the verification is passed.

Exemplarily, according to the comparison result of the ComponentSchema component instance of the current component node and the values in the current linkage configuration information, it is judged whether the verification function of the current component node is passed; if yes, execute step C4, otherwise execute step C11.

Step C11: Return verification failure.

Exemplarily, after it is determined that the verification function of the current component node fails, it is determined that the verification fails.

Step C12: Perform type conversion processing on the output data.

Exemplarily, according to the data type of the condition node in the linkage condition of the current component node, the output data of the verification function code related to the current component node can be type-converted to obtain the final output result.

Step C13: Return verification success.

Exemplarily, after the final output result is obtained, it is determined that the verification is successful.

Exemplarily, when starting to execute the generation verification function code, the linkage configuration array relationConfigArr including the linkage configuration information of all component nodes is taken out from the low-code core class. Exemplarily, the current component node in the linkage configuration array can represent For: '[{"key":"detail.identity","includeAttributeValues":[{"values":[{"regex":"\\S","errorRemind":""}],"condition": [{"key":"detail.identityType","values":[{"label":"ID card","value":"0"}],"formType":"select","valueType":" 2"}]}]}]'. relationConfigArr.*.key represents the current component node id, and relationConfigArr.*.includeAttributeValues represents the linkage configuration information of the current component node.

Then traverse the linkage configuration array relationConfigArr; perform linkage analysis processing for each component node of relationConfigArr according to the data structure specification. Among them, the linkage configuration information relationConfig of the current component node is as follows: ({"includeAttributeValues":[{"values":[{"regex":"\\S","errorRemind":""}],"condition":[ {"key":"detail.identityType","values":[{"label":"ID card","value":"0"}],"formType":"select","valueType":"2 "}]}]}) and the result data source of the submitted operation ({detail:{identity,identityType}}) for parsing instructions.

In the linkage analysis process, the condition node of relationConfig is used as the linkage judgment condition, and the value of condition.key "detail.identityType" is used as the dependency path to extract the value of detail.identityType from the data source, and then obtain it according to the condition.formType component type Go to the corresponding ComponentSchema component instance, pass the range values of the detail.identityType and condition.values judgment conditions to the ComponentSchema component instance and call validate for verification. If the match is successful, it means that the linkage condition node has passed, otherwise continue to traverse the next linkage configuration. If none of the conditional nodes match successfully, it can pass the verification on behalf of the current node relationConfig.key. If the conditional node matches successfully, the corresponding ComponentSchema component instance is obtained according to the relationConfig.key node id. Then, by configuring relationConfig.key to "detail.identity" as the value path, take out the verification value from the data source, and pass the verification value and includeAttributeValues.*.values matching result range to the ComponentSchema component instance for verification. Only when the verification value conforms to the result range of includeAttributeValues.*.values can the verification pass, otherwise the node verification of relationConfig.key returns failure. Then use Array.every to traverse and analyze the verification configuration array relationConfigArr of all nodes. Only when all nodes can pass the verification process of the above-mentioned linkage configuration includeAttributeValues, the verification function of the verification function code is confirmed to pass, otherwise return fail. After the verification function is passed, it is necessary to perform type conversion of the output data to obtain the final data data. The process of conversion, such as ComponentSchema component instance, has config attribute to represent configuration information, and config.valueType represents output data type. For example, when the valueType is a number type, the output data of the current node needs to be processed as a number type. For example, 1 in a string will be updated to 1 in a number type. When the final verification function code is successful, output the verification result and output data such as {status: true, data: {a1, a2, a3}}.

Fig. 3 is a schematic diagram of the composition and structure of the device for realizing the linkage function according to the embodiment of the present application. As shown in Fig. 3, the device includes a receiving module 300, an obtaining module 301 and a linkage module 302, wherein,

The receiving module 300 is configured to receive the JSON Schema configuration sent from the user page; the JSON Schema configuration is obtained by the user page from the page designer; the JSON Schema configuration includes multiple The linkage configuration information of component nodes, and the linkage configuration information of different component nodes corresponds to the same data structure specification;

The obtaining module 301 is configured to obtain the linkage configuration information of each component node in the plurality of component nodes by traversing the JSON Schema configuration; perform linkage to the linkage configuration information of each component node according to the data structure specification Analyzing and processing to obtain the linkage function code after linkage analysis and processing;

The linkage module 302 is configured to use the linkage function code after the linkage analysis and processing to realize the linkage function for each component node.

In some embodiments, the component node includes multiple pieces of linkage configuration information, and each piece of linkage configuration information in the multiple pieces of linkage configuration information includes: the final setting result of the component node and a linkage condition; the linkage condition includes a condition node path and condition component node types;

Determine whether the found component nodes meet the linkage conditions;

In some embodiments, the linkage condition further includes a condition node value and a condition node value type, and the linkage module 302 is configured to determine whether the found component node satisfies the linkage condition, including:

In some embodiments, the linkage module 302 is configured to use the linkage function code after the linkage analysis and processing to realize the linkage function for each component node, including:

In some embodiments, the device further includes a verification module, and the verification module is configured to:

Determine whether the found component nodes meet the linkage conditions;

When it is determined that the found component node does not meet the linkage condition, determine that the current component node has passed the verification; continue to judge whether the next component node of the current component node has passed the verification, until all the component nodes that need to be analyzed and processed by linkage Judgment complete.

In some embodiments, the checking module is configured to find out component nodes from other component nodes according to the condition node path and condition component node type in the linkage condition, including:

In some embodiments, the verification module is configured to implement the verification function of each component node by using the verification function code after the parsing and processing of the verification, including:

In some embodiments, after executing the verification function code, the verification module is further configured to:

In practical applications, the above-mentioned receiving module 300, obtaining module 301, linkage module 302 and verification module can all be realized by a processor located in the electronic device, and the processor can be ASIC, DSP, DSPD, PLD, FPGA, CPU, At least one of controller, microcontroller, microprocessor.

In addition, each functional module in this embodiment may be integrated into one processing unit, each unit may exist separately physically, or two or more units may be integrated into one unit. The above-mentioned integrated units can be implemented in the form of hardware or in the form of software function modules.

If the integrated unit is implemented in the form of a software function module and is not sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this embodiment is essentially or The contribution made by related technologies or all or part of the technical solution can be embodied in the form of software products, the computer software products are stored in a storage medium, and include several instructions to make a computer device (which can be a personal computer) , server, or network device, etc.) or a processor (processor) executes all or part of the steps of the method in this embodiment. And aforementioned storage medium comprises: various mediums that can store program codes such as U disk, mobile hard disk, read-only memory (Read Only Memory, ROM), RAM, magnetic disk or optical disk.

Specifically, the computer program instructions corresponding to a method for realizing the linkage function in this embodiment can be stored on a storage medium such as an optical disc, a hard disk, or a USB flash drive. When the instructions in the storage medium correspond to a method for realizing the linkage function When the computer program instructions are read or executed by an electronic device, any one of the methods for realizing the linkage function in the foregoing embodiments is implemented.

Based on the same technical concept as the foregoing embodiments, see FIG. 4 , which shows an electronic device 400 provided by an embodiment of the present application, which may include: a memory 401 and a processor 402; wherein,

memory 401 configured to store computer programs and data;

The processor 402 is configured to execute the computer program stored in the memory, so as to implement any one of the methods for realizing the linkage function in the foregoing embodiments.

In practical applications, the above-mentioned memory 401 can be a volatile memory (volatile memory), such as RAM; or a non-volatile memory (non-volatile memory), such as ROM, flash memory (flash memory), hard disk (Hard Disk Drive, HDD) or solid-state drive (Solid-State Drive, SSD); or a combination of the above-mentioned types of memory, and provide instructions and data to the processor 402.

The aforementioned processor 402 may be at least one of ASIC, DSP, DSPD, PLD, FPGA, CPU, controller, microcontroller, and microprocessor. It can be understood that, for different devices implementing linkage functions, the electronic device used to implement the above processor function may also be other, which is not specifically limited in this embodiment of the present application. The embodiment of the present application also provides a computer program product, the computer program product carries a program code, and the instructions included in the program code can be used to execute the load balancing method described in the above method embodiment, for details, please refer to the above method embodiment , which will not be repeated here.

Wherein, the above-mentioned computer program product may be specifically implemented by means of hardware, software or a combination thereof. In an optional embodiment, the computer program product is embodied as a computer storage medium, and in another optional embodiment, the computer program product is embodied as a software product, such as a software development kit (Software Development Kit, SDK) etc. wait.

In some embodiments, the functions or modules included in the device provided by the embodiments of the present application can be used to execute the methods described in the above method embodiments, and its specific implementation can refer to the descriptions of the above method embodiments. For brevity, here No longer.

The above descriptions of the various embodiments tend to emphasize the differences between the various embodiments, the same or similar points can be referred to each other, and for the sake of brevity, details are not repeated herein.

The methods disclosed in the various method embodiments provided in this application can be combined arbitrarily without conflict to obtain new method embodiments.

The features disclosed in the various product embodiments provided in this application can be combined arbitrarily without conflict to obtain new product embodiments.

The features disclosed in each method or device embodiment provided in this application can be combined arbitrarily without conflict to obtain a new method embodiment or device embodiment.

Those skilled in the art should understand that the embodiments of the present application may be provided as methods, systems, or computer program products. Accordingly, the present application may take the form of a hardware embodiment, a software embodiment, or an embodiment combining software and hardware aspects. Furthermore, the present application may take the form of a computer program product embodied on one or more computer-usable storage media (including but not limited to disk storage, optical storage, etc.) having computer-usable program code embodied therein.

The present application is described with reference to flowcharts and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the present application. It should be understood that each procedure and/or block in the flowchart and/or block diagram, and a combination of procedures and/or blocks in the flowchart and/or block diagram can be realized by computer program instructions. These computer program instructions may be provided to a general purpose computer, special purpose computer, embedded processor, or processor of other programmable data processing equipment to produce a machine such that the instructions executed by the processor of the computer or other programmable data processing equipment produce a An apparatus for realizing the functions specified in one or more procedures of the flowchart and/or one or more blocks of the block diagram.

These computer program instructions can also be loaded onto a computer or other programmable data processing device, causing a series of operational steps to be performed on the computer or other programmable device to produce a computer-implemented process, thereby The instructions provide steps for implementing the functions specified in the flow chart or blocks of the flowchart and/or the block or blocks of the block diagrams.

The above are only preferred embodiments of the present application, and are not intended to limit the protection scope of the present application.

Claims

A method for implementing linkage functions, applied to the low-code core classes of the Formily framework, the method includes:

Receive the JSON Schema configuration sent from the user page; the JSON Schema configuration is obtained by the user page from the page designer; the JSON Schema configuration includes linkage configuration information for describing multiple component nodes of the user page , and the linkage configuration information of different component nodes corresponds to the same data structure specification;

By traversing the JSON Schema configuration, the linkage configuration information of each component node in the plurality of component nodes is obtained; according to the data structure specification, the linkage configuration information of each component node is subjected to linkage analysis processing, and the linkage analysis is obtained. The processed linkage function code;

The linkage function code for each component node is realized by using the linkage function code after the linkage analysis and processing.
The method according to claim 1, wherein the component node includes multiple pieces of linkage configuration information, and each piece of linkage configuration information in the multiple pieces of linkage configuration information includes: the final setting result and linkage conditions of the component node; Linkage conditions include condition node path and condition component node type;

The linkage function code after the linkage analysis and processing is used to perform the following steps:

In the current linkage configuration information included in the current component node, according to the condition node path and the condition component node type in the linkage condition, find out the component nodes from the remaining component nodes; the current component node represents the plurality of component nodes Among the component nodes that currently need linkage analysis and processing, the remaining component nodes represent component nodes in the plurality of component nodes except the current component node;

Determine whether the linkage condition is satisfied in the found component nodes;

When it is determined that the found component node satisfies the linkage condition, it is determined that the current piece of linkage configuration information satisfies the linkage condition, and the final setting result in the current piece of linkage configuration information is set to the current component node on the results.
The method according to claim 2, wherein the linkage condition further includes a condition node value and a condition node value type, and the judging whether the found component node satisfies the linkage condition comprises:

performing type conversion on the condition node value of the found component node according to the condition node value type in the linkage condition, to obtain a type-converted condition value;

When the condition value after the type conversion is the same as the condition node value in the linkage condition, determine that the found component node satisfies the linkage condition;

If the condition value after the type conversion is different from the condition node value in the linkage condition, it is determined that the found component node does not satisfy the linkage condition.
The method according to claim 1, wherein said utilizing the linkage function code after said linkage analysis and processing to realize the linkage function of each component node includes:

Registering the linkage function code after the linkage analysis and processing in the linkage function application programming interface api of the Formily framework;

When it is determined that the user page triggers linkage for each component node, the linkage function code is invoked through the linkage function api to realize the linkage function for each component node.
The method according to claim 1, wherein the method further comprises:

Perform verification and analysis processing on the linkage configuration information of each component node according to the data structure specification, and obtain the verification function code after the verification and analysis processing;

The verification function code for each component node is realized by using the verification function code after the verification analysis.
The method according to claim 5, wherein the component node includes multiple pieces of linkage configuration information, and each piece of linkage configuration information in the multiple pieces of linkage configuration information includes: the final setting result and linkage conditions of the component node; Linkage conditions include condition node path and condition component node type;

The verification function code after the linkage analysis and processing is used to perform the following steps:

In the current linkage configuration information included in the current component node, according to the condition node path and the condition component node type in the linkage condition, find out the component nodes from the remaining component nodes; the current component node represents the plurality of component nodes Among the component nodes that currently need linkage analysis and processing, the remaining component nodes represent component nodes in the plurality of component nodes except the current component node;

Determine whether the found component nodes meet the linkage conditions;

When determining that the found component node satisfies the linkage condition, determine that the current linkage configuration information satisfies the linkage condition, continue to judge whether the result of the current component node passes the verification, and obtain the verification result; After the verification result determines that the current component node has passed the verification, continue to judge whether the next component node of the current component node has passed the verification until all the component nodes that need linkage analysis and processing are judged; or,

When it is determined that the found component node does not meet the linkage condition, determine that the current component node has passed the verification; continue to judge whether the next component node of the current component node has passed the verification, until the component node that needs linkage analysis processing All judgments are complete.
The method according to claim 2 or 6, wherein, according to the condition node path and the condition component node type in the linkage condition, finding the component node from the remaining component nodes includes:

determining a part of component nodes corresponding to the condition node path in the linkage condition from the remaining component nodes;

A component node of the same type as the conditional component node in the linkage condition is found from the partial component nodes.
The method according to claim 5, wherein said using the verification function code after the verification analysis processing to realize the verification function of each component node includes:

Register the verification function code after the linkage analysis and processing into the submission function of the low-code core class;

When it is determined that the user page is performing a data recovery or submission operation, the verification function for each component node is realized by executing the verification function code.
The method according to claim 8, wherein, after executing the verification function code, the method further comprises:

Perform type conversion on the output data of the verification function code according to the data type of the condition node in the linkage condition of the current component node.
A device for realizing the linkage function, which is applied to the low-code core class of the Formily framework, and the device includes:

The receiving module is used to receive the JSON Schema configuration sent from the user page; the JSON Schema configuration is obtained by the user page from the page designer; the JSON Schema configuration includes multiple components used to describe the user page The linkage configuration information of the node, and the linkage configuration information of different component nodes corresponds to the same data structure specification;

Obtaining a module for obtaining the linkage configuration information of each component node in the plurality of component nodes by traversing the JSON Schema configuration; performing linkage analysis on the linkage configuration information of each component node according to the data structure specification processing to obtain the linkage function code after linkage analysis and processing;

The linkage module is configured to realize the linkage function of each component node by using the linkage function code after the linkage analysis and processing.
An electronic device, the device comprising a memory, a processor, and a computer program stored in the memory and operable on the processor, the processor implementing the program according to any one of claims 1 to 9 method.
A computer storage medium, on which a computer program is stored, and when the computer program is executed by a processor, the method according to any one of claims 1 to 9 is realized.
A computer program product comprising computer readable codes, when the computer readable codes are run in an electronic device, a processor in the electronic device executes the method according to any one of claims 1 to 9.