Task processing method, system, storage medium and electronic device

Abstract

The application provides a task processing method, system, storage medium and electronic equipment, the method comprising: a near-end device determines and sends a starting instruction of a target RPA task to a server in response to a starting operation of the target RPA task; the server determines an execution end from the near-end device and a cloud end according to the starting instruction of the target RPA task, and sends an RPA instruction set of the target RPA task to the execution end; the execution end executes each RPA instruction in the RPA instruction set of the target RPA task to obtain an execution result of the target RPA task; and the near-end device acquires and displays the execution result of the target RPA task. Based on the scheme, the server flexibly determines the execution end from the near-end device and the cloud end according to the starting instruction of the target RPA task, significantly improves the flexibility of RPA task processing, and effectively meets the diversified processing requirements of RPA tasks.

Description

Technical Field

[0001] This specification relates to the field of computer technology, and more specifically, to a task processing method, system, storage medium, and electronic device in the field of computer technology. Background Technology

[0002] Robotic Process Automation (RPA) is a technology that automates workflows by using software robots to simulate human operations. In related technologies, RPA tasks initiated by local devices are typically processed either by the local device or by the cloud. This fixed approach of having either the local device or the cloud handle RPA tasks makes it difficult to flexibly meet the diverse processing needs of RPA tasks. Summary of the Invention

[0003] This specification provides a task processing method, system, storage medium, and electronic device that can improve the flexibility of RPA task processing and effectively meet the diverse processing needs of RPA tasks.

[0004] Firstly, a task processing method is provided for use in a near-end device, the method comprising:

[0005] In response to the start operation of the target RPA task, the start command of the target RPA task is determined and sent to the server. The server then determines the execution end from the near-end device and the cloud according to the start command of the target RPA task and sends the RPA instruction set of the target RPA task to the execution end.

[0006] The execution result of the target RPA task is obtained and displayed. The execution result of the target RPA task is obtained by the execution end executing each RPA instruction in the RPA instruction set of the target RPA task.

[0007] In conjunction with the first aspect, in some possible implementations, when the near-end device is determined to be the execution end, in response to the start operation of the target RPA task, after determining the start instruction of the target RPA task and sending the start instruction of the target RPA task to the server, and before obtaining and displaying the execution result of the target RPA task, the method further includes: receiving the RPA instruction set of the target RPA task sent by the server; executing each RPA instruction in the RPA instruction set of the target RPA task to obtain the execution result of the target RPA task.

[0008] Combining the first aspect and the above implementation methods, in some possible implementation methods, when the cloud is identified as the execution end, the execution result of the target RPA task is obtained and displayed, including: receiving the execution result of the target RPA task sent by the cloud through the server; and displaying the execution result of the target RPA task.

[0009] In combination with the first aspect and the above implementation methods, in some possible implementation methods, when the cloud is determined as the execution end, after determining the start instruction of the target RPA task in response to the start operation of the target RPA task and sending the start instruction of the target RPA task to the server, and before obtaining and displaying the execution result of the target RPA task, the method further includes: receiving the human-computer interaction RPA instruction sent by the cloud through the server; rendering and displaying the human-computer interaction interface according to the human-computer interaction RPA instruction; determining the human-computer interaction result information in response to the interaction operation on the human-computer interaction interface; and sending the human-computer interaction result information to the cloud through the server.

[0010] Combining the first aspect and the above implementation methods, in some possible implementation methods, rendering and displaying the human-computer interaction interface according to the human-computer interaction RPA instructions includes: rendering and displaying interactive prompts and interactive controls according to the human-computer interaction RPA instructions to form the human-computer interaction interface, wherein the interactive prompts are used to prompt the user to perform interactive operations, and the interactive controls are used to respond to the user's interactive operations.

[0011] Secondly, a task processing method is provided for application on the server side, the method including:

[0012] Receive the start command for the target RPA task sent by the near-end device;

[0013] Based on the start command of the target RPA task, determine the execution end from the near-end device and the cloud;

[0014] The RPA instruction set of the target RPA task is sent to the execution end, so that the execution end can execute each RPA instruction in the RPA instruction set of the target RPA task to obtain the execution result of the target RPA task. The near-end device obtains and displays the execution result of the target RPA task.

[0015] In conjunction with the second aspect, in some possible implementations, the execution end is determined from the near-end device and the cloud based on the start command of the target RPA task, including: determining the permission level of the target RPA task based on the start command of the target RPA task; if the permission level of the target RPA task is higher than the preset reference permission level, the near-end device is determined as the execution end; if the permission level of the target RPA task is not higher than the preset reference permission level, the cloud is determined as the execution end.

[0016] In conjunction with the second aspect and the above implementation methods, in some possible implementation methods, when the cloud is determined as the execution end, after sending the RPA instruction set of the target RPA task to the execution end, the method further includes: determining the status of each RPA executor in the cloud, wherein the status of the RPA executor includes a busy state and an idle state; determining the target RPA executor from the idle RPA executors in the cloud; generating an RPA executor invocation instruction based on the target RPA executor, and sending the RPA executor invocation instruction to the cloud, wherein the RPA executor invocation instruction is used to instruct the cloud to invoke the target RPA executor to execute each RPA instruction in the RPA instruction set of the target RPA task.

[0017] Thirdly, a task processing method is provided for cloud application, which includes:

[0018] Receive the RPA instruction set of the target RPA task sent by the server. The RPA instruction set of the target RPA task is sent by the server to the cloud after determining that the cloud is the execution end from the near-end device and the cloud according to the start instruction of the target RPA task.

[0019] The execution results of each RPA instruction in the RPA instruction set of the target RPA task are obtained, so that the near-end device can obtain and display the execution results of the target RPA task.

[0020] In conjunction with the third aspect, in some possible implementations, the execution results of each RPA instruction in the RPA instruction set of the target RPA task are obtained, so that the near-end device can obtain and display the execution results of the target RPA task. This includes: determining the execution order of each RPA instruction in the RPA instruction set of the target RPA task; traversing each RPA instruction sequentially according to the execution order of each RPA instruction in the RPA instruction set of the target RPA task; executing the current RPA instruction among the traversed RPA instructions; and if the last RPA instruction in the execution order has been executed, the execution result of the target RPA task is obtained, and the execution result of the target RPA task is sent to the near-end device through the server so that the near-end device can receive and display the execution result of the target RPA task.

[0021] Combining the third aspect and the above implementation methods, in some possible implementation methods, for the current RPA instruction among the traversed RPA instructions, the current RPA instruction is executed, including: for the current RPA instruction among the traversed RPA instructions, if the current RPA instruction is a human-computer interaction RPA instruction, the human-computer interaction RPA instruction is sent to the near-end device through the server, the near-end device renders and displays the human-computer interaction interface according to the human-computer interaction RPA instruction, determines the human-computer interaction result information in response to the interaction operation on the human-computer interaction interface, sends the human-computer interaction result information to the cloud through the server, and receives the human-computer interaction result information.

[0022] Combining the third aspect and the above implementation methods, in some possible implementation methods, for the current RPA instruction among the traversed RPA instructions, the current RPA instruction is executed, including: for the current RPA instruction among the traversed RPA instructions, if the current RPA instruction is an interaction pre-RPA instruction whose execution order precedes the human-computer interaction RPA instruction, then the interaction prompt information is obtained according to the interaction pre-RPA instruction, and the interaction prompt information is filled into the human-computer interaction RPA instruction. The interaction prompt information is used to prompt the user to perform interactive operations in the human-computer interaction interface rendered and displayed by the near-end device according to the human-computer interaction RPA instruction.

[0023] Combining the third aspect and the above implementation methods, in some possible implementation methods, for the current RPA instruction among the traversed RPA instructions, the current RPA instruction is executed, including: for the current RPA instruction among the traversed RPA instructions, if the current RPA instruction is an interaction-following RPA instruction whose execution order is after the human-computer interaction RPA instruction, then the interaction-following RPA instruction is executed according to the received human-computer interaction result information, wherein the human-computer interaction result information is the human-computer interaction interface rendered and displayed by the near-end device according to the human-computer interaction RPA instruction, and the response to the interaction operation on the human-computer interaction interface is determined and sent to the cloud through the server.

[0024] In conjunction with the third aspect and the above implementation methods, in some possible implementation methods, after receiving the RPA instruction set of the target RPA task sent by the server, and before executing each RPA instruction in the RPA instruction set of the target RPA task to obtain the execution result of the target RPA task, the method further includes: receiving an RPA executor invocation instruction sent by the server, wherein the RPA executor invocation instruction is generated by the server based on the target RPA executor in the cloud, and the target RPA executor is determined by the server from the idle RPA executors in the cloud; executing each RPA instruction in the RPA instruction set of the target RPA task to obtain the execution result of the target RPA task includes: invoking the target RPA executor to execute each RPA instruction in the RPA instruction set of the target RPA task according to the RPA executor invocation instruction to obtain the execution result of the target RPA task.

[0025] Fourthly, a task processing system is provided, which includes a near-end device, a server, and a cloud.

[0026] The near-end device is used to respond to the start operation of the target RPA task, determine the start command of the target RPA task, send the start command of the target RPA task to the server, and obtain and display the execution result of the target RPA task.

[0027] The server is used to receive the start command of the target RPA task sent by the near-end device; determine the execution end from the near-end device and the cloud according to the start command of the target RPA task; and send the RPA instruction set of the target RPA task to the execution end so that the execution end can execute each RPA instruction in the RPA instruction set of the target RPA task to obtain the execution result of the target RPA task.

[0028] The cloud is used to receive the RPA instruction set of the target RPA task sent by the server. The RPA instruction set of the target RPA task is sent by the server to the cloud after determining that the cloud is the execution end based on the start instruction of the target RPA task from the near-end device and the cloud. The execution result of the target RPA task is obtained by executing each RPA instruction in the RPA instruction set of the target RPA task.

[0029] Fifthly, a computer-readable storage medium is provided that stores computer program code, which, when executed on a computer, causes the computer to perform the methods described in the first, second, or third aspects, or any possible implementation thereof.

[0030] In a sixth aspect, an electronic device is provided, comprising: a processor and a memory; wherein the memory stores a computer program adapted to be loaded by the processor and to execute the steps of the method described above.

[0031] In a seventh aspect, a computer program product is provided, comprising: computer program code, which, when run on a computer, causes the computer to perform the methods of the first aspect, the second aspect, the third aspect, or any possible implementation of the first aspect, the second aspect, or the third aspect.

[0032] In the embodiments described in this specification: The near-end device responds to the start operation of the target RPA task by determining and sending the start command of the target RPA task to the server; the server determines the execution end from the near-end device and the cloud based on the start command of the target RPA task, and sends the RPA instruction set of the target RPA task to the execution end; the execution end executes each RPA instruction in the RPA instruction set of the target RPA task to obtain the execution result of the target RPA task; the near-end device obtains and displays the execution result of the target RPA task. Thus, by introducing a server, the execution end can be flexibly determined from the near-end device and the cloud based on the start command of the target RPA task, significantly improving the flexibility of RPA task processing. It is not limited to RPA tasks being processed solely by the near-end device or the cloud, effectively meeting the diverse processing needs of RPA tasks. Attached Figure Description

[0033] Figure 1 This is a schematic diagram of the architecture of a task processing system provided in the embodiments of this specification;

[0034] Figure 2 This is a flowchart illustrating a task processing method provided in an embodiment of this specification;

[0035] Figure 3 This is a flowchart illustrating a human-computer interaction process provided in the embodiments of this specification;

[0036] Figure 4 This is a schematic diagram illustrating an example of a human-computer interaction interface provided in the embodiments of this specification;

[0037] Figure 5 This is a schematic diagram illustrating an example of a human-computer interaction interface provided in the embodiments of this specification;

[0038] Figure 6 This is a schematic diagram illustrating an example of a human-computer interaction interface provided in the embodiments of this specification;

[0039] Figure 7 This is a flowchart illustrating a task processing method provided in an embodiment of this specification;

[0040] Figure 8 This is a schematic diagram illustrating an example of the unit configuration of a server provided in the embodiments of this specification;

[0041] Figure 9 This is a schematic diagram illustrating an example of a cloud-based RPA executor call provided in the embodiments of this specification;

[0042] Figure 10 This is a flowchart illustrating a task processing method provided in an embodiment of this specification;

[0043] Figure 11This is a flowchart illustrating the execution of RPA instructions provided in an embodiment of this specification;

[0044] Figure 12 This is an interactive diagram illustrating the execution of instructions by a near-end device, as provided in an embodiment of this specification.

[0045] Figure 13 This is an interactive diagram illustrating the execution of instructions by a near-end device in a logistics information query scenario, provided by an embodiment of this specification.

[0046] Figure 14 This is an interactive diagram illustrating a cloud-based execution instruction provided in an embodiment of this specification;

[0047] Figure 15 This is an interactive diagram illustrating the execution of instructions in the cloud during a logistics information query scenario, as provided in the embodiments of this specification.

[0048] Figure 16 This is a schematic diagram of the structure of an electronic device provided in the embodiments of this specification. Detailed Implementation

[0049] The technical solutions in this specification will now be described clearly and in detail with reference to the accompanying drawings. In the description of the embodiments in this specification, unless otherwise stated, " / " indicates "or," for example, A / B can mean A or B. "And / or" in the text is merely a description of the relationship between related objects, indicating that three relationships can exist. For example, A and / or B can represent: A existing alone, A and B existing simultaneously, and B existing alone. Furthermore, in the description of the embodiments in this specification, "multiple" refers to two or more than two.

[0050] Hereinafter, the terms "first" and "second" are used for descriptive purposes only and should not be construed as implying or suggesting relative importance or implicitly indicating the number of technical features indicated. Thus, a feature defined as "first" or "second" may explicitly or implicitly include one or more of that feature.

[0051] RPA (Robotic Process Automation) is a technology that automates transaction processes by using software robots to simulate human operations. In related technologies, RPA tasks initiated by local devices are typically processed either by the local device or by the cloud. This approach of always having one end handle RPA tasks has several drawbacks. For example, local devices have limited computing resources. For certain resource-intensive RPA tasks, always having the local device handle them can severely impact its efficiency. Furthermore, the cloud environment is more vulnerable to external attacks and unauthorized access compared to local devices. For high-privilege RPA tasks, always having the cloud handle them could lead to data security and privacy breaches. In short, always having one end handle RPA tasks, either the local device or the cloud, makes it difficult to flexibly meet the diverse processing needs of RPA tasks.

[0052] To address these issues, embodiments of this specification propose introducing a server between the near-end device and the cloud. See also... Figure 1 , Figure 1 This is a schematic diagram of the architecture of a task processing system provided in the embodiments of this specification. The task processing system includes a near-end device, a server, and a cloud, each comprising corresponding hardware and software. For example, the near-end device can be a user's personal computer, smartphone, or tablet; the server and cloud can be servers, service devices, or server clusters. The above examples do not constitute a limitation on the specific implementation form or type of the near-end device, server, or cloud in this specification. It should be noted that in some cases, the server and cloud each have independent hardware, meaning they do not share hardware; while in other cases, the server and cloud share all or part of the hardware.

[0053] The near-end device communicates with the server, and the server communicates with the cloud. In other words, data transmission between the near-end device and the cloud is achieved through the server's data forwarding function. For RPA tasks initiated by the near-end device, the server can flexibly select either the near-end device or the cloud to primarily handle the RPA task, and ensure necessary data interaction between the near-end device and the cloud during the RPA task processing, thus providing support from both the near-end device and the cloud for the RPA task processing.

[0054] based on Figure 1 The system architecture shown below will be combined with... Figure 2 - Figure 15 This document provides a detailed description of the task processing methods provided in the embodiments of this specification.

[0055] Please see Figure 2This is a flowchart illustrating a task processing method provided in an embodiment of this specification. Figure 2 As shown, the method of the embodiments of this specification is applied to a near-end device and may include the following steps S102-S104.

[0056] S102, in response to the start operation of the target RPA task, determines the start instruction of the target RPA task and sends the start instruction of the target RPA task to the server, so that the server can determine the execution end from the near-end device and the cloud according to the start instruction of the target RPA task and send the RPA instruction set of the target RPA task to the execution end.

[0057] Specifically, the RPA task involved in this embodiment refers to a task that uses a software robot to simulate human operations, thereby automating transaction processes. RPA tasks can involve multiple aspects such as data input, data processing, and system interaction. There is at least one RPA task supported by both the near-end device and the cloud. The target RPA task refers to the RPA task determined based on the user's initiation operation on the near-end device, among at least one RPA task supported by both the near-end device and the cloud. The target RPA task can also be understood as representing a specific RPA task that the user currently needs to focus on or process. It is understood that the target RPA task can be one or more RPA tasks, and this embodiment does not limit this.

[0058] First, the user initiates the target RPA task on the near-end device. Correspondingly, the near-end device determines the target RPA task's start command. This start command is the specific instruction used to initiate the target RPA task. It includes at least the target RPA task's identification information, which distinguishes different RPA tasks. In addition, the specific command may include other parameters that help instruct the processing of the target RPA task.

[0059] In one possible implementation, the near-end device provides an RPA task startup interface, which includes a startup control corresponding to the target RPA task. When a user clicks the startup control corresponding to the target RPA task in the RPA task startup interface, it is considered that a startup operation for the target RPA task has been initiated. Accordingly, the near-end device responds to the startup operation of the target RPA task by determining the startup instruction for the target RPA task.

[0060] In one possible implementation, the target RPA task is configured to be bound to other user operations on the near-end device. For example, the target RPA task is configured to be bound to a user's power-on operation on the near-end device. When the user powers on the near-end device, this binding relationship is considered as a start operation for the target RPA task. Accordingly, the near-end device, in response to the start operation of the target RPA task, determines the start instruction for the target RPA task.

[0061] In addition to the two possible implementation methods listed above, triggering the start operation of the target RPA task based on a physical button, triggering the start operation of the target RPA task based on a timer, etc. are all optional implementation methods, which will not be listed one by one in this embodiment.

[0062] After determining the start command for the target RPA task, the near-end device sends the start command to the server. Correspondingly, the server receives the start command, determines the execution end from the near-end device and the cloud based on the target RPA task, and sends the RPA instruction set for the target RPA task to the execution end.

[0063] The RPA instruction set for the target RPA task can be pre-stored on the server or generated in real-time by the server based on the target RPA task. The RPA instruction set for the target RPA task includes at least one RPA instruction for the target RPA task. The execution end's processing of the target RPA task essentially involves executing the RPA instructions within the target RPA task's instruction set. RPA instructions are a series of commands that instruct the execution end to automatically execute corresponding steps, simulating human operation to automate the transaction process.

[0064] In one possible implementation, the RPA directive includes the following parameters:

[0065] Basic attribute parameters include at least one of the following: RPA instruction name, RPA instruction identifier, and remarks. The RPA instruction name identifies the specific name of the RPA instruction; the RPA instruction identifier uniquely identifies the number of each RPA instruction; and the remarks provide additional explanations or comments for the RPA instruction.

[0066] Type parameters: These include at least one of operation type and interaction type. Operation type defines the specific operation executed by the RPA command, such as operations on a webpage (opening a website, controlling UI elements, retrieving UI element values), operations on the network (retrieving remote HTTP / WS / TCP / UDF protocol interface data), operations on local files (creating, deleting, modifying, and querying local files), operations on the execution system (calling operating system windows, command execution windows, etc.), and operations on large models (generating text or image content based on contextual prompts), etc. Further details are omitted here. Interaction type indicates the type of RPA command requiring human intervention, used to achieve human-computer collaboration.

[0067] Input parameters: These represent dependency information and are used to indicate the input data required for the execution of RPA instructions. For example, an RPA instruction to open a URL needs to specify a Uniform Resource Locator (URL), and an RPA instruction to retrieve page element values ​​needs to specify the XML path (or XPath) of the page's Document Object Model (DOM) or a Cascading Style Sheets Selector (CSS Selector).

[0068] Output parameters include at least one of the following: normal output value, abnormal environment information, and execution result status. The normal output value is the return result after successful execution of the RPA instruction; the abnormal environment information is the environment information captured when an RPA instruction execution encounters an error; and the execution result status indicates the result of the RPA instruction execution, including success, failure, and interruption.

[0069] Fault tolerance parameters: characterize the fault tolerance mechanism. The fault tolerance mechanism indicates the measures taken when RPA instruction execution encounters abnormal conditions, such as execution timeout handling, retry mechanisms, or interruption of execution.

[0070] Execution order parameter: Characterizes the execution order of RPA instructions, ensuring that each RPA instruction corresponding to the RPA task is executed in a predetermined order.

[0071] The above parameters together constitute the complete definition of RPA instructions, supporting the flexible combination of automated operation and manual intervention in various transaction scenarios for RPA tasks.

[0072] In one possible scenario, the near-end device is designated as the execution end. The near-end device receives the RPA instruction set of the target RPA task sent by the server, executes each RPA instruction in the target RPA task instruction set in sequence, and obtains the execution result of the target RPA task.

[0073] In one possible scenario, the cloud is designated as the execution end. The cloud receives the RPA instruction set of the target RPA task sent by the server, executes each RPA instruction in the target RPA task instruction set in sequence, obtains the execution result of the target RPA task, and then sends the execution result of the target RPA task to the near-end device through the server.

[0074] It should be noted that the execution result of the target RPA task refers to the information obtained after the target RPA task is completed. This may include output values ​​(such as the data that needs to be obtained), abnormal environment information (such as the context when an error occurs), execution status (such as execution success or execution failure), and any output from manual intervention, comprehensively reflecting the final execution status of the target RPA task.

[0075] S104, Obtain and display the execution result of the target RPA task, wherein the execution result of the target RPA task is obtained by the execution end executing each RPA instruction in the RPA instruction set of the target RPA task.

[0076] Specifically, in one possible scenario, if the near-end device is designated as the execution end, then the near-end device executes each RPA instruction in the RPA instruction set of the target RPA task to obtain the execution result of the target RPA task, and the execution result of the target RPA task is stored locally on the near-end device. Furthermore, the near-end device can first retrieve the locally stored execution result of the target RPA task, and then display the execution result of the target RPA task.

[0077] In one possible scenario, if the cloud is designated as the execution end, then the cloud executes each RPA instruction in the target RPA task's RPA instruction set to obtain the execution result of the target RPA task. The cloud then sends the execution result of the target RPA task to the near-end device through the server. Furthermore, the near-end device can receive the execution result of the target RPA task and display it.

[0078] It should be noted that in one possible implementation, during the processing of the target RPA task, the user can terminate the task on the near-end device. Accordingly, the near-end device responds to the termination operation by determining a termination instruction and sending it to the server. The server receives the termination instruction and terminates the processing of the target RPA task on the executor according to the instruction. This allows the user to decide whether to terminate the processing of the target RPA task.

[0079] It should be noted that the aforementioned near-end devices can run on any operating system, such as Windows, Linux, macOS, iOS, Android, HarmonyOS, etc., without any restrictions.

[0080] In this embodiment, the near-end device responds to the start operation of the target RPA task by determining and sending the start command of the target RPA task to the server. The server, based on the start command, determines the execution end from both the near-end device and the cloud, and sends the RPA instruction set of the target RPA task to the execution end. The execution end executes each RPA instruction in the RPA instruction set of the target RPA task to obtain the execution result of the target RPA task. The near-end device then obtains and displays the execution result of the target RPA task. Thus, by introducing a server, the execution end can be flexibly determined from both the near-end device and the cloud based on the start command of the target RPA task, significantly improving the flexibility of RPA task processing. It is not limited to RPA tasks being processed solely by the near-end device or the cloud, effectively meeting the diverse processing needs of RPA tasks.

[0081] In one embodiment, when the near-end device is determined to be the execution end, in Figure 2 In the illustrated embodiment, after step S102 and before step S104, the following steps may also be included:

[0082] Receive the RPA instruction set for the target RPA task sent by the server;

[0083] The execution results of the target RPA task are obtained by executing each RPA instruction in the RPA instruction set.

[0084] Specifically, when the near-end device is identified as the execution end, the server sends the RPA instruction set of the target RPA task to the near-end device. Correspondingly, the near-end device receives the RPA instruction set of the target RPA task sent by the server; determines the execution order of each RPA instruction in the target RPA task's RPA instruction set; sequentially traverses each RPA instruction according to the execution order of the target RPA task's RPA instruction set; executes the current RPA instruction among the traversed RPA instructions; and if the last RPA instruction in the execution order has been executed, the execution result of the target RPA task is obtained.

[0085] In one possible implementation, for any of the aforementioned RPA instructions, during the execution of the RPA instruction, the near-end device obtains the required data based on the input parameters of the RPA instruction and performs the corresponding operation (such as opening a website or filling in an input box) according to the operation type. After the RPA instruction is executed, it generates output parameters, including normal output values, abnormal environment information, and execution result status. The near-end device may collect the output parameters of the RPA instruction to provide them as input parameters for the next RPA instruction, or to form the execution result of the target RPA task.

[0086] In this embodiment, the server assigns the target RPA task to a local device for processing. The local device receives the RPA instruction set for the target RPA task sent by the server and executes each RPA instruction in the RPA instruction set to obtain the execution result of the target RPA task. For some RPA tasks that require human-computer interaction or have sensitive permissions, this embodiment can effectively meet the processing needs of such RPA tasks, improve the convenience of human-computer interaction, and enhance the security of RPA task processing.

[0087] In one embodiment, when the cloud is identified as the execution endpoint, the cloud... Figure 2 Step S104 in the illustrated embodiment can be further refined and may include the following steps:

[0088] Receive the execution results of the target RPA task sent from the cloud via the server;

[0089] Displays the execution results of the target RPA task.

[0090] Specifically, when the target RPA task is identified as the execution end in the cloud, the server sends the RPA instruction set of the target RPA task to the cloud. Correspondingly, the cloud receives the RPA instruction set of the target RPA task sent by the server; determines the execution order of each RPA instruction in the target RPA task's RPA instruction set; iterates through each RPA instruction sequentially according to the execution order; for each RPA instruction encountered during the iteration, the current RPA instruction is executed; if the last RPA instruction in the execution order has been executed, the execution result of the target RPA task is obtained. Further, the cloud sends the execution result of the target RPA task to the near-end device through the server.

[0091] Accordingly, the near-end device receives the execution result of the target RPA task and then displays it. To facilitate understanding of this embodiment regarding the display of the target RPA task's execution result, several examples are provided below:

[0092] In one example, if the result of the target RPA task includes text information, the near-end device can display that text information in a text box or label.

[0093] In one example, if the result of the target RPA task includes image information, the near-end device can display that image information on an interface.

[0094] In one example, if the execution result of the target RPA task contains multiple data items, and these data items have a clear structural relationship, a corresponding table can be constructed and displayed based on the execution result of the target RPA task. Each row of the table represents a data item, and each column represents an attribute of the data item.

[0095] In one example, for the execution results of a target RPA task that requires visualization analysis, the near-end device can construct and display corresponding charts (such as line charts, bar charts, pie charts, etc.) based on the execution results of the target RPA task.

[0096] In one example, if the execution result of the target RPA task needs to be promptly communicated to the user, the near-end device can use a pop-up window to display the execution result of the target RPA task.

[0097] In one example, if the execution result of the target RPA task affects certain interface elements (such as button states, input box contents, etc.) of the near-end device interface, the near-end device can update the state or content of these interface elements according to the execution result of the target RPA task.

[0098] It should be noted that the above example does not constitute a limitation on the step of displaying the execution result of the target RPA task. The execution result of the target RPA task may include a variety of information, and the way to display the execution result of the target RPA task can also be varied.

[0099] In this embodiment, the server assigns the target RPA task to the cloud for processing. The cloud can receive the RPA instruction set of the target RPA task sent by the server and execute each RPA instruction in the RPA instruction set of the target RPA task to obtain the execution result of the target RPA task. The near-end device can obtain the execution result of the target RPA task. For some RPA tasks that require a lot of resources or are not sensitive to permissions, this embodiment can effectively meet the processing needs of such RPA tasks, reduce the resource consumption of the near-end device, and improve the efficiency of RPA task processing by utilizing the computing power of the cloud.

[0100] Please see Figure 3 This document provides a flowchart illustrating a human-computer interaction process for an embodiment of this specification. Figure 3 As shown, when the cloud is identified as the execution terminal, the method in the embodiments of this specification is... Figure 2 In the illustrated embodiment, after step S102 and before step S104, the following steps S202-S208 may also be included.

[0101] S202, receives human-computer interaction RPA commands sent from the cloud via the server;

[0102] S204, Render and display the human-computer interaction interface according to the human-computer interaction RPA instructions;

[0103] S206, determine the human-computer interaction result information in response to the interactive operation on the human-computer interaction interface;

[0104] S208 sends human-computer interaction result information to the cloud via the server.

[0105] Specifically, when the cloud is identified as the execution end, it receives the RPA instruction set of the target RPA task sent by the server; determines the execution order of each RPA instruction in the target RPA task's RPA instruction set; and executes each RPA instruction sequentially according to the execution order of each RPA instruction in the target RPA task's RPA instruction set.

[0106] During the sequential execution of RPA commands in the cloud, some commands may be human-computer interaction (HCI) commands. HCI commands require human intervention to complete. Since the cloud cannot be directly operated by the user or lacks the necessary permissions, it cannot independently complete the interactive actions required by these commands. Therefore, the cloud executes HCI commands by sending them from the server to the local device.

[0107] Accordingly, the near-end device receives human-computer interaction RPA instructions sent from the cloud via the server, and then renders and displays the human-computer interaction interface according to the human-computer interaction RPA instructions.

[0108] In one possible implementation, the human-computer interaction RPA instructions contain interface configuration information required for rendering and displaying the human-computer interaction interface. In this case, the near-end device parses the interface configuration information from the human-computer interaction RPA instructions and renders and displays the human-computer interaction interface according to the interface configuration information.

[0109] In one possible implementation, the human-computer interaction RPA instruction does not contain the interface configuration information required for rendering and displaying the human-computer interaction interface, but the near-end device locally stores the interface configuration information required for rendering and displaying the human-computer interaction interface. In this case, the near-end device calls the locally stored interface configuration information according to the human-computer interaction RPA instruction, and renders and displays the human-computer interaction interface according to the interface configuration information.

[0110] The aforementioned interface configuration information refers to the various information required to describe and construct a human-computer interaction interface. For example, interface configuration information may include the layout, style, color, font, interactive control type, interactive control position, interactive control size, interactive control properties, and the specific configuration of interface elements such as text and images that need to be displayed on the human-computer interaction interface.

[0111] The aforementioned human-computer interaction interface includes at least interactive controls. Interactive controls refer to interface elements in the human-computer interaction interface used for interaction with the user. Interactive controls typically have specific functions and behaviors, are able to respond to user interaction operations, and execute corresponding logical steps or display corresponding results based on the user's interaction operations.

[0112] Therefore, users can interact with the interactive controls in the human-computer interaction interface. Correspondingly, the near-end device determines the human-computer interaction result information in response to the interactive operations on the human-computer interaction interface. These interactive operations can include data input operations and decision operations. The human-computer interaction result information determined by the near-end device in response to data input operations on the human-computer interaction interface may include the input data corresponding to the data input operation; the human-computer interaction result information determined by the near-end device in response to decision operations on the human-computer interaction interface may include the decision data corresponding to the decision operation.

[0113] After receiving the human-computer interaction result information, the near-end device sends the human-computer interaction result information to the cloud through the server. Correspondingly, the cloud receives the human-computer interaction result information and executes subsequent RPA instructions based on the human-computer interaction result information.

[0114] In this embodiment, for situations where manual intervention is required during the processing of a target RPA task in the cloud, the cloud can send human-computer interaction commands to the near-end device via the server. The near-end device, based on the received human-computer interaction commands, renders and displays a human-computer interaction interface, determines the human-computer interaction result information in response to the interactive operations on the interface, and sends the human-computer interaction result information back to the cloud via the server. Thus, the cloud can execute subsequent RPA commands based on the received human-computer interaction result information. Based on this embodiment, the problem of inconvenient manual intervention during cloud-based RPA task processing can be solved. While fully utilizing the cloud's computing power to improve RPA task processing efficiency, it also allows for necessary manual intervention from the near-end device, improving both the efficiency and stability of RPA task processing.

[0115] In one embodiment, for Figure 3 Step S204 in the illustrated embodiment can be further refined and may include the following steps:

[0116] The human-computer interaction RPA command renders and displays interactive prompts and interactive controls to form a human-computer interaction interface. The interactive prompts are used to prompt the user to perform interactive operations, and the interactive controls are used to respond to the user's interactive operations.

[0117] Specifically, as indicated in the foregoing embodiments, interface configuration information refers to various information required to describe and construct the human-computer interaction interface. In this embodiment, the interface configuration information specifically includes interactive prompt information. Interactive prompt information is used to prompt the user to perform interactive operations. For example, interactive prompt information can be image information such as verification code images or operation guidance images, text information such as inquiry statements or prompt statements, or multimedia information such as sound information or animation demonstration information; there are no limitations on this.

[0118] In one possible scenario, the interactive prompts are obtained by the cloud during the execution of the RPA instructions prior to the human-computer interaction RPA instructions, and then populated into the interface configuration information of the human-computer interaction RPA instructions by the cloud.

[0119] In one possible scenario, the interface configuration information of the human-computer interaction RPA command does not directly include interactive prompts; instead, the near-end device obtains the interactive prompts based on the human-computer interaction RPA command.

[0120] The near-end device renders and displays interactive prompts and controls based on the Human-Computer Interaction (RPA) instructions to form the human-computer interaction interface. The near-end device can employ various methods to render and display the human-computer interaction interface. For example, it can use front-end frameworks such as React or Vue; or it can utilize Hyper Text Markup Language (HTML), CSS, or JavaScript (JS). Furthermore, it can leverage graphics engines such as WebGL (Web Graphics Library) to render and display the human-computer interaction interface. The above methods are only supplementary explanations; in reality, near-end devices can use many other methods to render and display the human-computer interaction interface, which will not be listed here.

[0121] It is understandable that a human-computer interaction interface should include at least interactive prompts and interactive controls.

[0122] To facilitate understanding of the human-computer interaction interface involved in this embodiment, the following will be combined with Figure 4 - Figure 6 Please provide an explanation.

[0123] Please see Figure 4 , Figure 4 This is a schematic diagram illustrating an example of a human-computer interaction interface provided in the embodiments of this specification. Figure 4The provided human-computer interaction interface includes interactive prompt information 001, a verification code image, a verification code input prompt statement "Please enter the verification code in the image," and the word "Submit" embedded in the button control. The verification code image contains the correct verification code "Test." The verification code input prompt statement prompts the user to enter the verification code into the verification code input box control, and the word "Submit" prompts the user to click the submit button control. Interactive controls 002 include a verification code input box control and a submit button control. The user enters the verification code into the verification code input box control in the human-computer interaction interface and clicks the submit button control after completion. The near-end device then receives the human-computer interaction result information. It can be understood that the verification code input operation into the verification code input box control can be considered a data input operation, and the human-computer interaction result information includes the input data corresponding to the data input operation, representing the verification code entered by the user.

[0124] Please see Figure 5 , Figure 5 This is a schematic diagram illustrating an example of a human-computer interaction interface provided in the embodiments of this specification. Figure 5 The provided human-computer interaction interface includes interactive prompts 001 such as the check operation prompt "Please check the data to be exported," checkbox prompts "Data A," "Data B," "Data C," "Data D," "Data E," and "Data F," and the button control embedding "Submit." The check operation prompt prompts the user to check the checkboxes, the checkbox prompts indicate the data to be exported, and the button control embedding prompts the user to click the submit button. Interactive controls 002 include checkboxes and submit buttons, with different checkboxes corresponding to different data to be exported. When a user checks at least one checkbox in the human-computer interaction interface and then clicks the submit button, the near-end device receives the human-computer interaction result information. It can be understood that the checkbox operation can be considered a data input operation, and the human-computer interaction result information includes the input data corresponding to the data input operation, indicating that the user has confirmed the data to be exported.

[0125] Please see Figure 6 , Figure 6 This is a schematic diagram illustrating an example of a human-computer interaction interface provided in the embodiments of this specification; Figure 6The provided human-computer interaction interface includes interactive prompt information 001, which includes a click operation prompt statement "The following matter is expected to be unprocessed... Do you want to send a reminder message to the corresponding handler?" and button control embeddings "Yes" and "No". The click operation prompt statement prompts the user to click either the first or second decision button control. The button control embeddings prompt the user to click the first decision button control to confirm sending the message (corresponding to the button control embedding "Yes") and to click the second decision button control to confirm not sending the message (corresponding to the button control embedding "No"). Interactive controls 002 include both the first and second decision button controls. When the user clicks either the first or second decision button control in the human-computer interaction interface, the near-end device receives the human-computer interaction result information. It can be understood that the click operation on the first or second decision button control can be considered a decision operation, and the human-computer interaction result information includes the decision data corresponding to the decision operation, indicating whether the user has decided to send the message.

[0126] In this embodiment, the near-end device renders and displays interactive prompts and interactive controls according to the human-computer interaction RPA instructions to form a human-computer interaction interface. The interactive prompts and interactive controls provide necessary support for the user's interactive operation, effectively improving the convenience of human intervention in the RPA task processing process.

[0127] Please see Figure 7 This is a flowchart illustrating a task processing method provided in an embodiment of this specification. Figure 7 As shown, the method in the embodiments of this specification is applied to the server and may include the following steps S302-S306.

[0128] S302, Receive the start command for the target RPA task sent by the near-end device;

[0129] S304, based on the start command of the target RPA task, determines the execution end from the near-end device and the cloud;

[0130] S306, send the RPA instruction set of the target RPA task to the execution end, so that the execution end can execute each RPA instruction in the RPA instruction set of the target RPA task to obtain the execution result of the target RPA task, and the near-end device can obtain and display the execution result of the target RPA task.

[0131] Specifically, first, the user initiates the target RPA task on the near-end device. Correspondingly, the near-end device determines the start command for the target RPA task. After determining the start command, the near-end device sends the start command to the server.

[0132] Accordingly, the server receives the start command of the target RPA task, determines the execution end from the near-end device and the cloud based on the target RPA task, and sends the RPA instruction set of the target RPA task to the execution end. The RPA instruction set of the target RPA task can be pre-stored by the server or generated by the server in real time based on the target RPA task. The RPA instruction set of the target RPA task includes at least one RPA instruction of the target RPA task.

[0133] In one possible scenario, the near-end device is designated as the execution end. The near-end device receives the RPA instruction set of the target RPA task sent by the server, executes each RPA instruction in the target RPA task instruction set sequentially, and obtains the execution result of the target RPA task. In this case, the near-end device can first retrieve the execution result of the target RPA task from its local storage, and then display the execution result of the target RPA task.

[0134] In one possible scenario, the cloud is designated as the execution end. The cloud receives the RPA instruction set for the target RPA task from the server, executes each RPA instruction in the target RPA task instruction set sequentially, obtains the execution result of the target RPA task, and then sends the execution result of the target RPA task to the near-end device through the server. In this case, the near-end device can receive the execution result of the target RPA task and then display it.

[0135] It should be noted that for any points not explained in detail in this embodiment, please refer to [link / reference needed]. Figure 2 The illustrated embodiment will not be described in detail.

[0136] In this embodiment, the near-end device responds to the start operation of the target RPA task by determining and sending the start command of the target RPA task to the server. The server, based on the start command, determines the execution end from both the near-end device and the cloud, and sends the RPA instruction set of the target RPA task to the execution end. The execution end executes each RPA instruction in the RPA instruction set of the target RPA task to obtain the execution result of the target RPA task. The near-end device then obtains and displays the execution result of the target RPA task. Thus, by introducing a server, the execution end can be flexibly determined from both the near-end device and the cloud based on the start command of the target RPA task, significantly improving the flexibility of RPA task processing. It is not limited to RPA tasks being processed solely by the near-end device or the cloud, effectively meeting the diverse processing needs of RPA tasks.

[0137] In one embodiment, based on Figure 7 The illustrated embodiment shows that the server includes multiple units to support the implementation of various functions. Please refer to [link / reference]. Figure 8 , Figure 8This is a schematic diagram illustrating an example of the unit configuration of a server provided in an embodiment of this specification. The server includes a monitoring unit, a decision-making unit, a scheduling unit, and an execution unit. The scheduling unit includes an RPA executor resource pool. The following describes the purpose of each unit of the server:

[0138] Monitoring Unit: Responsible for real-time monitoring of RPA task execution status. In practical applications, RPA tasks may encounter various unexpected situations, such as network latency, insufficient system resources, or instruction execution errors. By collecting and analyzing status information fed back from the execution end (whether near-end device or cloud), the monitoring unit can promptly identify and report any potential problems, providing a basis for subsequent decision-making and scheduling. Furthermore, the monitoring unit may also have the ability to automatically handle certain common problems, such as restarting tasks and adjusting resource allocation, to further improve system stability and reliability.

[0139] Decision Unit: This unit receives the start command for a target RPA task sent by the near-end device and determines the execution endpoint from both the near-end device and the cloud based on the start command. In one possible implementation, the decision unit determines the permission level of the target RPA task based on the start command and determines the execution endpoint from both the near-end device and the cloud based on that permission level. This ensures that the near-end device handles RPA tasks with higher permission levels, while the cloud handles RPA tasks with lower permission levels, improving the security of RPA task processing. In another possible implementation, the decision unit determines the resource consumption level of the target RPA task based on the start command and determines the execution endpoint from both the near-end device and the cloud based on that resource consumption level. This ensures that the near-end device handles RPA tasks with lower resource consumption, while the cloud handles RPA tasks with higher resource consumption, improving the stability and efficiency of RPA task processing. Furthermore, the decision unit can also determine the execution endpoint from both the near-end device and the cloud based on other information provided by the start command, enabling flexible RPA task flow and ensuring that RPA tasks run efficiently in the most suitable environment.

[0140] The scheduling unit includes an RPA executor resource pool. In one scenario, this pool records the status of all RPA executors in the cloud; in another, it records the status of all RPA executors in both the cloud and near-end devices. Once the decision unit determines the execution end, the scheduling unit selects a suitable RPA executor from the resource pool to execute the RPA instructions in the target RPA task's RPA instruction set. Additionally, the server can receive heartbeat signals from the cloud in real time. These heartbeat signals contain the status information of the RPA executors in the cloud. The server's scheduling unit parses this information from the heartbeat signals and maintains the RPA executor resource pool accordingly, ensuring that the resource pool reflects the real-time status of the RPA executors in the cloud.

[0141] Execution Unit: Primarily responsible for data forwarding during RPA task processing. For example, after the scheduling unit determines a suitable RPA executor, the execution unit sends the RPA instruction set of the target RPA task to the execution end. Alternatively, if the cloud is the execution end, the execution unit receives human-machine interaction instructions sent from the cloud and forwards them to the near-end device. Then, the execution unit receives the human-machine interaction result information sent from the near-end device and forwards it to the cloud. Another example is when the cloud is the execution end, the execution unit receives the execution result of the target RPA task sent from the cloud and forwards it to the near-end device.

[0142] In this embodiment, the server, through the close collaboration of the monitoring unit, decision-making unit, scheduling unit, and execution unit, not only improves the stability and reliability of RPA task processing, but also ensures that RPA tasks can be dynamically allocated between near-end devices and the cloud according to actual needs, thereby meeting the diverse needs of transaction scenarios.

[0143] In one embodiment, for Figure 7 Step S304 in the illustrated embodiment can be further refined and may include the following steps:

[0144] Determine the permission level of the target RPA task based on its startup command;

[0145] If the permission level of the target RPA task is higher than the preset reference permission level, the near-end device is identified as the execution end.

[0146] If the permission level of the target RPA task is not higher than the preset reference permission level, the cloud will be designated as the execution end.

[0147] Specifically, this embodiment proposes using permission levels to characterize the importance of permissions required for RPA tasks. Different RPA tasks may correspond to different permission levels. The higher the permission level, the more important (or sensitive) the permissions required for the corresponding RPA task. Therefore, considering that the cloud environment is more vulnerable to external attacks and unauthorized access compared to near-end devices, or that the data interaction process between near-end devices and the cloud is prone to eavesdropping, RPA tasks with higher permission levels are more suitable for processing by near-end devices.

[0148] Therefore, upon receiving the start command for the target RPA task, the server determines the permission level of the target RPA task based on the start command. In one possible implementation, the start command carries permission level information; the server parses this information from the start command to determine the target RPA task's permission level. In another possible implementation, the server stores a mapping between RPA tasks and permission levels; by querying this mapping relationship based on the target RPA task, the server can determine the target RPA task's permission level.

[0149] Then, the server obtains a preset reference permission level and compares the permission level of the target RPA task with the reference permission level to obtain the comparison result. The reference permission level is a preset threshold used to determine whether the RPA task is suitable for execution on a local device or in the cloud. It represents a boundary for permission levels. When the RPA task's permission level is higher than this boundary, for security and privacy protection reasons, the RPA task will be preferentially executed on the local device; conversely, when the RPA task's permission level is not higher than this boundary, in order to fully utilize cloud resources and computing power, the RPA task will be preferentially executed in the cloud.

[0150] Therefore, if the comparison result indicates that the target RPA task has a higher permission level than the reference permission level, then the near-end device is determined as the execution end; if the comparison result indicates that the target RPA task has a lower permission level than the reference permission level, then the cloud is determined as the execution end.

[0151] To facilitate understanding of the solution in this embodiment, an example will be provided below:

[0152] In a specific numerical example, for Figure 7 Step S304 in the illustrated embodiment is detailed as follows:

[0153] Suppose there are three RPA tasks: RPA task A, RPA task B, and RPA task C, with corresponding permission levels of 4, 2, and 6, respectively. The default reference permission level is set to 3.

[0154] When the server receives the start command for RPA task A, it first parses the command to determine that RPA task A has a permission level of 4 (or obtains this level by querying the stored mapping). Next, the server compares RPA task A's permission level of 4 with a reference permission level of 3. Since 4 is greater than 3, the server determines that RPA task A has a higher permission level. Therefore, for security and privacy protection reasons, the near-end device is designated as the execution end of RPA task A.

[0155] Similarly, when the server receives the start command for RPA task B, it determines that the permission level of RPA task B is 2. Comparing permission level 2 of RPA task B with the reference permission level 3, it finds that 2 is not greater than 3. Therefore, in order to fully utilize the resources and computing power of the cloud, the server determines the cloud as the execution end for RPA task B.

[0156] Similarly, when the server receives the start command for RPA task C, it determines that the permission level of RPA task C is 6. The server compares the permission level 6 of RPA task C with the reference permission level 3. Since 6 is greater than 3, the server, also for security and privacy protection reasons, determines the near-end device as the execution end of RPA task C.

[0157] In this embodiment, by comparing the permission level of the target RPA task with a preset reference permission level, the server can determine whether the RPA task contains sensitive or important permissions, thereby deciding whether to execute it on a local device or in the cloud. This permission level-based allocation strategy ensures that high-privilege RPA tasks are executed in a relatively more secure local device environment, effectively reducing the risk of data leakage and unauthorized access. Simultaneously, for RPA tasks with lower permission levels, the resources and computing power of the cloud are fully utilized, improving task processing efficiency. In summary, this embodiment not only enhances the security and privacy protection of RPA task execution but also optimizes resource utilization, achieving a dual improvement in security and efficiency.

[0158] In one embodiment, when the cloud is identified as the execution endpoint, in Figure 7 Following step S306 in the illustrated embodiment, the following steps may also be included:

[0159] Determine the status of each RPA executor in the cloud, including busy and idle states;

[0160] Identify the target RPA executor from the idle RPA executors in the cloud;

[0161] The RPA executor call instruction is generated based on the target RPA executor and sent to the cloud. The RPA executor call instruction is used to instruct the cloud to call the target RPA executor to execute each RPA instruction in the RPA instruction set of the target RPA task.

[0162] Specifically, in the RPA task processing flow, once the cloud is identified as the execution end, the server needs to further manage the RPA executor resources in the cloud to ensure that the target RPA task can be executed efficiently and accurately.

[0163] First, the server needs to determine the status of each RPA executor in the cloud. An RPA executor is an entity in the cloud used to execute RPA instructions, and its status may include busy and idle states. A busy state indicates that the executor is currently processing other RPA tasks and cannot immediately accept new RPA tasks; or, a busy state indicates that the executor has reached its maximum number of RPA tasks it can currently process and cannot immediately accept new RPA tasks. An idle state indicates that the executor is not currently executing any RPA tasks and can accept new RPA tasks; or an idle state indicates that the executor has not reached its maximum number of RPA tasks it can currently process and can accept new RPA tasks.

[0164] To determine the status of each RPA executor in the cloud, one possible implementation involves the server communicating with the cloud to query the status of all RPA executors on the cloud. Another possible implementation involves the server receiving heartbeat signals from the cloud in real time. These heartbeat signals contain the status information of the RPA executors in the cloud. The server's scheduling unit parses the heartbeat signals to obtain the status information of the RPA executors in the cloud and maintains an RPA executor resource pool based on this information. This ensures that the RPA executor resource pool reflects the status of the RPA executors in the cloud in real time, and the status of all RPA executors on the cloud can be queried directly from the RPA executor resource pool when needed.

[0165] After determining the status of each RPA executor in the cloud, the server needs to identify at least one target RPA executor from those in an idle state. For example, the server can randomly select at least one target RPA executor from the idle RPA executors; alternatively, the server can sort or filter the idle RPA executors based on parameters such as performance, load capacity, and historical execution records, thereby selecting at least one executor suitable for executing the target RPA task as the target RPA executor.

[0166] Once the target RPA executor is identified, the server needs to generate an RPA executor invocation instruction based on it. This instruction is sent from the server to the cloud, instructing the cloud to invoke the target RPA executor to execute the RPA instructions within the target RPA task's instruction set. Specifically, the RPA executor invocation instruction may include the target RPA executor's identification information, the identification information of the RPA instruction set to be executed, execution parameters, and other information. This information enables the cloud to accurately invoke the target RPA executor and execute the corresponding RPA instructions accordingly.

[0167] Finally, the server sends the generated RPA executor invocation instructions to the cloud. Correspondingly, after receiving the RPA executor invocation instructions, the cloud will invoke the target RPA executor based on the information in the instructions and begin executing the various RPA instructions in the target RPA task's RPA instruction set.

[0168] For a better understanding of this embodiment, please refer to [link / reference]. Figure 9 , Figure 9 This is an example diagram illustrating a cloud-based RPA executor invocation provided in the embodiments of this specification. As an example, a virtual machine in the cloud can run multiple processes simultaneously, each process corresponding to an RPA task, and each process involves at least one RPA executor. Assuming the target RPA task corresponds to process 1, then the x RPA executors involved in process 1 (RPA executor 1-1, RPA executor 1-2, ..., RPA executor 1-x) are all used to execute the RPA instructions in the RPA instruction set of the target RPA task. Similarly, assuming the target RPA task corresponds to process n, then the y RPA executors involved in process n (RPA executor 2-1, RPA executor 2-2, ..., RPA executor 2-y) are all used to execute the RPA instructions in the RPA instruction set of the target RPA task. It should be noted that the above virtual machine can run on any operating system such as Windows, Linux, or macOS, and there are no restrictions on this.

[0169] In this embodiment, by determining the real-time status of each RPA executor in the cloud, the server can accurately grasp the availability of RPA executors, avoiding resource waste and conflicts. Secondly, intelligently selecting the target executor from idle RPA executors not only improves the rationality of resource allocation but also ensures the efficiency and quality of task execution. Finally, by generating and sending RPA executor invocation instructions, the server can precisely command the cloud to execute the target RPA task, achieving remote control and automated processing of the task.

[0170] Please see Figure 10 This is a flowchart illustrating a task processing method provided in an embodiment of this specification. Figure 10 As shown, the method in the embodiments of this specification is applied to the cloud and may include the following steps S402-S404.

[0171] S402, Receive the RPA instruction set of the target RPA task sent by the server, wherein the RPA instruction set of the target RPA task is sent by the server to the cloud after determining that the cloud is the execution end from the near-end device and the cloud according to the start instruction of the target RPA task;

[0172] S404: The execution results of each RPA instruction in the RPA instruction set of the target RPA task are obtained, so that the near-end device can obtain and display the execution results of the target RPA task.

[0173] Specifically, first, the user initiates the target RPA task on the near-end device. Correspondingly, the near-end device determines the start command for the target RPA task. After determining the start command, the near-end device sends the start command to the server.

[0174] Accordingly, the server receives the start command for the target RPA task, determines the cloud as the execution end from the near-end device and the cloud based on the target RPA task, and sends the RPA instruction set of the target RPA task to the cloud. The RPA instruction set of the target RPA task can be pre-stored by the server or generated by the server in real time based on the target RPA task. The RPA instruction set of the target RPA task includes at least one RPA instruction of the target RPA task.

[0175] The cloud receives the RPA instruction set of the target RPA task sent by the server, executes each RPA instruction in the target RPA task instruction set sequentially, obtains the execution result of the target RPA task, and then sends the execution result of the target RPA task to the near-end device through the server. Accordingly, the near-end device receives the execution result of the target RPA task and then displays the execution result of the target RPA task.

[0176] It should be noted that for any points not explained in detail in this embodiment, please refer to [link / reference needed]. Figure 2 The illustrated embodiment will not be described in detail.

[0177] In this embodiment, the near-end device responds to the start operation of the target RPA task by determining and sending the start command of the target RPA task to the server. The server, based on the start command, determines the execution end from both the near-end device and the cloud, and sends the RPA instruction set of the target RPA task to the execution end. The execution end executes each RPA instruction in the RPA instruction set of the target RPA task to obtain the execution result of the target RPA task. The near-end device then obtains and displays the execution result of the target RPA task. Thus, by introducing a server, the execution end can be flexibly determined from both the near-end device and the cloud based on the start command of the target RPA task, significantly improving the flexibility of RPA task processing. It is not limited to RPA tasks being processed solely by the near-end device or the cloud, effectively meeting the diverse processing needs of RPA tasks.

[0178] Please see Figure 11 This document provides a flowchart illustrating the execution of RPA instructions in an embodiment of the present specification. Figure 11 As shown, the method in the embodiments of this specification may include the following steps S502-S508, where steps S502-S508 serve as a response to... Figure 10 Further refinement of step S404 in the illustrated embodiment.

[0179] S502, determine the execution order of each RPA instruction in the RPA instruction set of the target RPA task;

[0180] S504, according to the execution order of each RPA instruction in the RPA instruction set of the target RPA task, traverse each RPA instruction in sequence;

[0181] S506, for the current RPA instruction among the traversed RPA instructions, execute the current RPA instruction;

[0182] S508: If the last RPA instruction in the execution order has been executed, the execution result of the target RPA task is obtained. The execution result of the target RPA task is sent to the local device through the server so that the local device can receive and display the execution result of the target RPA task.

[0183] Specifically, an RPA instruction set typically contains multiple RPA instructions, each corresponding to a specific step, such as data input, data processing, or data interaction. These RPA instructions need to be executed in a specific order to ensure the RPA task can be completed correctly. After receiving the RPA instruction set for the target RPA task, the cloud needs to determine the execution order of each RPA instruction in the target RPA task's instruction set. The RPA instructions include execution order parameters, which characterize the execution order of the RPA instructions; that is, the cloud can determine the execution order of the RPA instructions based on the execution order parameters in the RPA instructions.

[0184] Furthermore, the cloud sequentially traverses each RPA instruction according to the execution order of the RPA instructions in the target RPA task's RPA instruction set. This traversal process is essentially an iterative loop; the cloud checks each RPA instruction in the instruction set one by one and processes them sequentially according to their execution order, ensuring that each RPA instruction is correctly identified and executed without omissions or errors.

[0185] During the traversal, for each RPA instruction encountered, the cloud simulates human operation to execute the corresponding steps based on the specific content and parameters of the current RPA instruction, such as data input, data processing, and data interaction. It can be understood that as the cloud continues to traverse each RPA instruction, the current RPA instruction can be any one of the traversed RPA instructions in the RPA instruction set.

[0186] Finally, the cloud verifies whether the last RPA instruction in the execution order has been completed. If so, it indicates that the target RPA task has been executed according to the preset process, and the cloud receives the execution result of the target RPA task. The cloud then sends the execution result of the target RPA task to the local device via the server. Furthermore, the local device can receive the execution result of the target RPA task and display it.

[0187] In this embodiment, by determining the execution order of RPA instructions, the cloud can process each instruction in an orderly manner, avoiding confusion and errors in RPA instruction execution. Secondly, the process of sequentially traversing each RPA instruction ensures that each RPA instruction can be correctly identified and executed, improving the completeness and accuracy of task execution. For each current RPA instruction, the cloud implements automated processing based on the current RPA instruction, improving work efficiency. Finally, after the last RPA instruction is executed, the cloud promptly sends the execution result of the target RPA task to the near-end device through the server, enabling the near-end device to obtain and display the execution result of the target RPA task in real time. In summary, this embodiment optimizes the RPA task processing process and improves the execution efficiency and accuracy of RPA tasks.

[0188] In one embodiment, for Figure 11 Step S506 in the illustrated embodiment can be further refined and may include the following steps:

[0189] For the current RPA instruction among the traversed RPA instructions, if the current RPA instruction is a human-computer interaction RPA instruction, the human-computer interaction RPA instruction is sent to the near-end device through the server. The near-end device renders and displays the human-computer interaction interface according to the human-computer interaction RPA instruction, determines the human-computer interaction result information in response to the interactive operation on the human-computer interaction interface, and sends the human-computer interaction result information to the cloud through the server.

[0190] Receive human-computer interaction result information.

[0191] Specifically, RPA instructions include type parameters, which can include at least one of operation type and interaction type. The operation type defines the specific action performed by the RPA instruction, such as "open a website" or "fill in an input box." The interaction type indicates the type of RPA instruction that requires human intervention, enabling human-computer collaboration. It can be understood that RPA instructions with an interaction type as their type parameter are human-computer interaction RPA instructions.

[0192] During the sequential execution of RPA commands in the cloud, some of these commands may be human-computer interaction (HCI) RPA commands. Since the cloud cannot be directly manipulated by the user or lacks the necessary permissions, it cannot independently complete the interactive actions required by the HCI RPA commands. Therefore, for the current HCI command among the traversed RPA commands, if it is an HCI RPA command, the cloud executes it by sending the HCI RPA command from the server to the local device.

[0193] Accordingly, the near-end device receives human-computer interaction (HCI) RPA instructions sent from the cloud via the server, and then renders and displays the HCI interface based on these instructions. Users can interact with the interactive controls on the HCI interface. The near-end device then determines the HCI result information in response to the interaction on the HCI interface. After receiving the HCI result information, the near-end device sends it to the cloud via the server. The cloud then receives the HCI result information and executes subsequent RPA instructions based on it.

[0194] In this embodiment, the cloud can accurately determine whether the current RPA instruction is a human-computer interaction instruction requiring manual intervention. For human-computer interaction RPA instructions, the cloud sends the instruction to the near-end device via the server. The near-end device renders and displays the human-computer interaction interface based on the received instruction, determines the human-computer interaction result information in response to the interaction operation on the interface, and sends the human-computer interaction result information back to the cloud via the server. In this way, the cloud can execute subsequent RPA instructions based on the received human-computer interaction result information. Based on this embodiment, the problem of inconvenient manual intervention in the cloud processing of RPA tasks can be solved. While making full use of the cloud's computing power to improve the efficiency of RPA task processing, it can also combine the near-end device to provide necessary manual intervention, thereby improving the efficiency and stability of RPA task processing.

[0195] In one embodiment, for Figure 11 Step S506 in the illustrated embodiment can be further refined and may include the following steps:

[0196] For the current RPA instruction among the traversed RPA instructions, if the current RPA instruction is an interaction-preceding RPA instruction that is executed before the human-computer interaction RPA instruction, then the interaction prompt information is obtained according to the interaction-preceding RPA instruction and filled into the human-computer interaction RPA instruction. The interaction prompt information is used to prompt the user to perform interactive operations in the human-computer interaction interface rendered and displayed by the near-end device according to the human-computer interaction RPA instruction.

[0197] Specifically, as indicated in the foregoing embodiments, RPA instructions with an interaction type as the type parameter are human-computer interaction RPA instructions. The interaction-before-action RPA instructions involved in this embodiment are not human-computer interaction RPA instructions; that is, the type parameter of the interaction-before-action RPA instructions is the operation type.

[0198] In the processing of target RPA tasks, to ensure smooth human-computer interaction, it is sometimes necessary to execute some pre-interaction instructions before the actual human-computer interaction commands. The purpose of these pre-interaction instructions is to obtain necessary information or prepare the appropriate environment so as to provide correct prompts and guidance to the user in subsequent human-computer interactions.

[0199] During the process of traversing various RPA instructions in the cloud, if the current RPA instruction encountered is a pre-interaction RPA instruction that precedes the human-computer interaction RPA instruction in the execution order, then that pre-interaction RPA instruction needs to be executed. Specifically, interactive prompt information is obtained based on the pre-interaction RPA instruction and populated into the interface configuration information of the human-computer interaction RPA instruction. This process is actually a dynamic modification or enhancement of the human-computer interaction RPA instruction, enabling it to include more contextual information or user guidance in subsequent executions. The interactive prompt information is used to prompt the user to perform interactive operations in the human-computer interaction interface rendered and displayed on the near-end device according to the human-computer interaction RPA instruction. For example, interactive prompt information can be image information such as verification code images or operation guidance images, text information such as query statements or prompt statements, or multimedia information such as sound information or animation demonstrations; there are no restrictions on this.

[0200] To facilitate understanding of this embodiment, an example is provided below: Assume that the human-computer interaction (HCI) command is used to render and display the HCI interface on a near-end device. The user needs to input a verification code corresponding to a verification code image within the HCI interface. Then, when the cloud executes the pre-interaction RPA command before executing the HCI command, it can obtain the verification code image as interactive prompt information and fill this prompt information into the interface configuration information of the HCI RPA command. Subsequently, the HCI interface rendered and displayed by the near-end device based on the interface configuration information of the HCI RPA command can include the verification code image, which provides reference content for the user to input the verification code.

[0201] In this embodiment, by executing pre-interaction instructions before the human-computer interaction RPA instructions, the cloud can obtain necessary interaction prompts and populate them into the human-computer interaction RPA instructions. This process not only enriches the content of the human-computer interaction interface but also provides users with clearer and more accurate interaction guidance.

[0202] In one embodiment, for Figure 11 Step S506 in the illustrated embodiment can be further refined and may include the following steps:

[0203] For the current RPA instruction among the traversed RPA instructions, if the current RPA instruction is an interaction-following RPA instruction whose execution order is after the human-computer interaction RPA instruction, then the interaction-following RPA instruction is executed according to the received human-computer interaction result information. The human-computer interaction result information is the human-computer interaction interface rendered and displayed by the near-end device according to the human-computer interaction RPA instruction, and the response to the interaction operation on the human-computer interaction interface is confirmed and sent to the cloud through the server.

[0204] Specifically, as indicated in the following embodiments, RPA instructions with an interaction type as the type parameter are human-computer interaction RPA instructions. The interactive post-processing RPA instructions involved in this embodiment are not human-computer interaction RPA instructions; that is, the type parameter of the interactive post-processing RPA instructions is the operation type.

[0205] In the processing of target RPA tasks, to ensure the continuity of the automation process, it is sometimes necessary to execute some post-interaction instructions after the actual human-computer interaction instructions. These post-interaction instructions take the human-computer interaction result information as input parameters.

[0206] During the process of traversing various RPA instructions in the cloud, if the current RPA instruction encountered is a post-interaction RPA instruction that follows the human-computer interaction RPA instruction in the execution order, it needs to execute the post-interaction RPA instruction based on the received human-computer interaction result information. Specifically, the human-computer interaction result information may include the input data corresponding to the data input operation and / or the decision data corresponding to the decision operation.

[0207] To facilitate understanding of this embodiment, an example is provided below: Assume that the human-computer interaction command is used to provide the near-end device with a rendering and display of the human-computer interaction interface. The user needs to input a verification code corresponding to a verification code image in the human-computer interaction interface. Then, the human-computer interaction result information received by the cloud includes the input data corresponding to the data input operation, i.e., the verification code entered by the user. Further, the cloud executes the post-interaction RPA instruction based on the verification code entered by the user, filling the verification code entered by the user into the corresponding verification code input box to complete the verification.

[0208] This embodiment refines step S506 so that after the human-computer interaction RPA instruction is executed, the cloud can automatically execute the post-interaction RPA instruction based on the interaction result information provided by the user, thereby achieving seamless connection of the automated process and improving the processing efficiency of RPA tasks.

[0209] In one embodiment, in Figure 10 In the illustrated embodiment, after step S402 and before step S404, the following steps may also be included:

[0210] Receive the RPA executor invocation instruction sent by the server. The RPA executor invocation instruction is generated by the server based on the target RPA executor in the cloud. The target RPA executor is determined by the server from the idle RPA executors in the cloud.

[0211] right Figure 10 Step S404 in the illustrated embodiment can be further refined and may include the following steps:

[0212] Based on the RPA executor invocation instruction, the target RPA executor is invoked to execute each RPA instruction in the target RPA task's RPA instruction set, thereby obtaining the execution result of the target RPA task.

[0213] Specifically, first, the server needs to determine the status of each RPA executor in the cloud. An RPA executor is an entity in the cloud used to execute RPA instructions, and its status may include busy and idle states. A busy state indicates that the executor is currently processing other RPA tasks and cannot immediately accept new RPA tasks; or, a busy state indicates that the executor has reached its maximum number of RPA tasks it is currently processing and cannot immediately accept new RPA tasks. An idle state indicates that the executor currently has no RPA tasks being executed and can accept new RPA tasks; or an idle state indicates that the executor has not reached its maximum number of RPA tasks it is currently processing and can accept new RPA tasks.

[0214] After determining the status of each RPA executor in the cloud, the server needs to identify at least one target RPA executor from the idle RPA executors. Once the target RPA executor is identified, the server generates an RPA executor invocation instruction based on it. This instruction instructs the cloud to invoke the target RPA executor to execute the RPA instructions within the target RPA task's RPA instruction set. Specifically, the instruction may include the target RPA executor's identification information, the identification information of the RPA instruction set to be executed, execution parameters, and other information. This information enables the cloud to accurately invoke the target RPA executor and execute the corresponding RPA instructions accordingly.

[0215] The server sends the generated RPA executor invocation command to the cloud. Upon receiving the RPA executor invocation command from the server, the cloud initiates a series of processing steps to ensure that the target RPA executor is correctly invoked and the specified target RPA task is processed.

[0216] First, the cloud will parse the received RPA executor call instructions and extract the identification information of the target RPA executor, the identification information of the RPA instruction set to be executed, and the execution parameters.

[0217] Next, the cloud will locate the specific RPA executor based on the identifier information of the target RPA executor. There may be multiple RPA executors in the cloud's resource pool, each with its own unique identifier. By matching the identifier information, the cloud can accurately find the target RPA executor that needs to be invoked.

[0218] After locating the target RPA executor, the cloud checks its current state. Although the server has already determined that the RPA executor is idle in previous steps, the cloud typically performs a second check before the actual call to avoid conflicts caused by delayed or incorrect state updates. If the target RPA executor is still idle, the cloud proceeds to the next step; if the target RPA executor has become busy, the cloud may return an error message to the server or attempt to call another idle RPA executor.

[0219] Once the target RPA executor is confirmed to be idle, the cloud will obtain the RPA instruction set of the target RPA task to be executed based on the RPA instruction set identification information, and call the target RPA executor to execute each RPA instruction in the target RPA task's RPA instruction set to obtain the execution result of the target RPA task.

[0220] For a better understanding of this embodiment, please refer to [link / reference]. Figure 9 , Figure 9 This is an example diagram illustrating a cloud-based RPA executor invocation provided in the embodiments of this specification. As an example, a virtual machine in the cloud can run multiple processes simultaneously, each process corresponding to an RPA task, and each process involves at least one RPA executor. Assuming the RPA executor invocation instruction indicates that the target RPA executor is RPA executor 1-1, RPA executor 1-2, ..., RPA executor 1-x, a total of x RPA executors, then the cloud can create process 1, and through process 1, invoke RPA executors 1-1, RPA executor 1-2, ..., RPA executor 1-x to execute each RPA instruction in the RPA instruction set of the target RPA task. Similarly, assuming the RPA executor invocation instruction indicates that the target RPA executor is RPA executor 2-1, RPA executor 2-2, ..., RPA executor 2-y, a total of y RPA executors, then the cloud can create a process n, and through process n, call RPA executor 2-1, RPA executor 2-2, ..., RPA executor 2-y to execute each RPA instruction in the RPA instruction set of the target RPA task.

[0221] In this embodiment, real-time monitoring and intelligent scheduling of the cloud-based RPA executor status by the server ensures that RPA tasks can be quickly and accurately assigned to idle RPA executors, thereby improving the response speed and execution efficiency of RPA task processing. Simultaneously, it ensures that the cloud can accurately locate and execute the target RPA task after receiving the RPA executor call instruction, avoiding resource conflicts and task processing delays. Furthermore, this embodiment supports parallel calls to multiple RPA executors, achieving multi-threaded processing of RPA tasks by creating multiple processes, further improving the throughput and performance of RPA task processing. In summary, this embodiment improves the processing efficiency and accuracy of RPA tasks by optimizing the RPA executor call flow and task processing method.

[0222] Based on the above description of the task processing method embodiments, the following will combine... Figure 12 - Figure 15 This paper presents examples of interactions between near-end devices, servers, and the cloud.

[0223] Please see Figure 12 , Figure 12 This is an interactive schematic diagram of a near-end device executing instructions provided in an embodiment of this specification.

[0224] Specifically, first, the user initiates the target RPA task on the near-end device. Correspondingly, the near-end device determines the start command for the target RPA task. After determining the start command, the near-end device sends the start command to the server.

[0225] Accordingly, the server receives the start command for the target RPA task, determines the near-end device as the execution end from both the near-end device and the cloud based on the target RPA task, and sends the RPA instruction set of the target RPA task to the near-end device. The RPA instruction set of the target RPA task can be pre-stored by the server or generated in real-time by the server based on the target RPA task. The RPA instruction set of the target RPA task includes at least one RPA instruction of the target RPA task.

[0226] The near-end device receives the RPA instruction set of the target RPA task sent by the server, executes each RPA instruction in the RPA instruction set of the target RPA task in sequence, obtains the execution result of the target RPA task, and then retrieves the execution result of the target RPA task from the local machine and displays the execution result of the target RPA task.

[0227] Please see Figure 13 , Figure 13 This is an interactive diagram illustrating the execution of instructions by a near-end device in a logistics information query scenario, as provided in the embodiments of this specification.

[0228] Specifically, when the target RPA task is a logistics information query task, the user first initiates the logistics information query task on the near-end device. Correspondingly, the near-end device responds to this initiation by determining the initiation command for the logistics information query task. After determining the initiation command, the near-end device sends the initiation command to the server.

[0229] Accordingly, the server receives the start command for the logistics information query task, determines the near-end device as the execution end from both the near-end device and the cloud based on the logistics information query task, and sends the RPA instruction set for the logistics information query task to the near-end device. The RPA instruction set for the logistics information query task can be pre-stored by the server or generated in real-time by the server based on the logistics information query task. The RPA instruction set for the logistics information query task includes RPA instruction 1 to RPA instruction 8.

[0230] The near-end device receives the RPA instruction set for the logistics information query task sent by the server, executes each RPA instruction in the logistics information query task instruction set in sequence, and obtains the execution result of the logistics information query task. The execution result of the logistics information query task is the logistics information corresponding to the logistics ID (the unique identifier of the logistics order) to be queried (used to indicate the current status of the logistics order).

[0231] The specific RPA instructions in the RPA instruction set for near-end devices to perform logistics information query tasks are as follows:

[0232] The near-end device executes RPA instruction 1 to open the logistics website. Specifically, the near-end device automatically navigates to the logistics website URL specified by RPA instruction 1 by calling the system browser or built-in browser component, ensuring that subsequent logistics information query operations can be performed in the correct web page environment.

[0233] The near-end device executes RPA instruction 2 to locate the logistics ID input box. Specifically, the near-end device uses the page element recognition capability of RPA technology to locate the logistics ID input box on the logistics query page, preparing for subsequent input operations.

[0234] The near-end device executes RPA instruction 3, inputting the logistics ID to be queried into the logistics ID input box. Specifically, the near-end device inputs the logistics ID string provided by RPA instruction 3 character by character into the previously located logistics ID input box by simulating keyboard input, ensuring the information is accurate.

[0235] The near-end device executes RPA instruction 4, clicking the query button control to display the verification code input interface. Specifically, after entering the logistics ID, the near-end device automatically triggers the click of the query button, redirecting to the verification code input interface.

[0236] The near-end device executes RPA instruction 5, responding to the operation by entering a verification code into the verification code input box on the verification code input interface. Specifically, the user manually enters the verification code into the verification code input box on the verification code input interface to pass the website's verification mechanism.

[0237] The near-end device executes RPA instruction 6 and clicks the confirmation button control. Specifically, after the verification code is correctly entered, the near-end device automatically clicks the confirmation button control, submits the query request, and waits for the server to return the query results.

[0238] The near-end device executes RPA instruction 7 and waits for the query results page to be rendered and displayed. Since the web query results may take some time to load, the near-end device will pause the execution of subsequent instructions during this stage until it detects that the query results page has been fully loaded and displayed.

[0239] The near-end device executes RPA instruction 8 to determine the logistics information corresponding to the queried logistics ID from the query results page. Specifically, the near-end device uses RPA's page parsing capabilities to extract specific logistics information matching the input logistics ID from the query results page, such as package location and estimated arrival time, for the user to view or further process.

[0240] Finally, the near-end device retrieves the logistics information corresponding to the logistics ID to be queried from the local machine, and then displays the logistics information corresponding to the logistics ID to be queried.

[0241] Please see Figure 14 , Figure 14 This is an interactive diagram illustrating a cloud-based execution instruction provided in an embodiment of this specification.

[0242] Specifically, first, the user initiates the target RPA task on the near-end device. Correspondingly, the near-end device determines the start command for the target RPA task. After determining the start command, the near-end device sends the start command to the server.

[0243] Accordingly, the server receives the start command for the target RPA task, determines the cloud as the execution end from the near-end device and the cloud based on the target RPA task, and sends the RPA instruction set of the target RPA task to the cloud. The RPA instruction set of the target RPA task can be pre-stored by the server or generated by the server in real time based on the target RPA task. The RPA instruction set of the target RPA task includes at least one RPA instruction of the target RPA task.

[0244] The cloud receives the RPA instruction set of the target RPA task sent by the server, executes each RPA instruction in the target RPA task instruction set sequentially, obtains the execution result of the target RPA task, and then sends the execution result of the target RPA task to the near-end device through the server. Accordingly, the near-end device receives the execution result of the target RPA task and then displays the execution result of the target RPA task.

[0245] Please see Figure 15 , Figure 15 This is an interactive diagram illustrating the execution of instructions in the cloud during a logistics information query scenario, as provided in the embodiments of this specification.

[0246] Specifically, when the target RPA task is a logistics information query task, the user first initiates the logistics information query task on the near-end device. Correspondingly, the near-end device responds to this initiation by determining the initiation command for the logistics information query task. After determining the initiation command, the near-end device sends the initiation command to the server.

[0247] Accordingly, the server receives the start command for the logistics information query task, determines the cloud as the execution end from the near-end device and the cloud based on the logistics information query task, and sends the RPA instruction set for the logistics information query task to the cloud. The RPA instruction set for the logistics information query task can be pre-stored by the server or generated in real-time by the server based on the logistics information query task. The RPA instruction set for the logistics information query task includes RPA instruction 1 to RPA instruction 10.

[0248] The cloud will receive the RPA instruction set for the logistics information query task sent by the server, and execute each RPA instruction in the logistics information query task RPA instruction set in sequence to obtain the execution result of the logistics information query task. The execution result of the logistics information query task is the logistics information corresponding to the logistics ID (the unique identifier of the logistics order) to be queried (used to indicate the current status of the logistics order).

[0249] The specific RPA commands in the cloud-based RPA command set for performing logistics information query tasks are as follows:

[0250] The cloud executes RPA instruction 1 to open the logistics website. Specifically, the cloud automatically navigates to the logistics website URL specified by RPA instruction 1 by calling the system browser or built-in browser component, ensuring that subsequent logistics information query operations can be performed in the correct web page environment.

[0251] The cloud executes RPA instruction 2 to locate the logistics ID input box. Specifically, the cloud utilizes the page element recognition capabilities of RPA technology to locate the logistics ID input box on the logistics query page, preparing for subsequent input operations.

[0252] The cloud executes RPA command 3, inputting the logistics ID to be queried into the logistics ID input box. Specifically, the cloud inputs the logistics ID string provided by RPA command 3 character by character into the previously located logistics ID input box by simulating keyboard input, ensuring the information is accurate.

[0253] The cloud executes RPA instruction 4, clicking the query button control to display the verification code input interface. Specifically, after entering the logistics ID, the cloud automatically triggers the operation of clicking the query button, redirecting to the verification code input interface.

[0254] The cloud executes RPA instruction 5 to retrieve the CAPTCHA image from the CAPTCHA input interface and populate it into RPA instruction 6. Specifically, the cloud utilizes the page element recognition capabilities of RPA technology to locate the CAPTCHA image in the CAPTCHA input interface, and then retrieves and populates the CAPTCHA image into RPA instruction 6.

[0255] The cloud executes RPA instruction 6 and sends it. Specifically, the cloud sends RPA instruction 6 to the server. After receiving RPA instruction 6, the server forwards it to the near-end device. The near-end device renders and displays the human-computer interaction interface according to RPA instruction 6, determines the verification code in response to the interaction on the human-computer interaction interface, and sends the verification code to the server. After receiving the verification code, the server forwards it to the cloud. Finally, the cloud receives the verification code.

[0256] The cloud executes RPA instruction 7 to input the verification code into the verification code input box on the verification code input interface. Specifically, the cloud automatically inputs the verification code into the verification code input box on the verification code input interface to pass the website's verification mechanism.

[0257] The cloud executes RPA instruction 8, clicking the confirmation button control. Specifically, after the verification code is correctly entered, the cloud automatically clicks the confirmation button control, submits the query request, and waits for the server to return the query results.

[0258] The cloud executes RPA instruction 9 and waits for the query results page to render and display. Since the webpage query results may take some time to load, the cloud will pause the execution of subsequent instructions during this stage until the query results page is detected to be fully loaded and displayed.

[0259] The cloud executes RPA instruction 10 to determine the logistics information corresponding to the queried logistics ID from the query results page. Specifically, the cloud utilizes RPA's page parsing capabilities to extract specific logistics information matching the input logistics ID from the query results page, such as package location and estimated arrival time, for the user to view or further process.

[0260] Finally, the cloud sends the logistics information corresponding to the logistics ID to be queried to the server. The server receives the logistics information corresponding to the logistics ID to be queried and forwards it to the near-end device. The near-end device receives the logistics information corresponding to the logistics ID to be queried and further displays it.

[0261] Please see Figure 16 This document provides a schematic diagram of the structure of an electronic device as an embodiment of the present specification. Figure 16 As shown, the electronic device 1000 may include: at least one processor 1001, such as a CPU; at least one network interface 1004; an input / output interface 1003; a memory 1005; and at least one communication bus 1002. The communication bus 1002 is used to enable communication between these components. The network interface 1004 may optionally include a standard wired interface or a wireless interface (such as a Wi-Fi interface). The memory 1005 may be high-speed RAM or non-volatile memory, such as at least one disk drive. Optionally, the memory 1005 may also be at least one storage device located remotely from the aforementioned processor 1001. Figure 16 As shown, the memory 1005, which serves as a computer storage medium, may include an operating system, a network communication module, an input / output interface module, and a task processing application.

[0262] exist Figure 16 In the electronic device 1000 shown, the input / output interface 1003 is mainly used to provide an input interface for the user and to obtain the user input data.

[0263] In one embodiment, the processor 1001 can be used to invoke a task processing application stored in the memory 1005, and specifically perform the following operations:

[0264] In response to the start operation of the target RPA task, the start command of the target RPA task is determined and sent to the server. The server then determines the execution end from the near-end device and the cloud according to the start command of the target RPA task and sends the RPA instruction set of the target RPA task to the execution end.

[0265] The execution result of the target RPA task is obtained and displayed. The execution result of the target RPA task is obtained by the execution end executing each RPA instruction in the RPA instruction set of the target RPA task.

[0266] Optionally, when the near-end device is determined to be the execution end, after the processor 1001 executes the start operation in response to the target RPA task, determines the start instruction of the target RPA task, and sends the start instruction of the target RPA task to the server, and before executing the acquisition and display of the execution result of the target RPA task, it specifically performs the following operations: receiving the RPA instruction set of the target RPA task sent by the server; executing each RPA instruction in the RPA instruction set of the target RPA task to obtain the execution result of the target RPA task.

[0267] Optionally, when the cloud is identified as the execution end, the processor 1001 performs the following operations when executing the task of obtaining and displaying the execution result of the target RPA task: receiving the execution result of the target RPA task sent by the cloud through the server; and displaying the execution result of the target RPA task.

[0268] Optionally, when the cloud is identified as the execution end, after the processor 1001 executes the start operation in response to the target RPA task, determines the start instruction of the target RPA task, and sends the start instruction of the target RPA task to the server, and before executing the acquisition and display of the execution result of the target RPA task, it specifically performs the following operations: receiving the human-computer interaction RPA instruction sent by the cloud through the server; rendering and displaying the human-computer interaction interface according to the human-computer interaction RPA instruction; determining the human-computer interaction result information in response to the interaction operation on the human-computer interaction interface; and sending the human-computer interaction result information to the cloud through the server.

[0269] Optionally, when the processor 1001 executes the human-computer interaction RPA instruction to render and display the human-computer interaction interface, it specifically performs the following operations: renders and displays interactive prompts and interactive controls according to the human-computer interaction RPA instruction to form a human-computer interaction interface, wherein the interactive prompts are used to prompt the user to perform interactive operations, and the interactive controls are used to respond to the user's interactive operations.

[0270] In one embodiment, the processor 1001 can be used to invoke a task processing application stored in the memory 1005, and specifically perform the following operations:

[0271] Receive the start command for the target RPA task sent by the near-end device;

[0272] Based on the start command of the target RPA task, determine the execution end from the near-end device and the cloud;

[0273] The RPA instruction set of the target RPA task is sent to the execution end, so that the execution end can execute each RPA instruction in the RPA instruction set of the target RPA task to obtain the execution result of the target RPA task. The near-end device obtains and displays the execution result of the target RPA task.

[0274] Optionally, when the processor 1001 determines the execution end from the near-end device and the cloud according to the start instruction of the target RPA task, it specifically performs the following operations: determines the permission level of the target RPA task according to the start instruction of the target RPA task; if the permission level of the target RPA task is higher than the preset reference permission level, the near-end device is determined as the execution end; if the permission level of the target RPA task is not higher than the preset reference permission level, the cloud is determined as the execution end.

[0275] Optionally, when the cloud is determined as the execution end, after the processor 1001 executes the RPA instruction set for sending the target RPA task to the execution end, it specifically performs the following operations: determines the status of each RPA executor in the cloud, wherein the status of the RPA executor includes a busy state and an idle state; determines the target RPA executor from the idle RPA executors in the cloud; generates an RPA executor invocation instruction based on the target RPA executor, and sends the RPA executor invocation instruction to the cloud, wherein the RPA executor invocation instruction is used to instruct the cloud to invoke the target RPA executor to execute each RPA instruction in the RPA instruction set of the target RPA task.

[0276] In one embodiment, the processor 1001 can be used to invoke a task processing application stored in the memory 1005, and specifically perform the following operations:

[0277] Receive the RPA instruction set of the target RPA task sent by the server. The RPA instruction set of the target RPA task is sent by the server to the cloud after determining that the cloud is the execution end from the near-end device and the cloud according to the start instruction of the target RPA task.

[0278] The execution results of each RPA instruction in the RPA instruction set of the target RPA task are obtained, so that the near-end device can obtain and display the execution results of the target RPA task.

[0279] Optionally, when the processor 1001 executes the execution results of the target RPA task by executing each RPA instruction in the RPA instruction set of the target RPA task, so that the near-end device can obtain and display the execution results of the target RPA task, it specifically performs the following operations: determining the execution order of each RPA instruction in the RPA instruction set of the target RPA task; traversing each RPA instruction sequentially according to the execution order of each RPA instruction in the RPA instruction set of the target RPA task; executing the current RPA instruction among the traversed RPA instructions; if the last RPA instruction in the execution order has been executed, the execution result of the target RPA task is obtained, and the execution result of the target RPA task is sent to the near-end device through the server so that the near-end device can receive and display the execution result of the target RPA task.

[0280] Optionally, when the processor 1001 executes the current RPA instruction among the traversed RPA instructions, it performs the following operations: If the current RPA instruction is a human-computer interaction RPA instruction, the processor 1001 sends the human-computer interaction RPA instruction to the near-end device through the server. The near-end device renders and displays the human-computer interaction interface according to the human-computer interaction RPA instruction, determines the human-computer interaction result information in response to the interaction operation on the human-computer interaction interface, and sends the human-computer interaction result information to the cloud through the server; and receives the human-computer interaction result information.

[0281] Optionally, when the processor 1001 executes the current RPA instruction among the traversed RPA instructions, it performs the following operations: If the current RPA instruction is an interaction-preceding RPA instruction whose execution order precedes the human-machine interaction RPA instruction, then the processor 1001 obtains interaction prompt information based on the interaction-preceding RPA instruction and fills the interaction prompt information into the human-machine interaction RPA instruction. The interaction prompt information is used to prompt the user to perform interactive operations in the human-machine interaction interface rendered and displayed by the near-end device according to the human-machine interaction RPA instruction.

[0282] Optionally, when the processor 1001 executes the current RPA instruction among the traversed RPA instructions, it performs the following operations: If the current RPA instruction is an interaction-following RPA instruction whose execution order is after the human-machine interaction RPA instruction, then the interaction-following RPA instruction is executed according to the received human-machine interaction result information. The human-machine interaction result information is the human-machine interaction interface rendered and displayed by the near-end device according to the human-machine interaction RPA instruction, and the response to the interaction operation on the human-machine interaction interface is confirmed and sent to the cloud through the server.

[0283] Optionally, after the processor 1001 executes the RPA instruction set of the target RPA task sent by the receiving server, and before executing each RPA instruction in the RPA instruction set of the target RPA task to obtain the execution result of the target RPA task, the processor 1001 specifically performs the following operations: receiving the RPA executor invocation instruction sent by the server, wherein the RPA executor invocation instruction is generated by the server based on the target RPA executor in the cloud, and the target RPA executor is determined by the server from the idle RPA executors in the cloud; when the processor 1001 executes each RPA instruction in the RPA instruction set of the target RPA task to obtain the execution result of the target RPA task, the processor 1001 specifically performs the following operations: according to the RPA executor invocation instruction, invoking the target RPA executor to execute each RPA instruction in the RPA instruction set of the target RPA task to obtain the execution result of the target RPA task.

[0284] For the effects achievable in this embodiment, please refer to the relevant embodiments of the task processing method described above, which will not be repeated here.

[0285] This specification also provides a computer storage medium that can store multiple program instructions, which are adapted to be loaded and executed by a processor as described above. Figure 2 - Figure 15 The method steps of the illustrated embodiment can be found in the following documentation for detailed execution. Figure 2 - Figure 15 The specific details of the illustrated embodiments will not be elaborated here.

[0286] This specification also provides an embodiment of a computer program product, which stores at least one instruction, and the at least one instruction is loaded and executed by a processor as described above. Figure 2 - Figure 15 The task processing method of the illustrated embodiment can be found in the following document for detailed execution process. Figure 2 - Figure 15 The specific details of the illustrated embodiments will not be elaborated here.

[0287] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The program can be stored in a computer-readable storage medium, and when executed, it can include the processes of the embodiments of the methods described above. The storage medium can be a magnetic disk, optical disk, read-only memory (ROM), or random access memory (RAM), etc.

[0288] The above-disclosed embodiments are merely preferred embodiments of this specification and should not be construed as limiting the scope of this specification. Therefore, any equivalent variations made in accordance with the claims of this specification shall still fall within the scope of this specification.

Claims

1. A task processing method applied to a near-end device, the method comprising: In response to the start operation of the target RPA task, the start instruction of the target RPA task is determined and sent to the server. The server then determines the execution end from the near-end device and the cloud according to the start instruction of the target RPA task, and sends the RPA instruction set of the target RPA task to the execution end. The execution end is determined based on the permission level and / or resource consumption level of the RPA task, and the executor that executes the RPA instruction set is determined based on the status of the executor. The execution result of the target RPA task is obtained and displayed, wherein the execution result of the target RPA task is obtained by the execution terminal executing each RPA instruction in the RPA instruction set of the target RPA task; If a task abort operation is received, a task abort instruction is determined, and the processing of the target RPA task on the execution end is terminated according to the task abort instruction.

2. The method according to claim 1, wherein when the near-end device is determined to be the execution end, after determining the start instruction of the target RPA task in response to the start operation of the target RPA task and sending the start instruction of the target RPA task to the server, and before obtaining and displaying the execution result of the target RPA task, the method further includes: Receive the RPA instruction set for the target RPA task sent by the server; The execution result of the target RPA task is obtained by executing each RPA instruction in the RPA instruction set of the target RPA task.

3. The method according to claim 1, wherein when the cloud is determined to be the execution end, the step of acquiring and displaying the execution result of the target RPA task includes: Receive the execution result of the target RPA task sent by the cloud through the server; Display the execution result of the target RPA task.

4. The method according to claim 1, wherein, when the cloud is determined to be the execution end, after determining the start instruction of the target RPA task in response to the start operation of the target RPA task and sending the start instruction of the target RPA task to the server, and before obtaining and displaying the execution result of the target RPA task, the method further includes: Receive human-computer interaction RPA commands sent by the cloud through the server; The human-computer interaction interface is rendered and displayed according to the human-computer interaction RPA instructions; The human-computer interaction result information is determined in response to the interactive operation on the human-computer interaction interface; The server sends the human-computer interaction result information to the cloud.

5. The method according to claim 4, wherein rendering and displaying the human-computer interaction interface according to the human-computer interaction RPA instruction comprises: The human-computer interaction RPA instructions are used to render and display interactive prompts and interactive controls to form the human-computer interaction interface. The interactive prompts are used to prompt the user to perform interactive operations, and the interactive controls are used to respond to the user's interactive operations.

6. A task processing method, applied on a server, the method comprising: Receive the start command for the target RPA task sent by the near-end device; According to the start command of the target RPA task, the execution end is determined from the near-end device and the cloud, and the execution end is determined based on the permission level and / or resource consumption level of the RPA task; The execution terminal sends the RPA instruction set of the target RPA task to the execution terminal, so that the execution terminal can execute each RPA instruction in the RPA instruction set of the target RPA task to obtain the execution result of the target RPA task. The near-end device obtains and displays the execution result of the target RPA task. The executor that executes the RPA instruction set is determined based on the state of the executor. If the near-end device sends a task abort command, the processing of the target RPA task on the execution end is terminated according to the task abort command.

7. The method according to claim 6, wherein determining the execution end from the near-end device and the cloud based on the start instruction of the target RPA task comprises: Determine the permission level of the target RPA task based on the start command of the target RPA task; If the permission level of the target RPA task is higher than the preset reference permission level, the near-end device is determined as the execution end; If the permission level of the target RPA task is not higher than the preset reference permission level, the cloud is determined as the execution end.

8. The method according to claim 6, wherein, when the cloud is determined to be the execution end, after sending the RPA instruction set of the target RPA task to the execution end, it further includes: Determine the status of each RPA executor in the cloud, wherein the status of the RPA executor includes a busy state and an idle state; The target RPA executor is determined from the idle RPA executors in the cloud. An RPA executor invocation instruction is generated based on the target RPA executor, and the RPA executor invocation instruction is sent to the cloud. The RPA executor invocation instruction is used to instruct the cloud to invoke the target RPA executor to execute each RPA instruction in the RPA instruction set of the target RPA task.

9. A task processing method applied in the cloud, the method comprising: The server receives the RPA instruction set of the target RPA task sent by the server. The RPA instruction set of the target RPA task is sent by the server to the cloud when the server determines the cloud as the execution end based on the start instruction of the target RPA task from the near-end device and the cloud. The execution end is determined based on the permission level and / or resource consumption level of the RPA task. The execution result of the target RPA task is obtained by executing each RPA instruction in the RPA instruction set of the target RPA task, so that the near-end device can obtain and display the execution result of the target RPA task. The executor executing the RPA instruction set is determined based on the state of the executor. If the server receives a task abort instruction, the processing of the target RPA task is terminated.

10. The method according to claim 9, wherein the execution result of the target RPA task is obtained from each RPA instruction in the RPA instruction set executing the target RPA task, so that the near-end device can acquire and display the execution result of the target RPA task, includes: Determine the execution order of each RPA instruction in the RPA instruction set of the target RPA task; According to the execution order of each RPA instruction in the RPA instruction set of the target RPA task, each RPA instruction is traversed sequentially; For each of the traversed RPA instructions, execute the current RPA instruction; Once the last RPA instruction in the execution order has been executed, the execution result of the target RPA task is obtained. The execution result of the target RPA task is then sent to the near-end device through the server, so that the near-end device can receive and display the execution result of the target RPA task.

11. The method according to claim 10, wherein executing the current RPA instruction for each of the traversed RPA instructions comprises: For the current RPA instruction among the traversed RPA instructions, if the current RPA instruction is a human-computer interaction RPA instruction, then the human-computer interaction RPA instruction is sent to the near-end device through the server. The near-end device renders and displays a human-computer interaction interface according to the human-computer interaction RPA instruction, determines the human-computer interaction result information in response to the interaction operation on the human-computer interaction interface, and sends the human-computer interaction result information to the cloud through the server. Receive the human-computer interaction result information.

12. The method according to claim 10, wherein executing the current RPA instruction for each of the traversed RPA instructions comprises: For the current RPA instruction among the traversed RPA instructions, if the current RPA instruction is an interaction-preceding RPA instruction whose execution order precedes the human-computer interaction RPA instruction, then interaction prompt information is obtained according to the interaction-preceding RPA instruction, and the interaction prompt information is filled into the human-computer interaction RPA instruction. The interaction prompt information is used to prompt the user to perform interactive operations in the human-computer interaction interface rendered and displayed by the near-end device according to the human-computer interaction RPA instruction.

13. The method according to claim 10, wherein executing the current RPA instruction for each of the traversed RPA instructions comprises: For the current RPA instruction among the traversed RPA instructions, if the current RPA instruction is an interaction-following RPA instruction whose execution order is after the human-computer interaction RPA instruction, then the interaction-following RPA instruction is executed according to the received human-computer interaction result information. The human-computer interaction result information is the human-computer interaction interface rendered and displayed by the near-end device according to the human-computer interaction RPA instruction, the interaction operation on the human-computer interaction interface is determined, and the information is sent to the cloud through the server.

14. The method according to claim 9, further comprising, after receiving the RPA instruction set of the target RPA task sent by the server and before executing each RPA instruction in the RPA instruction set of the target RPA task to obtain the execution result of the target RPA task, the method further comprising: Receive an RPA executor invocation instruction sent by the server, wherein the RPA executor invocation instruction is generated by the server based on the target RPA executor in the cloud, and the target RPA executor is determined by the server from the RPA executors in the cloud that are in an idle state; The execution result of the target RPA task obtained by each RPA instruction in the RPA instruction set executing the target RPA task includes: According to the RPA executor invocation instruction, the target RPA executor is invoked to execute each RPA instruction in the RPA instruction set of the target RPA task to obtain the execution result of the target RPA task.

15. A task processing system, the system comprising a near-end device, a server, and a cloud; The near-end device is configured to respond to the start operation of the target RPA task, determine the start instruction of the target RPA task, send the start instruction of the target RPA task to the server, obtain and display the execution result of the target RPA task, and if a task abort operation is received, determine the task abort instruction and abort the target RPA task according to the task abort instruction. The server is configured to receive a start command for the target RPA task sent by the near-end device; determine an execution end from the near-end device and the cloud according to the start command for the target RPA task; send the RPA instruction set of the target RPA task to the execution end so that the execution end can execute each RPA instruction in the RPA instruction set of the target RPA task to obtain the execution result of the target RPA task. The execution end is determined based on the permission level and / or resource consumption level of the RPA task, and the executor executing the RPA instruction set is determined based on the status of the executor. If the near-end device sends a task abort command, the server will abort the processing of the target RPA task of the execution end according to the task abort command. The cloud platform is used to receive the RPA instruction set of the target RPA task sent by the server, wherein... The RPA instruction set for the target RPA task is sent by the server to the cloud when the server determines the cloud as the execution end based on the start instruction of the target RPA task from the near-end device and the cloud. The server executes each RPA instruction in the RPA instruction set of the target RPA task to obtain the execution result of the target RPA task. If the server transmits a task abort instruction, the processing of the target RPA task is aborted.

16. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores computer program code that, when executed, implements the method as described in any one of claims 1 to 14.

17. An electronic device comprising: A processor and a memory; wherein the memory stores a computer program adapted to be loaded by the processor and to perform the steps of the method as claimed in any one of claims 1 to 14.

18. A computer program product having at least one instruction stored thereon, which, when executed by a processor, implements the steps of the method according to any one of claims 1 to 14.

Images