Form rendering method and device, computer equipment and storage medium

Abstract

The invention discloses a form rendering method and device, computer equipment and a storage medium. The method comprises the steps that process data needing to be displayed are obtained, and the process data comprise instance data; judging whether the form type of the process data is a URL (Uniform Resource Locator); if yes, a version number and a process definition identifier are extracted from the process data; determining a front-end development component of a corresponding version, loading the front-end development component through the URL, and transmitting instance data to component rendering; if not, extracting a version number, a process definition identifier and form data from the process data; analyzing the form data to obtain recognizable form data; obtaining a form rendering component of a corresponding version; and inputting the recognizable form data and instance data into a rendering component for rendering. By implementing the method provided by the invention, the technical problems that the existing rendering engine is different in compatibility, difficult in dynamic adjustment and high in operation complexity, and the user experience is affected due to the fact that updating cannot be carried out in time when the business process is changed can be solved.

Description

Technical Field

[0001] The present invention relates to a rendering engine, and more specifically to a form rendering method, device, computer equipment and storage medium. Background Art

[0002] Table rendering refers to the process of displaying data in a table format on the user interface. Through table rendering, data can be organized and displayed in the form of rows and columns, helping users to understand and manipulate data more intuitively.

[0003] However, because different companies use different programming languages, databases, and middleware, table rendering engines often face compatibility issues when integrating with these heterogeneous technology environments. For example, some engines have better support for specific versions of databases, but when combined with other versions of databases, compatibility barriers may arise; for some companies using old systems, the engine may face problems such as differences in technical architecture and inconsistent interfaces when integrating with these systems, which increases the difficulty of integration; business processes are not static, and as needs change, processes need to be dynamically adjusted. Some process engines have limitations in supporting such dynamic adjustments and cannot quickly respond to and adapt to changes in business needs; the operation interface design of some process engines is relatively complex, and users need to invest more time to learn and adapt. For non-technical personnel, especially those without development experience, it may be difficult to use these engines.

[0004] Moreover, these problems will cause format errors or data mismatches when rendering table data, affecting the user experience; the table cannot be updated in time when the business process changes, and cannot display the latest data status; the high learning cost may make it difficult for users to get started quickly, and the efficiency when customizing and operating table functions is low.

[0005] Therefore, it is necessary to design a new method to solve the technical problems of existing rendering engine compatibility differences, dynamic adjustment difficulties, high operational complexity, and inability to update in time when business processes change, which affects the user experience. Summary of the invention

[0006] The purpose of the present invention is to overcome the defects of the prior art and provide a form rendering method, device, computer equipment and storage medium.

[0007] To achieve the above object, the present invention adopts the following technical solution: a form rendering method, comprising:

[0008] Acquire process data to be displayed, wherein the process data includes instance data;

[0009] Determine the form type of the process data to determine whether the form type of the process data is a URL;

[0010] If the form type of the process data is URL, extracting a version number and a process definition identifier from the process data;

[0011] Determine the front-end development component of the corresponding version according to the version number and the process definition identifier, load the front-end development component through the URL, and transmit the instance data to the component for rendering;

[0012] If the form type of the process data is not a URL, extracting a version number, a process definition identifier, and form data from the process data;

[0013] Parsing the form data to obtain recognizable form data;

[0014] Get the corresponding version of the form rendering component according to the current version number and process definition identifier;

[0015] The recognizable form data and instance data are input into a rendering component for rendering.

[0016] The further technical solution is: the step of obtaining the corresponding version of the form rendering component according to the current version number and the process definition identifier includes:

[0017] According to the current version number and process definition identifier, the current front-end display component is searched in the mapping table to obtain the corresponding version of the form rendering component.

[0018] Its further technical solution is: the mapping table is constructed through the recursive component and slot mechanism of Vue, and is used to manage different versions of form rendering components.

[0019] A further technical solution is: inputting the identifiable form data and instance data into a rendering component for rendering, including:

[0020] Determine whether the structure of the instance data or the structure of the form data has changed;

[0021] If the structure of the instance data and the structure of the form data have not changed, the identifiable form data and instance data are input into the rendering component for form rendering;

[0022] If the structure of the instance data or the structure of the form data changes, the current version number and the component used to parse the form data are added to the mapping table, and the identifiable form data and instance data are input into the rendering component for form rendering.

[0023] A further technical solution is: the step of inputting the identifiable form data and instance data into the rendering component for form rendering includes:

[0024] Input the recognizable form data and instance data into the rendering component and render the form according to the form format.

[0025] A further technical solution is: the form format is defined based on a nested structure, including tabs, areas, and fields.

[0026] A further technical solution is: the corresponding form data and instance data are input into the rendering component to perform form rendering according to the form format, including:

[0027] The corresponding form data and instance data are input into the rendering component and the form is rendered recursively according to the form format.

[0028] The present invention also provides a form rendering device, comprising:

[0029] A data acquisition unit, used to acquire process data to be displayed, wherein the process data includes instance data;

[0030] A judging unit, configured to determine a form type of the process data, and to judge whether the form type of the process data is a URL;

[0031] A first extraction unit, configured to extract a version number and a process definition identifier from the process data if the form type of the process data is a URL;

[0032] A first rendering unit, configured to determine a front-end development component of a corresponding version according to the version number and the process definition identifier, load the front-end development component through a URL, and transmit the instance data to the component for rendering;

[0033] a second extraction unit, configured to extract a version number, a process definition identifier, and form data from the process data if the form type of the process data is not a URL;

[0034] A parsing unit, used for parsing the form data to obtain recognizable form data;

[0035] A component acquisition unit is used to acquire the corresponding version of the form rendering component according to the current version number and process definition identifier;

[0036] The second rendering unit is used to input the identifiable form data and instance data into a rendering component for rendering.

[0037] The present invention further provides a computer device, which includes a memory and a processor. The memory stores a computer program, and the processor implements the above method when executing the computer program.

[0038] The present invention also provides a storage medium, wherein the storage medium stores a computer program, and the computer program implements the above method when executed by a processor.

[0039] Compared with the prior art, the beneficial effects of the present invention are as follows: the present invention solves the differences in compatibility of existing rendering engines by dynamically identifying the form type of process data; automatically selects and loads the corresponding version of the front-end development component according to whether the form type is a URL, thereby simplifying the dynamic adjustment process of the rendering component; for form data of non-URL type, the form data is extracted and parsed to ensure compatibility with the rendering component; the components of the corresponding version are accurately matched through version numbers and process definition identifiers, effectively coping with the timely update problem when the business process changes; this method reduces the complexity of operation, improves the user experience, and ensures the efficiency and stability of the rendering process.

[0040] The present invention is further described below in conjunction with the accompanying drawings and specific embodiments. BRIEF DESCRIPTION OF THE DRAWINGS

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

[0042] Figure 1 A schematic diagram of an application scenario of the form rendering method provided by an embodiment of the present invention;

[0043] Figure 2 A schematic diagram of a flow chart of a form rendering method provided by an embodiment of the present invention;

[0044] Figure 3 A schematic diagram of a sub-process of a form rendering method provided in an embodiment of the present invention;

[0045] Figure 4 A schematic block diagram of a form rendering device provided by an embodiment of the present invention;

[0046] Figure 5 A schematic block diagram of a second rendering unit of a form rendering device provided in an embodiment of the present invention;

[0047] Figure 6 A schematic block diagram of a computer device provided for an embodiment of the present invention;

[0048] Figure 7 A schematic diagram of process data display provided by an embodiment of the present invention;

[0049] Figure 8 A schematic diagram of recursive rendering provided by an embodiment of the present invention;

[0050] Fig. 9 A schematic diagram of a form format provided in an embodiment of the present invention. DETAILED DESCRIPTION

[0051] The following will be combined with the drawings in the embodiments of the present invention to clearly and completely describe the technical solutions in the embodiments of the present invention. Obviously, the described embodiments are part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of the present invention.

[0052] It should be understood that when used in this specification and the appended claims, the terms "include" and "comprises" indicate the presence of described features, integers, steps, operations, elements and / or components, but do not exclude the presence or addition of one or more other features, integers, steps, operations, elements, components and / or combinations thereof.

[0053] It should also be understood that the terms used in this specification of the present invention are only for the purpose of describing specific embodiments and are not intended to limit the present invention. As used in the specification of the present invention and the appended claims, unless the context clearly indicates otherwise, the singular forms "a", "an" and "the" are intended to include plural forms.

[0054] It should be further understood that the term "and / or" used in the present description and the appended claims refers to and includes any and all possible combinations of one or more of the associated listed items.

[0055] See also Figure 1 and Figure 2 , Figure 1 A schematic diagram of an application scenario of the form rendering method provided in an embodiment of the present invention. Figure 2A schematic flow chart of a form rendering method provided by an embodiment of the present invention. The form rendering method is applied to a server. The server interacts with a terminal for data, obtains process data and determines the form type, flexibly supports the loading of front-end components of URL type, and solves the problem of compatibility differences of rendering engines. If the form type is not URL, the method dynamically selects and loads the corresponding version of the rendering component by obtaining the version number and the process definition identifier, ensuring that the rendering component matches the current business requirements. The mapping table mechanism uses Vue's recursive components and slot technology to support the management and loading of different versions of form components, thereby improving the compatibility of components. When the instance data structure changes, the method automatically adds a new version number and display code through the mapping table, thereby simplifying the dynamic adjustment process. During the form rendering process, by determining whether the instance data structure changes or not, the adaptation of the rendering component is optimized and the operation complexity is reduced. The form data and instance data are rendered in a nested form format, so that complex forms can be flexibly presented and the user experience is improved. Through the recursive rendering method, the hierarchical structure of the form can be efficiently and accurately presented to adapt to the dynamic changes of the business process. The entire method ensures that the form can be updated in time when the business process changes, thereby avoiding user experience problems caused by delayed component updates. .

[0056] Figure 2 is a flow chart of the form rendering method provided by an embodiment of the present invention. Figure 2 As shown, the method includes the following steps S110 to S160.

[0057] S110: Acquire process data to be displayed, wherein the process data includes instance data.

[0058] In this embodiment, during the form rendering process, data related to the current business process needs to be extracted from the system or database. These data mainly include the following two parts:

[0059] Form type: This part of the data indicates how or where the form is displayed, which may be a local front-end component, an external URL, a third-party integrated component, etc. The form type can determine how to select or load different form rendering components.

[0060] Instance data refers to the specific data instance that the current user interacts with. These instance data are the core content of the form display, including user input, information in the business process, or data generated by the system, including fields, options, default values, etc.

[0061] By obtaining these two types of data, the rendering engine can understand exactly how to render the form and what content should be displayed.

[0062] By explicitly obtaining the form type and instance data, you can flexibly choose different form display methods. Whether it is a local component, remote URL, or external system integration, the rendering method can be automatically switched according to the form type to meet different business needs.

[0063] In a dynamic business environment, processes and data may change at any time. By obtaining instance data, you can ensure that the form content reflects the latest status of the current business process in real time and accurately, avoiding the inadaptability problems caused by hard coding and static data.

[0064] After clearly obtaining the process data, the system can automatically match and render according to the form type and instance data, reducing manual intervention and configuration operations, improving the level of automation, and also improving data consistency and rendering efficiency.

[0065] By obtaining instance data, the rendering engine can provide users with personalized form content. Users see data related to their needs and processes, which allows them to complete tasks more efficiently and improves user experience.

[0066] The acquisition method of process data is modular and can be expanded as business needs evolve. For example, when adding a new form type or modifying the instance data structure, the system can be flexibly adjusted without large-scale reconstruction of existing functions.

[0067] In traditional form rendering, the form content is often fixed. By dynamically acquiring process data, the rendering engine can adapt to a variety of business processes, avoiding the tedious form maintenance and update work in traditional methods.

[0068] S120: Determine the form type of the process data to determine whether the form type of the process data is a URL.

[0069] In this embodiment, the form type field (such as type or formType) of the process data is checked through data parsing and field mapping; it is determined whether the field value is equal to "URL", if so, the next step (S130) is entered, otherwise, other processing logic is entered.

[0070] S130: If the form type of the process data is URL, extract a version number and a process definition identifier from the process data.

[0071] In this embodiment, if the form type is determined to be a URL in step S120, other information in the URL is analyzed. Parameter information in the URL can be extracted by regular expressions or a URL parsing library, including a version number (version) and a process definition identifier (processId). After extracting this information from the URL, the version number and the process definition identifier are saved as variables for use in subsequent steps.

[0072] S140, determining a front-end development component of a corresponding version according to the version number and the process definition identifier, loading the front-end development component through a URL, and transmitting the instance data to the component for rendering.

[0073] In this embodiment, the front-end development component of the corresponding version on the server is searched or requested according to the extracted version number and process definition identifier. These components can be obtained by calling the interface or consulting the local resource management library. Using the dynamic loading technology of the front end (such as Webpack, React dynamic import or loading resources through URL), the corresponding front-end development component is requested through the URL. After loading is completed, the process instance data is passed to the component, the data is passed into the component, and data rendering begins. In the process of rendering the component, the form or business process is dynamically displayed based on the passed-in instance data.

[0074] If the form type is URL, it means that the form is not displayed by a local front-end component, but by loading a remote front-end component through a specified external URL. In this case, the system will obtain the corresponding form component from the remote server according to the specified URL (it may be an independent front-end page, module, or front-end component provided by an API). After obtaining these components, the system will transfer the instance data to the remote component so that it can dynamically generate the form content and render it based on this data.

[0075] First, the system needs to identify the form type based on the configuration of the form in the business process. If the form type is a URL, the system will obtain and parse the URL. The system loads the remote front-end component by accessing the URL. These components usually have a set of predefined logic for displaying the corresponding UI based on the input data or request parameters. After loading the remote component, the system passes the instance data related to the current business process to the component. This data usually includes form fields, default values, options, and dynamic information related to the business process. The front-end component that receives the data renders a dynamic form based on the passed instance data and displays it to the user on the client. The user can interact on the form and fill in the necessary information.

[0076] By delegating the rendering of forms to external URLs and remote components, the system becomes more flexible. This means that different forms can be developed independently by different teams, systems, or services, and can be replaced or updated at any time without directly modifying the core application logic. After the front-end components are independent in the form of URLs, the front-end and back-end can be decoupled. Front-end developers can design and develop components independently of the back-end development process, and the back-end system only needs to ensure that data and URLs are provided correctly, without having to worry about the specific form display logic. By loading front-end components through URLs, remote components can be updated independently. As long as the URL remains unchanged, the new component version can be directly replaced through the URL, and the latest form logic is automatically loaded when the user accesses it without any local deployment or system upgrade. Instance data can be uniformly delivered and processed through URLs, avoiding the situation where form data is scattered in multiple places. This centralized management and delivery method simplifies the complexity of data synchronization and update. If form components are designed as cross-platform web components (for example, using frameworks such as React and Vue), they can adapt to different devices and browsers, and can maintain a consistent user experience whether on desktop or mobile devices. Loading components through URLs makes it easy for the system to integrate third-party services or tools. By simply configuring the appropriate URL, you can load externally developed form components for customized rendering, improving the scalability and integration capabilities of the business system. If the form component has been developed externally and is reusable, loading it using the URL method can avoid repeatedly developing the same form rendering logic, saving time and resources for front-end development. This also helps to centrally manage and maintain form components. By moving the rendering process to an external server, the burden on the local server can be reduced, especially when the form rendering logic is complex. In addition, the remote server may have more powerful hardware resources to handle rendering requests, improving overall performance.

[0077] In summary, loading the front-end developed components through the URL and passing instance data for form rendering not only improves the flexibility and scalability of the system, but also simplifies the front-end and back-end collaboration, ensures the efficiency of component updates, and greatly improves the efficiency of development and deployment.

[0078] S150: If the form type is not a URL, extract a version number, a process definition identifier, and form data from the process data.

[0079] In this embodiment, if the form type is not URL, it is XML data or JSON data.

[0080] In this embodiment, if it is XML data:

[0081] Extract version, processId, and formData (form data in XML format) from the process data. You can use an XML parsing library (such as Java's DOMParser or JavaScript's DOMParser) to convert the XML string into a DOM object.

[0082] Through DOM operation, the version number, process definition identifier and form data are extracted.

[0083] If it is JSON data: JSON data is usually already an object, and the version number, process definition ID, and form data can be directly extracted through field access (for example: jsonData.version, jsonData.processId, jsonData.formData).

[0084] This data format directly supports JavaScript object operations and can be processed using standard JSON parsing methods (such as JSON.parse()).

[0085] After obtaining the XML or JSON data, extract the required fields and save them to the corresponding variables for subsequent processing.

[0086] S160: Parse the form data to obtain recognizable form data.

[0087] In this embodiment, if the form data is in XML format, the XML document is first parsed and the relevant data fields are extracted. For example, XML contains <form> 、 <field> 、 <value>Tags such as , need to be parsed to get the actual form data. Use an appropriate XML parsing library to traverse the XML structure and extract the data into a structured object or list for further processing. For example, the name, type, value and other information of the field can be extracted as key-value pairs of the form field. Perform formatting or mapping conversion (such as mapping XML tag names to form field names) to convert the data into a format that can be used by the front end, such as JavaScript objects or JSO.

[0088] S170. Obtain a form rendering component of a corresponding version according to the current version number and process definition identifier.

[0089] In this embodiment, the current front-end display component is searched in the mapping table according to the current version number and the process definition identifier to obtain the form rendering component of the corresponding version.

[0090] Specifically, the mapping table is constructed through the recursive component and slot mechanism of Vue, and is used to manage different versions of form rendering components.

[0091] In the current system design, the selection of form rendering components is based on the version number and the process definition identifier. In specific implementation, the system searches for the corresponding front-end display component in a mapping table based on these two parameters to obtain the correct version of the form rendering component.

[0092] The construction of this mapping table relies on Vue's recursive components and slot mechanism. Through these two technologies, the system can flexibly manage and render different versions of form components. Recursive components and slot mechanisms allow content to be passed and nested between different components, allowing form components to be dynamically displayed according to specific versions and business process requirements.

[0093] The purpose of the mapping table is to associate the process definition and version number with the specific form rendering component. Whenever the system needs to display a form, it will find the corresponding component based on the current version number and process definition identifier and render it.

[0094] The use of recursive components and slot mechanisms allows different versions of form rendering components to be flexibly combined and nested. Whether it is the structure, fields or display method of the form, it can be adjusted according to business needs without frequently modifying the core code. This greatly enhances the flexibility and customizability of the system.

[0095] The mapping table is designed so that new versions or process definitions can be easily added to the system. Only the mapping table needs to be updated without extensive modifications to the existing code, which makes the system more efficient in handling complex version management and business processes.

[0096] Through Vue's recursive components and slot mechanism, different parts of the components can be managed modularly, and different versions of form components can also be developed and maintained independently. The front-end and back-end development teams can be better decoupled, with the front-end team focusing on component rendering and the back-end team focusing on process data and version control.

[0097] Recursive components and slot mechanisms allow for a high degree of reuse of component logic. Form components can be changed according to business needs by dynamically passing in different slot contents, avoiding repeated development of similar form display logic. At the same time, it also allows form components to easily adapt to the needs of different versions.

[0098] The mapping table can be updated dynamically, and the system can automatically select the appropriate form component for rendering according to different version numbers and process definition identifiers, ensuring the consistency and correctness of form presentation for different versions and processes. This means that when the system is updated, there is no need for a comprehensive reconstruction, only the mapping table needs to be updated.

[0099] Since form components and version management are implemented through mapping tables, later maintenance and version upgrades can be completed by updating the mapping table without frequently modifying the front-end code or redeploying form components. This not only reduces maintenance costs, but also speeds up the release of new features.

[0100] Since different versions of form rendering components can be accurately matched according to the process definition, the system can provide a more customized and flexible form display method. This dynamic rendering mechanism can better adapt to different users and business scenarios, thereby improving the overall user experience.

[0101] In summary, the mapping table built through Vue's recursive components and slot mechanism not only improves the flexibility and scalability of the system in multi-version management and form rendering, but also improves the modularity, reusability, and ease of maintenance of the system. This design approach enables the front-end components to render accurately according to specific versions and process requirements, ultimately providing a more flexible and dynamic form display experience.

[0102] In one embodiment, the data used by the engine used in the rendering process is as follows: Figure 7 As shown in the figure, a tree model is used to support hierarchical process design. Each node represents a step or state in the process, and its type, function and behavior are defined by different attributes. The root node contains child nodes (childNode) pointing to the next process node and multiple associated nodes (associatedNodes), through which cross-node connection and control are achieved.

[0103] Specifically, in the tree structure, each node contains the following key fields:

[0104] nodeType: This attribute is used to distinguish different node types, such as initiator, approver, conditional branch, parallel branch, etc., to clarify the role and function of each node in the process.

[0105] nodeName: This field stores the name of the node and supports modification, making it convenient for users to adjust and customize the process according to actual needs.

[0106] childNode: points to the subsequent process node, represents the order and hierarchical structure of the process, and supports nested child nodes to form a recursive hierarchy.

[0107] conditionNodes: This field stores possible conditional branches in the process. Each conditional node corresponds to a conditional judgment. The process selects different paths based on these conditions, flexibly supporting multiple scenarios.

[0108] associatedNodes: stores information about other nodes associated with the current node, and is used to manage cross-node dependencies and constraints to ensure collaborative execution of processes.

[0109] nodeInfo (node ​​additional information): This field is used to store additional information of the node, providing more detailed control, such as the node's execution status, parameter configuration, etc.

[0110] In addition, conditional branch and parallel branch nodes determine the execution order by setting the priorityLevel attribute to ensure that the process is executed in sequence according to priority. This attribute can help the system schedule multiple parallel tasks according to the set priority to ensure smooth and efficient processes.

[0111] By combining condition nodes and child nodes, the design can implement complex process control logic, including advanced functions such as conditional judgment, branch selection, parallel processing, etc. This makes process management more flexible and adaptable, and can cope with various complex business needs.

[0112] In general, the tree structure allows nodes to be flexibly combined, nested, and expanded according to process requirements, while maintaining a clear hierarchical layout to facilitate process management, monitoring, and maintenance. This design not only optimizes the execution efficiency of the process, but also improves the flexibility and scalability of process management.

[0113] The tree structure includes the following:

[0114] Start node: the starting point of the process, pointing to the next node - the conditional node.

[0115] Conditional node: After the start node, the conditional node contains multiple conditional branches (conditionNodes). The childNode of the conditional node points to the end node, and it contains two main conditions:

[0116] Conditional branch 1: The childNode of this branch points to the parallel branch node.

[0117] Other conditions: The childNode of this condition points to another condition node, which also contains multiple conditions.

[0118] Parallel branch node: Under conditional branch 1, enter the parallel branch node. This node contains 3 parallel tasks:

[0119] Parallel branch 1: points to the approver node (childNode).

[0120] Parallel branch 2: points to the CC recipient node (childNode).

[0121] Parallel branch 3: points to the handler node (childNode).

[0122] Other condition nodes: The "other conditions" branch under the condition node contains another condition node, which also has multiple condition branches:

[0123] Conditional branch 1: The childNode of this branch points to the approver node.

[0124] Conditional branch 2: The childNode of this branch points to the CC node.

[0125] Other conditional branches: The childNode of this branch points to the person in charge node.

[0126] End node: No matter how the process branches, all paths will eventually converge to the end node, marking the end of the process.

[0127] The process starts from the start node, enters the conditional node, and then according to the conditional branch judgment, may enter the parallel branch node or another conditional node.

[0128] Parallel branch nodes will execute multiple tasks in parallel and point to corresponding terminals under different conditions.

[0129] All branches will eventually lead to the end node, and the process ends.

[0130] This design allows process management to flexibly select different paths under multiple conditions, and the execution of parallel tasks can improve efficiency.

[0131] The content contained in the above tree structure belongs to one of the embodiments. In actual use, the nodes can be adjusted according to actual needs. For example, the next node of the start node can be a parallel branch node, etc., and it is not limited to the above method.

[0132] S180: Input the identifiable form data and instance data into a rendering component for rendering.

[0133] In one embodiment, see Figure 3 , the above-mentioned step S1960 may include steps S181 to S183.

[0134] S181, determining whether the structure of the instance data or the structure of the form data has changed;

[0135] S182: If the structure of the instance data and the structure of the form data have not changed, the identifiable form data and instance data are input into the rendering component for form rendering.

[0136] In this embodiment, the recognizable form data and instance data are input into the rendering component to perform form rendering in accordance with the form format.

[0137] The form format is defined based on a nested structure, including tabs, areas, and fields.

[0138] The corresponding form data and instance data are input into the rendering component and the form is rendered recursively according to the form format.

[0139] In this embodiment, the tree-structured data needs to match the recursive rendering method, such as Figure 8 As shown in the figure, in this process tree rendering design, Vue3's recursive components and slot mechanism are used to dynamically display process nodes. The entire rendering process is as follows:

[0140] First, when the application is initialized, a mapping relationship of process nodes is constructed. This mapping will help us efficiently find and access the data of each process node.

[0141] According to the type of each node (nodeType), we dynamically select the corresponding Vue component to display different types of node information. For example, for conditional nodes, parallel nodes or ordinary nodes, different components are used to display their content.

[0142] Using Vue3's template slot mechanism, recursively render the child nodes of each node. Specifically, when a node is a conditional node or a parallel node, render the child nodes of the node (such as conditional branches or parallel tasks). Each child node will continue to display its subordinate childNodes recursively until all nodes are rendered.

[0143] The entire process node tree is finally presented as a tree structure with clear hierarchy. Each node and its child nodes are displayed on the page through recursive components.

[0144] Specific implementation steps:

[0145] When the application is initialized, a map of process nodes is constructed. The information of each node (such as node type, subnodes, conditions, etc.) will be stored in the map to facilitate subsequent operations.

[0146] Use Vue components to display nodes: According to the nodeType of the node, select the appropriate component to display. For example, use different components to render the content of conditional nodes, parallel nodes, or ordinary nodes.

[0147] Through Vue's slot mechanism, recursively render the child nodes of each node. For conditional nodes and parallel nodes, different child node contents are rendered according to the type of node until all nodes are rendered.

[0148] Ultimately, all nodes will form a complete tree structure, showing the hierarchical relationship and execution path of the entire process.

[0149] This implementation uses Vue3's recursive components and slot mechanism to dynamically render process nodes. Through recursive rendering, the process tree can be flexibly displayed according to the different types and structures of each node, ensuring that the hierarchical relationship and execution path of the process are clearly visible.

[0150] S193. If the structure of the instance data or the structure of the form data changes, add the current version number and the components used to parse the form data in the mapping table, and execute step S192.

[0151] In this embodiment, in the form rendering system, the structural change of the instance data refers to a change in the format, field, type or hierarchical relationship of the data, which can be detected using existing technologies.

[0152] In this embodiment, the engine supports three formats of form rendering: XML, JSON and URL. The format to be used for rendering is determined according to formType. The rendering method of each format has flexible version control, and different form versions are distinguished according to formVersion. All form data is stored in instanceData, which is used to separate data from the interface.

[0153] After parsing the XML data, the system will create a process version mapping table. The mapping table selects different versions of the form to display based on procDefKey and formVersion. For example, if procDefKey is the identifier of a process, formVersion1 and formVersion2 represent different versions of the form.

[0154] If the structure of the XML data has not changed, the front-end does not need to make any adjustments and can directly publish a new form version. If the XML structure has changed, the front-end and back-end need to be updated and published together, and the new version and display logic need to be added to the front-end mapping table.

[0155] JSON format rendering is similar to XML. The form structure is obtained by parsing the JSON data, and the version mapping table is used to switch between different versions of the form. The mapping table also determines the displayed version based on procDefKey and formVersion.

[0156] The JSON format has the same characteristics as XML: if the data structure remains unchanged, the front end does not need to be modified and can be published seamlessly; if the structure changes, the front and back ends need to coordinate updates, and the front end needs to add a new version to the mapping table.

[0157] In the JSON and XML rendering process, the form definition is hierarchical, such as Fig. 9 As shown, Tab-Area-Field.

[0158] Tab: The top-level tab page display. When there is only one tab page, the tab page will not be displayed. Each Tab includes multiple areas (Area), and the data in each area can be updated according to the tab page switching.

[0159] Specifically, Tab: The top-level display structure, responsible for displaying tabs and switching data in different areas.

[0160] Attributes: tabName: used to get the field of corresponding data from the rendered data object (instanceData). tabTitle: the title name displayed on the current tab. areas: multiple display area cards under this tab (each card is an Area).

[0161] Logic: When there is only one tab, the tab itself is not displayed, and the content of the area is rendered directly. When switching tabs, the displayed data will change synchronously with the switching of tabs.

[0162] Area: Each area card displays different information. An area can contain multiple fields or nest other areas.

[0163] In this embodiment, Area displays cards for a specific area, and each card may contain different fields or other areas.

[0164] Attributes: areaName: used to get the data of the area from the rendering data object. areaTitle: the title of the current area. areaType: the type of the area, used to distinguish different display methods. Three types are supported:

[0165] Normal card rendering (displaying normal text, files, images, videos, forms, rich text fields).

[0166] Table rendering (displaying normal text, files, images, videos, forms, and rich text fields in table format).

[0167] Nested area rendering (displayed in a circular card manner, suitable for cases where it contains sub-areas).

[0168] fields: The field set displayed in the current area, supporting field types such as text, file, image, video, form, rich text, etc.

[0169] areas: A collection containing nested areas (if areaType is 3, it may contain nested areas).

[0170] Logic: Determine the display method based on the areaType:

[0171] areaType=1: Displayed as a normal card, rendering various fields (such as text, files, pictures, etc.).

[0172] areaType=2: Displayed as a table, with each area rendered as a table row.

[0173] areaType=3: If the area has sub-areas, a loop is used to render the list. List rendering is repeated rendering in the same area based on data (usually an array).

[0174] Field: Field display content, including text, files, pictures, videos, etc. The display method and data of the field are provided by instanceData.

[0175] In this embodiment, Field: each field represents a specific data item and supports different types of presentation.

[0176] Attributes: label: the label of the field, used to describe the meaning of the field. type: field type, the following types are supported:

[0177] Text: Ordinary text.

[0178] File: file.

[0179] Image: picture.

[0180] Video:Video.

[0181] Form: Form (nested form data).

[0182] Html: Rich text.

[0183] name: Used to get the field data from the rendering data object (instanceData).

[0184] file: When the field type is File, Image, or Video, file contains the address and name of the file.

[0185] form: When the field type is Form, define how the data of the form field is displayed.

[0186] Logic: Text, file, image, video, rich text and other fields: Rendered into different display formats according to the field type (for example, text is displayed directly, images are displayed as images, videos are displayed as video playback controls, and files are displayed as download links).

[0187] Form fields: If the field type is Form, the field may contain further nested data, rendered as form input controls.

[0188] Tab: contains one or more areas, each of which displays different content. Area: displays different types of data or controls, and determines the rendering method (card, table, or nested area) based on areaType. Field: defines the specific field and its display method, which can be text, file, image, video, rich text, or form type.

[0189] These structures together form a clearly hierarchical form rendering system, which enables flexible display and data binding through nested Tabs, Areas, and Fields.

[0190] When using URL rendering, the front end loads the corresponding components for rendering by specifying the URL. Developers can customize these components as needed to achieve more complex interactions or styles. URL rendering is very suitable for complex front-end display requirements.

[0191] The steps of the rendering process include: first, get the data through the interface, then parse the data according to formType and instanceData and select the corresponding rendering method. If it is in XML or JSON format, after parsing, the appropriate rendering component will be selected according to the version number and process definition. If it is URL rendering, the external component is loaded through the URL for display.

[0192] This method supports multiple data formats (XML, JSON, URL), so that it can be effectively supported in different application scenarios. Different versions of forms are managed through formVersion, and switching between different versions is very convenient. The version of form data can be updated independently without affecting the display of the front-end interface. The data and interface are separated. The front-end only needs to focus on the rendering process, not on how the data is stored and transmitted. The back-end is responsible for handling data format and version control. When the XML or JSON structure changes, the front-end only needs to update the version mapping table and display code without having to reconstruct the entire rendering logic, thereby reducing maintenance costs. The URL rendering method allows developers to create highly customized components according to their needs, making form display more flexible and powerful, and suitable for complex front-end interaction needs. Use a unified mapping table and structured data organization method to ensure that form content can be easily maintained, updated and expanded.

[0193] In summary, this rendering method provides high flexibility and scalability through data format parsing and version control, supports multiple data sources and version management, and simplifies the maintenance and update process while ensuring the separation of the front-end and back-end.

[0194] The engine of this embodiment is generally composed of two parts: a graphical designer and an execution engine. The graphical designer enables users to define and edit business processes through an intuitive interface, while the execution engine is responsible for executing tasks according to preset process rules.

[0195] With the help of this engine, enterprises can automate workflows, thereby improving work efficiency, reducing human errors, lowering operating costs, and increasing transparency and traceability of business processes. It helps standardize and optimize processes, reduce manual intervention, and ensure consistency in process execution. Process engines are widely used in order processing, customer service, approval, and other fields, and can significantly improve the operational efficiency and competitiveness of enterprises.

[0196] In this engine, different types of nodes are usually involved when designing and executing processes. Each node represents a specific operation or decision. The following are several common types of process nodes:

[0197] Start node: The starting point of the process, marking the start of the process. Each process instance must start from the start node.

[0198] End Node: The end point of a process, marking the completion or termination of the process. When the process instance reaches the end node, the subsequent tasks are no longer executed.

[0199] Approval node: A node used to perform manual approval or decision-making. The key lies in approval control in the business process.

[0200] Cc node: a node used to notify or copy relevant personnel or teams. Cc will not affect the progress of the main process.

[0201] Processing node: A node used to actually perform certain tasks or operations, such as data entry, document review, etc., which is completed by designated personnel or roles.

[0202] Conditional node: A node that determines the direction of a process based on specific conditions, allowing the process to branch or choose different paths based on different rules.

[0203] Parallel node: A node that allows multiple branches to be executed in parallel. When the process reaches a parallel node, it will trigger the simultaneous execution of multiple paths. The subsequent steps will be continued after all parallel paths are completed.

[0204] Association nodes: used to represent the relationship or connection between different processes, usually used to create jumps or connections between processes.

[0205] Through these nodes, enterprises can design flexible and intelligent business processes to ensure efficient, accurate and transparent process execution.

[0206] The above-mentioned form rendering method solves the compatibility differences of existing rendering engines by dynamically identifying the form type of process data; automatically selects to load the corresponding version of the front-end development component according to whether the form type is a URL, thereby simplifying the dynamic adjustment process of the rendering component; for non-URL type form data, the form data is extracted and parsed to ensure compatibility with the rendering component; the corresponding version of the component is accurately matched through the version number and process definition identifier, effectively coping with the timely update problem when the business process changes; this method reduces the complexity of operation, improves the user experience, and ensures the efficiency and stability of the rendering process.

[0207] Figure 4 is a schematic block diagram of a form rendering device 300 provided in an embodiment of the present invention. Figure 4 As shown, corresponding to the above form rendering method, the present invention also provides a form rendering device 300. The form rendering device 300 includes a unit for executing the above form rendering method, and the device can be configured in a server. Figure 4 The form rendering device 300 includes a data acquisition unit 301, a judgment unit 302, a first extraction unit 303, a first rendering unit 304, a second extraction unit 305, a parsing unit 306, a component acquisition unit 307 and a second rendering unit 308.

[0208] A data acquisition unit 301 is used to acquire process data to be displayed, wherein the process data includes instance data; a judgment unit 302 is used to determine the form type of the process data and determine whether the form type of the process data is a URL; a first extraction unit 303 is used to extract a version number and a process definition identifier from the process data if the form type of the process data is a URL; a first rendering unit 304 is used to determine a front-end development component of a corresponding version according to the version number and the process definition identifier, load the front-end development component through a URL, and transmit the instance data to the component for rendering; a second extraction unit 305 is used to extract a version number, a process definition identifier and form data from the process data if the form type of the process data is not a URL; a parsing unit 306 is used to parse the form data to obtain recognizable form data; a component acquisition unit 307 is used to obtain a form rendering component of a corresponding version according to the current version number and the process definition identifier; a second rendering unit 308 is used to input the recognizable form data and instance data into a rendering component for rendering.

[0209] In one embodiment, the component acquisition unit 307 is used to search the current front-end display component in the mapping table according to the current version number and the process definition identifier to obtain the form rendering component of the corresponding version.

[0210] In one embodiment, if Figure 5 As shown, the second rendering unit 308 includes a structure determination subunit 3081 , a form rendering subunit 3082 , and an updating subunit 3083 .

[0211] The structure judgment subunit 3081 is used to judge whether the structure of the instance data or the structure of the form data has changed; the form rendering subunit 3082 is used to input the identifiable form data and instance data into the rendering component for form rendering if the structure of the instance data and the structure of the form data have not changed; the update subunit 3083 is used to add the current version number and the component used to parse the form data in the mapping table if the structure of the instance data or the structure of the form data has changed, and execute the input of the identifiable form data and instance data into the rendering component for form rendering.

[0212] In one embodiment, the form rendering subunit 3082 is used to input corresponding form data and instance data into the rendering component to perform form rendering according to the form format.

[0213] In one embodiment, the form rendering subunit 3082 is used to input corresponding form data and instance data into the rendering component and perform form rendering in a recursive rendering manner according to the form format.

[0214] It should be noted that those skilled in the art can clearly understand that the specific implementation process of the above-mentioned form rendering device 300 and each unit can refer to the corresponding description in the above-mentioned method embodiment, and for the convenience and brevity of description, it will not be repeated here.

[0215] The form rendering device 300 can be implemented in the form of a computer program. Figure 6 Runs on the computer device shown.

[0216] See also Figure 6 , Figure 6 5 is a schematic block diagram of a computer device provided in an embodiment of the present application. The computer device 500 may be a server, wherein the server may be an independent server or a server cluster composed of multiple servers.

[0217] See also Figure 6 The computer device 500 includes a processor 502 , a memory and a network interface 505 connected via a system bus 501 , wherein the memory may include a non-volatile storage medium 503 and an internal memory 504 .

[0218] The non-volatile storage medium 503 may store an operating system 5031 and a computer program 5032. The computer program 5032 includes program instructions, and when the program instructions are executed, the processor 502 may execute a form rendering method.

[0219] The processor 502 is used to provide computing and control capabilities to support the operation of the entire computer device 500 .

[0220] The internal memory 504 provides an environment for the operation of the computer program 5032 in the non-volatile storage medium 503. When the computer program 5032 is executed by the processor 502, the processor 502 can execute a form rendering method.

[0221] The network interface 505 is used to communicate with other devices over the network. Figure 6 The structure shown in the figure is merely a block diagram of a portion of the structure related to the solution of the present application, and does not constitute a limitation on the computer device 500 to which the solution of the present application is applied. The specific computer device 500 may include more or fewer components than those shown in the figure, or combine certain components, or have a different arrangement of components.

[0222] The processor 502 is used to run the computer program 5032 stored in the memory to implement the following steps:

[0223] Obtain process data to be displayed, wherein the process data includes instance data; determine the form type of the process data to determine whether the form type of the process data is a URL; if the form type of the process data is a URL, extract the version number and process definition identifier from the process data; determine the corresponding version of the front-end development component according to the version number and the process definition identifier, load the front-end development component through the URL, and transfer the instance data to the component for rendering; if the form type of the process data is not a URL, extract the version number, the process definition identifier and the form data from the process data; parse the form data to obtain recognizable form data; obtain the corresponding version of the form rendering component according to the current version number and process definition identifier; input the recognizable form data and instance data into the rendering component for rendering.

[0224] In one embodiment, when the processor 502 implements the step of obtaining the corresponding version of the form rendering component according to the current version number and the process definition identifier, the processor 502 specifically implements the following steps:

[0225] According to the current version number and process definition identifier, the current front-end display component is searched in the mapping table to obtain the corresponding version of the form rendering component.

[0226] The mapping table is constructed through Vue's recursive components and slot mechanism, and is used to manage different versions of form rendering components.

[0227] In one embodiment, when the processor 502 implements the step of inputting the identifiable form data and the instance data into the rendering component to perform the rendering step, the processor 502 specifically implements the following steps:

[0228] Determine whether the structure of the instance data or the structure of the form data has changed; if the structure of the instance data and the structure of the form data have not changed, input the identifiable form data and the instance data into the rendering component for form rendering; if the structure of the instance data or the structure of the form data has changed, add the current version number and the component used to parse the form data in the mapping table, and execute the input of the identifiable form data and the instance data into the rendering component for form rendering.

[0229] In one embodiment, when the processor 502 implements the step of inputting the identifiable form data and the instance data into the rendering component to perform form rendering, the processor 502 specifically implements the following steps:

[0230] Input the recognizable form data and instance data into the rendering component and render the form according to the form format.

[0231] The form format is defined based on a nested structure, including tabs, areas, and fields.

[0232] In one embodiment, when the processor 502 implements the step of inputting the corresponding form data and the instance data into the rendering component to perform form rendering according to the form format, the processor 502 specifically implements the following steps:

[0233] The corresponding form data and instance data are input into the rendering component and the form is rendered recursively according to the form format.

[0234] It should be understood that in the embodiment of the present application, the processor 502 may be a central processing unit (CPU), and the processor 502 may also be other general-purpose processors, digital signal processors (DSP), application-specific integrated circuits (ASIC), field-programmable gate arrays (FPGA) or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. Among them, the general-purpose processor may be a microprocessor or the processor may also be any conventional processor, etc.

[0235] It can be understood by those skilled in the art that all or part of the processes in the method for implementing the above embodiment can be completed by instructing the relevant hardware through a computer program. The computer program includes program instructions, and the computer program can be stored in a storage medium, which is a computer-readable storage medium. The program instructions are executed by at least one processor in the computer system to implement the process steps of the embodiment of the above method.

[0236] Therefore, the present invention also provides a storage medium. The storage medium may be a computer-readable storage medium. The storage medium stores a computer program, wherein when the computer program is executed by a processor, the processor executes the following steps:

[0237] Obtain process data to be displayed, wherein the process data includes instance data; determine the form type of the process data to determine whether the form type of the process data is a URL; if the form type of the process data is a URL, extract the version number and process definition identifier from the process data; determine the corresponding version of the front-end development component according to the version number and the process definition identifier, load the front-end development component through the URL, and transfer the instance data to the component for rendering; if the form type of the process data is not a URL, extract the version number, the process definition identifier and the form data from the process data; parse the form data to obtain recognizable form data; obtain the corresponding version of the form rendering component according to the current version number and process definition identifier; input the recognizable form data and instance data into the rendering component for rendering.

[0238] In one embodiment, when the processor executes the computer program to implement the step of obtaining the corresponding version of the form rendering component according to the current version number and the process definition identifier, the processor specifically implements the following steps:

[0239] According to the current version number and process definition identifier, the current front-end display component is searched in the mapping table to obtain the corresponding version of the form rendering component.

[0240] The mapping table is constructed through Vue's recursive components and slot mechanism, and is used to manage different versions of form rendering components.

[0241] In one embodiment, when the processor executes the computer program to implement the step of inputting the identifiable form data and instance data into the rendering component to perform rendering, the processor specifically implements the following steps:

[0242] Determine whether the structure of the instance data or the structure of the form data has changed; if the structure of the instance data and the structure of the form data have not changed, input the identifiable form data and the instance data into the rendering component for form rendering; if the structure of the instance data or the structure of the form data has changed, add the current version number and the component used to parse the form data in the mapping table, and execute the input of the identifiable form data and the instance data into the rendering component for form rendering.

[0243] In one embodiment, when the processor executes the computer program to implement the step of inputting the identifiable form data and the instance data into the rendering component to perform form rendering, the processor specifically implements the following steps:

[0244] Input the recognizable form data and instance data into the rendering component and render the form according to the form format.

[0245] The form format is defined based on a nested structure, including tabs, areas, and fields.

[0246] In one embodiment, when the processor executes the computer program to implement the step of inputting the corresponding form data and instance data into the rendering component to perform form rendering in accordance with the form format, the processor specifically implements the following steps:

[0247] The corresponding form data and instance data are input into the rendering component and the form is rendered recursively according to the form format.

[0248] The storage medium may be a USB flash drive, a mobile hard disk, a read-only memory (ROM), a magnetic disk, or an optical disk, or any other computer-readable storage medium that can store program codes.

[0249] Those of ordinary skill in the art will appreciate that the units and algorithm steps of each example described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, computer software, or a combination of the two. In order to clearly illustrate the interchangeability of hardware and software, the composition and steps of each example have been generally described in terms of function in the above description. Whether these functions are performed in hardware or software depends on the specific application and design constraints of the technical solution. Professional and technical personnel can use different methods to implement the described functions for each specific application, but such implementation should not be considered to be beyond the scope of the present invention.

[0250] In the several embodiments provided by the present invention, it should be understood that the disclosed devices and methods can be implemented in other ways. For example, the device embodiments described above are only schematic. For example, the division of each unit is only a logical function division, and there may be other division methods in actual implementation. For example, multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed.

[0251] The steps in the method of the embodiment of the present invention can be adjusted in order, combined and deleted according to actual needs. The units in the device of the embodiment of the present invention can be combined, divided and deleted according to actual needs. In addition, the functional units in the various embodiments of the present invention can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit.

[0252] If the integrated unit is implemented in the form of a software functional unit and sold or used as an independent product, it can be stored in a storage medium. Based on this understanding, the technical solution of the present invention is essentially or the part that contributes to the prior art, or all or part of the technical solution can be embodied in the form of a software product, and the computer software product is stored in a storage medium, including a number of instructions for a computer device (which can be a personal computer, terminal, or network device, etc.) to perform all or part of the steps of the method described in each embodiment of the present invention.

[0253] The above is only a specific embodiment of the present invention, but the protection scope of the present invention is not limited thereto. Any technician familiar with the technical field can easily think of various equivalent modifications or replacements within the technical scope disclosed by the present invention, and these modifications or replacements should be included in the protection scope of the present invention. Therefore, the protection scope of the present invention shall be based on the protection scope of the claims.< / value> < / field> < / form>

Claims

1. A form rendering method, characterized in that: include: Acquire process data to be displayed, wherein the process data includes instance data; Determine the form type of the process data to determine whether the form type of the process data is a URL; If the form type of the process data is URL, extracting a version number and a process definition identifier from the process data; Determine the front-end development component of the corresponding version according to the version number and the process definition identifier, load the front-end development component through the URL, and transmit the instance data to the component for rendering; If the form type of the process data is not a URL, extracting a version number, a process definition identifier, and form data from the process data; Parsing the form data to obtain recognizable form data; Get the corresponding version of the form rendering component according to the current version number and process definition identifier; The identifiable form data and instance data are input into a rendering component for rendering.

2. The form rendering method according to claim 1, characterized in that: The obtaining of the corresponding version of the form rendering component according to the current version number and the process definition identifier includes: According to the current version number and process definition identifier, the current front-end display component is searched in the mapping table to obtain the corresponding version of the form rendering component.

3. The form rendering method according to claim 2, characterized in that: The mapping table is constructed through Vue's recursive components and slot mechanism, and is used to manage different versions of form rendering components.

4. The form rendering method according to claim 3, characterized in that: The step of inputting the identifiable form data and the instance data into a rendering component for rendering includes: Determining whether the structure of the instance data or the structure of the form data has changed; If the structure of the instance data and the structure of the form data have not changed, the identifiable form data and instance data are input into the rendering component for form rendering; If the structure of the instance data or the structure of the form data changes, the current version number and the component used to parse the form data are added to the mapping table, and the identifiable form data and instance data are input into the rendering component for form rendering.

5. The form rendering method according to claim 4, characterized in that: The step of inputting the identifiable form data and the instance data into the rendering component for form rendering includes: Input the recognizable form data and instance data into the rendering component and render the form according to the form format.

6. The form rendering method according to claim 5, characterized in that: The form format is defined based on a nested structure, including tabs, areas, and fields.

7. The form rendering method according to claim 5, characterized in that: The step of inputting the corresponding form data and instance data into the rendering component and performing form rendering in accordance with the form format includes: The corresponding form data and instance data are input into the rendering component and the form is rendered recursively according to the form format.

8. A form rendering device, characterized in that: include: A data acquisition unit, used to acquire process data to be displayed, wherein the process data includes instance data; A judging unit, configured to determine a form type of the process data, and to judge whether the form type of the process data is a URL; A first extraction unit, configured to extract a version number and a process definition identifier from the process data if the form type of the process data is a URL; A first rendering unit, configured to determine a front-end development component of a corresponding version according to the version number and the process definition identifier, load the front-end development component through a URL, and transmit the instance data to the component for rendering; a second extraction unit, configured to extract a version number, a process definition identifier, and form data from the process data if the form type of the process data is not a URL; A parsing unit, used for parsing the form data to obtain recognizable form data; A component acquisition unit is used to acquire the corresponding version of the form rendering component according to the current version number and process definition identifier; The second rendering unit is used to input the identifiable form data and instance data into a rendering component for rendering.

9. A computer device, characterized in that: The computer device comprises a memory and a processor, wherein a computer program is stored in the memory, and when the processor executes the computer program, the method according to any one of claims 1 to 7 is implemented.

10. A storage medium, characterized in that: The storage medium stores 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.

Images