Information processing apparatus, information processing method, and information processing program

Abstract

To provide an information processing apparatus, an information processing method, and an information processing program capable of shortening an application startup processing time by continuously executing an application while the application is being started as much as possible when executing the automatic operation of the application.SOLUTION: An information processing apparatus according to an embodiment of the present invention executes an automatic operation of one or a plurality of target applications, and is provided with automatic operation means for executing the next process while an application is running without restarting it when the process of the application finishes successfully, and for restarting the application when the process of the application finishes unsuccessfully.SELECTED DRAWING: Figure 5

Description

Technical Field

[0001] The present invention relates to an information processing apparatus, an information processing method, and an information processing program.

Background Art

[0002] Recently, the demand for application automation operations called RPA (Robotic Process Automation) has been increasing. Such RPA is an automation tool for automating operations. Specifically, by registering (defining) a plurality of operations by a user and executing the registered operations, it is possible to easily execute the subsequent operations that have been formalized. Conventionally, as a system using RPA, for example, there is Patent Document 1.

Prior Art Documents

Patent Documents

[0003]

Patent Document 1

Summary of the Invention

Problems to be Solved by the Invention

[0004] However, Patent Document 1 does not describe anything regarding shortening the startup processing time of an application by continuously executing the application while keeping it started as much as possible when performing an automatic operation of the application.

[0005] The present invention has been made in view of the above, and an object of the present invention is to provide an information processing apparatus, an information processing method, and an information processing program capable of shortening the startup processing time of an application by continuously executing the application while keeping it started as much as possible when performing an automatic operation of the application.

Means for Solving the Problems

[0006] In order to solve the above-described problems and achieve the object, the present invention is an information processing apparatus including a control unit that executes automatic operation of one or a plurality of applications to be operated, and when the process of an application ends successfully, the control unit executes the next process while keeping the application running without restarting the application, and when the process of the application ends in failure, the control unit includes an automatic operation means for restarting the application.

[0007] Further, according to one aspect of the present invention, the automatic operation means determines whether it is the first loop of the automatic operation. If it is the first loop, the automatic operation means starts the application, holds the operation target process ID, and changes the continuous operation flag to FLG = false. On the other hand, if it is not the first loop, the automatic operation means may include start determination means for specifying the target process based on the operation target process ID and changing the continuous operation flag to FLG = true.

[0008] Further, according to one aspect of the present invention, the automatic operation means determines whether it is the last loop. If it is not the last loop, the automatic operation means checks the execution result. If the execution result is an error end, the automatic operation means ends the process of the application. If the execution result is a successful end, the automatic operation means may include end determination means for not ending the process of the application.

[0009] Further, according to one aspect of the present invention, the automatic operation means checks the continuous operation flag FLG. When the continuous operation flag FLG = true, the automatic operation means executes the initial operation at the time of continuous execution of the application. When the continuous operation flag FLG = false, the automatic operation means may include operation execution means for executing the initial operation immediately after starting the application.

[0010] Further, according to one aspect of the present invention, each time the automatic operation means executes the process of the application, it counts up the number of consecutive executions, and when the execution result ends in an error or the number of consecutive executions reaches the maximum number of consecutive executions, it ends the process of the application and resets the number of consecutive executions to "0". It may include means for determining the number of consecutive executions.

[0011] Further, according to one aspect of the present invention, the automatic operation may be an automatic operation based on RPA (Robotic Process Automation).

[0012] Further, according to one aspect of the present invention, the application may include an accounting application.

[0013] Also, in order to solve the above-described problems and achieve the object, the present invention is an information processing method for executing an automatic operation of one or a plurality of applications to be operated, which is executed by an information processing apparatus including a control unit. When the process of the application executed in the control unit ends successfully, the next process is executed while the application remains started without restarting the application. When the process of the application ends in failure, it includes an automatic operation step of restarting the application.

[0014] Also, in order to solve the above-described problems and achieve the object, the present invention is an information processing program for causing an information processing apparatus including a control unit to execute an automatic operation of one or a plurality of applications to be operated. In the control unit, when the process of the application ends successfully, the next process is executed while the application remains started without restarting the application. When the process of the application ends in failure, it is an information processing program for executing an automatic operation step of restarting the application.

Effects of the Invention

[0015] According to the present invention, when executing the automatic operation of an application, it is possible to shorten the startup processing time of the application by continuously executing the application while keeping it launched as much as possible, which has the effect of achieving this.

Brief Description of the Drawings

[0016]

Figure 1

Figure 2

Figure 3

Figure 4

Figure 5

Figure 6

Figure 7

Figure 8

Figure 9

Figure 10

Figure 11

Figure 12

Figure 13

Figure 14

Figure 15

Figure 16

Figure 17

Figure 18

Figure 19

Figure 20

Figure 21

Figure 22

Figure 23

Figure 24

Figure 25

Figure 26

Figure 27

Figure 28

[0017] Embodiments of an information processing apparatus, an information processing method, and an information processing program according to the present invention will be described in detail below with reference to the drawings. Note that the present invention is not limited to the present embodiment.

[0018] [1. Overview] For example, in RPA (Robotic Process Automation), it is assumed that it is used to repeatedly input a large amount of slip data into a system. Specifically, it includes (1) data migration from an old system before system operation and (2) automation of double registration of an old system and a new system in parallel operation before system operation.

[0019] Currently, when continuously executing RPA, an application (hereinafter sometimes abbreviated as "app") is restarted every time a slip is registered. This is because when an error occurs, there are various patterns of screen states within one application, and if an attempt is made to continuously register the next slip in that state, incorrect values may be registered or continuous errors may occur. Since the patterns of errors that occur are diverse, it is difficult and unrealistic to define the operations of the robot for each pattern. Therefore, regardless of the successful termination or error termination of the application, the application is restarted every time so that the slips can be continuously registered with the screen initialized.

[0020] Figures 1 to 4 are diagrams showing examples of screen states when an error occurs. Figure 1 is a diagram showing an example of a pattern in which an error dialog is displayed. In this example, an error message "The stock quantity has been exceeded." is displayed. Figure 2 is a diagram showing an example of a pattern in which the screen transitions to an error page. In this example, an error message "System Error. Please contact the administrator." is displayed.

[0021] Figure 3 is a diagram showing an example of a pattern in which an error message is displayed in the message area. In this example, an error message "There are unentered items." is displayed. Figure 4 is a diagram showing an example of a pattern in which an error provider is displayed. In this example, an error message "Please enter a number." is displayed.

[0022] Thus, conventionally, since the application is restarted every time, the overall RPA execution time increases by only the time required for the startup process. In addition, since there are cases where login processing is required during the startup process, the execution time further increases.

[0023] Also, the startup process of the application places a load on the CPU. Generally, since heavy processing such as security check processing is executed in the background during application startup, the load is particularly high.

[0024] Therefore, in this embodiment, when performing continuous registration, the following branching process is performed. Pattern A: When the process ends successfully, the application is not terminated and the next slip is input while the application remains running. Pattern B: When the process ends with an error, the application is restarted and the next slip is input from the initial state.

[0025] According to this embodiment, the total execution time of the RPA can be significantly reduced, and it is also possible to reduce the CPU load caused by the application startup process.

[0026] More specifically, in this embodiment, the following Implementations 1 to 4 are implemented in the RPA system.

[0027] (Implementation 1) When the robot starts execution, if the target application has already been launched, start operating the application (for example, if the previous ticket registration was successfully completed). On the other hand, if the target application has not been launched, launch it and start the operation (for example, if the previous ticket registration ended in an error).

[0028] (Implementation 2) When the robot execution ends, if it ends successfully, do not terminate the application. On the other hand, if it ends in an error, terminate the application.

[0029] When taking this solution, the following problems newly occur. There are cases where the initial state of the screen is different depending on patterns A and B. Implementation 3 solves such problems.

[0030] (Implementation 3) Internally flag-manage a value (continuous execution flag) indicating whether it is an input from the initial state when the application is launched or a continuous registration from the launched state. Make the continuous execution flag accessible in the L2 layer that defines the behavior of the robot. This makes it possible to easily implement the branching process in L2. The layer will be described later.

[0031] There is a problem that continuous registration while the application is running compresses the memory and unexpected system errors occur. Implementation 4 solves such problems.

[0032] (Implementation 4) Master-manage the maximum number of continuous executions. When the number of continuous executions reaches the maximum number of continuous executions, restart the target application even if it ends successfully.

[0033] [2. Configuration] The configuration of the information processing apparatus 100 according to the present embodiment will be described with reference to FIG. 5. FIG. 5 is a block diagram showing an example of the configuration of the information processing apparatus 100 according to the present embodiment.

[0034] The information processing apparatus 100 is a commercially available desktop personal computer. Note that the information processing apparatus 100 is not limited to a stationary information processing apparatus such as a desktop personal computer, and may be a portable information processing apparatus such as a commercially available notebook personal computer, a PDA (Personal Digital Assistants), a smartphone, or a tablet personal computer.

[0035] As shown in FIG. 5, the information processing apparatus 100 includes a control unit 102, a communication interface unit 104, a storage unit 106, and an input / output interface unit 108. Each unit included in the information processing apparatus 100 is communicably connected via an arbitrary communication path.

[0036] The communication interface unit 104 communicably connects the information processing apparatus 100 to the network 300 via a communication device such as a router and a wired or wireless communication line such as a dedicated line. The communication interface unit 104 has a function of communicating data with other devices via a communication line. Here, the network 300 has a function of communicably connecting the information processing apparatus 100 and the server 200 to each other, and is, for example, the Internet or a LAN (Local Area Network). Note that the data stored in the storage unit 106 described later may be stored in a server.

[0037] An input / output interface unit 108 has an input device 112 and an output device 114 connected thereto. As the output device 114, in addition to a monitor (including a home television), a speaker or a printer can be used. As the input device 112, in addition to a keyboard, a mouse, and a microphone, a monitor that cooperates with the mouse to realize a pointing device function can be used. Hereinafter, in some cases, the output device 114 may be described as the monitor 114, and the input device 112 may be described as the keyboard 112 or the mouse 112. Also, the operation by the user on the screen (GUI or the like) of the output device (monitor) 114 using the input device 112 may be simply described as a "user operation".

[0038] The storage unit 106 stores various databases, tables, files, and the like. The storage unit 106 records a computer program for giving instructions to the CPU (Central Processing Unit) in cooperation with the OS (Operating System) to perform various processes. As the storage unit 106, for example, a memory device such as a RAM (Random Access Memory) or a ROM (Read Only Memory), a fixed disk device such as a hard disk, a flexible disk, and an optical disk can be used.

[0039] The storage unit 106 includes a definition file 106a, a maximum consecutive execution count master 106b, a log file 106c, a memory variable file 106d, and the like.

[0040] The definition file 106a is a file for storing a definition (also referred to as an "RPA robot execution definition") that defines a series of operation instructions for the automatic operation unit (RPA system) 102a to automatically operate one or more applications. A unit that defines a series of operation instructions required for one execution of processing (one loop) defined for each operation target application is referred to as a "robot" or an "RPA robot". The details of the "RPA robot execution definition" will be described later.

[0041] The log file 106c is a file for storing the execution logs created by the automatic operation unit (RPA system) 102a. As execution logs, there are, for example, three levels of logs: a summary log, a detail log, and a detailed log (see FIGS. 8 to 11).

[0042] The maximum consecutive execution times master 106b is a master that registers the maximum consecutive execution times for each application to be operated, and can be configured by a table or the like that associates the application name with the maximum consecutive execution times (see FIG. 14). The maximum consecutive execution times master 106b is used in the control of Implementation 4. Since the characteristics of the memory usage rate vary depending on the application, the maximum consecutive execution times are registered for each application.

[0043] The memory variable file 106d is a file for storing memory variables. The memory variables are, for example, the process ID to be operated, the continuous execution flag, and the number of consecutive executions. For each application to be operated, the process ID to be operated, the continuous execution flag, and the number of consecutive executions are stored. The process ID to be operated is used for the control of Implementation 1. The continuous execution flag is used for the control of Implementation 3. The number of consecutive executions is used for the control of Implementation 4. The memory variables in the memory variable file 106d are updated and referenced by the automatic operation unit 102a.

[0044] The control unit 102 is a CPU or the like that comprehensively controls the information processing apparatus 100. The control unit 102 has an internal memory for storing control programs such as the OS, programs defining various processing procedures, and required data, and executes various information processes based on these stored programs. Conceptually in terms of functions, the control unit 102 includes an automatic operation unit (RPA system) 102a and an application 102b.

[0045] The automatic operation unit (RPA system) 102a executes an automatic operation on the application 102b according to the definition that defines a series of operations on the application 102b registered in the definition file 106a. At this time, if the process of the application 102b ends successfully, the next process is executed without restarting the application 102b, and if the process of the application 102b ends in failure, the application 102b is restarted.

[0046] Functionally conceptually, the automatic operation unit (RPA system) 102a includes a startup determination unit 102a1, an end determination unit 102a2, an initial operation unit 102a3, and a continuous execution determination unit 102a4. The automatic operation unit 102a is incorporated into the aforementioned RPA. In addition to being incorporated into RPA, it may also be incorporated into other automatic operation tools such as RDA (Robotic Desktop Automation).

[0047] The startup determination unit 102a1 determines whether it is the first loop of the automatic operation. If it is the first loop, the application is started, the operation target process ID is held, and the continuous operation in progress flag is changed to false. On the other hand, if it is not the first loop, the target process is identified based on the operation target process ID, and the continuous operation in progress flag is changed to true. The startup determination unit 102a1 corresponds to implementation 1 and executes the definition of implementation 1.

[0048] The end determination unit 102a2 determines whether it is the last loop. If it is not the last loop, the execution result is checked. If the execution result is an error end, the process of the application is ended. If the execution result of the application is a successful end, the process of the application is not ended. The end determination unit 102a2 corresponds to implementation 2 and executes implementation 2.

[0049] The initial operation unit 102a3 checks the continuous operation flag. When the continuous operation flag = true, it executes the initial operation during continuous execution. When the continuous operation flag = false, it executes the initial operation immediately after the application starts. The initial operation unit 102a3 corresponds to Implementation 3 and executes the definition of Implementation 3.

[0050] The continuous execution determination unit 102a4 increments the continuous execution count every time the application process is executed. Also, when the execution result is an error termination or the continuous execution count reaches the maximum continuous execution count, it terminates the application process and resets the continuous execution count to "0". The continuous execution determination unit 102a4 corresponds to Implementation 4 and executes the definition of Implementation 4.

[0051] The application 102b is one or more applications. For example, it is an accounting application that inputs various vouchers such as order input, purchase input, issue order input, sales input, etc., or prints and outputs various vouchers. The present invention is also applicable to other applications. The application is stored in the storage unit 106, but the application stored in the storage unit 106 that the control unit 102 executes is conceptually represented as the application 102b of the control unit 102 in terms of function.

[0052] [3. Specific examples of processing] With reference to FIGS. 5 to 28, a specific example of the processing of the control unit 102 of the information processing apparatus 100 in the present embodiment will be described. FIGS. 5 to 28 are diagrams for explaining a specific example of the processing of the control unit 102 of the information processing apparatus 100 in the present embodiment. The automatic operation unit (RPA system) 102a of the control unit 102 executes the following processing (flow) according to the RPA robot execution definition (program and data) stored in the definition file 106a. The following processing (flow) shows the processing executed by the automatic operation unit 102a according to the RPA execution definition. However, for the sake of simplicity of explanation, the RPA execution definition may be described as the operating entity.

[0053] (3-1. Common (basic) definition) Referring to FIGS. 6 to 13, the common definition of the RPA robot execution definition will be described. The present invention implements Implementations 1 to 4 in the common definition. First, the basic common definition will be described. It is what implements Implementations 1 to 4 in the common definition. First, the basic common definition will be described.

[0054] (Definition of RPA Flow) FIG. 6 is a diagram showing an execution flow including the processes before and after the execution of the RPA robot. It is assumed that data to be input to the robot is prepared in Excel or the like and is repeatedly input.

[0055] In FIG. 6, when the RPA flow is started (step S1), the RPA data source is read (step S2). Here, for example, a data source prepared in Excel or the like is read.

[0056] The RPA data source loop is executed (step S3). Here, loop processing is performed for the number of pieces of the read data.

[0057] When the loop is started (step S4), the RPA robot is executed (step S7). Detailed settings for what movements the robot makes are separately performed. The success or failure of the execution result is determined. If the execution result is successful (step S8), the next loop is executed (step S10). If the execution result is a failure (step S9), a handling pattern is selected according to the operation. (1) In the case of the continue-on-error type (processing continues even after an error occurs) (step S11), the next loop is executed (step S10). (2) In the case of the stop-on-error type (processing stops at the time of an error occurrence) (step S12), the RPA scenario is terminated (step S13).

[0058] When the loop ends (step S5), the RPA flow ends (step S6).

[0059] (Definition of RPA Robot Execution) Describe the detailed definition in "RPA Robot Execution". Combine the processing components to define the behavior of the robot. The RPA robot execution definition consists of (1) Layer 1 (L1): RPA flow definition, (2) Layer 2 (L2): robot execution definition, and (3) Layer 3 (L3): internal implementation of screen operation processing.

[0060] (1) Layer 1 (L1): RPA flow definition This is the "RPA flow definition" mentioned above. It is the layer set by the RPA execution setter.

[0061] (2) Layer 2 (L2): robot execution definition This is the detailed execution definition of the robot. It is the layer set by the RPA execution setter. Operation processing corresponding to screen items is prepared as components, and the behavior of the robot is defined by combining them. In general RPA tools, various processing components are prepared in addition to screen operation processing.

[0062] For example, the screen capture processing is a process to be incorporated when it is desired to capture a screen shot at an arbitrary timing. The waiting process is a process to wait for time-consuming processes such as screen transition and registration processing. It is common to set the waiting time at the time of setting. The value acquisition processing of screen items is a process to acquire what values are input on the screen. The branching process is a process to branch the behavior of the robot based on conditions such as the values of screen items. The loop process is a process to be used when repeated input is required for details items, etc.

[0063] (3) Layer 3 (L3): internal implementation of screen operation processing This is the internal implementation of the "screen operation processing component" incorporated into the robot execution definition. It is a layer that the RPA execution setter does not need to be aware of. By incorporating common processing into this layer, the RPA settings can be simplified while making it highly functional.

[0064] FIG. 7 is a diagram showing an example of a processing flow of (1) layer 1 (L1): RPA flow definition, (2) layer 2 (L2): robot execution definition, and (3) layer 3 (L3): internal implementation of screen operation processing.

[0065] In FIG. 7, in L1: RPA flow definition, when starting the PRA flow (step S21), after executing a series of pre - processing (step S22), perform RPA robot execution (step S23), after executing a series of post - processing (step S24), end the RPA flow (step S25).

[0066] In L2: robot execution definition, when starting RPA robot execution (step S31), for example, input to a text box (step S32), input to a check box (step S33), input to a radio button (step S34), execute a series of processes (step S35), press the registration button (step S36), and end RPA robot execution (step S37).

[0067] In L3: internal implementation of screen operation processing, when starting the operation process (step S41), identify the operation target item (step S42). For example, identify the operation target item based on the ID or coordinates. If the identification of the operation target item fails (step S44), that is, if the operation target item does not exist, "RPA robot execution" is immediately interrupted as an error.

[0068] If the identification of the operation target item is successful (step S43), acquire the input data (step S45). Specifically, acquire the data to be input to the target item from the data read in "RPA data source reading".

[0069] If the acquisition of the input data fails (step S47), "RPA robot execution" is immediately interrupted as an error.

[0070] If the acquisition of input data is successful (step S46), a series of preprocessing is executed (step S48), operation processing is executed (step S49), a series of postprocessing is executed (step S50), the execution log is output and stored in the log file 106c (step S51), and the operation processing is terminated (step S52).

[0071] (Execution Log) As the execution log, three levels of logs, namely summary log, detail log, and detailed log, are assumed. The summary log is a log created for each execution instruction unit of the RPA flow. The detail log is a log output for each processing unit (L1: each step unit of the RPA flow definition) in one execution of the RPA flow. The detailed log is a log output for each processing unit (L2: each step unit of the RPA robot execution definition) in the RPA robot execution definition. Note that the execution log may include data on the success or error of the execution result.

[0072] Figure 8 is a diagram showing an example of a summary log. The summary log may include data such as SEQ, log level, execution definition name, execution start date and time, execution end date and time, execution ID, and execution type CD.

[0073] Figure 9 is a diagram showing an example of a detail log. The detail log may include data such as execution ID, SEQ, log level, execution content, execution robot name, operation target application name, loop SEQ, execution start date and time, and execution end date and time.

[0074] Figure 10 is a diagram showing an example of a detailed log. The detailed log may include data such as execution ID, detail SEQ, SEQ, log level, execution content, operation target item name, input information, and execution date and time.

[0075] Figure 11 is a diagram showing an example of a screen shot log. The screen shot log may include an example of execution ID, detail SEQ, detailed SEQ, and screen data.

[0076] (Execution of Multiple Robots) The assumed use of RPA to run two applications continuously will be described. For example, an example of running an application to print the created slip data after executing the input application will be described.

[0077] The data registered in Application 1 is carried over to execute Application 2 (e.g., order receipt (Application 1) → sales (Application 2), purchase order (Application 1) → procurement (Application 2), etc.). FIG. 12 is a diagram showing an example of the screen display when Applications 1 and 2 are run continuously.

[0078] In Application 1, on the slip input screen shown in FIG. 12(A), enter the A code (character type), B amount (numeric type), and C flag (TRUE / FALSE), and press the registration button.

[0079] After pressing the registration button, obtain the automatically assigned slip number from the message or the like shown in FIG. 12(B) that is displayed, and use it for subsequent input.

[0080] In Application 2, on the print input screen shown in FIG. 12(C), enter the slip number, A code (character type), B amount (numeric type), C flag (TRUE / FALSE), P code (character type), and Q flag (TRUE / FALSE), and press the registration button.

[0081] The slip number is input by carrying over the slip data created in Application 1. The A code, B amount, and C flag are data carried over from the slip created in Application 1, and are not subject to operation by Robot 2. Since Robots 1 and 2 are run continuously, it is not assumed that the values input by Robot 1 are rewritten by Robot 2 intentionally. The values on the acceptance file are also only referred to by Robot 1. The P code and Q flag are items to be input in Application 2.

[0082] FIG. 13 is a diagram showing an example of an RPA flow for executing multiple robots. In FIG. 13, when the RPA flow is started (step S61), the RPA data source is read (step S62). Here, for example, a data source prepared in Excel or the like is read.

[0083] Execute the RPA data source loop (step S63). Here, loop processing is performed for the number of pieces of data read.

[0084] When starting the loop (step S64), execute RPA robot 1 (step S67). If the execution result of RPA robot 1 is successful (step S68), execute RPA robot 2 (step S70) and execute the next loop (step S72).

[0085] If the execution result of RPA robot 1 is a failure (step S69), execute the next loop (step S71). If the execution of robot 1 fails within one loop, robot 2 is not executed and the process proceeds to the next loop. There is no usage assumption of executing robot 2 despite the failure of robot 1.

[0086] When the loop ends (step S65), end the RPA flow (step S66).

[0087] (3-2. Definition of the present invention) With reference to FIGS. 14 to 28, the RPA robot execution definition of the present invention will be described. The information processing apparatus 1 of the present embodiment implements implementations 1 to 4 in the above-described common definition.

[0088] (Implementation method) As described above, the information processing apparatus 1 of the present embodiment implements the maximum continuous execution count master 106b. The maximum continuous execution count master 106b is used for the control of implementation 4. FIG. 14 shows a data example of the maximum continuous execution count master 106b. In the example shown in FIG. 14, in the first row, the application name is "Order Receiving Input" and the maximum continuous execution count is "10", and in the second row, the application name is "Order Confirmation Document" and the maximum continuous execution count is "5". Since file output-based applications such as "Order Confirmation Document" tend to use a large amount of memory during operation, the maximum continuous execution count is set to "5".

[0089] Also, as described above, the information processing apparatus 1 of the present embodiment implements the memory variable file 106d. In the memory variable file 106d, for each application to be operated, data such as the process ID to be operated, the continuous execution flag, and the number of continuous executions is stored as memory variables. The process ID to be operated is used for the control of Implementation 1. The continuous execution flag is used for the control of Implementation 3. The number of continuous executions is used for the control of Implementation 4. Each memory variable is held and controlled for each application to be operated. The value is set for each application to be operated. This is because the characteristics of the memory usage rate vary depending on the application.

[0090] Also, the information processing apparatus 100 of the present embodiment incorporates Implementations 1 to 4. In Implementation 1, in the L3 layer which is the internal implementation of the L2 RPA robot execution start process, a check is made for the existence of a process whose process ID matches the "process ID to be operated" in the process ID. If it does not exist, a new process is started, the process ID of the started application is set to the "process ID to be operated", and the "continuous execution flag" is set to false. If it exists, the process is connected to and the "continuous execution flag" is set to true.

[0091] In Implementation 2, the log of the execution result is checked in the L3 layer which is the internal implementation of the L2 RPA robot execution end process. If the execution is successfully completed, the process is not terminated. If the execution ends with an error, the process is terminated.

[0092] In Implementation 3, by referring to the "continuous operation flag" when creating the robot execution definition in L2, the process branches, corresponding to both the first startup process and the initialization process at the time of continuous input. The behavior of each robot is defined in the L2 layer.

[0093] In Implementation 4, the "number of continuous executions" is incremented for each loop process. When the upper limit value "maximum number of continuous executions" set in the maximum continuous execution count master 106b is reached, the process is always terminated. When the process is terminated, the "number of continuous executions" is reset to 0.

[0094] (RPA Robot Execution Definition of the Present Invention) FIG. 15 is a diagram showing an example of the flow of RPA robot execution definition. In FIG. 15, in L1:RPA flow definition, when starting the PRA flow (step S81), after executing a series of pre-processing (step S82), start a loop (step S83), repeatedly execute RPA robot execution until the loop ends (step S84), when the loop ends (step S85), after executing a series of post-processing (step S86), end the RPA flow (step S87).

[0095] In the internal implementation of L3: screen operation processing, when starting RPA robot execution (step S91), it is determined whether it is the first loop (step S100). If it is the first loop (\"Yes\" in step S100), it proceeds to step S101. If it is not the first loop (\"No\" in step S100), it is determined whether the operation target process ID (assigned by the OS) is NULL (empty) (step S104). If the execution result is an error, the process ID is explicitly cleared as an implementation (see step S117). This is because although the probability is low, the OS may accidentally start another application with the same process ID. If the operation target process ID is NULL (\"YES\" in step S104), it proceeds to step S101.

[0096] In step S101, start the application (step S101), hold the operation target process ID (step S102), change the continuous operation in progress FLG to false (step S103), and increment the \"number of consecutive executions\" (step S107).

[0097] If the operation target process ID is not NULL (i.e., "No" in step S104), connect to the target process based on the "operation target process ID" (step S105). Identifying a process by its process ID is a function of the operating system and is a process that can be implemented using common programming languages. Also, it does not depend on a specific operating system. Next, change the "continuous operation in progress" flag to true during continuous operation (step S106), and increment the "number of consecutive executions" (step S107).

[0098] The processing of steps S100 to S106 corresponds to implementation 1.

[0099] L2: In the robot execution definition, check the "continuous operation in progress" flag (step S92). If the "continuous operation in progress" flag is true, execute the "initial operation during continuous execution" (step S93). For example, execute a clear button click or the like.

[0100] If the "continuous operation in progress" flag is false, execute the "initial operation from immediately after app startup" (step S94). For example, perform operations on the login screen or the like.

[0101] Execute common screen operation processing (step S95). For example, perform text box input, checkbox input, radio button input, button click, etc. Subsequently, execute the end of RPA robot execution (step S96).

[0102] The processing of steps S92 to S94 corresponds to implementation 3.

[0103] L3: In the internal implementation of the screen operation processing, determine whether it is the last loop process (step S110). For example, this is to ensure that no process is left at the end of the last slip (data) input.

[0104] If it is the last loop process (i.e., "YES" in step S110), the process proceeds to step S115. If it is not the last loop process (i.e., "No" in step S110), the execution result is checked (step S111). If the execution result is an error termination, the process proceeds to step S115. This is to smoothly proceed with the next RPA execution when an error occurs.

[0105] If the execution is successful, it is determined whether the number of consecutive executions < the maximum number of consecutive executions (step S112). If the number of consecutive executions < the maximum number of consecutive executions (i.e., "Yes" in step S112), the robot execution is terminated (step S118). If the number of consecutive executions is not < the maximum number of consecutive executions (i.e., "No" in step S112), that is, when the "maximum number of consecutive executions" is reached, the process proceeds to step S115. This is to resolve memory shortages.

[0106] In step S115, after terminating the application process and setting the process ID of the operation target to NULL (step S116), the "number of consecutive executions" is reset to "0" (step S117), and the robot execution is terminated (step S118).

[0107] The processing of steps S110 - S111 and steps S115 - S116 corresponds to implementation 2, and the processing of steps S107 and steps 112 - S117 corresponds to implementation 4.

[0108] (Process Flow) Describes the images of the robot process and the process of the operation target application. A "robot" is a unit that defines a series of operation instructions required for one execution of processing (one loop) defined for each operation target application. Since a robot is created for each operation target application, the relationship between the application and the robot is 1:1. The present invention can be utilized without problems even if there are multiple operation target applications in the flow. Since the screen and process ID are independent for each application, processing such as process existence check determination can be implemented for each.

[0109] FIG. 16 is a diagram showing the life cycle (start to end) of one process as viewed from the OS. In FIG. 16, the part where the background of the block is continuously black or has a speckled pattern is during the process startup, with the upper end being "start" and the lower end being "end". Among them, the part with the background shown in "black" is during the automatic operation, and the part shown in "speckled pattern" is during standby.

[0110] (Conventional process flow) FIG. 17 is a diagram showing the conventional process flow (when Implementations 1 to 4 are not implemented). Each time the robot call task (L2) is executed, the startup / termination of the application to be operated is repeated. Here, an example when the total number of execution loop times = 4 (actually determined by the number of received data items) will be described. In the figure, pid indicates the process ID.

[0111] In FIG. 17, when the RPA flow (L1) is started, loops 1 to 4 are executed. First, when starting the task of the first loop, the robot call task (L2) starts the application to be operated and executes the process (pid = 001) of the application. Regardless of successful completion / error termination, the process ends every time. When the task of the first loop ends, the task of the second loop is started and this is executed up to the fourth loop. Thus, conventionally, regardless of the success / error of the process, the application was restarted every time.

[0112] (Process flow in the present invention (in the case of a single robot execution flow)) With reference to FIGS. 18 and 19, the process flow in the present invention (in the case of a single robot execution flow) will be described. FIG. 18 shows a data example of the maximum continuous execution count master 106b. In the example shown in FIG. 18, the application name "App 1" and the maximum continuous execution count "3" are set.

[0113] Figure 19 is a diagram showing an example of the process flow (in the case of a single robot execution flow) in the present invention. Here, taking the application to be operated as Application 1, the case where the total number of execution loop times = 7 (determined by the number of received data items) and the maximum continuous execution times is "3" will be exemplified and described. When an error occurs, when the number of repeated executions reaches the maximum value, or in the case of the last loop process, the process ends. In Figure 19, the transition of the memory variables indicates that (1) is the continuous execution flag, (2) is the number of continuous executions, and (3) is the ID of the process to be operated on.

[0114] When starting the RPA flow (L1), loops 1 to 7 are executed. First, when starting the task of the first loop, the robot call task (L2) starts the application to be operated and executes the process of the application. Since it is the first loop with successful completion, (1) the continuous execution flag = false, (2) the number of continuous executions = 1 is set, and (3) the ID of the process to be operated on = 001 is held.

[0115] When starting the task of the second loop, (1) the continuous execution flag = true, and (2) the number of continuous executions = 2. However, since it ends with an error, (2) the number of continuous executions is set to 0, and (3) the ID of the process to be operated on is cleared to "NULL".

[0116] In the third loop, since the ID of the process to be operated on = "NULL", the application is restarted, and the new (3) ID of the process to be operated on = 002 is held, and (1) the continuous execution flag = false, and the number of continuous executions = 1.

[0117] In the fourth loop, (1) the continuous execution flag = true, and (2) the number of continuous executions = 2 is set.

[0118] In the fifth loop, when starting the task, (2) the number of continuous executions = 3. Since the number of continuous executions = the maximum number of continuous executions = 3, even if the process is successfully completed, the process ends, and (2) the number of continuous executions = 0, and (3) the ID of the process to be operated on = NULL.

[0119] In the 6th loop, since the process ID to be operated on = "NULL", restart the application, hold the new (3) process ID to be operated on = 003, and set (1) the continuous execution flag = false and the continuous execution count = 1.

[0120] In the 7th loop, start the task and set (1) the continuous execution flag = true and (2) the continuous execution count = 2. Since it is the last loop, even if the process ends successfully, end the process and set (2) the continuous execution count = 0 and (3) the process ID to be operated on = NULL.

[0121] (Process flow in the present invention (in the case of multiple robot execution flows)) Referring to FIGS. 20 and 21, the process flow in the present invention (in the case of multiple robot execution flows) will be described. FIG. 20 shows an example of the data of the maximum continuous execution count master 106b. In the example shown in FIG. 20, the application name "App 1", the maximum continuous execution count "3", the application name "App 2", and the maximum continuous execution count "5" are set.

[0122] FIG. 21 is a diagram showing an example of the process flow in the present invention (in the case of multiple robot execution flows). Here, taking the applications to be operated on as App 1 and App 2, the total number of execution loop times = 5 (determined by the number of received data items), the maximum continuous execution count of "App 1" is "3", and the maximum continuous execution count of "App 2" is "5" as an example for explanation.

[0123] When multiple robots are executed, similar to the multiple single-robot execution flows, when an error occurs, when the number of repeated executions reaches the maximum value, and in the case of the last loop process, the process ends. Memory variables are defined in units of robots and are held in the process of "RPA flow (L1)".

[0124] Robot 1 automatically operates Application 1, and Robot 2 automatically operates Application 2. Each parameter is held for each target application to be operated. The timing of counting up and resetting the number of consecutive executions is also controlled independently for each target application to be operated. If the automatic operation of Application 1 fails, the automatic operation of Application 2 shall be "not executed". The transition of the memory variables of Robots 1 and 2 indicates that (1) is the continuous execution flag, (2) is the number of consecutive executions, and (3) is the target process ID.

[0125] In Fig. 21, when starting the RPA flow (L1), 1 to 5 loops are executed. First, when starting the task of the first loop, the robot call task (L2) causes Robot 1 to start the target application 1 and execute the process of Application 1. Since it is the first loop with successful completion, (1) the continuous execution flag = false, (2) the number of consecutive executions = 1 is set, and (3) the target process ID = 001 is held.

[0126] Next, Robot 2 starts the target application 2 and executes the process of Application 2. Since it is the first loop with successful completion, (1) the continuous execution flag = false, (2) the number of consecutive executions = 1 is set, and (3) the target process ID = 011 is held.

[0127] Start the task of the second loop and execute the process of Application 1. Since the execution is successful, (1) the continuous execution flag = true, and (2) the number of consecutive executions = 2. Next, execute the process of Application 2 and set (1) the continuous execution flag = true and (2) the number of consecutive executions = 2. However, since the execution ends with an error, the process is terminated, (2) the number of consecutive executions is set to 0, and (3) the target process ID is cleared to "NULL".

[0128] In the third loop, execute the process of Application 1 and set (2) consecutive execution count = 3. Since the consecutive execution count = maximum consecutive execution count = 3, even if the process ends successfully, end the process and set (2) consecutive execution count = 0 and (3) target process ID = NULL. Next, for Application 2, since the target process ID = "NULL", restart Application 2, hold the new (3) target process ID = 012, and set (1) in - continuous - execution flag = false and consecutive execution count = 1.

[0129] In the fourth loop, for Application 1, since the target process ID = "NULL", restart Application 1, execute the process, hold the new (3) target process ID = 002, and set (1) in - continuous - execution flag = false and consecutive execution count = 1. However, since it ends with an error, end the process, set (2) consecutive execution count to 0, and clear (3) target process ID to "NULL".

[0130] For Application 2, since an error occurred during the operation of Application 1, set the operation to "not executed".

[0131] In the fifth loop, for Application 1, since the target process ID = "NULL", restart Application 1, hold the new (3) target process ID = 003, and set (1) in - continuous - execution flag = false and consecutive execution count = 1. Since it is the last loop, even if the process ends successfully, end the process and set (2) consecutive execution count = 0 and (3) target process ID = NULL.

[0132] For Application 2, execute the process and set (1) in - continuous - execution flag = true and (2) consecutive execution count = 2. Since it is the last loop process, even if the process ends successfully, end the process and set (2) consecutive execution count = 0 and (3) target process ID = NULL.

[0133] (Screen initialization pattern) Referring to FIGS. 22 to 28, the screen initialization pattern of the above-described Implementation 3 will be described. For each application to be operated, the screen initialization pattern after the registration process is completed is different. Here, three initialization patterns and their respective robot definitions (L2) are exemplified. The following examples are merely examples of implementations, and the present invention is not limited to these implementations.

[0134] FIG. 22 is a diagram for explaining a conventional robot execution definition (when Implementations 1 to 4 do not exist). The state transition of the screen and the L2: robot execution definition are explained. "Screen Title" is a process for identifying the screen to be operated by RPA based on the screen title. "Item Name" and "Operation Method" describe what operation process is to be performed on which screen item.

[0135] In FIG. 22, when the execution of the RPA robot is started (step S200), for example, a login screen as shown in FIG. 22(A) is displayed. Input the user ID, input the password, and click the "Login Button" on the login screen (S201 to S204), and a menu screen as shown in FIG. 22(B) is displayed (step S205). Click the "Order Input Button" on the menu screen (step S206), and an order input list screen as shown in FIG. 22(C) is displayed (step S207). Click the "New Button" on the order input list screen (step S208), and an order input - input screen as shown in FIG. 22(D) is displayed (step S209).

[0136] On the order input - input screen, input "A Code", input "B Amount", input "C Flag", and click the "Register Button" (S210 to S213), and a message as shown in FIG. 22(E) is displayed (step S214). The input of "A Code", the input of "B Amount", and the input of "C Flag" are to read values from an order file (for example, Excel, etc.) and input them. FIG. 22(F) is a diagram showing an image after input on the order input - input screen. FIG. 22(G) is a diagram showing an image of the order file. Click the "OK Button" on the message screen (step S215), and the execution of the RPA robot is terminated (step S216).

[0137] There are, for example, the following three initialization patterns after the registration process is completed. There is one initialization pattern for each application. Therefore, depending on the application to be operated, initialization of any of the following three patterns will be implemented. Note that since the sample applications have the same order input in FIGS. 23 to 25, be careful not to misunderstand. There are multiple error patterns within one application.

[0138] FIG. 23 is a diagram showing an example of Pattern 1 of the initialization pattern. In Pattern 1, the input screen closes and transitions to the list screen. FIG. 24 is a diagram showing an example of Pattern 2 of the initialization pattern. In Pattern 2, all items on the screen are cleared. FIG. 25 is a diagram showing an example of Pattern 3 of the initialization pattern. In Pattern 3, all except some items on the screen are cleared. The example shown in FIG. 25 shows an example of an item for which the previous input value remains without being cleared, and all items can be cleared by pressing the clear button.

[0139] With reference to FIGS. 26 to 28, the robot execution definition in the present invention will be described. FIGS. 26 to 28 show an example of the detailed processing of steps S92 to S95 (Implementation 3) in FIG. 15, and the same step numbers are assigned.

[0140] FIG. 26 is a diagram for explaining the robot execution definition of Pattern 1. In Pattern 1, the input screen closes and transitions to the list screen. When the continuous operation flag FLG = true during continuous operation, automatic operation starts from the step of clicking the "New Button" on the list screen.

[0141] In FIG. 26, check the continuous operation flag FLG (step S92). If the continuous operation flag FLG = true, execute the "initial operation during continuous execution" (step S93). In this example, it is assumed that there is no particular process (operation).

[0142] When FLG = false during continuous operation, execute "Initial device immediately after app startup" (step S94). In this example, display the login screen, enter the user ID and password on the login screen, click the "Login button" to display the menu screen, and click the "Order input button" on the menu screen.

[0143] Next, execute the common screen operation process (step S95). In this example, display the order input list screen, click the "New button" on the order input list screen to display the order input - input screen. On the order input - input screen, enter "A code", "B amount", "C flag", click the "Register button" to display the message screen. Click "OK" on the message screen to end the execution of the RPA robot.

[0144] Figure 27 is a diagram for explaining the robot execution definition of Pattern 2. In Pattern 2, all items on the screen are cleared. When FLG = true during continuous operation, start the automatic operation from the input screen.

[0145] In Figure 27, check FLG during continuous operation (step S92). When FLG = true during continuous operation, execute "Initial operation during continuous execution" (step S93). In this example, assume there is no particular process (operation).

[0146] When FLG = false during continuous operation, execute "Initial operation immediately after app startup" (step S94). In this example, display the login screen, enter the user ID and password on the login screen, click the "Login button" to display the menu screen. Click the "Order input button" on the menu screen to display the order input list screen. Click the "New button" on the order input list screen.

[0147] Next, execute the common screen operation process (step S95). In this example, display the order input - input screen. On the order input - input screen, perform "A code" input, "B amount" input, "C flag" input, click the "Register button", and display the message screen. On the message screen, click "OK" to end the execution of the RPA robot.

[0148] Figure 28 is a diagram for explaining the robot execution definition of Pattern 3. In Pattern 3, all except some items on the screen are cleared. If FLG = true during continuous operation, click the "Clear" button on the order input screen to clear the screen items and then start the automatic operation.

[0149] In Figure 28, check the FLG during continuous operation (step S92). If FLG = true during continuous operation, execute the "Initial operation during continuous execution" (step S93). In this example, display the order input - input screen, and on the order input - input screen, click the "Clear button" to clear all items on the order input - input screen.

[0150] If FLG = false during continuous operation, execute the "Initial operation from immediately after app startup" (step S94). In this example, display the login screen, perform user ID input, password input, click the "Login button" on the login screen to display the menu screen. On the menu screen, click the "Order input button" to display the order input list screen. On the order input list screen, click the "New button" to display the order input - input screen.

[0151] Next, execute the common screen operation process (step S95). In this example, on the order input - input screen, perform "A code" input, "B amount" input, "C flag" input, click the "Register button" to display the message screen. On the message screen, click the "OK button" to end the execution of the RPA robot.

[0152] As described above, according to the present embodiment, when automatically operating one or more applications to be operated and the process of the application ends successfully, the next process is executed while the application remains running without restarting the application. When the process of the application ends in failure, since the automatic operation unit 120a for restarting the application is provided, when performing the automatic operation of the application, it is possible to shorten the startup processing time of the application by continuously executing the application while keeping it started as much as possible.

[0153] [4. Contribution to the United Nations-led Sustainable Development Goals (SDGs)] According to the present embodiment, since it is possible to contribute to improving business efficiency and promoting appropriate management decisions of enterprises, it is possible to contribute to Goals 8 and 9 of the SDGs.

[0154] In addition, according to the present embodiment, since it is possible to contribute to reducing waste loss and promoting paperless and digitalization, it is possible to contribute to Goals 12, 13 and 15 of the SDGs.

[0155] In addition, according to the present embodiment, since it is possible to contribute to strengthening control and governance, it is possible to contribute to Goal 16 of the SDGs.

[0156] [5. Other Embodiments] The present invention may be implemented in various different embodiments within the scope of the technical idea described in the claims, in addition to the above-described embodiments.

[0157] For example, among the respective processes described in the embodiment, all or part of the processes described as being automatically performed can be manually performed, or all or part of the processes described as being manually performed can be automatically performed by a known method.

[0158] Also, regarding the processing procedures, control procedures, specific names, information including parameters such as registered data and search conditions for each process, screen examples, and database configurations shown in this specification and the drawings, they can be arbitrarily changed unless otherwise specified.

[0159] Also, regarding the information processing apparatus 100, each illustrated component is a functional concept and does not necessarily have to be physically configured as shown in the figure.

[0160] For example, regarding the processing functions provided by the information processing apparatus 100, especially each processing function performed by the control unit 102, all or any part of them may be realized by a CPU and a program interpreted and executed by the CPU, or may be realized as hardware by wired logic. Note that the program includes non-temporary computer-readable instructions for causing the information processing apparatus to execute the processing described in this embodiment and is recorded on a non-temporary computer-readable recording medium. As needed, it is mechanically read by the information processing apparatus 100. That is, in a storage unit 106 such as a ROM or an HDD (Hard Disk Drive), a computer program for giving instructions to the CPU in cooperation with the OS to perform various processes is recorded. This computer program is executed by being loaded into the RAM and constitutes the control unit 102 in cooperation with the CPU.

[0161] Also, this computer program may be stored in an application program server connected to the information processing apparatus 100 via an arbitrary network, and all or part of it can be downloaded as needed.

[0162] Also, a program for executing the processes described in this embodiment may be stored in a non-transitory computer-readable recording medium, or may be configured as a program product. Here, this "recording medium" includes any "portable physical medium" such as a memory card, a USB (Universal Serial Bus) memory, an SD (Secure Digital) card, a flexible disk, a magneto-optical disk, a ROM, an EPROM (Erasable Programmable Read Only Memory), an EEPROM (registered trademark) (Electrically Erasable and Programmable Read Only Memory), a CD-ROM (Compact Disk Read Only Memory), an MO (Magneto-Optical disk), a DVD (Digital Versatile Disk), and a Blu-ray (registered trademark) Disc.

[0163] Also, the "program" is a data processing method described in any language or description method, and is not limited to a form such as source code or binary code. Note that the "program" is not necessarily limited to being configured singularly, and also includes those that are distributed as a plurality of modules or libraries, or those that achieve their functions in cooperation with other separate programs represented by an OS. Note that for the specific configuration, reading procedure, and installation procedure after reading for reading the recording medium in each device shown in the embodiment, well-known configurations and procedures can be used.

[0164] The various databases and the like stored in the storage unit 106 are storage means such as a memory device such as a RAM or a ROM, a fixed disk device such as a hard disk, a flexible disk, and an optical disk, and store various programs, tables, databases, and web page files used for various processes and website provision.

[0165] Further, the information processing apparatus 100 may be configured as an information processing apparatus such as a known personal computer or workstation, or may be configured as the information processing apparatus to which any peripheral device is connected. Further, the information processing apparatus 100 may be realized by installing software (including programs or data, etc.) for realizing the processing described in the present embodiment in the information processing apparatus.

[0166] Furthermore, the specific forms of the distribution and integration of the apparatuses are not limited to those illustrated, and all or part of them can be functionally or physically distributed and integrated in arbitrary units according to various additions or function additions. That is, the above-described embodiments may be arbitrarily combined and implemented, or the embodiments may be selectively implemented.

Explanation of Signs

[0167] 100 Information processing apparatus 102 Control unit 102a Automatic operation unit (RPA system) 102a1 Activation determination unit 102a2 Termination determination unit 102a3 Initial operation unit 102a4 Continuous execution determination unit 102b Application 104 Communication interface unit 106 Storage unit 106a Definition file 106b Maximum continuous execution count master 106c Log file 106d Memory variable file 108 Input / output interface unit 112 Input device 114 Output device 200 Server 300 Network

Claims

【Claim 1】 An information processing apparatus that includes a control unit and executes automatic operations of one or more applications to be operated, wherein the control unit, when the process of an application ends successfully, executes the next process while keeping the application running without restarting the application, and when the process of the application ends in failure, includes an automatic operation means for restarting the application, wherein the automatic operation means, determines whether it is the first loop of the automatic operation. If it is the first loop, the application is started, the operation target process ID is held, and the continuous operation in progress flag is changed to false. On the other hand, if it is not the first loop, the target process is specified based on the operation target process ID, and the continuous operation in progress flag is changed to true, and includes a startup determination means. An information processing apparatus characterized by this.

Images