A B / S architecture cross-platform cross-terminal RPA designer system and implementation method

Abstract

The present invention provides a B / S architecture cross-platform and cross-terminal RPA designer system and implementation method, which relates to the field of information technology. The system includes a designer front-end and a designer back-end, both of which are deployed on the server side in the form of Docker containers. The front-end includes a node component area, a work canvas area, and a desktop real-time screen area. Nodes and components in the node component area are dragged to the work canvas area to design and arrange the RPA process robot, and the remote desktop real-time screen is displayed in the corresponding area of ​​the browser. The back-end provides technical support such as service calls, data calculations, logical processing, and node scheduling, and receives UI control elements sent by the Agent side and forwards them to the designer front-end. The Agent side runs in an execution device, receives the UI control elements picked up by the RPA picker, and sends them to the designer back-end. The present invention implements a B / S architecture that uses an RPA designer in a browser to design, develop, and arrange RPA process robots.

Description

Technical Field

[0001] The present invention relates to the field of information technology, and in particular to a B / S architecture cross-platform and cross-terminal RPA designer system and implementation method. Background Art

[0002] RPA, or Robotic Process Automation, primarily simulates and enhances human-computer interaction by invoking or simulating user interface (GUI) operations, leveraging low-code programming methods like visual drag-and-drop, and incorporating artificial intelligence technologies like OCR and NLP. This software solution executes rule-based, repetitive, and high-volume tasks. Also known as digital labor or digital employees, RPA is the intelligent software supporting digital development. It completes tasks previously performed only by humans, or serves as a supplement or replacement for labor in high-volume, repetitive, inefficient, low-value-added, and high-intensity tasks.

[0003] Currently, the core of the RPA product consists of the RPA process robot designer, the RPA process robot management console, the RPA process robot executor, and the RPA picker. Designers use the RPA process robot designer to design, develop, and orchestrate RPA process robots through a drag-and-drop, low-code approach, including data input, reading, transmission, verification, and processing. This includes the execution sequence and triggering conditions, logical judgments, condition merging and branching, and the relationships and flow between nodes or components. The RPA process robot executor is responsible for executing the RPA process robot design, which can be published or exported as an executable file or project. It automatically simulates human operations according to the conditions, rules, logic, and actions orchestrated by the RPA designer. The RPA process robot management console is responsible for managing, scheduling, starting, stopping, and monitoring the RPA process robot. The RPA picker is responsible for picking up application UI control elements, including information such as their name, handle, title, ID, coordinates, and hierarchy.

[0004] Currently, the RPA process robot designer mainly uses a C / S architecture (client / server architecture) and needs to be installed separately on a computer device (mainly on a Windows system). By installing the RPA process robot designer software installation package, you can design, develop, and orchestrate the RPA process robot. After the design and development is completed, it can be published to the server or exported to the local computer.

[0005] The existing architecture, implementation methods, and systems for RPA process robot designers based on a client-server architecture require users to separately download the designer client software installation package. Most applications only support installation and design and orchestration on Windows platforms. To achieve compatibility with a wider range of platforms, such as Linux, Unix, macOS, HarmonyOS, iOS, and Android, not only does the designer software vendor have to conduct extensive adaptation work for each platform, but some platforms may not be compatible.

[0006] The existing RPA process robot designer based on the C / S architecture has the following problems in centralized scenarios or situations: (1) When using the RPA process robot designer, users must download the software installation package separately and install it, and cannot use it directly without installation. (2) The same Windows system platform system cannot shield the differences in system platform environments of different versions, and certain adjustments and adaptations are required. (3) The designer can only be installed and used on the Windows platform system to design and orchestrate RPA process robots, and does not support cross-platform use of the RPA designer on other non-Windows system platforms. (4) The designer can only be used on terminal devices on the Windows platform to design and orchestrate RPA process robots, and does not support cross-terminal use of other non-computer devices. (5) It does not support multiple people using the same RPA process robot designer online at the same time, and does not support multiple people collaborating on the same RPA process. (6) It does not support online use of the designer anytime and anywhere (when the designer is installed on a server or a personal desktop or other non-portable computer). (7) The RPA process robot designer cannot be installed and run in containers such as Docker. Summary of the Invention

[0007] To address the above issues, the present invention provides a cross-platform, cross-terminal RPA designer system and implementation method for a B / S architecture. The RPA process robot designer is installed, deployed, and run in containers such as Docker, enabling elastic scaling to cope with concurrency. RPA process robots can be designed and orchestrated via browser network access (forming a B / S architecture, i.e., a browser / server architecture), without the need to install the RPA designer on a user's computer or other device, thus shielding against differences in various system platforms. The designer can be used to design, develop, and orchestrate RPA process robots on various terminal devices (computers, tablets, and mobile phones, etc.) with any browser (Chrome, Firefox, 360, IE11, Edge, Safari, etc.). It also supports the use of the designer via a browser on Linux, Unix, macOS, HarmonyOS, iOS, Android, and other systems, enabling the design and orchestration of RPA process robots across heterogeneous operating system platforms and anytime, anywhere via the network. The RPA designer supports simultaneous online use by multiple people and the simultaneous online collaboration of multiple people on the same RPA process.

[0008] To achieve the above objectives, the present invention provides a method for implementing a cross-platform and cross-terminal RPA designer in a B / S architecture, comprising: a designer front-end, a designer back-end, and an agent end that are communicatively connected in sequence, wherein the designer front-end and the designer back-end are both deployed on the server end in the form of Docker containers, and the agent end runs on the execution device;

[0009] The designer front end includes a node component area, a work canvas area, and a desktop real-time screen area, which are used to:

[0010] The designer drags the nodes and components in the node component area to the work canvas area to design and arrange the nodes, components, logic, and actions of the RPA process robot;

[0011] Connecting to the remote desktop of the execution device and displaying the real-time image of the remote desktop to the corresponding area of ​​the designer's operation page;

[0012] The designer backend is used to:

[0013] Provide technical support for the design and orchestration of the RPA process robot, including service calls, data calculation, logic processing, node scheduling, and data storage, receive UI control elements sent by the Agent end, and send them to the designer front end;

[0014] The Agent is used to:

[0015] Receive the UI control elements picked up by the RPA picker and send them to the designer backend.

[0016] As a further improvement of the present invention, the designer front end further includes a toolbar area, a property panel area, a debugging and log area;

[0017] The toolbar area is used to:

[0018] Provide common functions and tools;

[0019] Set a deployment button to persist the designed and orchestrated RPA process robot to the designer backend for data storage.

[0020] The property panel area is used to:

[0021] Setting the node name, attributes, actions, variables and processing logic information;

[0022] Set the UI control type to be picked up by the node;

[0023] Display the UI control elements sent by the Agent;

[0024] The debugging and logging area is used to:

[0025] Edit test data, test node functionality, and display, track, and record node errors, exceptions, and other information.

[0026] As a further improvement of the present invention, the designer front end is developed using the JavaScript template engine Mustache, the designer back end is developed using the Express framework of NodeJS, and the Agent end is developed using Kotlin and Python.

[0027] As a further improvement of the present invention, the designer backend and the Agent end communicate and transmit data via HTTP / HTTPS or WebSocket or MQTT protocol.

[0028] As a further improvement of the present invention, the designer front end and the designer back end are both packaged and compiled using Grunt and then ported into the Docker container. The package structure includes: the package @node-rpa / editor-front for the designer front end, the package @node-rpa / editor-api for the designer back end, the package @node-rpa / runtime for the runtime, the package node-rpa / util for public functions and tools, the package @node-rpa / nodes for basic functions, built-in logic, and general nodes, and the package @node-rpa / registry for node management, installation, dependency, registration, and loading.

[0029] The present invention also provides a method for implementing a cross-platform and multi-terminal RPA designer in a B / S architecture, including:

[0030] Drag the injection trigger node and the desktop real-time screen node from the node component area to the work canvas area;

[0031] Click the desktop real-time screen node to configure the execution device information connected to the desktop real-time screen, and display the remote desktop real-time screen of the execution device in the desktop real-time screen area;

[0032] Drag the required node or node combination from the node component area to the work canvas area, double-click the node to open the node property panel, click Pick, and select the UI control type to be picked;

[0033] The agent is started in the real-time screen of the remote desktop. The RPA picker of the agent moves to the UI control element that meets the UI control type, picks up the UI control element and sends it to the designer backend. The designer backend then passes it to the designer frontend and displays it in the property panel area.

[0034] Continue to set the action or processing logic of the node in the property panel area, save the node information, and drag connecting lines at both ends of the node to connect the previous node and the next node respectively to obtain the RPA process robot;

[0035] Click the deploy button in the toolbar area to persist the RPA process robot to the designer backend, and click the injection trigger node to start running the RPA process robot.

[0036] As a further improvement of the present invention, configuring execution device information connected to the desktop real-time screen and displaying the remote desktop real-time screen of the execution device in the desktop real-time screen area includes:

[0037] The designer backend receives the execution device information configured by the designer frontend and connects to the server of the execution device through the remote desktop gateway service;

[0038] The designer front end communicates with the remote desktop gateway service of the designer back end through WebSocket, and displays the remote desktop real-time screen in the desktop real-time screen area of ​​the designer operation page in HTML5.

[0039] As a further improvement of the present invention, the connection with the server of the execution device through the remote desktop gateway service includes:

[0040] The designer backend selects the corresponding remote desktop protocol and the client connection providing the remote desktop gateway service through the remote desktop gateway service;

[0041] Installing and starting the corresponding remote desktop server service in the execution device;

[0042] Connect to the remote desktop server through the client of the remote desktop gateway service, and pass the remote desktop protocol, port, resolution and whether to allow the operation to the server of the execution device;

[0043] The server side of the execution device connects to the port, and after selecting to allow the operation, completes the connection with the designer backend.

[0044] As a further improvement of the present invention, the process of creating a node in the node component area includes:

[0045] Create a node project and modify the project's package.json file, including adding the node-rpa identifier, node name, and node path;

[0046] Create a js file of the node object in the package.json file under the node path;

[0047] Write the constructor in the js file and instantiate the object, registering it as an available node;

[0048] Register a listener on the node and create the html of the node;

[0049] Install the node and restart the node-rpa service. The node will appear in the node component area.

[0050] As a further improvement of the present invention, it is also possible to implement multiple people online designing RPA process robots at the same time, and this can be divided into multiple people online designing different RPA processes in the RPA process robots at the same time and multiple people online designing the same RPA process in the RPA process robots at the same time; including:

[0051] The administrator assigns RPA Designer usage permissions;

[0052] Each user logs in to the RPA designer and clicks Add Process in the RPA center.

[0053] The designer backend and designer frontend create multiple independent RPA designer instances for multiple users. Each user uses the RPA designer to design and orchestrate their own RPA processes in the RPA process robot.

[0054] Alternatively, the designer backend and designer frontend create an RPA designer instance and assign it to multiple users. The RPA process is split into several sub-processes according to logical functional units. Each user designs and orchestrates a sub-process, and finally the sub-processes are connected in series according to the main process.

[0055] Compared with the prior art, the present invention has the following beneficial effects:

[0056] The present invention is based on the B / S architecture and deploys the RPA designer in a Docker container. There is no need to install the RPA designer software on user computers and other devices. The RPA process robot can be designed, developed, and orchestrated directly on the browser. There is no need to develop different component modules, pages, and bottom-layer adaptations for different platforms and different terminals. A set of methods and a system are implemented to support multiple platform systems, which solves the problems of universality and compatibility during the download and installation of RPA designers on different devices. The use of RPA designer is not restricted by the operating system platform system, and the cross-platform application of RPA designer is realized, filling the gap in the cross-platform field of RPA designer.

[0057] This invention solves the problems of scalability and flexibility of the RPA designer. The same RPA designer can be used on different terminals (computers, tablets, mobile phones, etc.). At the same time, the RPA designer modules and components can be customized and added as required, and support deployment and operation in Docker containers.

[0058] The present invention deploys and runs the RPA designer in a Docker container, which also facilitates the rapid migration, rapid deployment, rapid distribution, and rapid fault switching of the RPA designer.

[0059] The system and implementation method of the present invention improve overall operating efficiency and reduce R&D costs. A set of implementation methods and an RPA designer system can be used on different system platforms and terminals without the need for different adaptations for different platform systems, and can enable multiple people to assist in use online at the same time.

[0060] The system and implementation method of the present invention solve the problem of elastic scaling, realize the horizontal expansion of its own instance by deploying and running in a Docker container, and improve the throughput and concurrency of the RPA designer.

[0061] The present invention accesses the service address (domain name or IP address) through a browser. The RPA designer backend integrates the remote desktop gateway service, and the front end uses HTML5 to achieve real-time interaction with different system platforms. BRIEF DESCRIPTION OF THE DRAWINGS

[0062] Figure 1This is a schematic diagram of a cross-platform, cross-terminal RPA designer system for a B / S architecture disclosed in an embodiment of the present invention;

[0063] Figure 2 This is a schematic diagram of a method for implementing a cross-platform, cross-terminal RPA designer for a B / S architecture disclosed in an embodiment of the present invention;

[0064] Figure 3 This is a schematic diagram of the RPA designer service call process disclosed in one embodiment of the present invention;

[0065] Figure 4 A schematic diagram of an RPA designer deployment extension architecture disclosed in an embodiment of the present invention.

[0066] Description of reference numerals:

[0067] 1. Designer front-end; 11. Node component area; 12. Toolbar area; 13. Work canvas area; 14. Property panel area; 15. Debug and log area; 16. Desktop real-time screen area; 2. Designer back-end; 3. Agent end. DETAILED DESCRIPTION

[0068] To make the objectives, technical solutions, and advantages of the embodiments of the present invention more clear, the technical solutions in the embodiments of the present invention will be clearly and completely described below in conjunction with the accompanying drawings 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 making creative efforts shall fall within the scope of protection of the present invention.

[0069] The present invention is described in further detail below with reference to the accompanying drawings:

[0070] like Figure 1 As shown, the present invention provides a B / S architecture cross-platform and multi-terminal RPA designer system, comprising: a designer front-end 1, a designer back-end 2, and an agent end 3 that are communicatively connected in sequence. The designer front-end 1 and the designer back-end 2 are both deployed on the server end in the form of Docker containers, and the agent end 3 runs on the execution device;

[0071] The designer front end 1 includes a node component area 11, a work canvas area 13, and a desktop real-time screen area 16, which are used for:

[0072] Designers drag nodes and components from the node component area 11 to the work canvas area 13 to design and arrange the nodes, components, logic, and actions of the RPA process robot.

[0073] Connect to the remote desktop of the execution device and display the real-time image of the remote desktop to the corresponding area of ​​the designer's operation page;

[0074] Designer Backend 2 is used to:

[0075] Provide technical support for the design and orchestration of RPA process robots, including service calls, data calculations, logic processing, node scheduling, and data storage. Receive UI control elements sent by the Agent 3 and send them to the Designer Front-end 1.

[0076] Agent 3 is used to:

[0077] Receives UI control elements picked up by the RPA picker and sends them to the designer backend 2.

[0078] The designer front end 1 also includes a toolbar area 12, a property panel area 14, and a debugging and log area 15; wherein,

[0079] Toolbar area 12 is used for:

[0080] Provide common functions and tools;

[0081] Set a deployment button to persist the designed and orchestrated RPA process robot to the designer backend 2 for data storage.

[0082] The property panel area 14 is used to:

[0083] Set node name, attributes, actions, variables and processing logic information;

[0084] Set the type of UI control that the node needs to pick up;

[0085] Display the UI control elements sent by Agent 3;

[0086] Debug and log area 15, used for:

[0087] Edit test data, test node functionality, and display, track, and record node errors, exceptions, and other information.

[0088] Further,

[0089] The designer front-end 1 is developed using the JavaScript template engine Mustache, the drag-and-drop interaction is developed using D3.js+jQuery, the designer back-end 2 is developed using the NodeJS Express framework, and the agent end 3 is developed using Kotlin and Python.

[0090] The designer backend 2 and the agent end 3 communicate and transmit data through protocols such as HTTP / HTTPS, WebSocket, or MQTT.

[0091] Both the designer front-end 1 and the designer back-end 2 are packaged and compiled using Grunt and then ported to the Docker container. The package structure includes: the package @node-rpa / editor-front for the designer front-end 1, the package @node-rpa / editor-api for the designer back-end 2, the runtime package @node-rpa / runtime, the package node-rpa / util for public functions and tools, the package @node-rpa / nodes for basic functions, built-in logic, and common nodes, and the package @node-rpa / registry for node management, installation, dependency, registration, and loading.

[0092] like Figure 2 As shown, the present invention also provides a method for implementing a cross-platform, cross-terminal RPA designer in a B / S architecture, which applies the above-mentioned cross-platform, cross-terminal RPA designer system in a B / S architecture, including:

[0093] Drag the injection trigger node and the desktop real-time screen node from the node component area 11 to the work canvas area 13;

[0094] Click the desktop real-time screen node, configure the execution device information (device address, protocol, port, user name and password) connected to the desktop real-time screen, and display the remote desktop real-time screen of the execution device in the desktop real-time screen area 16;

[0095] Drag the required node or node combination from the node component area 11 to the work canvas area 13, double-click the node to open the node property panel, click Pick, and select the UI control type to be picked (including: WIN32, UIA, JAB, SAP, IE, Chrome, Firefox, etc.);

[0096] Start Agent 3 (once only) in the real-time remote desktop screen. The RPA picker of Agent 3 moves to the UI control element that matches the UI control type, picks up the UI control element, and sends it to Designer Backend 2. Designer Backend 2 then passes it to Designer Frontend 1 and displays it in the property panel area 14 (such as the name, title, ID, handle, coordinates, and level of the UI control element).

[0097] In the property panel area 14, continue to set the node's action or processing logic. Click the OK or Save button of the control node to save the node information. Drag a connection line at both ends of the node to connect the previous node and the next node respectively to obtain the RPA process robot.

[0098] Click the Deploy button in toolbar area 12 to persist the RPA process robot to the designer backend 2. Click the Inject trigger node to start the RPA process robot. The node's running status is displayed at the bottom of the node.

[0099] in,

[0100] 1. Displaying the remote desktop real-time screen of the execution device to the desktop real-time screen area 16; specifically including:

[0101] The designer backend 2 receives the execution device information (including: device address, protocol, port, user name and password) configured by the designer frontend 1, and connects to the server of the execution device through the remote desktop gateway service;

[0102] The designer front end 1 communicates with the remote desktop gateway service of the designer back end 2 through WebSocket, and displays the remote desktop real-time screen in the desktop real-time screen area 16 of the designer operation page (that is, the desktop real-time screen area 16 of the browser page) in HTML5.

[0103] The method includes connecting to the server of the execution device through the remote desktop gateway service, including:

[0104] The designer backend 2 selects the corresponding remote desktop protocol and the client connection that provides the remote desktop gateway service through the remote desktop gateway service;

[0105] Install and start the corresponding remote desktop server service on the execution device (once only);

[0106] Connect to the remote desktop server through the client of the remote desktop gateway service, and pass the remote desktop protocol, port, resolution, and whether to allow the operation and other related parameters to the server of the execution device;

[0107] Execute the server connection port of the device, select Allow operation, and complete the connection with the designer backend 2.

[0108] 2. The specific process of creating a node in the node component area 11 includes:

[0109] Create a node project (according to the standard Node project development method, create and initialize the Node project), modify the project's package.json file, including adding the node-rpa logo, node name, and node path;

[0110] Create a js file of the nodes object in the package.json file under the node path;

[0111] Write the constructor in the js file and instantiate the object, register it as an available node for flow to call;

[0112] Register a listener on the node to receive messages from the previous node in the flow and send messages to the next node in the flow;

[0113] Create the HTML corresponding to the node, and write the palette category, editable properties, icons, dialog box content scripts, help text content scripts, logic processing scripts, etc.

[0114] In the corresponding directory, use npm to install the node and restart the node-rpa service. The node will appear in the node component area 11.

[0115] Furthermore, an injection trigger node and a debugging node are dragged into the work canvas area 13 , and test data is edited to test whether the functions of the new nodes meet expectations.

[0116] 3. The present invention can also enable multiple people to design RPA process robots online at the same time, and can be divided into multiple people designing different RPA processes in the RPA process robots online at the same time and multiple people designing the same RPA process in the RPA process robots online at the same time; including:

[0117] The administrator assigns RPA Designer usage permissions (the administrator proactively adds users and assigns them, or users proactively register, and the administrator reviews and then assigns them RPA Designer usage permissions).

[0118] Each user logs in to the RPA Designer and clicks Add Process in the RPA Center.

[0119] Designer backend 2 and designer frontend 1 create multiple independent RPA designer instances for multiple users (RPA designer instances do not interfere with each other, and context data is also isolated). Each user uses the RPA designer to design and orchestrate their own RPA process in the RPA process robot.

[0120] Or the designer backend 2 and the designer frontend 1 create an RPA designer instance and assign it to multiple users (that is, multiple users share an RPA designer instance object and instance context). The RPA process is split into several sub-processes according to logical functional units. Each user designs and orchestrates a sub-process. Finally, the sub-processes are connected in series according to the main process, allowing multiple users to design and orchestrate the same RPA process simultaneously online.

[0121] like Figure 3 The following is a schematic diagram of the RPA Designer service call process. The functions of each module are:

[0122] RPA designer front-end service (visual layout, drag and drop, design, and orchestration of nodes and flows);

[0123] RPA designer backend service (logical processing of nodes, flows, etc. (addition, deletion, modification, persistence, etc.));

[0124] RPA Designer custom code service (processing the logic and implementation of accessing custom code nodes, etc.);

[0125] The RPA designer runs the deployment service (storing and distributing RPA process files to the RPA executor);

[0126] RPA Designer Executor Service (responsible for executing the process designed by RPA Designer)

[0127] like Figure 4 The following is a diagram of the RPA Designer deployment extension architecture. The functions of each module are:

[0128] RPA designer (design and logical processing of nodes, flows, etc. (addition, deletion, modification, persistence, etc.));

[0129] RPA designer master node (implements node routing, load, scheduling, etc.);

[0130] RPA Designer work node (RPA Designer work instance node);

[0131] RPA Designer deploys and runs Docker containers (for rapid migration, expansion, fault recovery, etc.);

[0132] Example:

[0133] Scenario description: Design an RPA process robot to automatically open a browser on Windows and Linux systems, automatically enter www.baidu.com, automatically enter the keyword "RPA" in the input box, and automatically click the "Baidu search" button.

[0134] This scenario uses Google Chrome, Windows 10, and Ubuntu 20.04 as the verification environment.

[0135] Prerequisites: The RPA control and Agent or RPA picker have been installed in Google Chrome on Windows 10 and Ubuntu 20.04 systems, the system's Remote Desktop Service has been set up and enabled, and the RPA executor has been deployed.

[0136] Main steps:

[0137] 1. Open the RPA Designer URL in Google Chrome on Ubuntu 20.04 (the same applies to Windows 10) and enter your username and password to log in.

[0138] 2. Enter the RPA center and click Add Process in Process Management;

[0139] 3. Enter the execution device of the process, process name, unique identifier, type, etc. and save;

[0140] 4. Click Design to enter the RPA Designer page. In the Browser module in the Node Component area 11, select Open URL node.

[0141] 5. Drag the Open URL node in the node component area 11 to the work canvas area 13;

[0142] 6. Double-click the URL node in the work canvas area 13 to open it. The node property configuration page will pop up in the property panel area 14. Set the node property values ​​(node ​​name, execution device address, user and password, browser type to be opened, URL to be opened, browser resolution, dwell time, etc.). Click Finish after setting.

[0143] 7. Drag an input value node from the node component area 11 to the work canvas area 13. Double-click the input value node. The property configuration page of the node will pop up in the property panel area 14. Enter the node name, whether it is a password, the stay time, etc.

[0144] 8. At the same time, click to select the picking method (UIA, XPATH, JAB, SAP, etc.). Select UIA or XPATH here.

[0145] 9. Automatically connect to and enter the remote desktop of the execution device (using Windows 10 as an example, the same applies to Uubunt 20.04). The remote desktop is dynamically displayed in real-time. The RPA picker pops up. Select "Baidu Input Box" to pick. The XPATH value is / / *[@id="kw"]. After picking up the value, click Send. The value is returned through Agent 3 and displayed in the target element box on the input value node property configuration page. Enter the keyword "RPA" in the "Input Value" position on the input value node property configuration page and click Finish.

[0146] 10. Drag a mouse action node into the work canvas area 13 from the node component area 11 and configure the relevant properties. Select the search button and automatically return the corresponding UI control target element value / / *[@id="su"]. Set the mouse action to single click and the dwell time to 1 second. Click Done.

[0147] 11. Use lines to connect the Open URL node, Input Value node, and Mouse Action node in sequence by dragging;

[0148] 12. In the work canvas area 13, click the execution contact that triggers the URL opening node, and at the same time open the desktop real-time screen area 16. You can see that Google Chrome automatically starts, the Baidu URL is automatically opened, "RPA" is automatically entered in the Baidu search input box, and the search results appear after clicking the "Baidu" button.

[0149] Among them, the RPA picker and RPA executor are not patents applied for in this invention. They are the supporting software or methods in this example.

[0150] Advantages of the present invention:

[0151] The present invention is based on the B / S architecture and deploys the RPA designer in a Docker container. There is no need to install the RPA designer software on user computers and other devices. The RPA process robot can be designed, developed, and orchestrated directly on the browser. There is no need to develop different component modules, pages, and bottom-layer adaptations for different platforms and different terminals. A set of methods and a system are implemented to support multiple platform systems, which solves the problems of universality and compatibility during the download and installation process of different devices. The use of the RPA designer is not restricted by the operating system platform system, and the cross-platform application of the RPA designer is realized, filling the gap in the cross-platform field of the RPA designer.

[0152] This invention solves the problems of scalability and flexibility of the RPA designer. The same RPA designer can be used on different terminals (computers, tablets, mobile phones, etc.). At the same time, the RPA designer modules and components can be customized and added as required, and support deployment and operation in Docker containers.

[0153] The present invention deploys and runs the RPA designer in a Docker container, which also facilitates the rapid migration, rapid deployment, rapid distribution, and rapid fault switching of the RPA designer.

[0154] The system and implementation method of the present invention improve overall operating efficiency and reduce R&D costs. A set of implementation methods and an RPA designer system can be used on different system platforms and terminals without the need for different adaptations for different platform systems, and can enable multiple people to assist in use online at the same time.

[0155] The system and implementation method of the present invention solve the problem of elastic scaling, realize the horizontal expansion of its own instance by deploying and running in a Docker container, and improve the throughput and concurrency of the RPA designer.

[0156] The present invention accesses the service address (domain name or IP address) through a browser. The RPA designer backend integrates the remote desktop gateway service, and the front end uses HTML5 to achieve real-time interaction with different system platforms.

[0157] The above are merely preferred embodiments of the present invention and are not intended to limit the present invention. Those skilled in the art will readily appreciate that various modifications and variations of the present invention are possible. Any modifications, equivalent substitutions, or improvements made within the spirit and principles of the present invention shall be included within the scope of protection of the present invention.

Claims

1. A B / S architecture cross-platform cross-terminal RPA designer system, characterized by: include: A designer front-end, a designer back-end, and an agent end that are sequentially communicatively connected, wherein the designer front-end and the designer back-end are both deployed on the server end in the form of Docker containers, and the agent end runs on the execution device; The designer front end includes a node component area, a work canvas area, a desktop real-time screen area, a toolbar area, a property panel area, and a debugging and logging area, which are used to: The designer drags the nodes and components in the node component area to the work canvas area to design and arrange the nodes, components, logic, and actions of the RPA process robot; Connecting to the remote desktop of the execution device and displaying the real-time image of the remote desktop to the corresponding area of ​​the designer's operation page; The toolbar area is used to provide common functions and tools; Set a deployment button to persist the designed and orchestrated RPA process robot to the designer backend for data storage. The property panel area is used to set the name, properties, actions, variables and processing logic information of the node; set the type of UI control to be picked up by the node; and display the UI control elements sent by the Agent end; The debugging and logging area is used to edit test data, test node functions, and display, track, and record node errors, exceptions, and other information; The designer backend is used to: Provide technical support for the design and orchestration of the RPA process robot, including service calls, data calculation, logic processing, node scheduling, and data storage, receive UI control elements sent by the Agent end, and send them to the designer front end; The Agent is used to: Receive the UI control elements picked up by the RPA picker and send them to the designer backend.

2. The B / S architecture cross-platform cross-terminal RPA designer system according to claim 1 is characterized by: The designer front end is developed using the JavaScript template engine Mustache, the designer back end is developed using the Express framework of NodeJS, and the agent end is developed using Kotlin and Python.

3. The B / S architecture cross-platform cross-terminal RPA designer system according to claim 1 is characterized by: The designer backend and the Agent end communicate and transmit data via HTTP / HTTPS or WebSocket or MQTT protocol.

4. The B / S architecture cross-platform cross-terminal RPA designer system according to claim 1 is characterized by: The designer front-end and the designer back-end are both packaged and compiled using Grunt and then ported into the Docker container. The package structure includes: the package @node-rpa / editor-front for the designer front-end, the package @node-rpa / editor-api for the designer back-end, the package @node-rpa / runtime for the runtime, the package node-rpa / util for public functions and tools, the package @node-rpa / nodes for basic functions, built-in logic, and general nodes, and the package @node-rpa / registry for node management, installation, dependency, registration, and loading.

5. A method for implementing a cross-platform, cross-terminal RPA designer for a B / S architecture, applying the cross-platform, cross-terminal RPA designer system for a B / S architecture as described in any one of claims 1 to 4, characterized in that: include: Drag the injection trigger node and desktop real-time screen node from the node component area to the work canvas area; Click the desktop real-time screen node to configure the execution device information connected to the desktop real-time screen, and display the remote desktop real-time screen of the execution device in the desktop real-time screen area; Drag the required node or node combination from the node component area to the work canvas area, double-click the node to open the node property panel, click Pick, and select the UI control type to be picked; The agent is started in the real-time screen of the remote desktop. The RPA picker of the agent moves to the UI control element that meets the UI control type, picks up the UI control element and sends it to the designer backend. The designer backend then passes it to the designer frontend and displays it in the property panel area. Continue to set the action or processing logic of the node in the property panel area, save the node information, and drag connecting lines at both ends of the node to connect the previous node and the next node respectively to obtain the RPA process robot; Click the deploy button in the toolbar to persist the RPA process robot to the designer backend, and click the injection trigger node to start running the RPA process robot.

6. The method for implementing a cross-platform and cross-terminal RPA designer for a B / S architecture according to claim 5 is characterized by: Configuring the execution device information connected to the desktop real-time screen and displaying the remote desktop real-time screen of the execution device in the desktop real-time screen area; including: The designer backend receives the execution device information configured by the designer frontend and connects to the server of the execution device through the remote desktop gateway service; The designer front end communicates with the remote desktop gateway service of the designer back end through WebSocket, and displays the remote desktop real-time screen in the desktop real-time screen area of ​​the designer operation page in HTML5.

7. The method for implementing a cross-platform, cross-terminal RPA designer for a B / S architecture according to claim 6 is characterized by: The method of connecting to the server of the execution device through the remote desktop gateway service includes: The designer backend selects the corresponding remote desktop protocol and the client connection providing the remote desktop gateway service through the remote desktop gateway service; Installing and starting the corresponding remote desktop server service in the execution device; Connect to the remote desktop server through the client of the remote desktop gateway service, and pass the remote desktop protocol, port, resolution and whether to allow the operation to the server of the execution device; The server end of the execution device connects to the port, and after selecting to allow the operation, completes the connection with the designer backend.

8. The method for implementing a cross-platform, cross-terminal RPA designer for a B / S architecture according to claim 5 is characterized by: The process of creating a node in the node component area includes: Create a node project and modify the project's package.json file, including adding the node-rpa identifier, node name, and node path; Create a js file of the node object in the package.json file under the node path; Write the constructor in the js file and instantiate the object, registering it as an available node; Register a listener on the node and create the html of the node; Install the node and restart the node-rpa service. The node will appear in the node component area.

9. The method for implementing a cross-platform, cross-terminal RPA designer for a B / S architecture according to claim 5 is characterized by: It also enables multiple people to design RPA process robots online simultaneously, and can be divided into multiple people designing different RPA processes in RPA process robots online simultaneously, and multiple people designing the same RPA process in RPA process robots online simultaneously; including: The administrator assigns RPA Designer usage permissions; Each user logs in to the RPA designer and clicks Add Process in the RPA center. The designer backend and designer frontend create multiple independent RPA designer instances for multiple users. Each user uses the RPA designer to design and orchestrate their own RPA processes in the RPA process robot. Alternatively, the designer backend and designer frontend create an RPA designer instance and assign it to multiple users. The RPA process is split into several sub-processes according to logical functional units. Each user designs and orchestrates a sub-process, and finally the sub-processes are connected in series according to the main process.

Images