Version compatibility method and device of RPA system, electronic equipment and storage medium

Abstract

The application provides a version compatibility method and device of an RPA system, electronic equipment and a storage medium, wherein the method comprises: when the version of a robot process automation (RPA) system changes, determining an object to be updated and a current version of the RPA system; and updating the object to be updated based on the current version; wherein the version of the RPA system changes in at least one of the following cases: a component of the RPA system changes, or a designer version changes. The application can achieve comprehensive version compatibility for the RPA system.

Description

Technical Field

[0001] This invention relates to the field of computer technology, and in particular to a version compatibility method, apparatus, electronic device, and storage medium for an RPA system. Background Technology

[0002] RPA (Robotic Process Automation) automates user operations by simulating end-user actions within a software system, based on technologies such as interface recognition, browser operation, and AI capabilities. For RPA systems developed as products, multiple versions of designers, clients, executors, and components are generated during their iterative updates. These different versions of modules are difficult to adapt flexibly, easily leading to compatibility issues.

[0003] Currently, most systems store multiple versions of the executor in the client to address executor compatibility issues. However, storing multiple executor versions in the client's memory wastes storage space, and when the executor version is updated, the updated executor needs to be added to each client, increasing maintenance costs. This contradicts the cost reduction and efficiency improvement goals of RPA systems and fails to solve the compatibility issues of designer and component version updates. Therefore, achieving comprehensive version compatibility for RPA systems is a pressing issue that needs to be addressed. Summary of the Invention

[0004] This invention provides a version compatibility method, apparatus, electronic device, and storage medium for an RPA system, to address the shortcomings of existing technologies that cannot achieve comprehensive version compatibility.

[0005] This invention provides a version compatibility method for an RPA system, applied to the designer side, the method comprising:

[0006] When the version of the Robotic Process Automation (RPA) system changes, determine the object to be updated and the current version of the RPA system;

[0007] Based on the current version, update the object to be updated;

[0008] The changes in the RPA system version include at least one change in the RPA system components or the designer version.

[0009] According to a version compatibility method for an RPA system provided by the present invention, when the components of the RPA system change, the object to be updated is a process file, the current version is the current component version of the RPA system, and the process file is used to record component information of the components used in the process.

[0010] The step of updating the object to be updated based on the current version includes:

[0011] Obtain component update information of the RPA system, the component update information including update information between the component version of the process file and the current component version;

[0012] Based on the component update information, the component information of the process file is updated.

[0013] According to a version compatibility method for an RPA system provided by the present invention, the component information of the process file includes component class name and component attributes;

[0014] The step of updating the component information of the process file based on the component update information includes:

[0015] Based on the component update information, determine the information to be updated;

[0016] If the information to be updated is a component class name, update the component class name in the process file to the component class name corresponding to the current component version;

[0017] If the information to be updated is a component attribute, determine the attribute modification content, and update the component attribute of the process file based on the attribute modification content. The attribute modification content includes at least one of component attribute reduction, component attribute addition, and component attribute renaming.

[0018] According to a version compatibility method for an RPA system provided by the present invention, when the designer version of the RPA system changes, the object to be updated is a designer-core library mapping relationship, the current version is the current designer version of the RPA system, and the designer-core library mapping relationship is used to record the designer version and the core library version compatible with the designer version;

[0019] The step of updating the object to be updated based on the current version includes:

[0020] Obtain the target core library version that is compatible with the current designer version;

[0021] The designer-core library mapping relationship is updated based on the current designer version and the target core library version.

[0022] According to a version compatibility method for an RPA system provided by the present invention, the step of updating the designer-core library mapping relationship based on the current designer version and the target core library version further includes:

[0023] Send the updated designer-core library mapping to the capability center.

[0024] When a new component needs to be downloaded on the designer side, determine the component class name and component version of the component to be downloaded;

[0025] The component class name of the component to be downloaded, the component version of the component to be downloaded, and the current designer version are sent to the capability center so that the capability center can perform compatibility verification between the current designer version and the component version of the component to be downloaded.

[0026] If the verification at the capability center is successful, the component to be downloaded sent by the capability center shall be received.

[0027] If the verification fails at the capability center, receive the verification failure information sent by the capability center.

[0028] According to a version compatibility method for an RPA system provided by the present invention, when the designer version of the RPA system changes, the object to be updated is a process file, the current version is the current designer version of the RPA system, and the process file is used to record the executor version of the process.

[0029] The step of updating the object to be updated based on the current version includes:

[0030] Based on the current designer version, determine the current executor version;

[0031] Update the executor version of the process file to the current executor version.

[0032] This invention also provides a version compatibility method for an RPA system, applied to a capability center, the method comprising:

[0033] The designer-core library mapping relationship sent by the designer terminal is received. The designer-core library mapping relationship is used to record the designer version and the core library version compatible with the designer version.

[0034] Obtain the component-core library mapping relationship, which is used to record the component versions of multiple components and the core library versions that are compatible with the component versions of multiple components;

[0035] Based on the designer-core library mapping relationship and the component-core library mapping relationship, the designer-component mapping relationship is determined. The designer-component mapping relationship is used to record the designer version and the component class names and component versions that are compatible with the designer version. The designer-component mapping relationship is used to perform compatibility verification on the designer version and component version.

[0036] According to a version compatibility method for an RPA system provided by the present invention, the step of determining the designer-component mapping relationship based on the designer-core library mapping relationship and the component-core library mapping relationship further includes:

[0037] Receive the component class name of the component to be downloaded, the component version of the component to be downloaded, and the current designer version of the RPA system sent by the designer.

[0038] Based on the designer-component mapping relationship, the component class name of the component to be downloaded, the component version of the component to be downloaded, and the current designer version, a compatibility check is performed on the current designer version and the component version of the component to be downloaded;

[0039] If the verification is successful, the component to be downloaded is sent to the designer.

[0040] If the verification fails, a verification failure message is sent to the designer.

[0041] A version compatibility method for an RPA system provided by the present invention further includes:

[0042] Obtain the newly developed component and determine its core library version, component class name, and component version;

[0043] The component-core library mapping relationship is updated based on the core library version of the newly developed component, the component class name of the newly developed component, and the component version of the newly developed component.

[0044] The present invention also provides a version compatibility device for an RPA system, deployed on the designer side, the device comprising:

[0045] The first determining module is used to determine the object to be updated and the current version of the RPA system when the version of the Robotic Process Automation (RPA) system changes.

[0046] The update module is used to update the object to be updated based on the current version;

[0047] The changes in the RPA system version include at least one change in the RPA system components, designer version, or core library.

[0048] The present invention also provides a version compatibility device for an RPA system, deployed at a capability center, the device comprising:

[0049] The receiving module is used to receive the designer-core library mapping relationship sent by the designer end. The designer-core library mapping relationship is used to record the designer version and the core library version compatible with the designer version.

[0050] The first acquisition module is used to acquire the component-core library mapping relationship, wherein the component-core library mapping relationship is used to record the component versions of multiple components and the core library versions that the component versions of multiple components are compatible with;

[0051] The second determining module is used to determine the designer-component mapping relationship based on the designer-core library mapping relationship and the component-core library mapping relationship. The designer-component mapping relationship is used to record the designer version and the component class names and component versions that are compatible with the designer version. The designer-component mapping relationship is used to perform compatibility verification on the designer version and the component version.

[0052] The present invention also provides a version compatibility device for an RPA system, deployed on a client side, the device comprising:

[0053] The third determining module is used to determine the target process file to be executed, and the executor version indicated by the target process file;

[0054] The second acquisition module is used to acquire the target executor corresponding to the executor version from the control center, wherein the control center stores multiple versions of executors.

[0055] The execution module is used to execute the target process file based on the target executor.

[0056] The present invention also provides an electronic device, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the program to implement a version compatibility method for any of the RPA systems described above.

[0057] The present invention also provides a non-transitory computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements a version compatibility method for any of the RPA systems described above.

[0058] The present invention provides a method, apparatus, electronic device, and storage medium for RPA system version compatibility. When the RPA system version changes, it determines the object to be updated and the current version of the RPA system; based on the current version, it updates the object to be updated. Through this method, when the RPA system version changes, only the object to be updated needs to be updated, eliminating the need to store multiple versions of the RPA system. Version compatibility can be automatically achieved. Furthermore, changes to the RPA system version include at least one change in RPA system components, designer version, or core library, thus covering version compatibility at all stages of the process and achieving comprehensive version compatibility. Attached Figure Description

[0059] To more clearly illustrate the technical solutions in this invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of this invention. For those skilled in the art, other drawings can be obtained from these drawings without creative effort.

[0060] Figure 1 This is one of the flowcharts illustrating the version compatibility method of the RPA system provided by the present invention;

[0061] Figure 2 This is one of the structural schematic diagrams of the RPA system provided by the present invention;

[0062] Figure 3 This is the second schematic diagram of the RPA system provided by the present invention;

[0063] Figure 4 The second flowchart illustrates the version compatibility method of the RPA system provided by this invention.

[0064] Figure 5 The third flowchart illustrates the version compatibility method for the RPA system provided by this invention.

[0065] Figure 6 One of the structural schematic diagrams of the version compatibility device of the RPA system provided by the present invention;

[0066] Figure 7 A second schematic diagram of the structure of the version compatibility device for the RPA system provided by the present invention;

[0067] Figure 8 The third schematic diagram of the structure of the version compatibility device for the RPA system provided by the present invention;

[0068] Figure 9 This is a schematic diagram of the structure of the electronic device provided by the present invention. Detailed Implementation

[0069] To make the objectives, technical solutions, and advantages of this invention clearer, the technical solutions of this invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some, not all, of the embodiments of this invention. All other embodiments obtained by those skilled in the art based on the embodiments of this invention without creative effort are within the scope of protection of this invention.

[0070] Robotic Process Automation (RPA) automates user operations by simulating end-user actions within a software system, based on technologies such as interface recognition, browser operation, and AI capabilities. For RPA systems developed as products, multiple versions of designers, clients, executors, and components are generated during their iterative updates. Inflexible adaptation between these different versions of modules is difficult, easily leading to compatibility issues; for example, older versions of components may not be usable in a newer version of the designer. Therefore, a version compatibility solution is needed to address the backward compatibility problem of RPA systems.

[0071] Currently, most systems store multiple versions of the executor in the client to address compatibility issues. However, storing multiple executor versions in the client's memory requires hardware development, increasing development costs. It necessitates creating the hardware to store multiple executor versions, adding hardware development work to the RPA system development process, further increasing development costs. Furthermore, requiring each executor version to be installed on the client leads to a linear increase in client storage space with each version update. In long-term RPA system maintenance, this results in excessive client space usage, and not all executor versions are used, thus wasting storage space. Moreover, when an executor version is updated, the updated executor needs to be added to each client. With a large number of clients, adding drivers to each client for every executor update incurs significant maintenance costs, contradicting the cost reduction and efficiency improvement goals of RPA systems. Finally, storing multiple executor versions in the client's memory only solves compatibility issues during the process execution phase, not during the process opening or editing phases, i.e., it fails to address compatibility issues related to designer and component version updates. Therefore, achieving full version compatibility for RPA systems is a pressing issue that needs to be addressed.

[0072] To address the above problems, the present invention proposes the following embodiments. Figure 1 This is one of the flowcharts illustrating the version compatibility method of the RPA system provided by the present invention, such as... Figure 1 As shown, the version compatibility method of this RPA system is applied to the designer side. The version compatibility method of this RPA system includes:

[0073] Step 110: When the version of the Robotic Process Automation (RPA) system changes, determine the object to be updated and the current version of the RPA system.

[0074] Here, an RPA (Robotic Process Automation) system includes a designer, a control center, and a client. For example... Figure 2As shown, the designer 101 is responsible for developing the design process. Based on technologies such as interface recognition, browser operation, and AI capabilities, it encapsulates multiple components that implement specific functions (such as desktop element selection, opening / closing the browser, and OCR text recognition). These components are combined according to the user's required operations to generate an automated process that can complete the target function. The control center 102 is used for centralized management of the process, designer, and client, managing the uploading and distribution of processes, as well as the registration and activation of the designer and client. The client 103 is responsible for receiving and executing processes. It receives process information from the control center, executes the process using the built-in executor 104, and then reports the process status and output to the control center.

[0075] It should be noted that RPA systems are primarily used for generating and executing processes. A process is composed of multiple components combined according to specific logic to achieve the user's target functionality. In one embodiment, a process can be represented by a process file, which records component information, including the component class name and attribute information. In one embodiment, the process file can be an XML file.

[0076] Here, the object to be updated refers to the object that needs to be updated. When the components of the RPA system change, the object to be updated is the process file; when the designer version of the RPA system changes, the object to be updated is the designer-core library mapping relationship; when the core library of the RPA system changes, the objects to be updated are the designer-core library mapping relationship and the component-core library mapping relationship.

[0077] Here, the current version of the RPA system refers to the latest version of the RPA system. When the components of the RPA system change, the current version refers to the current version of the current component; when the designer version of the RPA system changes, the current version refers to the current version of the current designer; when the core library of the RPA system changes, the current version refers to the current version of the current core library.

[0078] Step 120: Update the object to be updated based on the current version.

[0079] The changes in the RPA system version include at least one change in the RPA system components, designer version, or core library.

[0080] Here, components are encapsulations of specific operations based on certain technologies, such as Excel operation components encapsulated based on Office automation technology, browser operation components encapsulated based on browser automation technology, and OCR text recognition components encapsulated based on AI technology.

[0081] It should be noted that changes to a component can be caused by changes in the component version or changes in the designer version.

[0082] To facilitate understanding, the relationships between the designer, components, core libraries, and processes are explained in the following reference. Figure 3 Designer 201 is responsible for developing the design process, which is assembled into a workflow by dragging and dropping components. Some functions of the designer rely on core library 203 for implementation. For example, the web page data retrieval 202 of designer 201 interacts with the element selection module 204 in core library 203 to obtain target data from browser 207. Core library 203 contains underlying methods such as element selection and designer-component interaction. The role of core library 203 is to provide element selection functionality and support the interaction between designer and components. The element selection module 204 can communicate with browser 207 to obtain data. The element selection module 204 provides an open element selection interface for the web page data capture module in the designer and the Web automation component in process 205 to call and implement their respective functions. Process 205 is composed of multiple components combined according to fixed logic. Its corresponding process file records the component information used, including component class name and component attributes. The process file can run on the designer 201 and the executor to realize business automation functions. Some components depend on the core library to implement their functions, such as Web automation component 206, which depends on element selection module 204. It should be noted that the architecture of the designer and the executor is similar, and the executor will not be described in detail here.

[0083] It should be noted that the components in the workflow and the designer rely on relevant modules of the core library to implement the required functions. The designer only saves the core library matched to that designer, and the components will execute functions based on that core library. The designer reads the workflow content, obtains its component attributes and logical order, and then performs workflow display, editing, and debugging.

[0084] Specifically, based on the current version, the objects to be updated are updated so that the current version of the RPA system is compatible with components, designers, core libraries, etc. from previous versions.

[0085] The version compatibility method for RPA systems provided in this invention is applied to the designer side. When the RPA system version changes, it determines the object to be updated and the current version of the RPA system; based on the current version, it updates the object to be updated. Through this method, when the RPA system version changes, only the object to be updated needs to be updated, eliminating the need to store multiple versions of the RPA system. Version compatibility can be automatically achieved. Furthermore, changes to the RPA system version include at least one change in RPA system components, designer version, or core library, thus covering version compatibility at all stages of the process and achieving comprehensive version compatibility.

[0086] Based on the above embodiments, considering that the designer cannot open an old version of the process using a new version of the component, for example, when the component information in the new version of the designer does not match the component information in the process file content, it may cause the process to fail to open, i.e., the process file to fail to open. Therefore, when the components of the RPA system change, the object to be updated is the process file, the current version is the current component version of the RPA system, and the process file is used to record the component information of the components used in the process; the above step 120 includes:

[0087] Obtain component update information of the RPA system, the component update information including update information between the component version of the process file and the current component version;

[0088] Based on the component update information, the component information of the process file is updated.

[0089] Here, component update information is used to record updates made during component upgrades, specifically updates from the component version in the process file to the current component version. This component update information includes modifications to the component class name and / or component properties during the component update.

[0090] Here, component information includes the component class name and component properties. In one embodiment, both the component class name and component properties may change.

[0091] Specifically, when the component update information includes a modification to the component class name, the component class name in the process file is updated; when the component update information includes a modification to the component attributes, the component attributes in the process file are updated. After updating the component information in the process file, the process is opened based on the updated process file.

[0092] In one embodiment, a process file upgrade module is added to the designer to update the component information of the process file.

[0093] In one specific embodiment, a process file is obtained; the component version of the process file is determined, and the component version in the designer is determined; the component version of the process file is compared with the component version in the designer; if the versions match, there is no need to update the component information of the process file, and the process file is opened directly; if the versions do not match, the component update information of the RPA system is obtained to update the component information of the process file.

[0094] The process file can be obtained in the following way: determine the process file path under the process project passed to the designer; obtain the process file based on the process file path.

[0095] The version compatibility method for RPA systems provided in this invention updates the component information of the process file when the components of the RPA system change, so that the components used in the process file match the components in the designer, thereby ensuring that the designer can open all old version processes, that is, the designer can use the new version components to open the old version processes, providing support for version compatibility in the process opening stage.

[0096] Based on any of the above embodiments, the component information of the process file includes component class names and component attributes. Updating the component information of the process file based on the component update information includes:

[0097] Based on the component update information, determine the information to be updated;

[0098] If the information to be updated is a component class name, update the component class name in the process file to the component class name corresponding to the current component version;

[0099] If the information to be updated is a component attribute, determine the attribute modification content, and update the component attribute of the process file based on the attribute modification content. The attribute modification content includes at least one of component attribute reduction, component attribute addition, and component attribute renaming.

[0100] Here, the information to be updated includes the component class name and / or component properties.

[0101] Here, the component class name is the basis for the designer to locate the component. Considering that if the component class name is modified, the designer will be unable to locate the component in the old version of the process, it is necessary to update the component class name in the process file to the component class name corresponding to the current component version. That is, find the corresponding component class name in the old version of the process file and modify it to the new component class name.

[0102] Here, component properties are the inputs and outputs required for component display and execution. Considering that modifying component properties may prevent the designer from displaying and running components from older versions of the workflow, it is necessary to determine the content to be modified and update the component properties in the workflow file accordingly.

[0103] In one embodiment, considering that there may be redundant component attributes during the early design of components, the designer may fail to display components because the component attributes recorded in the old version of the process file cannot be found in the new version of the component. Based on this, it is determined that the attribute modification content is the reduction of component attributes, and the component attributes of the process file are updated based on the attribute modification content of the reduced component attributes. That is, the component attributes of the target component in the old version of the process file are deleted. In the process file content, the component position is located according to the component class name, and then the corresponding component attributes in the component record are deleted.

[0104] In one embodiment, considering that during the iteration of the RPA system, component functionality may be required to be optimized due to changes in requirements, which may necessitate the addition of component attributes, the attribute modification content is determined to be the addition of component attributes. Based on the attribute modification content of the added component attributes, the component attributes of the process file are updated, that is, the component attributes of the target component in the old version of the process file are added. In the process file content, the component position is located according to the component class name, and then the corresponding component in the component record is added with component attributes.

[0105] If the added component attribute is not a required field, there is no need to update the component attribute in the process file; if the added component attribute is a required field, the component position needs to be located in the process file, and then the component attribute needs to be added and its default value set.

[0106] In one embodiment, considering that component attribute naming may be non-standard during the early design of components, such as unclear naming descriptions or non-standard formats, the attribute modification content is determined to be the renaming of component attributes. Based on the attribute modification content of the renaming of component attributes, the component attributes of the process file are updated. That is, the component attribute name of the target component in the old version of the process file is modified. In the process file content, the component position is located according to the component class name, and then the old component attribute name is changed to the new component attribute.

[0107] The version compatibility method for RPA systems provided in this invention updates the component class name and / or component attributes of the process file when the component class name and / or component attributes change, ensuring that the components used in the process file match the components in the designer. This guarantees that the designer can open all old version processes, meaning the designer can use the new version components to open old version processes, providing support for version compatibility during the process opening phase. Furthermore, the attribute modification content includes at least one of component attribute reduction, component attribute addition, and component attribute renaming, thus covering component attribute changes in various situations and achieving comprehensive version compatibility.

[0108] Based on any of the above embodiments, considering that during the editing process, the designer can download components and add them to the process, but because the designer may be incompatible with some components, the process may become unusable after adding components, therefore, when the designer version of the RPA system changes, the object to be updated is the designer-core library mapping relationship, the current version is the current designer version of the RPA system, and the designer-core library mapping relationship is used to record the designer version and the core library versions compatible with the designer version; the above step 120 includes:

[0109] Obtain the target core library version that is compatible with the current designer version;

[0110] The designer-core library mapping relationship is updated based on the current designer version and the target core library version.

[0111] Specifically, after upgrading the designer version, the designer developers need to determine the target core library version that is compatible with the current designer version, so that the execution subject of the method provided in this embodiment of the invention can obtain the target core library version that is compatible with the current designer version.

[0112] Here, the designer-core library mapping relationship can be represented by a designer-core library mapping relationship table. This designer-core library mapping relationship is also used to generate the designer-component mapping relationship. Specifically, when a new component needs to be downloaded on the designer side, the component class name and component version of the component to be downloaded are determined; based on the designer-component mapping relationship, the component class name of the component to be downloaded, the component version of the component to be downloaded, and the current designer version, a compatibility check is performed between the current designer version and the component version of the component to be downloaded; if the check is successful, the component to be downloaded is downloaded to the designer side; if the check fails, the component to be downloaded is not downloaded to the designer side.

[0113] The version compatibility method for RPA systems provided in this invention updates the designer-core library mapping relationship when the designer version of the RPA system changes. This ensures that subsequent compatibility checks are performed based on the updated designer-core library mapping relationship, guaranteeing that all components used by the designer can run correctly. Consequently, it ensures that the process in the designer can be edited correctly, providing support for version compatibility during the process editing stage.

[0114] Based on any of the above embodiments, the method further includes, after updating the designer-core library mapping relationship based on the current designer version and the target core library version:

[0115] Send the updated designer-core library mapping to the capability center.

[0116] When a new component needs to be downloaded on the designer side, determine the component class name and component version of the component to be downloaded;

[0117] The component class name of the component to be downloaded, the component version of the component to be downloaded, and the current designer version are sent to the capability center so that the capability center can perform compatibility verification between the current designer version and the component version of the component to be downloaded.

[0118] If the verification at the capability center is successful, the component to be downloaded sent by the capability center shall be received.

[0119] If the verification fails at the capability center, receive the verification failure information sent by the capability center.

[0120] To support the designer's component download and compatibility verification functions, a new endpoint, the Capability Center endpoint, needs to be added to the RPA system. The Capability Center endpoint stores the component versions and mapping relationship tables for the designer and executor to download components, and provides a component compatibility verification interface.

[0121] It should be noted that the key to whether a component is compatible with the designer lies in whether the core libraries used are consistent. Based on this, the designer-component mapping relationship can be formed by combining the component-core library mapping relationship and the designer-core library mapping relationship, thereby performing designer-component compatibility verification.

[0122] The component-core library mapping relationship is used to record the component versions of multiple components and the core library versions that the component versions of multiple components are compatible with; the designer-component mapping relationship is used to record the designer version and the component class names and component versions that the designer version is compatible with.

[0123] The version compatibility method for RPA systems provided in this embodiment of the invention sends the updated designer-core library mapping relationship to the capability center when the designer version of the RPA system changes. This allows the capability center to perform compatibility verification based on the updated designer-core library mapping relationship, ensuring that all components used by the designer can run correctly. This, in turn, ensures that the process in the designer can be edited correctly, providing support for version compatibility during the process editing stage.

[0124] Based on any of the above embodiments, considering that the processes running on the client may be designed by different versions of designers, and therefore the executors required for these processes are also different, if the same version of the executor is used to execute the process, the process execution may fail due to the incompatibility between the components used and the executor. Therefore, when the designer version of the RPA system changes, the object to be updated is the process file, the current version is the current designer version of the RPA system, and the process file is used to record the executor version of the process; step 120 above includes:

[0125] Based on the current designer version, determine the current executor version;

[0126] Update the executor version of the process file to the current executor version.

[0127] Here, each version of the designer corresponds to a corresponding version of the executor. Therefore, based on the current designer version, the corresponding current executor version can be determined. This current executor version can be identified by its version number.

[0128] In one specific embodiment, when the designer publishes the process, the executor version of the process file is synchronously updated to the current executor version.

[0129] It should be noted that after the designer publishes the process, the client can receive the process file, which allows the client to parse the process file to obtain the executor version corresponding to the process file. Then, the client obtains the target executor corresponding to the executor version from the control center, and then the client automatically switches to the target executor.

[0130] Furthermore, it's important to note that the control center stores all historical versions of the executor, and clients retrieve executors from the control center as needed. To ensure backward compatibility, clients need to be able to switch to multiple executor versions. Storing all versions of the executor on the client would cause the client's storage space to increase linearly with each version update, significantly impacting long-term product development and maintenance. Therefore, storing all executor versions on the control center and allowing clients to retrieve executors as needed based on the version recorded in the process file ensures compatibility while reducing client storage space.

[0131] The version compatibility method for RPA systems provided in this embodiment of the invention determines the current executor version based on the current designer version when the designer version of the RPA system changes, and then updates the executor version of the process file to the current executor version, so that the process file is executed by the executor corresponding to the current executor version, ensuring the successful execution of the process and providing support for version compatibility in the process execution stage.

[0132] Figure 4 This is the second flowchart illustrating the version compatibility method for the RPA system provided by the present invention, as shown below. Figure 4 As shown, the version compatibility method of this RPA system is applied to the capability center end. The version compatibility method of this RPA system includes:

[0133] Step 410: Receive the designer-core library mapping relationship sent by the designer end. The designer-core library mapping relationship is used to record the designer version and the core library version compatible with the designer version.

[0134] Step 420: Obtain the component-core library mapping relationship. The component-core library mapping relationship is used to record the component versions of multiple components and the core library versions that are compatible with the component versions of multiple components.

[0135] Step 430: Based on the designer-core library mapping relationship and the component-core library mapping relationship, determine the designer-component mapping relationship. The designer-component mapping relationship is used to record the designer version and the component class names and component versions that are compatible with the designer version. The designer-component mapping relationship is used to perform compatibility verification on the designer version and component version.

[0136] Here, the capability center is used to store the mapping relationships between different versions of components, the designer-core library, and the component-core library, so that the designer and executor can download components. To support the designer's component download and compatibility verification functions, an additional endpoint, the capability center, needs to be added to the RPA system to provide a component compatibility verification interface.

[0137] It should be noted that the key to whether a component is compatible with the designer lies in whether the core libraries used are consistent. Based on this, the designer-component mapping relationship can be formed by combining the component-core library mapping relationship and the designer-core library mapping relationship, thereby performing designer-component compatibility verification.

[0138] Specifically, based on the versions of each core library in the designer-core library mapping relationship and the versions of each core library in the component-core library mapping relationship, the designer version in the designer-core library mapping relationship and the component class name and component version in the component-core library mapping relationship are combined to obtain the designer-component mapping relationship.

[0139] In one embodiment, when the designer-core library mapping is updated, the designer-component mapping needs to be updated synchronously. In another embodiment, when the component-core library mapping is updated, the designer-component mapping needs to be updated synchronously.

[0140] The version compatibility method for an RPA system provided in this invention is applied to the capability center. It receives a designer-core library mapping relationship from the designer, which records the designer version and compatible core library versions. It then obtains a component-core library mapping relationship, which records the component versions of multiple components and compatible core library versions. Based on the designer-core library and component-core library mapping relationships, it determines a designer-component mapping relationship, which records the designer version and compatible component class names and versions. This designer-component mapping relationship is used to perform compatibility checks on the designer and component versions. Through this method, on the capability center, the designer-component mapping relationship is determined based on the designer-core library and component-core library mapping relationships. Furthermore, compatibility checks on the designer and component versions are performed based on this designer-component mapping relationship, ensuring that all components used by the designer can run correctly, thereby ensuring that the workflow in the designer can be correctly edited, providing support for version compatibility during the workflow editing stage.

[0141] Based on any of the above embodiments, the method further includes the following after step 430:

[0142] Receive the component class name of the component to be downloaded, the component version of the component to be downloaded, and the current designer version of the RPA system sent by the designer.

[0143] Based on the designer-component mapping relationship, the component class name of the component to be downloaded, the component version of the component to be downloaded, and the current designer version, a compatibility check is performed on the current designer version and the component version of the component to be downloaded;

[0144] If the verification is successful, the component to be downloaded is sent to the designer.

[0145] If the verification fails, a verification failure message is sent to the designer.

[0146] Specifically, based on the component class name, component version, and current designer version of the component to be downloaded, the component class name and component version corresponding to the current designer version are determined in the designer-component mapping relationship. The designer version corresponding to the component class name and component version of the component to be downloaded is also determined, and then a compatibility check is performed on the current designer version and the component version of the component to be downloaded.

[0147] Specifically, if the verification is successful, the components to be downloaded stored in the capability center are sent to the designer. If the verification fails, a verification failure message is generated and sent to the designer.

[0148] The version compatibility method for RPA systems provided in this embodiment of the invention performs compatibility verification based on the updated designer-core library mapping relationship when the designer version of the RPA system changes, ensuring that all components used by the designer can run correctly, thereby ensuring that the process in the designer can be edited correctly, and providing support for version compatibility in the process editing stage.

[0149] Based on any of the above embodiments, the method further includes:

[0150] Obtain the newly developed component and determine its core library version, component class name, and component version;

[0151] The component-core library mapping relationship is updated based on the core library version of the newly developed component, the component class name of the newly developed component, and the component version of the newly developed component.

[0152] Here, the newly developed component refers to a new version of the component, in which the core library version, component class name, and component version have all been upgraded.

[0153] In one specific embodiment, after developing a component, the component developer uploads the newly developed component to the capability center. The capability center reads the core library version that the component depends on from its dependencies, and then updates the component-core library mapping relationship with the newly developed component and its dependent core library version.

[0154] The version compatibility method for RPA systems provided in this embodiment of the invention updates the component-core library mapping relationship based on the core library version, component class name, and component version of the newly developed component when developing a new component. This updates the designer-component mapping relationship, ensuring that all components used by the designer can run correctly, and thus ensuring that the process in the designer can be edited correctly, providing support for version compatibility in the process editing stage.

[0155] Figure 5 This is the third flowchart illustrating the version compatibility method for the RPA system provided by the present invention, as shown below. Figure 5 As shown, the version compatibility method of this RPA system is applied to the client, and the version compatibility method of this RPA system includes:

[0156] Step 510: Determine the target process file to be executed and the executor version indicated by the target process file. The target process file is used to record component information of the components used in the process and to record the executor version of the process.

[0157] Step 520: Obtain the target executor corresponding to the executor version from the control center. The control center stores multiple versions of executors.

[0158] Step 530: Execute the target process file based on the target executor.

[0159] It should be noted that after the designer publishes the process, the client can receive the process file, which allows the client to determine the target process file to be executed.

[0160] Specifically, the client determines the executor version indicated by the target process file by parsing the target process file.

[0161] Here, the control center stores the executors of each historical version, and the client obtains the executor from the control center as needed.

[0162] The version compatibility method for the RPA system provided in this invention requires the client to be able to switch to multiple versions of the executor to ensure backward compatibility. Storing all versions of the executor on the client would cause the client's storage space to increase linearly with each version update, significantly impacting long-term product development and maintenance. Therefore, the executor versions are stored at the control center. The client retrieves the executor as needed based on the version recorded in the process file, ensuring compatibility while reducing the client's storage space. This achieves both process file compatibility and a lightweight client design.

[0163] In practical applications, the embodiments provided by this invention can be applied to various RPA systems, achieving backward compatibility of RPA systems and bringing significant benefits to RPA system development, operation and maintenance, saving manpower and expenses in operation and maintenance, and reducing the error rate of version compatibility management.

[0164] The version compatibility device for the RPA system provided by the present invention is described below. The version compatibility device for the RPA system described below and the version compatibility method for the RPA system described above can be referred to in correspondence.

[0165] Figure 6 This is one of the structural schematic diagrams of the version compatibility device for the RPA system provided by the present invention, such as... Figure 6 As shown, the version compatibility device of this RPA system is deployed on the designer side, and the version compatibility device of this RPA system includes:

[0166] The first determining module 610 is used to determine the object to be updated and the current version of the RPA system when the version of the Robotic Process Automation (RPA) system changes.

[0167] The update module 620 is used to update the object to be updated based on the current version;

[0168] The changes in the RPA system version include at least one change in the RPA system components, designer version, or core library.

[0169] The version compatibility device for RPA systems provided in this embodiment of the invention is deployed on the designer side. When the RPA system version changes, it determines the object to be updated and the current version of the RPA system; based on the current version, it updates the object to be updated. Through this method, when the RPA system version changes, only the object to be updated needs to be updated, eliminating the need to store multiple versions of the RPA system. Version compatibility can be automatically achieved. Furthermore, changes to the RPA system version include at least one change in RPA system components, designer version, or core library, thus covering version compatibility at all stages of the process and achieving comprehensive version compatibility.

[0170] Based on any of the above embodiments, when the components of the RPA system change, the object to be updated is a process file, the current version is the current component version of the RPA system, and the process file is used to record component information of the components used in the process; the update module 620 includes:

[0171] An information acquisition unit is used to acquire component update information of the RPA system, wherein the component update information includes update information between the component version of the process file and the current component version;

[0172] The information update unit is used to update the component information of the process file based on the component update information.

[0173] Based on any of the above embodiments, the component information of the process file includes component class names and component attributes; the information update unit is further configured to:

[0174] Based on the component update information, determine the information to be updated;

[0175] If the information to be updated is a component class name, update the component class name in the process file to the component class name corresponding to the current component version;

[0176] If the information to be updated is a component attribute, determine the attribute modification content, and update the component attribute of the process file based on the attribute modification content. The attribute modification content includes at least one of component attribute reduction, component attribute addition, and component attribute renaming.

[0177] Based on any of the above embodiments, when the designer version of the RPA system changes, the object to be updated is the designer-core library mapping relationship, the current version is the current designer version of the RPA system, and the designer-core library mapping relationship is used to record the designer version and the core library versions compatible with the designer version; the update module 620 includes:

[0178] The version acquisition unit is used to acquire the target core library version that is compatible with the current designer version;

[0179] The relationship update unit is used to update the designer-core library mapping relationship based on the current designer version and the target core library version.

[0180] Based on any of the above embodiments, the update module 620 further includes:

[0181] The relationship sending unit is used to send the updated designer-core library mapping relationship to the capability center.

[0182] The class name determination unit is used to determine the component class name and component version of the component to be downloaded when a new component needs to be downloaded on the designer side;

[0183] The class name sending unit is used to send the component class name of the component to be downloaded, the component version of the component to be downloaded, and the current designer version to the capability center, so that the capability center can perform compatibility verification between the current designer version and the component version of the component to be downloaded.

[0184] The component receiving unit is configured to receive the component to be downloaded sent by the capability center when the verification at the capability center is successful.

[0185] The information receiving unit is used to receive verification failure information sent by the capability center when the verification fails at the capability center.

[0186] Based on any of the above embodiments, when the designer version of the RPA system changes, the object to be updated is a process file, the current version is the current designer version of the RPA system, and the process file is used to record the executor version of the process; the update module 620 includes:

[0187] The version determination unit is used to determine the current executor version based on the current designer version;

[0188] The version update unit is used to update the executor version of the process file to the current executor version.

[0189] Figure 7 This is a second schematic diagram of the structure of the version compatibility device for the RPA system provided by the present invention, as shown below. Figure 7 As shown, the version compatibility device of this RPA system is deployed at the capability center. The version compatibility device of this RPA system includes:

[0190] The receiving module 710 is used to receive the designer-core library mapping relationship sent by the designer end. The designer-core library mapping relationship is used to record the designer version and the core library version compatible with the designer version.

[0191] The first acquisition module 720 is used to acquire the component-core library mapping relationship, wherein the component-core library mapping relationship is used to record the component versions of multiple components and the core library versions that are compatible with the component versions of multiple components;

[0192] The second determining module 730 is used to determine the designer-component mapping relationship based on the designer-core library mapping relationship and the component-core library mapping relationship. The designer-component mapping relationship is used to record the designer version and the component class names and component versions that are compatible with the designer version. The designer-component mapping relationship is used to perform compatibility verification on the designer version and the component version.

[0193] The version compatibility device of the RPA system provided in this embodiment of the invention is deployed at the capability center. It receives the designer-core library mapping relationship sent by the designer, which records the designer version and compatible core library versions. It then obtains the component-core library mapping relationship, which records the component versions of multiple components and compatible core library versions. Based on the designer-core library mapping relationship and the component-core library mapping relationship, it determines the designer-component mapping relationship. This designer-component mapping relationship records the designer version and compatible component class names and versions, and is used to perform compatibility checks on the designer version and component versions. Through this method, at the capability center, the designer-component mapping relationship is determined based on the designer-core library mapping relationship and the component-core library mapping relationship. Furthermore, compatibility checks on the designer version and component versions are performed based on the designer-component mapping relationship, ensuring that all components used by the designer can run correctly, thereby ensuring that the process in the designer can be correctly edited, providing support for version compatibility during the process editing stage.

[0194] Based on any of the above embodiments, the device further includes:

[0195] The class name receiving module is used to receive the component class name of the component to be downloaded, the component version of the component to be downloaded, and the current designer version of the RPA system sent by the designer end;

[0196] The compatibility verification module is used to perform compatibility verification between the current designer version and the component version of the component to be downloaded, based on the designer-component mapping relationship, the component class name of the component to be downloaded, the component version of the component to be downloaded, and the current designer version.

[0197] The component sending module is used to send the component to be downloaded to the designer terminal if the verification is successful;

[0198] The information sending module is used to send a verification failure message to the designer terminal in the event of a verification failure.

[0199] Based on any of the above embodiments, the device further includes:

[0200] The component acquisition module is used to acquire newly developed components and determine the core library version, component class name, and component version of the newly developed components;

[0201] The relationship update module is used to update the component-core library mapping relationship based on the core library version of the newly developed component, the component class name of the newly developed component, and the component version of the newly developed component.

[0202] Figure 8 This is the third schematic diagram of the structure of the version compatibility device for the RPA system provided by the present invention, as shown in Figure 3. Figure 8 As shown, the version compatibility device of this RPA system is deployed on the client side, and the version compatibility device of this RPA system includes:

[0203] The third determining module 810 is used to determine the target process file to be executed, and the executor version indicated by the target process file;

[0204] The second acquisition module 820 is used to acquire the target executor corresponding to the executor version from the control center terminal, wherein the control center terminal stores multiple versions of executors.

[0205] The execution module 830 is used to execute the target process file based on the target executor.

[0206] The version compatibility device for the RPA system provided in this embodiment of the invention requires the client to be able to switch to multiple versions of the executor in order to ensure backward compatibility. If all versions of the executor are stored in the client, the client's space usage will increase linearly with each version update, which will have a significant impact on long-term product development and maintenance. Therefore, the executor versions are stored in the control center. The client obtains the executor as needed according to the executor version recorded in the process file, which ensures compatibility while reducing the client's space usage. This achieves both client compatibility with process files and a lightweight client design.

[0207] Figure 9 An example is a schematic diagram of the physical structure of an electronic device, such as... Figure 9 As shown, the electronic device may include a processor 910, a communications interface 920, a memory 930, and a communication bus 940, wherein the processor 910, the communications interface 920, and the memory 930 communicate with each other via the communication bus 940. The processor 910 can call logical instructions in the memory 930 to execute a version compatibility method for the RPA system applied to the designer. This method includes: when the version of the Robotic Process Automation (RPA) system changes, determining the object to be updated and the current version of the RPA system; updating the object to be updated based on the current version; wherein the change in the RPA system version includes at least one change in the RPA system components or the designer version. Alternatively, a version compatibility method for the RPA system applied to the capability center can be executed. This method includes: receiving a designer-core library mapping relationship sent by the designer, wherein the designer-core library mapping relationship is used to record the designer version and the core library versions compatible with the designer version; obtaining a component-core library mapping relationship, wherein the component-core library mapping relationship is used to record the component versions of multiple components and the core library versions compatible with the component versions of multiple components; and determining a designer-component mapping relationship based on the designer-core library mapping relationship and the component-core library mapping relationship, wherein the designer-component mapping relationship is used to record the designer version and the component class names and component versions compatible with the designer version, and the designer-component mapping relationship is used to perform compatibility verification on the designer version and the component version. Alternatively, a version compatibility method for an RPA system applied to a client can be implemented. This method includes: determining a target process file to be executed, and an executor version indicated by the target process file, wherein the target process file is used to record component information of the components used in the process, and to record the executor version of the process; obtaining a target executor corresponding to the executor version from a control center, wherein the control center stores multiple versions of executors; and executing the target process file based on the target executor.

[0208] Furthermore, the logical instructions in the aforementioned memory 430 can be implemented as software functional units and, when sold or used as independent products, can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present invention, essentially, or the part that contributes to the prior art, or a part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of the present invention. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0209] On the other hand, the present invention also provides a computer program product, which includes a computer program that can be stored on a non-transitory computer-readable storage medium. When the computer program is executed by a processor, the computer is able to execute the version compatibility method for an RPA system applied to the designer end provided by the above methods. The method includes: when the version of the Robotic Process Automation (RPA) system changes, determining the object to be updated and the current version of the RPA system; updating the object to be updated based on the current version; wherein the change in the version of the RPA system includes at least one change in the components of the RPA system or the designer version. Alternatively, the computer can execute the version compatibility method for the RPA system applied to the capability center provided by the above methods. This method includes: receiving a designer-core library mapping relationship sent by the designer, wherein the designer-core library mapping relationship is used to record the designer version and the core library versions compatible with the designer version; obtaining a component-core library mapping relationship, wherein the component-core library mapping relationship is used to record the component versions of multiple components and the core library versions compatible with the component versions of multiple components; and determining a designer-component mapping relationship based on the designer-core library mapping relationship and the component-core library mapping relationship, wherein the designer-component mapping relationship is used to record the designer version and the component class names and component versions compatible with the designer version, and the designer-component mapping relationship is used to perform compatibility verification on the designer version and component versions. Alternatively, the computer can execute the version compatibility method for the RPA system applied to the client provided by the above methods. The method includes: determining the target process file to be executed, and the executor version indicated by the target process file, wherein the target process file is used to record component information of the components used in the process, and to record the executor version of the process; obtaining the target executor corresponding to the executor version from the control center, wherein the control center stores multiple versions of executors; and executing the target process file based on the target executor.

[0210] In another aspect, the present invention also provides a non-transitory computer-readable storage medium storing a computer program thereon, which, when executed by a processor, is implemented to perform the version compatibility method for an RPA system applied to the designer end provided by the above methods. The method includes: when the version of the Robotic Process Automation (RPA) system changes, determining the object to be updated and the current version of the RPA system; updating the object to be updated based on the current version; wherein the change in the version of the RPA system includes at least one change in the components of the RPA system or the designer version. Alternatively, when a computer program is executed by a processor, it implements a version compatibility method for an RPA system applied to a capability center, as provided by the methods described above. This method includes: receiving a designer-core library mapping relationship sent by a designer, wherein the designer-core library mapping relationship records the designer version and core library versions compatible with the designer version; obtaining a component-core library mapping relationship, wherein the component-core library mapping relationship records the component versions of multiple components and core library versions compatible with the component versions of the multiple components; and determining a designer-component mapping relationship based on the designer-core library mapping relationship and the component-core library mapping relationship, wherein the designer-component mapping relationship records the designer version and component class names and component versions compatible with the designer version, and the designer-component mapping relationship is used to perform compatibility checks on the designer version and component versions. Alternatively, when a computer program is executed by a processor, it implements a version compatibility method for an RPA system applied to a client, as provided by the methods described above. This method includes: determining a target process file to be executed, and an executor version indicated by the target process file, wherein the target process file is used to record component information of the components used in the process, and to record the executor version of the process; obtaining a target executor corresponding to the executor version from a control center, wherein the control center stores multiple versions of executors; and executing the target process file based on the target executor.

[0211] The device embodiments described above are merely illustrative. The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the modules can be selected to achieve the purpose of this embodiment according to actual needs. Those skilled in the art can understand and implement this without any creative effort.

[0212] Through the above description of the embodiments, those skilled in the art can clearly understand that each embodiment can be implemented by means of software plus necessary general-purpose hardware platforms, and of course, it can also be implemented by hardware. Based on this understanding, the above technical solutions, in essence or the part that contributes to the prior art, can be embodied in the form of a software product. This computer software product can be stored in a computer-readable storage medium, such as ROM / RAM, magnetic disk, optical disk, etc., and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute the methods described in the various embodiments or some parts of the embodiments.

[0213] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, and not to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features; and these modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present invention.

Claims

1. A version compatibility method for an RPA system, characterized in that, Applied to the designer side, the method includes: When the version of the Robotic Process Automation (RPA) system changes, determine the object to be updated and the current version of the RPA system; Based on the current version, update the object to be updated; The changes in the RPA system version include at least one change in the RPA system components or the designer version; When the designer version of the RPA system changes, the object to be updated is the designer-core library mapping relationship, the current version is the current designer version of the RPA system, and the designer-core library mapping relationship is used to record the designer version and the core library version compatible with the designer version; The step of updating the object to be updated based on the current version includes: Obtain the target core library version that is compatible with the current designer version; The designer-core library mapping relationship is updated based on the current designer version and the target core library version.

2. The version compatibility method for the RPA system according to claim 1, characterized in that, When the components of the RPA system change, the object to be updated is the process file, the current version is the current component version of the RPA system, and the process file is used to record the component information of the components used in the process; The step of updating the object to be updated based on the current version includes: Obtain component update information of the RPA system, the component update information including update information between the component version of the process file and the current component version; Based on the component update information, the component information of the process file is updated.

3. The version compatibility method for the RPA system according to claim 2, characterized in that, The component information in the process file includes the component class name and component attributes; The step of updating the component information of the process file based on the component update information includes: Based on the component update information, determine the information to be updated; If the information to be updated is a component class name, update the component class name in the process file to the component class name corresponding to the current component version; If the information to be updated is a component attribute, determine the attribute modification content, and update the component attribute of the process file based on the attribute modification content. The attribute modification content includes at least one of component attribute reduction, component attribute addition, and component attribute renaming.

4. The version compatibility method for the RPA system according to claim 1, characterized in that, The process of updating the designer-core library mapping relationship based on the current designer version and the target core library version further includes: Send the updated designer-core library mapping to the capability center. When a new component needs to be downloaded on the designer side, determine the component class name and component version of the component to be downloaded; The component class name of the component to be downloaded, the component version of the component to be downloaded, and the current designer version are sent to the capability center so that the capability center can perform compatibility verification between the current designer version and the component version of the component to be downloaded. If the verification at the capability center is successful, the component to be downloaded sent by the capability center shall be received. If the verification fails at the capability center, receive the verification failure information sent by the capability center.

5. The version compatibility method for the RPA system according to claim 1, characterized in that, When the designer version of the RPA system changes, the object to be updated is the process file, the current version is the current designer version of the RPA system, and the process file is used to record the executor version of the process; The step of updating the object to be updated based on the current version includes: Based on the current designer version, determine the current executor version; Update the executor version of the process file to the current executor version.

6. A version compatibility method for an RPA system, characterized in that, Applied to the capability center, the method includes: The system receives a designer-core library mapping relationship sent by the designer end. The designer-core library mapping relationship is used to record the designer version and the core library version compatible with the designer version. The designer-core library mapping relationship is updated by the version compatibility method of the RPA system described in claim 1. Obtain the component-core library mapping relationship, which is used to record the component versions of multiple components and the core library versions that are compatible with the component versions of multiple components; Based on the designer-core library mapping relationship and the component-core library mapping relationship, the designer-component mapping relationship is determined. The designer-component mapping relationship is used to record the designer version and the component class names and component versions that are compatible with the designer version. The designer-component mapping relationship is used to perform compatibility verification on the designer version and component version.

7. The version compatibility method for an RPA system according to claim 6, characterized in that, The process of determining the designer-component mapping relationship based on the designer-core library mapping relationship and the component-core library mapping relationship further includes: Receive the component class name of the component to be downloaded, the component version of the component to be downloaded, and the current designer version of the RPA system sent by the designer. Based on the designer-component mapping relationship, the component class name of the component to be downloaded, the component version of the component to be downloaded, and the current designer version, a compatibility check is performed on the current designer version and the component version of the component to be downloaded. If the verification is successful, the component to be downloaded is sent to the designer. If the verification fails, a verification failure message is sent to the designer.

8. The version compatibility method for an RPA system according to claim 6, characterized in that, Also includes: Obtain the newly developed component and determine its core library version, component class name, and component version; The component-core library mapping relationship is updated based on the core library version of the newly developed component, the component class name of the newly developed component, and the component version of the newly developed component.

9. A version compatibility method for an RPA system, characterized in that, Applied to a client, the method includes: Determine the target process file to be executed, and the executor version indicated by the target process file, wherein the target process file is used to record component information of the components used in the process, and to record the executor version of the process; The target executor corresponding to the executor version is obtained from the control center, which stores multiple versions of executors. The target process file is executed based on the target executor; The capability center executes the following steps: The system receives a designer-core library mapping relationship sent by the designer end. The designer-core library mapping relationship is used to record the designer version and the core library version compatible with the designer version. The designer-core library mapping relationship is updated by the version compatibility method of the RPA system described in claim 1. Obtain the component-core library mapping relationship, which is used to record the component versions of multiple components and the core library versions that are compatible with the component versions of multiple components; Based on the designer-core library mapping relationship and the component-core library mapping relationship, the designer-component mapping relationship is determined. The designer-component mapping relationship is used to record the designer version and the component class names and component versions that are compatible with the designer version. The designer-component mapping relationship is used to perform compatibility verification on the designer version and component version.

10. A version compatibility device for an RPA system, characterized in that, Deployed at the designer end, the device includes: The first determining module is used to determine the object to be updated and the current version of the RPA system when the version of the Robotic Process Automation (RPA) system changes. The update module is used to update the object to be updated based on the current version; The changes in the RPA system version include changes in at least one of the RPA system components, designer version, and core library. When the designer version of the RPA system changes, the object to be updated is the designer-core library mapping relationship, the current version is the current designer version of the RPA system, and the designer-core library mapping relationship is used to record the designer version and the core library version compatible with the designer version; The step of updating the object to be updated based on the current version includes: Obtain the target core library version that is compatible with the current designer version; The designer-core library mapping relationship is updated based on the current designer version and the target core library version.

11. A version compatibility device for an RPA system, characterized in that, Deployed at the capability center, the device includes: A receiving module is used to receive a designer-core library mapping relationship sent by the designer end. The designer-core library mapping relationship is used to record the designer version and the core library version compatible with the designer version. The designer-core library mapping relationship is updated by the version compatibility method of the RPA system described in claim 1. The first acquisition module is used to acquire the component-core library mapping relationship, wherein the component-core library mapping relationship is used to record the component versions of multiple components and the core library versions that the component versions of multiple components are compatible with; The second determining module is used to determine the designer-component mapping relationship based on the designer-core library mapping relationship and the component-core library mapping relationship. The designer-component mapping relationship is used to record the designer version and the component class names and component versions that are compatible with the designer version. The designer-component mapping relationship is used to perform compatibility verification on the designer version and the component version.

12. A version compatibility device for an RPA system, characterized in that, Deployed on a client, the device includes: The third determining module is used to determine the target process file to be executed, and the executor version indicated by the target process file; The second acquisition module is used to acquire the target executor corresponding to the executor version from the control center, wherein the control center stores multiple versions of executors. The execution module is used to execute the target process file based on the target executor; The capability center executes the following steps: The system receives a designer-core library mapping relationship sent by the designer end. The designer-core library mapping relationship is used to record the designer version and the core library version compatible with the designer version. The designer-core library mapping relationship is updated by the version compatibility method of the RPA system described in claim 1. Obtain the component-core library mapping relationship, which is used to record the component versions of multiple components and the core library versions that are compatible with the component versions of multiple components; Based on the designer-core library mapping relationship and the component-core library mapping relationship, the designer-component mapping relationship is determined. The designer-component mapping relationship is used to record the designer version and the component class names and component versions that are compatible with the designer version. The designer-component mapping relationship is used to perform compatibility verification on the designer version and component version.

13. An electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that, When the processor executes the program, it implements the version compatibility method of the RPA system as described in any one of claims 1 to 9.

14. A non-transitory computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by the processor, it implements the version compatibility method of the RPA system as described in any one of claims 1 to 9.

Images