CN113168335A - Application integration for robotic process automation - Google Patents

Abstract

Application integration of Robotic Process Automation (RPA) using a development application configured to support development of RPA applications is disclosed. In some embodiments, the development application may be used for integration with an attended robot executing locally on the same computing system as an instance of an RPA-enabled application, an unattended robot executing on a remote computing system, or both applications to create an RPA-enabled application. One or more User Interface (UI) elements, variables, and/or events of an RPA-enabled application may be linked to one or more respective RPA processes, thereby causing the respective RPA robot(s) to perform associated functionality.

Description

Application integration for robotic process automation

Cross Reference to Related Applications

This application claims the benefit of U.S. non-provisional patent application No. 15/930,518 filed on day 5, month 13, 2020. The subject matter of this earlier filed application is incorporated herein by reference in its entirety.

Technical Field

The present invention relates generally to Robotic Process Automation (RPA) and, more particularly, to application integration for RPA.

Background

Robotic Process Automation (RPA) can automate repetitive tasks, such as those that occur routinely and require manual performance by a user of a computing system. For example, the RPA robot may log in to an application, enter data, perform calculations, complete a task, and then log out. A user may run more than one RPA robot to accomplish a collective task, or may run multiple RPA robots to accomplish multiple tasks. It may be beneficial to automate various interactions with an application with an RPA robot to perform repetitive tasks without human intervention. Current RPA technology provides hard-coded automation functionality in applications. Accordingly, an improved solution for RPA may be beneficial.

Disclosure of Invention

Certain embodiments of the present invention may provide solutions to problems and needs in the art that have not yet been fully identified, appreciated, or solved by current RPA techniques. For example, some embodiments relate to application integration for RPA potentially supported by low code development applications.

In one embodiment, a computer-implemented method for developing an RPA-enabled application includes: the triggers in the RPA-enabled application are linked by the development application to the RPA process to be performed by the RPA robot. The computer-implemented method further comprises: an instance of the RPA-enabled application is generated by the development application that includes the linked trigger, and the instance of the RPA-enabled application is deployed to the computing system by the development application.

In another embodiment, a computer program for developing an RPA-enabled application is embodied on a non-transitory computer-readable medium. The program is configured to cause at least one processor to: the triggers in the RPA enabled application are linked to the RPA procedure to be performed by the RPA robot. The program is also configured to cause the at least one processor to generate an instance of the RPA enabled application including the linked trigger and deploy the instance of the RPA enabled application to the computing system.

In yet another embodiment, a computer program is embodied on a non-transitory computer readable medium. The program is configured to cause at least one processor to receive a trigger for initiation of an RPA procedure to be performed by an RPA robot. The program is also configured to cause the at least one processor to send a process initiation request to an RPA service platform for an unattended robot or to a locally executing attended robot via inter-process communication (IPC). The program is also configured to cause the at least one processor to receive, via IPC, output generated from running an RPA process from an attended robot or from an RPA service platform for an unattended RPA robot.

Drawings

In order that the advantages of certain embodiments of the invention will be readily understood, a more particular description of the invention briefly described above will be rendered by reference to specific embodiments that are illustrated in the appended drawings. While the present invention will be described and illustrated with additional specificity and detail through the use of the accompanying drawings in which:

fig. 1 is an architecture diagram illustrating an RPA system according to an embodiment of the present invention.

Fig. 2 is an architecture diagram illustrating a deployed RPA system in accordance with an embodiment of the present invention.

FIG. 3 is an architecture diagram illustrating the relationship between designer, activity and driver according to an embodiment of the invention.

Fig. 4 is an architecture diagram illustrating an RPA system according to an embodiment of the present invention.

Fig. 5 is an architecture diagram illustrating a computing system configured to provide and/or execute an instance of an RPA-enabled application, in accordance with an embodiment of the present invention.

Fig. 6A is an architecture diagram illustrating a low-code application development platform integrated with an RPA system, in accordance with an embodiment of the present invention.

FIG. 6B illustrates the interaction between a low code application development platform and an RPA service platform during application design time and runtime according to an embodiment of the present invention.

Fig. 7 is a flow diagram illustrating a process for developing an RPA application using an application development platform in accordance with an embodiment of the present invention.

Fig. 8 is a flow chart illustrating a process for execution of an RPA application in accordance with an embodiment of the present invention.

Fig. 9A-9E collectively illustrate a plurality of User Interfaces (UIs) showing a design time environment and an operating time environment for creating an RPA application, in accordance with an embodiment of the present invention.

Fig. 10 is a flow diagram illustrating a process for developing an RPA-enabled application according to an embodiment of the present invention.

Fig. 11 is a flowchart illustrating a process for executing an application supporting RPA according to an embodiment of the present invention.

FIG. 12 is a flow chart illustrating a process for: searching for a manned RPA robot or an unmanned RPA robot to perform an RPA procedure, and performing the RPA procedure.

Unless otherwise indicated, like reference numerals designate corresponding features throughout the drawings.

Detailed Description

Some embodiments relate to application integration for RPA using a development application configured to develop RPA-enabled applications. In some embodiments, the development application is a low-code development application. In some embodiments, the development application may be used for application integration with an attended robot executing locally on the same computing system as an instance of an RPA-enabled application, an unattended robot executing on a remote computing system, or both, creating an RPA-enabled application. In some embodiments, an instance of an RPA-enabled application first attempts to find a local RPA robot to perform a process, and if not, attempts to find a remote RPA robot to perform a process. In some embodiments, the developer application is web-based. One or more User Interface (UI) elements of an RPA-enabled application may be linked to one or more respective RPA processes, thereby causing the respective RPA robot(s) to perform associated functionality.

As used herein, "low code" means that the development task can be largely or completely completed without manual programming on the part of the user. Additionally, as used herein, an application "integrated with," "supporting" or "RPA application" means that the application or an instance thereof may initialize, invoke, or otherwise interact with one or more RPA robots via one or more UI elements or triggers during execution thereof. In some embodiments, a low code development application for developing software applications that interact with the RPA robot may be dragged and dropped to a large extent or completely so that individuals without substantial programming knowledge may develop the RPA robot. This may enable, for example, a business analyst to create RPA robots that implement various business logics. Indeed, in some embodiments, any employee may be able to create his or her own RPA robot. Thus, in some embodiments, an application (e.g., an RPA robot or another software application) may be developed using a low-code development application and then executed on a computing system to interact with the RPA robot.

In some embodiments, the development application may have discovery functionality for the RPA robot. The development application may first check if there is a local manned robot to perform the task. If there is no locally available robot(s) for the task, the development application may then examine the remote unattended robot to complete the task.

In some embodiments, an application developed using a development application communicates with a local manned robot, which may interact with the local manned robot via an inter-process communication (IPC) protocol. IPC protocols may support communication via networks, pipes, Component Object Models (COM), Remote Procedure Calls (RPCs), sockets, and the like. If supported, the IPC protocol may be used

Or any other suitable operating system. An application that invokes or otherwise interacts with the robot may send communications (e.g., commands) to the robot process using the IPC protocol. The robot may also send a status notification back to the application via the IPC protocol (e.g., indicating that the robot is starting, running, paused, etc.).

In some embodiments, certain activities that may be in the workflow of a robot integrated with an application provide certain functionality without creating an entirely new process. For example, activities that provide error handling, gather additional information, etc. may be provided without requiring the user to develop a new robot for the task. By using two-way communication (e.g., via IPC) at runtime, data can be sent to or received from the robot while the process of the robot is being performed. Thus, the robot may provide intermediate results as its process executes. For example, if a robot collects data from ten old systems, the robot may provide the data collection results to the application after completing the data collection for each old system. In some embodiments, an inline workflow may be used to perform some RPA activities on the web.

In some embodiments, the user may define whether the robot is operating unattended or unattended. This may be done by setting rules for starting the RPA robot process. While the bot may be launched due to a user action such as a button click, page load, etc., the bot may also be launched due to any logical reason (e.g., due to the occurrence of an event, due to a value change, due to the receipt of certain information, etc.). In some embodiments, the user may specify that the application use a "smart" option, where the application first finds a suitable locally attended robot and, if not, finds a remote unattended robot (e.g., via the RPA service platform) to complete the task.

In some embodiments, there is no build server for developing the application. Rather, the application definition can be created in the background when the user implements the associated logic using the development application. The application definition for the RPA enabled application may then be downloaded to a computing system that will execute the application at runtime, and the application definition, how the RPA enabled application is rendered, and the like may be controlled at runtime in a declarative manner. In some embodiments, a JavaScript class may be used for the script. In some embodiments, the reference to the robotic process may be stored in the RPA enabled application, rather than in the RPA process itself.

Embodiments may be deployed for Robotic Process Automation (RPA). Fig. 1 is an architectural diagram illustrating an RPA system 100 in accordance with an embodiment of the present invention. The RPA system 100 includes a designer 110 that allows a developer to design and implement a workflow. Designer 110 may provide solutions for application integration and automation of third party applications, administrative Information Technology (IT) tasks, and business IT processes. The designer 110 can support the development of an automation project, which is a graphical representation of a business process. In short, the designer 110 supports the development and deployment of workflows and robots.

Automation projects enable automation of rule-based processes by providing developers control over the execution order and relationships between a set of custom steps (defined herein as "activities") developed in a workflow. One commercial example of an embodiment of designer 110 is the UiPadh Studio^TM. Each activity may include an action, such as clicking a button, reading a file, writing a log panel, and so forth. In some embodiments, workflows can be nested or embedded.

Some types of workflows may include, but are not limited to, a sequence, a flow diagram, a FSM, and/or a global exception handler. The sequence may be particularly suited to a linear process, enabling flow from one activity to another without cluttering the workflow. The flow diagrams may be particularly suited to more complex business logic, enabling the integration of decisions and active joining in a more diverse manner by multiple branch logic operators. FSM may be particularly suited for larger workflows. The FSM may use a limited number of states in its execution, which are triggered by conditions (i.e., transitions) or activities. The global exception handler may be particularly suited to determine workflow behavior when an execution error is encountered and particularly suited to the debugging process.

Once the workflow is developed in the designer 110, execution of the business process is orchestrated by a director (conductor)120 that orchestrates one or more robots 130 that execute the workflow developed in the designer 110. One commercial example of an embodiment of director 120 is the UiPath Orchester^TM. Director 120 supports the management of the creation, monitoring, and deployment of resources in an environment. With third party solutions and applications, the director 120 may act as one of an integration point, or as an aggregation point.

The director 120 may manage a fleet of robots 130 to connect and execute the robots 130 from a centralized point. The types of robots 130 that may be managed include, but are not limited to: manned 132, unmanned 134, development robots (similar to unmanned 134 but for development and testing purposes), and non-production robots (similar to manned 132 but for development and testing purposes). The manned robot 132 may be triggered by a user event or scheduled to occur automatically and operate on the same computing system as a human. The manned robot 132 may be used with the director 120 to centralize process deployment and recording media. The manned robot 132 may assist a human user in completing various tasks and may be triggered by user events. In some embodiments, processes cannot be started from the director 120 on this type of robot and/or run under the lock screen. In some embodiments, the manned robot 132 may only be turned on from the robot pallet or upon command prompts. In some embodiments, the manned robot 132 should operate under human supervision.

The unattended robot 134 operates in an unattended manner in a virtual environment or on a physical machine and can automate many processes. The unattended robot 134 may be responsible for remote execution, monitoring, scheduling, and providing support for work queues. In some embodiments, debugging for all robot types may be run from the designer 110. Both manned and unmanned robots can automate various systems and applications including, but not limited to, mainframe, web applications, VMs, enterprise applications (e.g., by a mainframe, web application, VM, etc.)

Etc.) as well as computing system applications (e.g., desktop and notebook applications, mobile device applications, wearable computer applications, etc.).

The director 120 may have various capabilities including, but not limited to, provisioning (provisioning), deployment (deployment), versioning (versioning), configuration (configuration), queuing (queueing), monitoring (monitoring), logging (logging), and/or providing interconnectivity (interconnectivity). Provisioning may include creating and maintaining a connection between the bot 130 and the director 120 (e.g., a web application). Development may include ensuring that a package version is properly delivered to the assigned robot 130 for execution. In some embodiments, versioning may include the management of unique instances of a certain process or configuration. The configuration may include maintenance and delivery robot environment and process configuration. Queuing may include providing management of queues and queue entries. Monitoring may include tracking robot identification data and maintaining user privileges. Logging can include storing and indexing the log to a database (e.g., an SQL database) and/or another storage mechanism (e.g., a database with SQL data)

Which provides the ability to store and quickly query larger data sets). The director 120 can provide interconnectivity by acting as a centralized point of communication for third party solutions and/or applications.

The robot 130 is an executing agent that runs a workflow built into the designer 110. One commercial example of some embodiments of the robot(s) 130 is the UiPath Robots^TM. In some embodiments, the robot 130 installs Microsoft by default

Services managed by a Service Control Manager (SCM). As a result, such robots 130 can open interactive under local system accounts

A conversation and has

The rights of the service.

In some embodiments, the robot 130 may be installed in user mode. For such a robot 130, this means that it has the same rights as the user who has installed the given robot 130. This feature can also be used with High Density (HD) robots, which ensure full utilization of each machine at its maximum potential. In some embodiments, any type of robot 130 may be configured in an HD environment.

In some embodiments, the robot 130 is divided into several components that are each dedicated to a particular automation task. In some embodiments, the robotic components include, but are not limited to, SCM managed robotic services, user mode robotic services, actuators, agents, and command lines. SCM managed robot service management and monitoring

Converse, and act as a director 120 with the executing host (i.e., the computation on which the robot 130 is executed)System). These services are trusted by the robot 130 and manage credentials of the robot 130. The console application is launched by the SCM under the local system.

In some embodiments, user mode robotic service management and monitoring

A session and acts as a delegate between director 120 and the executing host. The user-mode robot service may be trusted by the robot 130 and manage credentials of the robot 130. In case that the robot service managed by the SCM is not installed,

the application may be automatically launched.

The actuator can be at

The agent may be a proxy that runs a given job under a session (i.e., the executor may execute a workflow

Presentation Foundation (WPF) application, which displays available jobs in a system tray window. The proxy may be a client of the service. The agent may request to start or stop jobs and change settings. The command line is a client of the service. A command line is a console application that can request to start a job and wait for its output.

Separating the components of the bot 130 as explained above generally helps developers, supporting users, and computing systems to more easily run, identify, and track what each component is executing. Special behaviors may be configured by component in this manner, such as setting different firewall rules for enforcers and services. In some embodiments, the actuator may always know the DPI settings of each monitor. As a result, the workflow may be executed at any DPI regardless of the configuration of the computing system that created the workflow. In some embodiments, the project from designer 110 may also be independent of browser zoom level. In some embodiments, DPI may be disabled for applications where DPI is unknown or intentionally marked as unknown.

Fig. 2 is an architectural diagram illustrating a deployed RPA system 200 in accordance with an embodiment of the present invention. In some embodiments, RPA system 200 may be, or may be a part of, RPA system 100 of fig. 1. It should be noted that the client-side, server-side, or both may include any desired number of computing systems without departing from the scope of the present invention. On the client side, the robotic application 210 includes an executor 212, an agent 214, and a designer 216. However, in some embodiments, designer 216 may not run on computing system 210. The actuator 212 is running the process. As shown in fig. 2, several business items may be running simultaneously. In this embodiment, agent 214 (e.g., a proxy)

Service) is a single point of contact for all actuators 212. The process-specific messages in this embodiment are logged into director 230, which further processes the messages via database server 240, indexer server 250, or both. As discussed above with respect to fig. 1, the implement 212 may be a robotic assembly.

In some embodiments, the robot represents an association between a machine name and a user name. The robot may manage multiple actuators simultaneously. In a computing system that supports multiple interactive sessions running simultaneously (e.g., in a web server

Server 2012), multiple robots may be running simultaneously, each using a separate user name

In a conversation. This is referred to as HD robot above.

The agent 214 is also responsible for sending the status of the robot (e.g., periodically sending a "heartbeat" message indicating that the robot is still functioning) and downloading the required version of the package to be executed. In some embodiments, communication between the agent 214 and director 230 is always initiated by the agent 214. In a notification scenario, agent 214 may open a WebSocket channel that is later used by director 230 to send commands (e.g., turn on, stop, etc.) to the robot.

On the server side, a presentation layer (web application 232, open data protocol (OData) representational state transfer (REST) Application Programming Interface (API) endpoint 234 and notification and monitoring 236), a service layer (API implementation/business logic 238), and a persistence layer (database server 240 and indexer server 250) are included. Director 230 includes web application 232, OData REST API endpoint 234, notification and monitoring 236, and API implementation/business logic 238. In some embodiments, most of the actions performed by the user in the interface of director 230 (e.g., via browser 220) are performed by calling various APIs. Such actions may include, but are not limited to, opening a job on the robot, adding/removing data in a queue, scheduling a job to run in an unattended manner, etc., without departing from the scope of the present invention. The Web application 232 is the visual layer of the server platform. In this embodiment, the web application 232 uses hypertext markup language (HTML) and JavaScript (JS). However, any desired markup language, scripting language, or any other format may be used without departing from the scope of the present invention. In this embodiment, a user interacts with a web page from a web application 232 via browser 220 to perform various actions to control director 230. For example, a user may create a group of robots, assign a package to the robots, analyze a log of each robot and/or each process, start and stop the robots, and so on.

In addition to the web application 232, the director 230 also includes a service layer that exposes the OData REST API endpoint 234. However, other endpoints may be included without departing from the scope of the present invention. The REST API is consumed by both the web application 232 and the agent 214. In this embodiment, agent 214 is a supervisor of one or more robots on a client computer.

In this embodiment, the REST API covers configuration, logging, monitoring, and queuing functionality. In some embodiments, configuration endpoints may be used to define and configure application users, permissions, bots, assets, publications, and environments. Logging REST endpoints may be used to log different information such as, for example, errors, explicit messages sent by the robot, and other environment-specific information. If a start job command is used in director 230, the deployment REST endpoint can be used by the robot to query the version of the package that should be executed. Queuing REST endpoints may be responsible for queue and queue entry management, such as adding data to the queue, obtaining transactions from the queue, setting the state of the transaction, and the like.

Monitoring the REST endpoint may monitor the web application 232 and the agent 214. The notification and monitoring API 236 may be a REST endpoint for registering the proxy 214, delivering configuration settings to the proxy 214, and for sending/receiving notifications from servers and the proxy 214. In some embodiments, the notification and monitoring API 236 may also communicate using WebSocket.

In this embodiment, the persistence layer includes a pair of servers — a database server 240 (e.g., an SQL server) and an indexer server 250. In this embodiment, database server 240 stores the configuration of robots, groups of robots, associated processes, users, roles, schedules, and the like. In some embodiments, this information is managed by web application 232. Database server 240 may manage queues and queue entries. In some embodiments, the database server 240 may store messages logged by the robot (in addition to the indexer server 250 or in place of the indexer server 250).

An optional indexer server 250 in some embodiments stores and indexes information recorded by the robot log. In certain embodiments, the indexer server 250 may be disabled by configuration settings. In some embodiments, the indexer server 250 uses

Which is an open source project full-text search engine. Messages logged by the robot (e.g. using e.g. log messages or write lines)Activity) may be sent to the indexer server 250 through the logged REST endpoint(s), where the messages are indexed for future use in the indexer server 250.

Figure 3 is an architecture diagram illustrating a relationship 300 between a designer 310, activities 320, 330, and drivers 340, according to an embodiment of the invention. From the above, the developer uses designer 310 to develop the workflow performed by the robot. The workflow may include user-defined activities 320 and UI automation activities 330. Some embodiments are capable of identifying non-textual visual components in an image, referred to herein as Computer Vision (CV). Some CV activities related to such components may include, but are not limited to, clicking, typing (type), fetching text, hovering, element presence, refreshing scope, highlighting, and the like. In some embodiments, the click identifies the element using, for example, CV, Optical Character Recognition (OCR), fuzzy text matching, and multi-anchor (multi-anchor), and clicks on the element. Typing may use the above to identify an element and a type in the element. Retrieving text may identify a location of a particular text and scan the location using OCR. The hover may identify the element and hover over the element. Element presence may use the techniques described above to check whether an element is present on the screen. In some embodiments, there may be hundreds or even thousands of activities that may be implemented in designer 310. However, any number and/or type of activities may be available without departing from the scope of the present invention.

The UI automation activity 330 is a subset of a particular lower level activity (e.g., CV activity) written in lower level code and facilitates interaction with the application through the UI layer. In some embodiments, the UI automation activity 300 may "simulate" user input, such as through window messages and the like. The UI automation activity 330 supports these interactions via drivers 340 that allow the robot to interact with the desired software. For example, the drivers 340 may include an OS driver 342, a browser driver 344, a VM driver 346, an enterprise application driver 348, and the like.

The driver 340 may interact with the OS at a low level to find hooks, monitor keys, etc. The driver may assist in the operation of

And the like. For example, the "click" activity plays the same role in these different applications via the driver 340.

Fig. 4 is an architecture diagram illustrating an RPA system 400 in accordance with an embodiment of the present invention. In some embodiments, RPA system 400 may be or include RPA systems 100 and/or 200 of fig. 1 and/or 2. RPA system 400 includes a plurality of client computing systems 410 running robots. The computing system 410 is capable of communicating with the director computing system 420 via a web application running thereon. Director computing system 420 can in turn communicate with database server 430 and optional indexer server 440.

With respect to fig. 1 and 3, it should be noted that although a web application is used in these embodiments, any suitable client and/or server software may be used without departing from the scope of the present invention. For example, the director may run a server-side application that communicates with a non-web-based client software application on the client computing system.

Fig. 5 is an architecture diagram illustrating a computing system 500 configured to provide and/or execute an instance of an RPA-enabled application, in accordance with an embodiment of the present invention. In some embodiments, computing system 500 may be one or more of the computing systems depicted and/or described herein. Computing system 500 includes a bus 505 or other communication mechanism for communicating information, and processor(s) 510 coupled to bus 505 for processing information. Processor(s) 510 may be any type of general or special purpose processor including a Central Processing Unit (CPU), an Application Specific Integrated Circuit (ASIC), a Field Programmable Gate Array (FPGA), a Graphics Processing Unit (GPU), multiple instances thereof, and/or any combination thereof. Processor(s) 510 may also have multiple processing cores, and at least some of the cores may be configured to perform specific functions. In some embodiments, multiple parallel processing may be used. In certain embodiments, at least one of the processor(s) 510 may be a neuromorphic circuit that includes a processing element that mimics a biological nerve. In some embodiments, the neuromorphic circuit may not require the typical components of a von neumann computing architecture.

Computing system 500 also includes memory 515 for storing information and instructions to be executed by processor(s) 510. The memory 515 may be comprised of any combination of Random Access Memory (RAM), Read Only Memory (ROM), flash memory, cache, static storage devices such as magnetic or optical disks, or any other type of non-transitory computer-readable medium or combination thereof. Non-transitory computer readable media can be any available media that can be accessed by processor(s) 510 and can include volatile media, non-volatile media, or both. The media may also be removable, non-removable, or both.

Additionally, computing system 500 includes a communication device 520 (such as a transceiver) to provide access to a communication network via a wireless and/or wired connection. In some embodiments, communications device 520 may be configured to use Frequency Division Multiple Access (FDMA), single carrier FDMA (SC-FDMA), Time Division Multiple Access (TDMA), Code Division Multiple Access (CDMA), Orthogonal Frequency Division Multiplexing (OFDM), Orthogonal Frequency Division Multiple Access (OFDMA), Global System for Mobile (GSM) communications, General Packet Radio Service (GPRS), Universal Mobile Telecommunications System (UMTS), CDMA2000, wideband CDMA (W-CDMA), High Speed Downlink Packet Access (HSDPA), High Speed Uplink Packet Access (HSUPA), High Speed Packet Access (HSPA), Long Term Evolution (LTE), LTE-advanced (LTE-a), 802.11x, Wi-Fi, Zigbee, Ultra Wideband (UWB), 802.16x, 802.15, home node b (hnb), bluetooth, Radio Frequency Identification (RFID), infrared data association (IrDA), Near Field Communications (NFC), fifth generation (5G), and/or the like without departing from the scope of the invention, A New Radio (NR), any combination thereof, and/or any other existing or future implemented communication standard and/or protocol. In some embodiments, the communication device 520 may include one or more antennas that are singular, array, phased, switched, beam formed, beam steered, combinations thereof, and/or any other antenna configuration without departing from the scope of the present invention.

Processor(s) 510 are further coupled via bus 505 to display 525, whichSuch as plasma displays, Liquid Crystal Displays (LCDs), Light Emitting Diode (LED) displays, Field Emission Displays (FEDs), Organic Light Emitting Diode (OLED) displays, flexible OLED displays, flexible substrate displays, projection displays, 4K displays, high definition displays, plasma displays, field emission displays (FEDs, Organic Light Emitting Displays (OLED) displays, flexible OLED displays, flexible substrate displays, projection displays, 4K displays, and so,

A display, an in-plane switching (IPS) display, or any other suitable display for displaying information to a user. The display 525 may be configured as a touch (tactile) display, three-dimensional (3D) touch display, multi-input touch display, multi-touch display, and the like, using resistive, capacitive, Surface Acoustic Wave (SAW) capacitive, infrared, optical imaging, dispersive signal technology, acoustic pulse recognition, frustrated total internal reflection, and the like. Any suitable display device and tactile I/O may be used without departing from the scope of the invention.

A keyboard 530 and a cursor control device 535 (such as a computer mouse, touchpad, and the like) are further coupled to bus 505 to enable a user to interface with computing system 500. However, in some embodiments, a physical keyboard and mouse may not be present, and a user may interact with the device only through the display 525 and/or a touchpad (not shown). Any type and combination of input devices may be used as a matter of design choice. In some embodiments, there is no physical input device and/or display. For example, a user may interact with computing system 500 remotely via another computing system with which the user communicates, or computing system 500 may operate autonomously.

The memory 515 stores software modules that provide functionality when executed by the processor(s) 510. The modules include an operating system 540 of the computing system 500. The modules also include an RPA integration module 545 configured to perform all or part of the processes described herein or derivatives thereof. The computing system 500 may include one or more additional functional modules 550 that include additional functionality.

Those skilled in the art will appreciate that a "system" may be implemented as a server, an embedded computing system, a personal computer, a console, a Personal Digital Assistant (PDA), a cell phone, a tablet computing device, a quantum computing system, or any other suitable computing device or combination of devices, without departing from the scope of the invention. The presentation of the above described functions as being performed by a "system" is not intended to limit the scope of the invention in any way, but rather is intended to provide one example of many embodiments of the invention. Indeed, the methods, systems, and apparatus disclosed herein may be implemented in localized and distributed forms consistent with computing technologies including cloud computing systems.

It should be noted that some of the system features described in this specification have been presented as modules, in order to more particularly emphasize their implementation independence. For example, a module may be implemented as a hardware circuit comprising custom Very Large Scale Integration (VLSI) circuits or gate arrays, off-the-shelf semiconductors such as logic chips, transistors, or other discrete components. A module may also be implemented in programmable hardware devices such as field programmable gate arrays, programmable array logic, programmable logic devices, graphics processing units, or the like.

Modules may also be at least partially implemented in software for execution by various types of processors. For example, an identified unit of executable code may comprise one or more physical or logical blocks of computer instructions, which may, for example, be organized as an object, procedure, or function. Nevertheless, the executables of an identified module need not be physically located together, but may comprise disparate instructions stored in different locations which, when joined logically together, comprise the module and achieve the stated purpose for the module. Further, the modules may be stored on a computer readable medium, which may be, for example, a hard disk drive, a flash memory device, a RAM, a tape, and/or any other such non-transitory computer readable medium for storing data, without departing from the scope of the present invention.

Indeed, a module of executable code may be a single instruction, or many instructions, and may even be distributed over several different code segments, among different programs, and across several memory devices. Similarly, operational data may be identified and illustrated herein within modules, and may be embodied in any suitable form and organized within any suitable type of data structure. The operational data may be collected as a single data set, or may be distributed over different locations including over different storage devices, and may exist, at least partially, merely as electronic signals on a system or network.

Fig. 6A is an architecture diagram illustrating a low-code application development platform 602 integrated with an RPA system 600, in accordance with an embodiment of the present invention. However, in some embodiments, RPA system 600 may not be present and RPA-enabled application instance 612 may only interact with local robots (e.g., manned robot 640 a). The RPA system 600 includes an RPA service platform 600a and an unattended robot 640 a. An attended robot 640b is located on the user device 610 (i.e., computing system), and an unattended robot 640a is operatively coupled with the RPA service platform 600 a. In some embodiments, robot(s) from one or both of unattended robot 640a and attended robot 640b may be invoked by RPA enabled application instance 612 on user device 610. In some embodiments, a subset or all of the elements of the application development platform 602 may be located on the user device 610 and/or caused to be executed by the user device 610. In some embodiments, a development computing system (not shown) uses design portal 604, object store 606, and build server 608 before RPA-enabled applications are deployed to user device 610.

RPA system 600 may be implemented as a cloud-based infrastructure, an in-house deployed infrastructure, or a combination thereof. RPA services platform 600a may include one or more RPA procedures, which may be available as services. In some embodiments, the architecture and functionality of RPA service platform 600a may be a director (e.g., director 120 of FIG. 1), an Action Center (e.g., UiPadh Action Center)^TM) Containers for holding items (e.g. UiPad queue)^TM) Or any other suitable RPA service platform, without departing from the scope of the present invention.

The application development platform 602 (e.g., a low-code application development platform) can be an application development environment that enables users to build applications using code with little or no knowledge of programming languages and/or in isolation. As shown in FIG. 6A, application development platform 602 includes design portal 604, object store 606, and build server 608. The object store 606 includes UI components 606a, screen layouts 606b, and other functional elements 606c, such as widgets, templates, tables, functions, designs, and so forth. In some embodiments, object store 606 is used during development of an application to define and store a set of objects needed to build screens, UI components, and reports. In some embodiments, once object store 606 is populated, new application components may be developed by copying the necessary objects from object store 606. In some embodiments, in addition to the development time saved by creating objects once, the object store 606 can be used to easily update application objects by using inheritance. In some embodiments, when an object is copied from object store 606, the copy or child object may retain the attribute definition of the original object (i.e., its parent). If the properties of the parent object are changed in the repository, the properties that the child object has inherited can also be automatically updated. Object store 606 can provide consistency and control over the look and feel of applications and their data elements.

Design portal 604 may provide a collaborative environment for the design, development, and deployment of RPA-enabled applications. In some embodiments, a developer may use design portal 604 to design an application using drag-and-drop functionality or other similar features. Design portal 604 may provide a workspace environment for building different features of an application and may include one or more features to interface with RPA service platform 600a and one or more user computing systems (e.g., user device 610).

Build server 608 can be a centralized, stable, and reliable environment for building distributed development projects. However, in some embodiments, the server need not be built, and the application may be deployed using a one-click deployment. Build server 608 can be configured to flag problems and notify developers that conflicts or lack of dependent items exist. Build server 608 may also be configured to mimic the environment of the end user. In this manner, build server 608 can highlight areas where the local configuration of an individual developer causes the behavior of the developed application on its hardware to differ from the behavior in production. In some embodiments, build server 608 may also accelerate the development process by freeing resources on the developer's local machine.

In some embodiments, the developer accesses a design portal 604 of the application development platform 602, the application development platform 602 for developing RPA-enabled applications (also referred to herein as "RPA applications"). An RPA-enabled application may be a software application (e.g., a desktop application, a web application, a smartphone application, a tablet application, a subcomponent of another application, etc.) for a computing system integrated with an RPA process. In some embodiments, the application development platform 602 may be a web-based application development platform or an application development platform installed on the user device 610. In some embodiments, a developer may use the UI component 606a, screen layout 606b, and other functional components 606c from the object store 606 to design a visual presentation of an application, such as adding a new screen, connecting with the RPA service platform 600a, obtaining functionality, and the like, using drag-and-drop functionality and multiple functional components present in the design portal 604. Further, for example, if the RPA services platform 600a is a web-based application, the developer may request a connection between the application and the RPA services platform 600a via a web server, or if the RPA services platform 600a is a local application on the developer's computing system, via the operating system. After authorization, the application may be connected to the RPA service platform 600a using the tenant name, username, and password (or hybrid where the application is on the cloud and the director is preset), the connection between the application and the RPA service platform 600a may be automatically established based on an existing registration with the RPA service platform 600a, and so on.

Upon successful connection with the RPA service platform 600a, the different processes and bots (e.g., unattended bot 640a) associated with the RPA service platform 600a may be displayed in the design portal 604 and one or more UI elements of the application may be linked with one or more RPA processes and the unattended bot 640a and/or the local attended bot 640b associated with the RPA service platform 600 a. These processes may include one or more RPA workflows. In some embodiments, the developer may designate the selected RPA process as "attended", "unattended", or "intelligent" when linking the process with the robot.

At this stage, the RPA enabled applications are integrated with the RPA processes associated with the RPA service platform 600 a. Once the RPA-enabled application is linked with one or more RPA processes, the RPA-enabled application is sent to build server 608 (in some embodiments, a one-click deployment may be used if one build server is used according to the above), build server 608 performs aggregation of different instances of the RPA-enabled application (e.g., there may be scenarios where multiple developers are using different features of the application, which would create different instances of the application), and compiles the RPA-enabled application to test whether it is operating correctly. If an error is found, an error report may be generated and shared with the developer. Build server 608 can also create a deployment package from artifacts (e.g., models, style sheets, custom JavaScript classes, etc.) in the RPA-enabled application on a central repository to manage and versify the application models, wherein the application artifacts are versioned and stored in corresponding project folders.

In some embodiments, once an RPA-enabled application is linked with one or more RPA processes, at least some of the above-described functionality of build server 608 may be skipped, and thus, build server 608 may be optional for some development scenarios. The RPA-enabled application (e.g., application instance 612) is then deployed to one or more user devices 610. References to one or more procedures, such as procedure IDs, can be stored as JavaScript object notation (JSON) objects in application instance 612 and/or application development platform 602.

FIG. 6B illustrates the interaction between the low code application development platform 602 and the RPA service platform 600a during application design time and runtime according to an embodiment of the present invention. In fig. 6B, an RPA application (e.g., application instance 612) developed using application development platform 602 has a design-time configuration 622a and a runtime configuration 622B. In some embodiments, a developer computing system (via design portal 604) may interact with RPA service platform 600a during application design time 622a, and a user computing system 610 (via RPA-enabled application instance 612) may interact with RPA service platform 600a at runtime 622 b. Different steps may be involved during design time of the application and runtime of the application. The application development platform 602 can create an application instance Identifier (ID) for each application instance created using the application development platform 602.

During design time 622a, application development platform 602 performs initialization, process selection, and webhook registration at 624 using RPA service platform 600 a. In some embodiments, initialization may be performed by sending a connect request to RPA service platform 600a via a Uniform Resource Locator (URL) of RPA service platform 600a for connecting the RPA application with RPA service platform 600a and providing a tenant name, username, and password for authentication. Alternatively, the RPA application may be automatically connected based on an existing registration of the user device 610 with the RPA service platform 600 a. If user device 610 is already registered on RPA service platform 600a, RPA service platform 600a may identify that the connection request is from a registered user device and immediately accept the request without further authentication.

After the connection is established, a list of RPA procedures, robots, and machines associated with RPA services platform 600a may be presented on design portal 604. One or more RPA procedures may be selected from the displayed list of RPA procedures, and the selected RPA procedures may be linked with one or more UI elements of the RPA application. The RPA processes may include RPA workflows for completing tasks or processes or adding available processes to a queue of running RPA processes from the RPA service platform 600 a. The developer may assign a robot type (e.g., manned, unmanned, or intelligent) to a selected RPA process during design time, and the selected RPA process may be linked to the robot to implement different functions, such as starting a job or adding an available process to a queue from the RPA service platform 600 a.

A unique process ID may be generated for each selected RPA process associated with RPA services platform 600 a. The application development platform 602 registers webhook with the RPA service platform 600a for each selected RPA procedure using a unique procedure ID. In some embodiments, the application development platform 602 may register a unique process ID to the RPA service platform 600a using a callback URL that corresponds to a URL used during establishment of a connection with the RPA service platform 600 a. The inputs and outputs of the selected RPA process may be linked to one or more UI elements of the application. In some embodiments, the linking of the input and output of the selected RPA process to one or more UI elements may be accomplished using canvas controls associated with application development in the design portal 604. The output of the selected RPA procedure may be configured to provide success or failure of the selected RPA procedure at runtime via the linked UI elements. In some embodiments, in the event of a failure, the output may show information indicating the failure of the process and the reason for the failure and a suggestion to correct the problem. The linked RPA procedures may be stored as JSON objects in the application. In some embodiments, once the RPA application is developed and simulated, the RPA application is deployed on the user device 610 as an interfaced ". exe" file or web-based application at 626. In some embodiments, the RPA application is accessible via a URL to its production version.

During runtime 622b of the RPA application on user device 610, an application instance (e.g., application instance 612) is presented on user device 610 that may interact with one or more manned robots running locally on user device 610 (e.g., manned robot 640b), unmanned robots running remotely and accessible via RPA service platform 600a, or both. In some embodiments, when a user runs application instance 612, or application instance 612 is otherwise caused to run, the stored JSON object is converted to JavaScript, which is triggered by input from the application (e.g., clicking on a UI element, loading a screen, etc.), and then invokes RPA service platform 600 a. The one or more UI elements of the application instance 612 are associated with one or more functions (interchangeably referred to herein as "jobs"), such as initiating a linked RPA process, obtaining a status of a linked RPA process during execution, and so forth. Accordingly, when a UI element is triggered or another RPA trigger occurs, the corresponding job may be initialized. A job ID may be generated with each initialized job. At 628, a process initiation request is issued to the RPA service platform 600a to initiate a job. The request may include an application instance ID, a unique process ID, and a job ID.

RPA service platform 600a may identify the initialized RPA process based on the unique process ID provided in the registered webhook and assign a robot to perform the initialized RPA process. The assigned robots may be selected exclusively or dynamically based on certain rules. Once the RPA process is completed, RPA service platform 600a sends the process output at 630 to application development platform 602 along with the application instance ID, unique process ID, and job ID. Alternatively, in some embodiments, RPA services platform 600a may send intermediate results, such as status updates of RPA processes, to application development platform 602 (e.g., to a developer computing system for design time or to user device 610 for runtime) along with an application instance ID, a unique process ID, and a job ID. For locally executed robots, such intermediate results, as well as any other desired communications that may occur at the beginning of a process, at the end of a process, or anywhere in between, may occur via IPC. This IPC capability of some embodiments may be provided by default or may be available as an optional user-selected feature. In some embodiments, IPCs may be bi-directional.

In some embodiments, RPA service platform 600a may send output directly to application instance 612 during runtime based on the application instance ID, the unique process ID, and the job ID. The application development platform 602 can identify the application instance 612 from which the process initiation request originated based on the application instance ID, and send the output to the correct application instance at 632. Upon receiving the output, application instance 612 binds the received output to the corresponding UI element at 634. The output may be displayed to a user via an application instance.

Fig. 7 is a flow diagram illustrating a process 700 for developing an RPA application using an application development platform in accordance with an embodiment of the present invention. Fig. 7 is described in conjunction with the description of fig. 6A and 6B.

At step 702, a workspace is selected by a user of an application development platform (e.g., application development platform 602) to create an RPA application. The RPA application may be, for example, a web application, a sidebar application, a desktop application, a widget, a full screen application, an embedded application, an RPA bot, or any other suitable RPA integrated application for any desired purpose without departing from the scope of the present invention. In some embodiments, the application development platform 602 may include one or more design tabs. The one or more design tabs may include a component/design palette tab (palette tab) that may include one or more design functions, such as labels, tables, lists, buttons, and the like. The one or more design tabs may include a view tab (e.g., a tree view tab), which may include a collection of different types of screen layouts. See, e.g., screen layout 908 of fig. 9A. To select a workspace, the application development platform 602 can receive a selection of a screen layout from a set of screen layouts. A corresponding screen layout for the development of the RPA application may be presented on the screen. The screen layout may be a visual model in which one or more UI elements of one or more user interfaces (e.g., UI component 606a) may be located. In some embodiments, the application development platform 602 may generate an application instance ID for the RPA application while initiating the process of RPA application development. The application instance ID may be used to uniquely identify each RPA application created. Alternatively, in some embodiments, the application instance ID may be assigned to the RPA application once the development of the RPA application is completed.

At step 704, one or more UI elements of the selected screen layout of the RPA application are embedded, such as by using drag-and-drop functionality, click functionality, user-specified formulas and expressions of the application development platform 602, or a combination thereof (if provided), to drag-and-drop one or more design functions from the component tabs onto the layout. One or more user interfaces may be built for the RPA application using one or more design functions. After placing the one or more design functions on the layout, one or more UI elements of the one or more user interfaces may be embedded on the layout of the RPA application. For example, one or more design functions, such as clickable buttons, may be dragged and dropped from the component tabs onto the layout to create a button interface on the layout of the RPA application. Thus, application development platform 602 enables users to create RPA applications with little or no coding knowledge.

At step 706, after creating the RPA application, a connection is established between the RPA application and the RPA service platform 600a via the application development platform 602. To establish a connection, a user may enter an address (e.g., a URL address) of RPA service platform 600a in application development platform 602 and enter user credentials. The address of RPA service platform 600a may be stored in memory by application development platform 602. Thus, the address of the RPA service platform 600a may be retrieved from memory. In some embodiments, the RPA service address may be detected based on a currently authenticated user on the platform (e.g., the user may select from available director services on his or her cloud account).

User credentials, such as tenant name, username, and password, may be authenticated prior to establishing a connection with RPA service platform 600a using the user-provided credentials. The application development platform 602 can determine the validity of the credentials by comparing the credentials provided by the user with pre-stored credentials of the user. Application development platform 602 may authenticate user credentials to verify that the user is authorized to establish a connection to RPA service platform 600 a. For example, if authorization of user credentials fails, application development platform 602 may deny a connection with RPA service platform 600 a. Accordingly, the application development platform 602 may prevent unauthorized users from using the RPA service platform 600 a. In some embodiments, the connection may be established using single sign-on (SSO) or other authentication mechanism, wherein user devices registered with RPA service platform 600a may be automatically connected after receiving a connection request without providing further details, such as tenant name, username, and password.

In some embodiments, the connection between the RPA application and the RPA service platform 600a is established based on a successful authentication of the entered URL and user credentials of the RPA service platform 600 a. In some embodiments, an application level connection is created between application development platform 602 and RPA service platform 600 a.

The connection between the application development platform 602 and the RPA service platform 600a may provide access to all or a subset of the RPA functionality of the RPA service platform 600a, which may be made available by the RPA application. For example, code application development platform 602 may retrieve one or more RPA procedures associated with desired RPA functionality from RPA services platform 600a for use by RPA applications.

At step 708, a list of one or more RPA processes available in RPA services platform 600a is displayed on application development platform 602 that will execute instances of the RPA application locally on the user's machine, or both. See RPA procedure list 914 of fig. 9D. For example, the application development platform 602 may be configured to display a list of RPA procedures retrieved from the RPA service platform 600a based on the connection established with the RPA service platform 600 a. These processes may be associated with an unattended robot accessible via RPA service platform 600a, and in some embodiments may include a manned robot available on the local machine(s) that will deploy the RPA application. In certain embodiments, a manned robotic process is provided via connection(s) to local machine(s). The application development platform 602 may also be configured to display one or more parameters associated with at least one RPA procedure in the list of one or more RPA procedures.

At step 710, application development platform 602 receives at least one RPA procedure selection from the displayed list of RPA procedures to be invoked via interaction with a UI element or another trigger (e.g., those available via RPA service platform 600a, those available on user device 610, or both). At step 712, at least one selected RPA procedure is integrated with the RPA application (e.g., with at least one UI element of one or more user interfaces, with variable changes, with trigger events or state changes, etc.) using, for example, drag-and-drop functionality or other linking capabilities.

The application development platform 602 may generate a unique process ID for each selection and assignment of at least one RPA process. In some embodiments, the user may select at least one RPA procedure from the displayed list of RPA procedures. In some embodiments, the user may also select one or more parameters associated with at least one RPA procedure. In some embodiments, RPA service platform 600a may assign an unattended robot to each selected RPA procedure. The robots may be assigned exclusively or dynamically based on a set of rules. Each selected RPA procedure linked to the robot(s) may be stored as a JSON object in the RPA application. In some embodiments, the one or more UI elements may also be configured to make Application Programming Interface (API) calls to the respective one or more RPA procedures.

At step 714, if an unattended robot is to be used, the application development platform 602 sends a notification to the RPA service platform 600a for each selected RPA process to be performed by the unattended RPA robot(s). In some embodiments, a check for webhook of at least one RPA process may be performed. If there is a webhook, the RPA process is already registered in the RPA service platform 600 a. If a webhook is not found, a new webhook may be created and stored in the RPA service platform 600a, which includes a list of selected RPA procedures and assigned robots. The notification may include a unique process ID generated for each RPA process that is shared with the RPA service platform 600 a. Thus, the RPA service platform 600a may be updated with respect to each selected RPA procedure and assigned robot. In some embodiments, the notification may be sent to the RPA service platform 600a based on the address (e.g., callback URL) of the RPA service platform 600 a.

In some embodiments, each UI element integrated with the RPA process (es) may be a trigger point to initiate tasks associated with the RPA process (es) allocated to the assigned robot(s). JavaScript for a UI element may be linked to the RPA procedure triggered based on the input, making calls from the RPA application to the RPA service platform 600a using the standard API for unattended bots, and making calls from the RPA service platform 600a to the assigned bot, and running the RPA procedure associated with the UI element. In embodiments where the manned robot resides locally on the same computing system as the RPA process, for example, the robot may be invoked directly rather than invoking the RPA service platform 600a via IPC. The output of the RPA process may be shown on a display associated with the user device 610.

At step 716, the developed RPA application is deployed to a machine (e.g., user device 610) to run and control or invoke an associated one or more processes running locally and/or remotely on the machine. The RPA application may be configured to be displayed in parallel with other applications on the user device 610 without interrupting the operation of the other applications. In a non-limiting example, the RPA application may be a web application presented as a sidebar application on a display of the user device 610 or in association with the user device 610. The sidebar application may be provided as an ". exe" file docked on the screen of the user device for easy access. The user can control the manned robot being run locally by the RPA application without suspending ongoing jobs on the already running application. In some embodiments, a remotely operated unattended robot may be controlled. In some embodiments, the user may not need to navigate multiple windows to access different manned robots running locally on the user device 610. Instead, the user can easily access and control all attended robots that are running locally via the RPA application.

Fig. 8 is a flow chart illustrating a process for execution of an RPA application in accordance with an embodiment of the present invention. Fig. 8 is described in conjunction with the description of fig. 6A and 6B.

At step 802, an instance of an RPA application (e.g., instance 612) is running on user device 610. In a manned scenario in which the RPA bot is local to user device 610, after running a selected RPA application, input may be received via one or more UI elements of the RPA application or some other trigger. In some embodiments, an event-based trigger for an RPA procedure may be received from an RPA application, such as a trigger that is generated when a condition is met (e.g., the procedure is complete, a parameter changes or goes to a certain value, an event such as a screen load, a control change, a button click, etc.). In some embodiments, JSON objects associated with one or more RPA procedures may be converted to JavaScript output when a user runs an RPA application.

At step 804, one or more RPA procedures are initiated. One or more RPA procedures may be initiated based on interactions with UI elements, event-based triggers, and/or the like. For manned robots, the RPA application may locally initiate RPA procedure(s) for the manned RPA robot(s). For unattended robots, the RPA application may initiate RPA process (es) via RPA service platform 600a, or may retrieve the state of one or more associated RPA processes based on events. For an unattended robot, upon initiation, a request is sent to the RPA service platform 600a to run at least one process associated with receiving an input or event-based UI element. When the input triggers JavaScript, a call may be made from the RPA application to the RPA service platform 600a, and a call may be made from the RPA service platform 600a to a respective unattended robot for running a respective one or more RPA procedures. In some embodiments, the application development platform 602 may generate a job ID for each request made to the RPA service platform 600a to initiate an RPA process. The generated job ID may be stored by application development platform 602 for further reference, along with the corresponding application instance ID. The request sent to RPA services platform 600a may include: a job ID associated with the request to initiate the RPA process, an application instance ID associated with the RPA application instance 612, a unique process ID associated with the initiated RPA process, and other information associated with the RPA process (e.g., user system identifier, user credentials, etc.). RPA service platform 600a may reference a registered webhook and assign an unattended robot to at least one process based on a unique process ID and a job ID.

At step 806, for the unattended robot, a notification is obtained by the application development platform 602 from the RPA service platform 600a, the notification indicating completion of at least one RPA process. Accordingly, the application development platform 602 may be informed about the status of the at least one RPA process in real-time or near real-time.

At step 808, the application development platform 602 receives output generated by at least one RPA process from the RPA service platform 600 a. The generated output may include a message indicating a result of the at least one RPA procedure, a status of the at least one RPA procedure, and/or the like. For example, the output may include: an indication of success, failure, error, result after running the process; an indication that another RPA procedure is run after the initiated RPA procedure is completed, etc. In some embodiments, the output may be routed directly to RPA application instance 612.

At step 810, output for manned or unmanned robot execution is routed to the application instance (e.g., application instance 612) that initiated the RPA process (es) via IPC or low code application development platform 602, respectively. For unattended robotic execution, this may be done based on the application instance ID, the unique ID, and the job ID. The unique ID, application instance ID, and job ID, or corresponding information received via IPC or stored locally for application instance 612, may be used to route the output further to one or more UI elements where the output should be displayed. In some embodiments, the application development platform 602 may bind the output to one or more UI elements of the RPA application.

At step 812, if the UI elements are to be modified based on the robotic execution results, the output is presented via one or more UI elements of the RPA application instance.

Fig. 9A-9E collectively illustrate a plurality of User Interfaces (UIs) showing a design-time environment and a runtime environment for RPA applications integrated with an RPA service platform, in accordance with an embodiment of the present invention. In some embodiments, the application development platform 602 may be used to create RPA applications. The low-code application development platform may include various design tools and drag-and-drop functionality to create RPA applications. In fig. 9A, the application development platform includes a design tools section 902 and a design section 904, the design section 904 including a workspace to design RPA applications. The design tools section 902 includes a tree view tab 906 and a component tab 910. The tree view tab 906 may include various options for designing an RPA application, such as a collection of different types of screen layouts 908. After receiving a selection of at least one screen layout, such as screen layout 908a, the selected screen layout is used to create a design of a workspace for the RPA application. The screen layout may also represent a visual presentation of the RPA model when accessing the RPA application on the deployed system. For example, upon selection of a screen layout such as screen layout 908a, the RPA application may be presented, for example, on the left side of the user device as a sidebar application. However, any application type and location may be implemented without departing from the scope of the invention. The design portion 904 may allow the developer to preview the visual appearance of the RPA application as it will be presented on a user device (e.g., user device 610), and the developer may also embed functional elements within the workspace to provide different functionality to the application. Design portion 904 can change the visual representation of the workspace region in accordance with the selected screen layout.

The component tabs 910 may include one or more design functions, such as labels, tables, lists, buttons, and the like, as shown in FIG. 9B. The design function may be used to build one or more user interfaces for the RPA application. For example, the tag functionality may be used to add a text tag in the RPA application that provides a name for the functionality associated with the tag. For example, the tag "customer data" may be provided for a function that returns data related to a profile for a customer. Table functions may be used to create table fields in the RPA application. The list function may be used to add a series of text boxes so that a list of data may be input or output in the RPA application. In some embodiments, the list function may be specifically associated with the tag function. For example, a list of functions such as billing history, update plans, etc. may be linked specifically to the tag customer data. The button function may be used to add buttons to the RPA application. After each design function is added to the RPA application, it may be associated with RPA functionality. A user may add design functionality to the RPA application using drag and drop functionality of the low code application development platform. For example, the user may drag design functions from the design tools section 902 and drop the design functions into the workspace of the RPA application. Similarly, an RPA application may be built with one or more design functions. Thus, a low-code application development platform may enable users to build RPA applications with little or no coding knowledge.

Further, one or more user interfaces built using one or more design functions may be associated with one or more RPA functions. The low code application development platform may be connected to an RPA service platform, such as RPA service platform 600a, to access one or more RPA functions associated with the RPA service platform for the unattended robot. Additionally or alternatively, the low-code application development platform may provide manned robot functionality for the manned robot on the user device. The RPA service platform may include one or more RPA procedures associated with RPA functionality.

As shown in fig. 9C, the icon "+" is used to initiate the connection process with the RPA service platform. When the developer clicks the "+" icon, a window 916 is presented on the design portion 904, the window 916 including input fields such as the URL of the RPA service platform, the tenant name of the low code application development platform, and the user password. After the detailed information is submitted in the input field, the low-code application development platform is connected with the RPA service platform. In some embodiments, the process of connecting to the orchestrator may be a one-time authentication process.

In some embodiments, clicking on the "+" icon may also give the option of "continue existing RPA service platform" or "add new RPA service platform connection" when a low code application development platform has been connected to an RPA service platform. A selection of the option "continue existing RPA service platform" may provide a list of available RPA procedures associated with the corresponding RPA service platform without an authentication step, while a selection of the option "add new RPA service platform connection" may prompt the user to provide connection information, such as a URL of the RPA service platform, a tenant name of the low code application development platform, and a user password for a one-time authentication procedure. In some embodiments, clicking on the "+" icon may show the available RPA procedures associated with the RPA service platform when the low code application development platform has been connected to the RPA service platform. The RPA service platform may have the capability to trigger an unattended robot to perform one or more RPA procedures associated with RPA functionality.

After connecting to the RPA service platform, the low code application development platform may display a list of RPA procedures 918, as shown in fig. 9D. The user may select at least one RPA procedure from the displayed list 914 of RPA procedures. The selected RPA procedure may be associated with one or more UI elements, such as UI elements 912 and 914, of one or more user interfaces of the RPA application. The user may associate at least one RPA procedure in the list of RPA procedures 918 with one or more UI elements by using drag-and-drop functionality of the low-code application development platform. Thus, the RPA application may be associated with RPA functionality and further may be capable of locally processing RPA workflows.

The RPA application may be presented on a user device, such as user device 610. The RPA application may function simultaneously with one or more applications being presented on the same user device. For example, RPA application 920 is simultaneously active with other applications concurrently presented in main window 922, as shown in fig. 9E. The user may invoke the RPA procedure associated therewith using the RPA enabled UI element.

In some embodiments, a user may provide input to one or more RPA-enabled UI elements. This may occur in a similar manner as process 800 of fig. 8. Output from the execution of the RPA robot(s) may be presented on the user device through a pop-up window 924, as shown in fig. 9E.

Fig. 10 is a flow diagram illustrating a process 1000 for developing an RPA-enabled application according to an embodiment of the present invention. At 1002, one or more UI elements associated with a user interface of an RPA application are created using drag-and-drop functionality of an application development platform. At 1004, the RPA application is optionally connected to an RPA service platform (e.g., RPA service platform 600 a). This may be done to obtain the RPA process of an unattended RPA robot. At 1006, the UI elements and/or other triggers to be supported RPA in the RPA application are linked with one or more corresponding RPA procedures for manned (local) and/or unmanned (remote) RPA robots. At 1008, an instance of the RPA application is presented on the user device.

Fig. 11 is a flow diagram illustrating a process 1100 for executing an RPA enabled application according to an embodiment of the present invention. In some embodiments, process 1000 of fig. 10 may be performed before process 1100 of fig. 11 to create an RPA-enabled application. At 1102, the RPA application receives a trigger to initiate an RPA robot to perform a task. The trigger may be due to a user interacting with an RPA enabled UI element of an RPA application, an event occurring, a variable being set to a certain value, etc. At 1104, the RPA application sends a process initiation request to an RPA service platform for an unattended robot or to a locally executing attended robot via IPC. In some embodiments, the process initiation request may include a request to run a process integrated with the RPA enabled UI element that received the user interaction or input. At 1106, a job ID may be assigned to the process initiation request for unattended RPA robot execution. At 1108, output generated from the RPA robot running process is received from the robot via IPC, written to a file, retrieved from a database, etc., for the manned RPA robot, or received from the RPA service platform for the unmanned RPA robot. In some embodiments, the unattended robot may send output directly to an instance of an RPA-enabled application. At 1110, output from the RPA robot execution is displayed in the RPA application.

Fig. 12 is a flow diagram illustrating a process 1200 for searching for a manned or unmanned RPA robot to perform an RPA procedure and to perform an RPA procedure in accordance with an embodiment of the present invention. In some embodiments, process 1000 of fig. 10 may be performed before process 1200 of fig. 12 to create an RPA-enabled application. In some embodiments, process 1200 may be used to implement intelligent robot selection of an intelligent robot selection option selected in an application development platform for RPA-enabled applications. The process begins at 1202 with receiving a trigger for RPA robot initiation or interaction. The trigger may be due to a user interacting with an RPA enabled UI element of an RPA application, an event occurring (e.g., an event in the RPA enabled application or another application, a computing system on which the RPA application is executing, or a remote computing system), a variable being set to a certain value or being changed to a certain value, or any other suitable trigger, without departing from the scope of the present invention.

The RPA-enabled application then searches locally 1204 for a manned robot for a process. If a local manned robot is found 1206, then the RPA enabled application executes or causes execution of the manned robot 1208. In some embodiments, communication between an RPA-enabled application and a manned robot may occur via IPC.

If a suitable manned robot for the RPA process is not found at 1206, the RPA enabled application queries the RPA service platform for an unmanned robot for the RPA process at 1210. If a suitable unattended robot is found 1212, the RPA enabled application 1214 causes execution of the unattended robot via the RPA service platform and communicates with the RPA service platform (e.g., via an internet connection using TCP/IP, HTML, via an intranet or LAN, etc.). In some embodiments, in the event that the RPA enabled application is to display information during and/or after execution of the manned or unmanned robot, certain graphical elements of the RPA enabled application may be updated to display this information at 1216. However, if a suitable unattended robot is not found at 1212, the RPA enabled application 1218 raises an exception, and the process then ends.

The process steps performed in fig. 7, 8 and 10-12 may be performed by a computer program encoded with instructions for causing a processor(s) to perform at least a portion of the process (es) described in fig. 7, 8 and 10-12, according to an embodiment of the invention. The computer program may be embodied on a non-transitory computer readable medium. The computer-readable medium may be, but is not limited to, a hard disk drive, a flash memory device, a RAM, a magnetic tape, and/or any other such medium or combination of media for storing data. The computer program may include coded instructions for controlling the processor(s) of the computing system, such as processor(s) 510 of computing system 500 of fig. 5, to implement all or a portion of the process steps described in fig. 7, 8, and 10-12, which may also be stored on a computer-readable medium.

The computer program may be implemented in hardware, software or a hybrid implementation. Computer programs may be comprised of modules that are in operable communication with each other and are designed to communicate information or instructions for display. The computer program may be configured to operate on a general purpose computer, ASIC or any other suitable device.

It will be readily understood that the components of the various embodiments of the present invention, as generally described and illustrated in the figures herein, could be arranged and designed in a wide variety of different configurations. Thus, the detailed description of the embodiments of the present invention, as represented in the figures, is not intended to limit the scope of the invention, as claimed, but is merely representative of selected embodiments of the invention.

The features, structures, or characteristics of the invention described throughout this specification may be combined in any suitable manner in one or more embodiments. For example, reference throughout this specification to "certain embodiments," "some embodiments," or similar language means that a particular feature, structure, or characteristic described in connection with the embodiments is included in at least one embodiment of the present invention. Thus, appearances of the phrases "in certain embodiments," "in some embodiments," "in other embodiments," or similar language throughout this specification do not necessarily all refer to the same group of embodiments and the described features, structures, or characteristics may be combined in any suitable manner in one or more embodiments. Furthermore, the terms "a" and "an" herein do not denote a limitation of quantity, but rather denote the presence of at least one of the referenced item.

It should be noted that reference throughout this specification to features, advantages, or similar language does not imply that all of the features and advantages that may be realized with the present invention should be or are in any single embodiment of the invention. Rather, language referring to the features and advantages is understood to mean that a specific feature, advantage, or characteristic described in connection with an embodiment is included in at least one embodiment of the present invention. Thus, discussion of the features and advantages, and similar language, throughout this specification may, but do not necessarily, refer to the same embodiment.

Furthermore, the described features, structures, or characteristics of the invention may be combined in any suitable manner in one or more embodiments. One skilled in the relevant art will recognize that the invention may be practiced without one or more of the specific features or advantages of a particular embodiment. In other instances, additional features and advantages may be recognized in certain embodiments that may not be present in all embodiments of the invention.

In the following description, for purposes of explanation, numerous specific details are set forth in order to provide a thorough understanding of the present disclosure. It will be apparent, however, to one skilled in the art that the present disclosure may be practiced without these specific details. In other instances, devices and methods have been shown in block diagram form only, in order to avoid obscuring the present disclosure.

One of ordinary skill in the art will readily appreciate that the invention as described above may be practiced with steps in a different order and/or with hardware elements in configurations other than those disclosed. Thus, while the invention has been described based upon these preferred embodiments, it would be apparent to those of ordinary skill in the art that certain modifications, variations, and alternative constructions would be apparent, while remaining within the spirit and scope of the invention. Therefore, to ascertain the metes and bounds of the invention, the appended claims should be referenced.

Claims (20)

1. A computer-implemented method for developing an application that supports Robot Process Automation (RPA), comprising:

linking, by a development application, a trigger in the RPA enabled application to an RPA process to be performed by an RPA robot;

generating, by the development application, an instance of the RPA-enabled application that includes the linked trigger; and

deploying, by the development application, the instance of the RPA-enabled application to a computing system.

2. The computer-implemented method of claim 1, wherein the triggering comprises: user interaction with a User Interface (UI) element, an event occurring in the RPA enabled application or another application, an event occurring in the computing system to which the RPA enabled application is deployed or in a remote computing system, a variable of the RPA enabled application, a variable of another application, a variable of an RPA robot, a variable of an operating system, or a combination thereof.

3. The computer-implemented method of claim 1, wherein the developing an application comprises: drag and drop functionality, click functionality, user specified formulas and expressions, or combinations thereof, for placing User Interface (UI) elements in the UI of the RPA enabled application.

4. The computer-implemented method of claim 1, wherein the development application is or includes an RPA development platform.

5. The computer-implemented method of claim 1, wherein the RPA robot is a manned RPA robot executed on the computing system to which the RPA enabled application is deployed or an unmanned robot remotely accessible by the RPA enabled application via an RPA service platform.

6. The computer-implemented method of claim 1, further comprising:

receiving, by the RPA enabled application, the trigger for initiation of the RPA procedure;

sending a process initiation request to an RPA service platform for an unattended robot or to a locally executed attended robot via inter-process communication (IPC); and

receiving an output generated from running the RPA process from the manned robot via an IPC, or receiving the output generated from running the RPA process from the RPA service platform for the unmanned RPA robot.

7. The computer-implemented method of claim 6, further comprising:

displaying, by the RPA-enabled application, results from the output generated from running the process in a User Interface (UI).

8. The computer-implemented method of claim 1, further comprising:

setting, by the development application, a robot-type variable for the triggering to be attended, unattended, or intelligent.

9. The computer-implemented method of claim 8, wherein when the robot type variable for the trigger is set to intelligent, the method further comprises:

receiving, by the RPA enabled application, the trigger for initiation of the RPA procedure;

locally searching, by the RPA enabled application, for a manned robot for the RPA process; and

causing, by the RPA-enabled application, the manned robot to perform the RPA procedure when a suitable local manned robot for the RPA procedure is found.

10. The computer-implemented method of claim 9, wherein when the suitable locally attended robot for the RPA procedure is not found, the method further comprises:

querying, by the RPA enabled application, an RPA service platform for an appropriate unattended robot for the RPA procedure; and

causing execution of the unmanned robot by the RPA enabled application when the suitable unmanned robot for the RPA procedure is found.

11. A computer program, embodied on a non-transitory computer readable medium, for developing an application that supports robot flow automation (RPA), the program configured to cause at least one processor to:

linking a trigger in the RPA enabled application to an RPA process to be performed by an RPA robot;

generating an instance of the RPA enabled application that includes the linked trigger; and

deploying the instance of the RPA-enabled application to a computing system.

12. The computer program of claim 11, wherein the triggering comprises: user interaction with a User Interface (UI) element, an event occurring in the RPA enabled application or another application, an event occurring in the computing system to which the RPA enabled application is deployed or in a remote computing system, a variable of the RPA enabled application, a variable of another application, a variable of an RPA robot, a variable of an operating system, or a combination thereof.

13. The computer program of claim 11, wherein the developing an application comprises: drag and drop functionality, click functionality, user specified formulas and expressions, or combinations thereof, for placing User Interface (UI) elements in the UI of the RPA enabled application.

14. The computer program of claim 11, wherein the program is or includes an RPA development platform.

15. The computer program of claim 11, wherein the RPA robot is a manned RPA robot executed on the computing system to which the RPA enabled application is deployed or an unmanned robot remotely accessible by the RPA enabled application via an RPA service platform.

16. The computer program of claim 11, wherein the program is further configured to cause the at least one processor to:

setting a robot-type variable for the triggering to be attended, unattended or intelligent.

17. A computer program embodied on a non-transitory computer readable medium, the program configured to cause at least one processor to:

receiving a trigger for initiation of a Robot Procedure Automation (RPA) process to be performed by an RPA robot;

sending a process initiation request to an RPA service platform for an unattended robot, or to a locally executed attended robot via inter-process communication (IPC); and

receiving an output generated from running the RPA process from the manned robot via an IPC, or receiving the output generated from running the RPA process from the RPA service platform for the unmanned RPA robot.

18. The computer program of claim 17, wherein the program is further configured to cause the at least one processor to:

displaying results from the output generated from running the process in a User Interface (UI) of the RPA-enabled application.

19. The computer program of claim 17, wherein when the robot type variable for the trigger is set to intelligent, the program is further configured to cause the at least one processor to:

receiving the trigger for initiation of the RPA procedure;

locally searching for a manned robot for the RPA process; and

causing the manned robot to perform the RPA process when a suitable local manned robot for the RPA process is found.

20. The computer program of claim 19, wherein when the suitable locally attended robot for the RPA procedure is not found, the program is further configured to cause the at least one processor to:

querying an RPA service platform for an appropriate unattended robot for the RPA process; and

causing execution of the unmanned robot when the suitable unmanned robot for the RPA procedure is found.

Images