Scenario management device, scenario management program, recording medium, and scenario management method

Abstract

To allow a user to confirm an entity value of a variable referred by a scenario when editing the scenario that has been created.SOLUTION: When an execution unit 35 acquires an entity value E of a variable V referred by an activity Act in a first storage region R1 (step S103) following execution of the activity Act included in a scenario, a holding unit 372 holds the entity value E in a second storage region R2 in association with the variable V (step S203). Therefore, even after creation of the scenario is terminated, the entity value E of the variable V referred by the activity Act included in the scenario can be read from the second storage region R2.SELECTED DRAWING: Figure 8

Description

[Technical Field]

[0001] The present invention relates to RPA (Robotic Process Automation) technology that aims to reduce the workload of users by automating tasks that users have previously performed using computers. [Background technology]

[0002] RPA uses a scenario (sometimes called a "flow") that indicates the order in which processes are executed by a computer. The computer that executes the processes according to the scenario also references various variables, such as files that manage data in tabular format and the data managed by the files, as appropriate. For example, in Patent Document 1, a scenario file that indicates the order in which processes are executed and a customization file that indicates the setting values ​​of variables required to execute the scenario file are prepared, and the computer that executes the processes according to the scenario file references the setting values ​​indicated in the customization file. [Prior art documents] [Patent documents]

[0003] [Patent Document 1] Japanese Patent Publication No. 2020-113034 Summary of the Invention [Problem to be solved by the invention]

[0004] Incidentally, tasks automated by RPA technology include a task in which a user refers to arbitrary data and inputs the arbitrary data in a format that can be processed by a computer. Patent Document 1 discloses that a user edits a customization file that is referenced as a variable included in a scenario file. Therefore, while the above task can be replaced by editing the customization file, it is not automated. To automate the task, it is necessary to manage the variables included in the scenario so that the arbitrary data can be referenced in the same way that a user references arbitrary data when performing the above task.

[0005] However, one advantage of RPA technology is that it creates scenarios based on actual user operations, i.e., entity values ​​processed during user operations. In other words, users can create scenarios by accessing entity values ​​through their actual operations. However, variables included in a scenario do not reference entity values ​​except when the scenario is actually executed, which poses a problem: when a user manages variables included in a scenario, the entity values ​​referenced by the variables cannot be accessed.

[0006] The present invention has been made in view of the above-mentioned problems, and has as its object to provide a configuration in which, when managing a scenario, the actual values ​​of variables referenced in the scenario are accessed. [Means for solving the problem]

[0007] The scenario management device of the present invention is a scenario management device that manages scenarios for automating operations on other application programs, and is equipped with: a management unit that manages scenarios including a first activity and a second activity selected from multiple types of activities including activities corresponding to operations for obtaining values ​​from other application programs, activities corresponding to operations for inputting values ​​into other application programs, and activities corresponding to operations for processing the obtained values; an execution unit that executes the first activity included in the scenario based on a scenario execution instruction; a first storage area that is accessed by the execution unit when executing the first activity included in the scenario, and that holds the entity values ​​of variables referenced in the first activity so that they can be referenced as entity values ​​of variables included in a second activity included in the scenario; a second storage area that is accessible by the management unit, and that holds the entity values ​​of variables held in the first storage area in association with the variables; and a holding unit that stores the entity values ​​of the variables held in the first storage area in the second storage area.

[0008] A scenario management program according to the present invention causes a computer to function as the above-described scenario management device.

[0009] A recording medium according to the present invention records the above-described scenario management program in a computer-readable manner.

[0010] The scenario management method of the present invention is a scenario management method for managing a scenario including a first activity and a second activity selected from a plurality of types of activities including an activity corresponding to an operation of obtaining a value from another application program, an activity corresponding to an operation of inputting a value into another application program, and an activity corresponding to an operation of processing the obtained value, as a scenario for automating operations on other application programs, and includes the steps of executing the first activity based on a scenario execution instruction and storing the entity value of a variable referenced in the first activity in a first storage area so that it can be referenced as the entity value of a variable included in the second activity, and storing the entity value of the variable stored in the first storage area in association with the variable in a second storage area accessible by a management unit that manages the scenario.

[0011] In the present invention (scenario management device, scenario management program, recording medium, and scenario management method) configured in this manner, when a first activity included in a scenario is executed and the entity value of the variable is stored in a first storage area so that it can be referenced as the entity value of a variable included in a second activity, the storage unit associates the entity value with the variable and stores it in a second storage area accessible by the management unit. Therefore, the user can access the referenced entity value not only when the scenario is executed but also when managing the scenario. As a result, for example, when editing a scenario, the user can check the entity value of a variable referenced in the scenario. [Effects of the Invention]

[0012] As described above, according to the present invention, when managing a scenario, it is possible to access the actual values ​​of variables referenced in the scenario. [Brief explanation of the drawings]

[0013] [Figure 1] 1 is a block diagram showing an example of a scenario management system including a scenario management device according to the present invention; [Figure 2] FIG. 2 is a block diagram showing an example of each functional unit configured in the calculation unit for scenario management. [Figure 3] FIG. 4 is a diagram schematically showing an example of a scenario management screen displayed on a display. [Figure 4A] FIG. 10 is a diagram schematically showing an example of operations that can be performed on the scenario management screen in a scenario creation mode. [Figure 4B] FIG. 10 is a diagram schematically showing an example of operations that can be performed on the scenario management screen in a scenario creation mode. [Figure 4C] FIG. 10 is a diagram schematically showing an example of operations that can be performed on the scenario management screen in a scenario creation mode. [Figure 4D] FIG. 10 is a diagram schematically showing an example of operations that can be performed on the scenario management screen in a scenario creation mode. [Figure 4E] FIG. 10 is a diagram schematically showing an example of operations that can be performed on the scenario management screen in a scenario creation mode. [Figure 4F] FIG. 10 is a diagram schematically showing an example of operations that can be performed on the scenario management screen in a scenario creation mode. [Figure 4G] FIG. 10 is a diagram schematically showing an example of operations that can be performed on the scenario management screen in a scenario creation mode. [Figure 5] FIG. 4 is a block diagram showing the operation of each functional unit of the calculation unit when variable management is executed. [Figure 6] 10 is a flowchart showing an example of control executed by an execution unit for variable management. [Figure 7] 10 is a flowchart showing an example of control executed by a monitoring unit for variable management. [Figure 8] FIG. 8 is a diagram schematically showing the operation of variable management executed based on the flowcharts of FIGS. 6 and 7. [Figure 9] FIG. 4 is a diagram schematically illustrating an example of entity values ​​stored in a memory unit. [Figure 10A] FIG. 10 is a diagram schematically showing an example of operations that can be performed on the scenario management screen in the scenario editing mode. [Figure 10B]FIG. 10 is a diagram schematically showing an example of operations that can be performed on the scenario management screen in the scenario editing mode. [Figure 10C] FIG. 10 is a diagram schematically showing an example of operations that can be performed on the scenario management screen in the scenario editing mode. [Figure 10D] FIG. 10 is a diagram schematically showing an example of operations that can be performed on the scenario management screen in the scenario editing mode. [Figure 10E] FIG. 10 is a diagram schematically showing an example of operations that can be performed on the scenario management screen in the scenario editing mode. [Figure 11] FIG. 10 is a block diagram showing the operation of each functional unit of the calculation unit when a scenario edit mode is executed. [Figure 12] 10 is a flowchart showing an example of variable display executed by the editing operation unit in a scenario editing mode. [Figure 13] FIG. 10 is a diagram schematically showing the contents of variable name management. [Figure 14] 10 is a flowchart showing an example of variable name management executed in association with acquisition of the entity value of a variable. [Figure 15] 10 is a flowchart showing an example of control for displaying substance values ​​in a scenario editing mode. [Figure 16] FIG. 16 is a diagram schematically showing an example of the result of the control shown in FIG. 15. [Figure 17] 10 is a flowchart showing an example of control for partial execution in a scenario edit mode. DETAILED DESCRIPTION OF THE INVENTION

[0014] 1 is a block diagram showing an example of a scenario management system equipped with a scenario management device according to the present invention. This scenario management system 1 comprises a server 11 and a terminal device 2 that functions as a client of the server 11. The server 11 is a computer and has a storage unit 111 configured with an HDD (Hard Disk Drive) or an SSD (Solid State Drive) or the like, and a scenario management program 12 is stored in the storage unit 111.

[0015] The terminal device 2 is a computer for managing scenarios used in RPA. The terminal device 2 includes a calculation unit 21, a memory unit 22, a storage unit 23, a UI (User Interface) 24, a communication unit 25, and a bus 26, and signals are transmitted and received between the calculation unit 21, the memory unit 22, the storage unit 23, the UI 24, and the communication unit 25 via the bus 26.

[0016] The calculation unit 21 is a processor such as a CPU (Central Processing Unit), and controls the memory unit 22, the storage unit 23, the UI 24, and the communication unit 25. The memory unit 22 has a main memory, a cache memory, etc., and volatilely stores data based on instructions from the calculation unit 21, and the calculation unit 21 executes calculations using data read from the memory unit 22.

[0017] The storage unit 23 includes an HDD, an SSD, etc., and stores data in a nonvolatile manner. The UI 24 includes input devices such as a keyboard 241 and a mouse 242, and an output device such as a display 243. Therefore, a user can input data to the terminal device 2 by operating the keyboard 241 and the mouse 242, and can check various data stored in the memory unit 22 and the storage unit 23 by checking the display 243. The input and output devices do not need to be configured separately; they may be integrated into a touch panel display. The communication unit 25 communicates with the server 11. The communication unit 25 downloads the scenario management program 12 from the server 11, and the storage unit 23 stores the scenario management program 12. When the calculation unit 21 executes the scenario management program 12, the functional units shown in FIG. 2 for executing scenario management are configured in the calculation unit 21.

[0018] The manner in which the scenario management program 12 is provided to the terminal device 2 is not limited to downloading from the server 11. Therefore, the scenario management program 12 may be provided by other recording media such as an optical disc such as a DVD (Digital Versatile Disc) or a USB (Universal Serial Bus) memory. The terminal device 2 can store the scenario management program 12 read from these recording media in the storage unit 23.

[0019] In this embodiment, the scenarios used in RPA and managed by the terminal device 2 are scenarios for automating operations performed by the user of the terminal device 2 or other humans on application programs other than the scenario management program 12. These operations include an operation to obtain a value from an application program other than the scenario management program 12, an operation to process a value, and an operation to input a value into an application program other than the scenario management program 12. The operation to obtain a value from an application program other than the scenario management program 12 includes a human operating an application program other than the scenario management program 12 to output referenced information from an output device such as the display 243. The operation to input a value into an application program other than the scenario management program 12 includes a human operating an input device such as the keyboard 241 or the mouse 242 to input a value into an application program other than the scenario management program 12. For example, this includes directly inputting a value using the keyboard 241 or selecting a value to be input from options displayed by the application program using an input device.

[0020] 2 is a block diagram showing an example of each functional unit configured in the calculation unit for scenario management. As shown in FIG. 2, an editor 31, a scenario creation unit 33, an execution unit 35, and a debugger 37 are configured in the calculation unit 21 by execution of the scenario management program 12 by the calculation unit 21.

[0021] The editor 31 manages scenarios. In this embodiment, the scenarios managed by the editor 31 include multiple activities Act (not shown), which are computer operations corresponding to various human operations on applications other than the scenario management program 12, and the editor 31 manages multiple activities Act. The editor 31 accepts user operations on the UI 24 for scenario management. The editor 31 has an editing operation unit 311 and a scenario execution operation unit 312. The editing operation unit 311 displays a scenario management screen 4 (see FIG. 3, etc.) on the display 243 of the UI 24, which displays the contents of operations to be automated in the scenario, for the user's scenario management, and accepts user operations on the scenario management screen 4. The scenario execution operation unit 312 accepts an operation from the user to instruct execution of a scenario. To instruct execution of a scenario, the user selects some or all of the activities Act included in the scenario. The scenario execution operation unit 312 accepts the selection of an activity Act and sends a scenario execution instruction Ce to the execution unit 35, which instructs execution of the scenario corresponding to the selected activity Act.

[0022] The scenario creation unit 33 creates a scenario in response to user operations on the scenario management screen 4. More specifically, the scenario creation unit 33 accepts settings for the activity Act, which are settings related to the content of various human operations to be automated by the activity Act, through user operations, and generates the activity Act based on the settings. The scenario creation unit 33 also sends a scenario execution instruction Cg to the execution unit 35 based on the generated activity Act. In this embodiment, the scenario creation unit 33 sends a scenario execution instruction Cg to the execution unit 35 each time an activity Act is generated, the scenario execution instruction Cg instructing the execution of the generated activity Act. The scenario execution instruction Cg may be sent to the execution unit 35 each time a predetermined number of activities Acts are generated, or may be sent to the execution unit 35 in response to an operation on the scenario management screen 4 requesting the execution of the generated activity Act. The scenario creation unit 33 may also send a scenario execution instruction Cg to the execution unit 35 that does not include the activity Act as a target, depending on the type of activity Act.

[0023] The execution unit 35 executes part or all of a scenario based on a scenario execution instruction Ce from the editor 31 or a scenario execution instruction Cg from the scenario creation unit 33. The debugger 37 manages variables used by the execution unit 35 to execute a scenario when the execution unit 35 executes the scenario. The debugger 37 has a monitoring unit 371 and a holding unit 372. The monitoring unit 371 monitors the acquisition of entity values ​​of variables by the execution unit 35. The holding unit 372 holds the entity values ​​acquired by the execution unit 35 based on instructions from the monitoring unit 371.

[0024] FIG. 3 is a diagram that schematically shows an example of a scenario management screen that is displayed on a display. Note that the scenario management screen 4 shown in FIG. 3 is merely an example, and various modifications are possible. The scenario management screens 4 shown in the following figures can also be modified in a similar manner. As shown in FIG. 3, the scenario management screen 4 has a utility operation field 41, a mode selection field 43, and a scenario display field 45. The utility operation field 41 has a button 411 for naming and saving a newly created scenario, a button 412 for overwriting and saving an edited scenario, and a button 413 for executing part or all of the scenario.

[0025] The mode selection field 43 accepts an operation to select either the scenario creation mode or the scenario editing mode. That is, the user can select the scenario creation mode by operating (clicking) the expand / contract button provided in the scenario creation field 431 of the mode selection field 43 to expand the scenario creation field 431. The user can also select the scenario editing mode by operating (clicking) the expand / contract button provided in the scenario editing field 432 of the mode selection field 43 to expand the scenario editing field 432.

[0026] 4A to 4G are diagrams showing an example of operations that can be performed on the scenario management screen in the scenario creation mode. In these diagrams, the scenario creation field 431 is expanded, while the scenario editing field 432 is reduced. In the scenario creation mode, icons indicating various activities Act that can be used to create a scenario are displayed in the scenario creation field 431. The activities Act include: Activities that show the acquisition of tables written in CSV (Comma-Separated Values) format, etc. -Activity to narrow down the values ​​in the table using specified conditions An activity to extract values ​​from the table - An activity that outputs the value to a destination (table, web page, email address, etc.) Accessing certain web pages - Activities to retrieve images and text from web pages Various specific examples include the above. The user can select the activities Act that make up the scenario by placing the activities Act in the scenario creation field 431 in the scenario display field 45. In this way, a scenario can be created that includes each activity Act placed in the scenario display field 45. The user can place an activity Act in the scenario creation field 431 in the scenario display field by various operations, such as dragging the activity Act in the scenario creation field 431 to the scenario display field 45 or double-clicking the activity Act in the scenario creation field.

[0027] In addition, in the scenario creation mode, activities Act are unitized as units U according to the work purpose, such as table editing or web scraping. Therefore, the user can create a scenario including the activities Act that make up the units U by placing (dragging) the units U according to the work purpose into the scenario display field 45. This reduces the burden on the user required to create a scenario. However, it is not essential that activities Act be unitized in the scenario creation mode.

[0028] In the scenario creation mode, the user's operations of placing an activity Act in the scenario display field 45 and determining the content of the activity Act (for example, the variable V to be used) are input to the scenario creation unit 33 (FIG. 2). The scenario creation unit 33 then accepts the operations and creates a scenario. As a result, a scenario is created in which each activity Act is executed in accordance with the arrangement order of the activities Act in the scenario display field 45.

[0029] Furthermore, the scenario creation unit 33 sends a scenario execution instruction Cg to the execution unit 35, which indicates the execution of an activity Act arranged in the scenario display field 45, and the execution unit 35 executes the activity Act. That is, in the scenario creation mode, the activity Act included in the scenario is executed in parallel with the creation of the scenario. Therefore, the user can determine the activity Act that constitutes the scenario while checking the operation of the activity Act arranged in the scenario display field 45. In particular, the entity value E of the variable V used in the activity Act is acquired as the activity Act is executed. In this embodiment, the acquisition of the entity value as the activity Act is executed means that the entity value is stored in a predetermined storage area so that it can be referenced when an activity other than the activity Act is executed. This allows the user to create a scenario while checking the entity value E of the variable V. The acquisition of this entity value E will be specifically described using the examples of FIGS. 4A to 4G. Note that the execution of an activity Act in the scenario creation mode may be configured to receive an instruction from the user as to whether or not to execute the activity Act. For example, for activities such as writing data to other files or sending emails, which may have an impact on business operations if performed at the scenario creation stage, the user may be allowed to choose whether or not to perform the activities.

[0030] In FIG. 4A , an activity Act(1) that extracts a table and an activity Act(2) that extracts a value from the table are selected as activities Act that constitute a scenario (i.e., they are arranged in the scenario display field 45). In activity Act(1), a variable V_t is declared. A user can input a path to a table (data) to be acquired as the entity value E_t of the variable V_t in an input field 51. When a path is input in the input field 51, an activity Act(1) is set that acquires the table of the path as the entity value E_t of the variable V_t. When activity Act(1) is set in this way, the scenario creation unit 33 sends a scenario execution instruction Cg that instructs the execution unit 35 to execute the activity Act(1). When the execution unit 35 executes the activity Act(1), the entity value E_t of the variable V_t is acquired. At this time, variable management is performed in which the actual values ​​of the variables acquired by the execution unit 35 are stored in the memory unit 22, and details of this variable management will be described later.

[0031] In activity Act(2), a variable V_v1 is declared, and the entity value E_v1 of the variable V_v1 is acquired. The user can set the entity value E_v1 of the variable V_v1 by inputting it into the input field 52. In this embodiment, when the user selects (clicks) the input field 52, the user can choose to input directly into the input field 52 or to specify from options and input it into the input field 52. In this embodiment, the user selects one of two options: "Direct Input" and "Table: Value of V_t." When the user selects "Direct Input," the user can input directly into the input field 52. Furthermore, when the user selects "Table: Value of V_t," the user can specify whether to acquire the entity value E_v1 using any variable as an argument, or to use the variable V_t as an argument. In particular, in this embodiment, candidate variables F that can be used as arguments in activity Act(2) are displayed. The variables displayed as candidate F are variables whose entity values ​​are acquired at the time of executing the activity when the scenario is executed, for example. In this embodiment, since activity Act(1) is already executed at the time of executing activity Act(2), the variable V_t whose entity value E_t is acquired by executing activity Act(1) is displayed as candidate F. Note that the variables displayed as candidate F may be displayed according to the type of input field 52.

[0032] FIG. 4B illustrates a case where the option "Table: Value of V_t" is selected, i.e., an entity value E_v1 is acquired using an argument, and the variable V_t (Table) is selected from among the candidate variables F that can be used as the argument. In this example, a table is acquired as the entity value E_t in the activity Act(1), and therefore the value included in the variable V_t (Table) is selected as the entity value E_v1. That is, the scenario management screen 4 in FIG. 4B displays the entity value E_t (Table) of the variable V_t selected from multiple candidates F. This allows the user to confirm what kind of entity value E_t the candidate F selected as the argument of the activity Act(2) acquires. In addition, the variable V_t in this example is a table. Therefore, the user can specify in the input field 52 that the entity value E_v1 of the variable V_v1 is acquired from a cell included in the variable V_t (Table) by specifying one of the cells included in the displayed entity value E_t (Table). FIG. 4C illustrates a case in which the user designates a cell containing "3" in the first row and c column of the entity value E_t of the variable V_t. When the OK button is operated (clicked) in this state, activity Act(2) is set, which acquires the value in the first row and c column of the data (entity data) acquired as the entity value E_t of the variable V_t as the entity value E_v1 of the variable V_v1 (FIG. 4D). When activity Act(2) is set in this manner, the scenario creation unit 33 sends a scenario execution instruction Cg instructing the execution unit 35 to execute the activity Act(2). Then, the execution unit 35 executes the activity Act(2), thereby acquiring the entity value E_v1 of the variable V_v1. Note that in this embodiment, the entity value E_t of the variable V_t is displayed, but the entity value E_t may be displayed according to the type accepted by the input field 52. For example, in this embodiment, activity Act(2) is an activity Act that extracts a value, and input field 52 accepts input that extracts the value contained in variable V_t, so the entity value E_t is displayed so that the user can easily specify the source of extraction in variable V_t.If the activity Act(2) is an activity that outputs the data acquired as the entity value E_t of the variable V_t to an arbitrary file without any particular processing, it is not necessary to check the entity value E_t, as long as the data to be output is correctly specified in the input field 52. In this way, the input field 52 may be configured to determine whether or not the entity value E_t is displayed, and if it is displayed, its display format may change depending on the input received.

[0033] In FIG. 4E, in addition to activities Act(1) and Act(2), activity Act(3), which sends an email, is selected as an activity Act constituting a scenario. In the example shown in FIG. 4E, an email address and a reference destination of attached data are specified as variables, and the user sets activity Act(3) to declare each variable and send an email using the variable as an argument. In activity Act(3), variable V_v2 is declared as an email address, and the user can set the entity value E_v2 of variable V_v2 by inputting it into input field 53. Furthermore, variable V_v3 is declared as the file path of the attached data, and the entity value E_v3 of variable V_v3 can be set by inputting it into input field 54. In particular, as shown in FIG. 4F, when the user selects (clicks) input field 54, candidate F, which can be obtained as the entity value E_v3 of variable V_v3, is displayed. Specifically, the value contained in variable V_t (table) and variable V_v1 are displayed as candidate F. Then, when input is made into input fields 53 and 54 and the acquisition of entity value E_v2 of variable V_v2 and the acquisition of entity value E_v3 of variable V_v3 are set, the entity values ​​E_v2 and E_v3 are acquired, and activity Act(3) is set to send an email with the attached data indicated by entity value E_v3 to the email address E_v2 indicated by entity value E_v2 (FIG. 4G). In response to this, the scenario creation unit 33 sends a scenario execution instruction Cg instructing the execution unit 35 to execute the activity Act(3). Then, the execution unit 35 executes the activity Act(3), thereby acquiring entity values ​​E_v2 and E_v3 of variables V_v2 and V_v3. Note that when activity Act(3) is executed in scenario creation mode, it is not necessary to send an email. This makes it possible to avoid sending unnecessary emails.

[0034] As described above, variable management for managing the actual value E of the acquired variable V is executed in parallel with the execution of the scenario creation mode. Next, this variable management will be explained using Figures 5, 6, and 7. Here, Figure 5 is a block diagram showing the operation of each functional unit of the calculation unit when variable management is executed, Figure 6 is a flowchart showing an example of control executed by the execution unit for variable management, and Figure 7 is a flowchart showing an example of control executed by the monitoring unit for variable management.

[0035] As shown in FIG. 5, in the scenario creation mode, a first storage area R1 and a second storage area R2 are secured in the memory unit 22.

[0036] The first storage area R1 is an area accessible by the execution unit 35. By executing an activity Act, the execution unit 35 stores the entity value E of the variable V in the first storage area R1. At this time, the entity value E stored in the first storage area R1 is referenced when the execution unit 35 executes an activity including the variable V. In other words, the entity value E stored in the first storage area R1 by executing one activity Act (e.g., activity Act(1)) is stored so as to be referable when another activity Act (e.g., activity Act(2)) is executed. The first storage area R1 is secured in the memory unit 22 as an area accessible when the execution unit 35 executes a scenario, and is therefore secured for a period corresponding to the timing when the execution unit 35 executes the scenario, and is released when the period ends. In the scenario creation mode, a scenario execution instruction Cg is sent from the scenario creation unit 33 to the execution unit 35 at any time, and therefore the first storage area R1 may be secured in the memory unit 22 during the scenario creation mode. In addition, when the execution unit 35 executes a scenario based on a scenario execution instruction Ce sent from the scenario execution operation unit 312, a first storage area R1 may be secured in the memory unit 22 from the time the execution unit 35 starts executing the activities indicated in the scenario execution instruction Ce until the time the execution unit 35 completes the execution of all the activities indicated in the scenario execution instruction Ce.

[0037] The first storage area R1 can also be accessed by the debugger 37. As described above, the debugger 37 has a monitoring unit 371 and a holding unit 372. The monitoring unit 371 monitors whether the execution unit 35 acquires the entity value E of the variable V, i.e., whether the entity value E of the variable V is held in the first storage area R1. Then, the holding unit 372 accesses the first storage area R1 and the second storage area R2 based on an instruction generated by the monitoring unit 371 in accordance with the monitoring result, and causes the entity value E held in the first storage area R1 to be held in the second storage area R2.

[0038] The second storage area R2 is an area reserved in a predetermined area of ​​the memory unit 22, i.e., a volatile memory element, and is an area accessible by the retention unit 372 of the debugger 37. An entity value E retained in the second storage area R2 is associated with a variable V that references the entity value E. More specifically, when the execution unit 35 executes an activity Act, the second storage area R2 retains the entity value E referenced as a variable V included in the activity Act, in association with the variable V. The second storage area R2 is reserved in the memory unit 22 as an accessible storage area by the retention unit 372, which retains the entity value E in response to the entity value E of the variable V being retained in the first storage area R1. Therefore, the second storage area R2 is reserved in the memory unit 22 at least during the period during which the first storage area R1 is reserved in the memory unit 22. In addition, as described below, the second storage area R2 is also an area accessible by the editor 31, and therefore is reserved in the memory unit 22 even during periods other than the period during which the first storage area R1 is reserved in the memory unit 22.

[0039] When the scenario creation mode is started, as shown in FIG. 6, the execution unit 35 checks whether a variable has been declared in the activity Act (step S101). If the declaration of a variable V is confirmed ("YES" in step S101), the execution unit 35 allocates a first storage area R1 for the declared variable V in the memory unit 22 (step S102). Next, the execution unit 35 acquires the entity value E of the variable V in the first storage area R1 (step S103). That is, the entity value E of the variable V is stored in the first storage area R1 so that it can be referenced by the execution unit 35. The entity value E is stored in the first storage area R1 until the variable V becomes unnecessary. On the other hand, when the variable V becomes unnecessary ("YES" in step S104), the execution unit 35 releases the first storage area R1, and the entity value E is deleted from the memory unit 22. A typical example of when the variable V declared in the scenario creation mode becomes unnecessary is when the user performs an operation to end the scenario creation mode and the execution unit 35 exits the scenario creation mode.

[0040] 7, when the scenario creation mode is started, the monitoring unit 371 monitors the acquisition of the entity value E of the variable V by the execution unit 35 (step S201). When it is confirmed that the execution unit 35 has acquired the entity value E of the variable V ("YES" in step S201), the monitoring unit 371 causes the holding unit 372 to execute steps S202 and S203. That is, the holding unit 372 secures a second storage area R2 in the memory unit 22 (step S202) and copies the entity value E of the first storage area R1 to the second storage area R2 (step S203). As a result, the entity value E is associated with the variable V and held in the second storage area R2.

[0041] FIG. 8 is a diagram illustrating the variable management operation performed based on the flowcharts of FIGS. 6 and 7. The above-described operation will be summarized chronologically using FIG. 8. When a variable V is declared in an activity Act included in a scenario being created, the execution unit 35 allocates a first storage area R1 corresponding to the variable V in the memory unit 22 (step S102) and acquires an entity value E of the variable V in the first storage area R1 (step S103). Furthermore, upon confirming the acquisition of the entity value E, the monitoring unit 371 causes the retaining unit 372 to allocate a second storage area R2 in the memory unit 22 (step S202) and copy the entity value E from the first storage area R1 to the second storage area R2 (step S203). As a result, the entity value E is associated with the variable V and retained in the second storage area R2. In step S105, the first storage area R1 is released as the variable V is no longer needed. Even after the first storage area R1 is released, the actual value E is still held in the second storage area R2.

[0042] When multiple variables V are declared in the scenario creation mode, the flowcharts of FIGS. 6 and 7 are executed for each of the multiple variables V. That is, in the example shown in FIGS. 4A to 4E, the flowcharts of FIGS. 6 and 7 are executed for each of the variables V_t, V_v1, V_v2, and V_v3. As a result, the memory unit 22 stores the entity value E shown in FIG. 9. Here, FIG. 9 is a diagram schematically illustrating an example of the entity value stored in the memory unit. When the flowcharts of FIGS. 6 and 7 are executed for the example shown in FIGS. 4A to 4E, the second storage areas R2(1), R2(2), R(3), and R(4) store the entity values ​​E_t, E_v1, E_v2, and E_v3 associated with the variables V_t, V_v1, V_v2, and V_v3, as shown in FIG. 9.

[0043] As explained with reference to Fig. 3, in addition to the scenario creation mode, the scenario edit mode can be selected in the mode selection field 43 of the scenario management screen 4. By selecting the scenario edit mode, it is possible to edit the scenario created in the scenario creation mode using the above procedure.

[0044] 10A to 10E are diagrams showing examples of operations that can be performed on the scenario management screen in scenario edit mode. In these diagrams, the scenario edit column 432 is expanded, while the scenario creation column 431 is contracted. Also, Fig. 11 is a block diagram showing the operation of each functional section of the calculation section when the scenario edit mode is executed.

[0045] As shown in Fig. 11, in the scenario editing mode, a second storage area R2 is secured in the memory unit. Fig. 11 shows the operation of each functional unit of the calculation unit when the scenario editing mode is entered after the scenario creation mode has ended. Compared to Fig. 5, which shows the operation of each functional unit of the calculation unit in the scenario creation mode, the first storage area R1 is released and disappears from the memory unit 22, while the second storage area R2 is continuously secured in the memory unit 22. The second storage area R2 is continuously secured in the memory unit 22 by the retaining unit 372. As a result, the entity value E that is stored in association with the variable V when the executing unit 35 executes the activity Act is continuously held in the second storage area R2.

[0046] The second storage area R2 is an area accessible by the editor 31 in addition to the above-described holding unit 372. The editor 31 accesses the second storage area R2 to refer to the entity value E stored in association with the variable V. As shown in FIG. 11 , the editor 31 accesses the second storage area R2 without going through the execution unit 35. Therefore, the editor 31 can refer to the entity value E stored in association with the variable V in parallel with the execution of a scenario by the execution unit 35. The editor 31 can also refer to the entity value E stored in association with the variable V during periods other than when the execution unit 35 is executing a scenario. Because the second storage area R2 is accessed by the editor 31 for managing a scenario, the second storage area R2 is secured in the memory unit 22 at least from the start of execution of an activity Act by the execution unit 35 until the end of a period during which the editor 31 accepts operations for managing a scenario. In this embodiment, the second storage area R2 is secured in the memory unit 22 when the calculation unit 21 starts executing the scenario management program 12, and is released when the calculation unit 21 ends executing the scenario management program 12.

[0047] In the scenario creation mode, the user's operations to place an activity Act in the scenario display field 45 and to edit the contents of the activity Act are input to the editing operation unit 311 (FIG. 11). The editing operation unit 311 then accepts the operation on the scenario display field 45 and edits the scenario in accordance with the operation.

[0048] 10A, a scenario created in the scenario creation mode illustrated in Figures 4A to 4E is selected as the subject of editing and is displayed in a scenario display field 45. Also, a scenario editing field 432 displays icons indicating various activities Act that can be added to the scenario.

[0049] 10B shows an editing operation for activity Act(2) out of multiple activities Act(1) to Act(3) included in the scenario. Specifically, data related to obtaining the entity value E_v1 of variable V_v1 declared in activity Act(2) is being edited. In particular, by the user selecting (clicking) input field 52, a candidate F that can be used as an argument in activity Act(2) is displayed.

[0050] FIG. 10C illustrates a case in which an entity value E_v1 is acquired using an argument, and a variable V_t is selected as the argument from among the candidates F. That is, the scenario management screen 4 in FIG. 10C displays the entity value E_t of the variable V_t selected from the candidates F. That is, by selecting the variable V_t from the candidates F, the variable V_t is designated as the display target. Since the variable V_t references the entity value E_t, which is a table consisting of multiple values, the display of the entity value E_t displays the multiple values ​​contained in the table. At this time, the editing operation unit 311 (FIG. 11) reads out the entity value E_t stored in the second storage area R2 and displays the entity value E_t on the scenario management screen 4. This allows the execution of the activity Act(1) for acquiring the entity value E_t to be omitted, and the entity value E_t can be confirmed by editing the activity Act(2).

[0051] On the scenario management screen 4 shown in FIG. 10C , the user performs an operation to designate one of the cells included in the table displayed as the entity value E_t as a value included in this entity value E_t. When the editing operation unit 311 accepts the operation to designate a cell included in the table, it changes the reference destination of the entity value E_v1 of the variable V_v1 based on the operation. That is, instead of directly inputting information indicating the reference destination into the input field 52, an activity that references a desired value among the multiple values ​​included in the data referenced by the variable V_t is set by accepting an operation on the display of the entity value E_t consisting of multiple values. Specifically, FIG. 10D shows a case where "5" in the second row, column b is selected from the entity values ​​E_t of the variable V_t. When the OK button is operated (clicked) in this state, the content of the activity Act(2) is changed so that the value in the second row, column b from the multiple values ​​constituting the entity value E_t acquired as the variable V_t is acquired as the entity value E_v1 of the variable V_v1 (FIG. 10E). In this way, the data acquired as the entity value E_v1 of the variable V_v1 when the activity Act(2) is executed can be changed.

[0052] FIG. 12 is a flowchart showing an example of variable display executed by the editing operation unit in the scenario editing mode. The display of the entity value E of the variable V shown in FIGS. 10B, 10C, and 10D is executed according to the flowchart in FIG. 12. In step S301, the editing operation unit 311 checks whether the user has specified the variable V to be displayed. For example, when the user performs the specification operation shown in FIG. 10B (the operation of selecting a variable from candidates F) ("YES" in step S301), the editing operation unit 311 checks whether the entity value E of the specified variable V is stored in the second storage area R2 (step S302). If the entity value is stored ("YES" in step S302), the editing operation unit 311 displays the entity value E of the specified variable V on the display 243 (step S303), as shown in FIGS. 10C and 10D. 10A to 10E, it is also possible that the entity value E of the variable V is not stored in the second storage area R2 in the memory unit 22. In such a case, the editing operation unit 311 determines "NO" in step S302 and displays on the display 243 a message indicating that the entity value E of the variable V does not exist (step S304). In this flowchart, when the variable V is specified, it is confirmed whether the entity value E of the variable V is stored in the second storage area R2. However, before the variable V is specified, it may be determined whether the entity value E associated with each variable V included in the scenario to be displayed is held in the second storage area R2, and a display indicating whether the entity value E is stored in the second storage area R2 may be displayed.

[0053] In the embodiment described above, as an activity Act included in a scenario is executed, the execution unit 35 acquires the entity value E of the variable V referenced by the activity Act and stores it in the first storage area R1 (step S103). That is, the execution unit 35 stores the entity value E of the variable V referenced by the activity Act in the second storage area R1 so that it can be referenced when another activity Act is executed. The storage unit 372 also associates the entity value E with the variable V and stores it in the second storage area R2 accessible by the editor 31 for managing scenarios (step S203). Therefore, when managing a scenario, the user can access the entity value E of the variable V using the editor 31 without going through the execution unit 35.

[0054] Furthermore, the second storage area R2 retains the entity value E even after the first storage area R1 is released (step S105 in FIG. 8). With this configuration, even after the creation of a scenario is completed (i.e., the scenario creation mode is completed) and the first storage area R1, from which the entity value E was acquired, is released, the entity value E of the variable V referenced by the activity Act included in the scenario can be read from the second storage area R2. Therefore, even after the first storage area R1 is released, the user can access the entity value E of the variable V referenced by the activity Act when managing a scenario.

[0055] The system is also provided with an editing operation unit 311. This editing operation unit 311 displays on the display 243, for a variable V included in the scenario, the entity value E stored in the second storage area R2 in association with the variable V, as a display showing the content of the operation automated by the scenario (FIGS. 10C and 10D). With this configuration, the user can check the content of the operation automated by the scenario while checking the entity value E of the variable V included in the scenario to be managed.

[0056] Furthermore, if there is no entity value E associated with the variable V and stored in the second storage area R2 (if "NO" in step S302), the editing operation unit 311 displays this fact on the display 243. With this configuration, the user can easily understand whether or not there is an entity value E for the variable V included in the scenario to be managed.

[0057] The scenario creation unit 33 also includes a scenario creation unit that receives settings for an activity Act included in a scenario and creates the activity Act. The scenario creation unit 33 sends a scenario execution instruction Cg to the execution unit 35 based on the created activity Act. With this configuration, as an activity Act set in the scenario being created is executed, the actual value E of the variable V used in the activity Act can be acquired (step S103) and stored in the second storage area R2 (step S203). Setting an activity Act includes, for example, determining the content of the activity Act. The scenario creation unit can also accept operations related to scenario creation, such as arranging an activity Act in a scenario display field (setting the processing order of the created activity Act). In this case, the scenario execution instruction Cg is not limited to one based on the created activity Act, and a scenario execution instruction Cg corresponding to the scenario creation status can also be sent.

[0058] Furthermore, when the editing operation unit 311 receives a variable designation operation (step S301) that designates a variable V to be displayed, it reads out the entity value E associated with the variable V from the second storage area R2 and displays it on the display 243. In this configuration, the user can check the entity value E of the variable V by the simple task of executing the variable designation operation on the editing operation unit 311 via the display 243.

[0059] The system also includes a monitoring unit 371 that monitors the execution unit 35 acquiring the entity value E of the variable V in the first storage area R1, i.e., the storing of the entity value E in the first storage area R1. When the monitoring unit 371 confirms that the execution unit 35 has stored the entity value E of the variable V in the first storage area R1 (step S201), the storing unit 372 stores the entity value E in the first storage area R1 in the second storage area R2 (step S203). With this configuration, the function of the monitoring unit 371 can reliably store the entity value E of the variable V acquired by the execution unit 35 in the second storage area R2.

[0060] 5, the functional units 311, 312, 33, 35, 371, and 372 included in the calculation unit 21 are implemented as separate processes. Specifically, the execution unit 35 executes the activity Act as an execution unit process (first process), and the retention unit 372, as a retention process (second process) different from the execution process, associates the entity value E acquired in the first storage area R1 with the variable V and retains it in the second storage area R2. In this configuration, the execution of the activity Act and the retention of the entity value E are performed by separate processes (the execution process and the retention process). This allows the retention unit 372 to retain the entity value E in the second storage area R2 in parallel with the execution of the activity Act by the execution unit 35, thereby reducing the impact on the execution of the activity Act by the execution unit 35. Therefore, the retention process can retain the entity value E in the second storage area R2 even after the execution process ends upon completion of the execution of the activity Act, while minimizing the impact on the execution of the activity Act by the execution unit 35. As a result, when managing a scenario, the editor 31 can access the entity value E of the variable V referenced in the scenario.

[0061] In a scenario, it is conceivable that the same name is assigned to multiple variables V. By performing variable name management, multiple variables V with the same name are managed separately.

[0062] FIG. 13 is a diagram illustrating the content of variable name management. In the example of FIG. 13, variables Var_a, Var_b, and Var_a are declared in this order, and the variable declared in the first declaration is the same as the variable declared in the third declaration. Therefore, when associating the entity value E of each of these variables Var_a with the variable and storing it in the second storage area R2, if the variable name itself is associated with the entity value E, a name conflict will occur. Therefore, in the variable name management described here, the monitoring unit 371 (and the storage unit 372) assigns a different identifier ID1, ID2, or ID3 to the variable V each time the variable V is declared, associates the identifier ID1, ID2, or ID3 with the entity value E, and stores the entity value E in the second storage area R2. Identifying the variable V using the identifiers ID1, ID2, or ID3 in this way corresponds to identifying the variable V based on its scope. The scope of the variable V is the range in which the variable V is valid in the scenario. Variables with the same variable name but valid in different scopes can be distinguished by identifying variable V based on the scope of variable V. Furthermore, storing entity value E in second storage area R2 in association with identifiers ID1, ID2, and ID3 corresponds to storing entity value E of variable V in second storage area R2 in association with the scope of variable V.

[0063] 14 is a flowchart showing an example of variable name management that is executed in conjunction with the acquisition of the entity value of a variable. When the execution unit 35 executes a line of an activity Act that constitutes a scenario (i.e., a line of a program that specifies the activity Act) (step S401), the monitoring unit 371 checks whether the execution of the line was successful (step S402). If the execution of the line fails ("NO" in step S402), the flowchart in FIG. 14 ends. On the other hand, if the execution of the line is successful ("YES" in step S402), the monitoring unit 371 identifies the variable declaration section that declares the variable V in the line executed in step S401. This corresponds to identifying the node (node ​​in syntax analysis) that declares the variable V.

[0064] In step S404, the monitoring unit 371 checks whether an identifier ID has already been assigned to the variable declaration section identified in step S403. If an identifier ID has already been assigned (if "YES" in step S404), the retaining unit 372 updates the entity value E stored in the second storage area R2 in association with the identifier ID to the most recently acquired entity value E (step S405). On the other hand, if an identifier ID has not been assigned (if "NO" in step S404), the monitoring unit 371 assigns an identifier ID to the variable declaration section (step S406), and the retaining unit 372 stores the entity value E of the variable V declared in the variable declaration section in association with the identifier ID in the second storage area R2.

[0065] 13 and 14, the retaining unit 372 retains the entity value E in the second storage area R2 in association with the scope of the variable V (steps S405, S406, S407). In this configuration, even if multiple variables V have the same name, the entity value E of the variable V can be identified based on the scope associated with the variable V.

[0066] In other words, the retaining unit 372 associates the node that declares the variable V (i.e., the variable declaration part) with the entity value E, thereby associating the scope of the variable V with the entity value E (steps S403 and S406). By using the variable declaration node in this way, the scope of the variable V can be accurately associated with the entity value E.

[0067] Furthermore, the second storage area R2 holds the latest entity value E obtained for the variable V (step S405). In this configuration, the entity value E in the second storage area R2 is updated every time a new entity value E is obtained, so the user can always check the latest entity value E.

[0068] In the above embodiment, in a scenario editing mode, which is an example in which the user manages a scenario, the entity value E of the variable V is displayed on the display 243, thereby assisting the user in editing. In particular, in the example of FIG. 10B, when the user edits the activity Act(2) related to the variable V_v1, a candidate F that can be used as an argument is displayed on the display 243. At this time, the variable V (variable V_t in the example of FIG. 10B) whose scope includes the activity Act to be edited is displayed as the candidate F, and the entity value E of the variable V selected from the candidate F is displayed. Next, an example of control that enables such entity value display will be described.

[0069] 15 is a flowchart showing an example of control for displaying entity values ​​in the scenario editing mode. In step S501, the editing operation unit 311 analyzes the syntax of the activity Act selected by the user as the activity to be edited (edit target activity Act). Then, the editing operation unit 311 acquires a scope that includes the edit target activity Act (step S502), and acquires a list of variables V that include the edit target activity Act in that scope (step S503). This corresponds to acquiring a list of variables V that can be used in the edit target activity Act.

[0070] Furthermore, in parallel with steps S502 and S503, the editing operation unit 311 acquires the type of variable V at the selected location in the activity Act to be edited (step S504). Specifically, in the example of Fig. 10B, since the input field 52 (selected location) is selected in the activity Act(2) to be edited, the type accepted by the input field 52 is acquired. Here, the type accepted by the input field 52 refers to the format of data, such as numeric, character, date, or table, that is handled in the activity Act(2) depending on the content entered in the input field 52.

[0071] In step S505, the editing operation unit 311 creates a list of variables V having the type obtained in step S504 from among the variables obtained in step S503, and displays the list on the display 243. In this way, a candidate F such as that shown in FIG. 10B is displayed.

[0072] In step S506, the editing operation unit 311 accepts a user's selection operation to select one variable V from among the candidates F. Then, the editing operation unit 311 acquires the identifier ID of the selected variable V and checks the entity value E associated with the identifier ID and stored in the second storage area R2 (step S507). If the entity value E exists (YES in step S508), the editing operation unit 311 displays the entity value E on the display 243 (step S509). On the other hand, if the entity value E does not exist (NO in step S508), the editing operation unit 311 displays a message on the display 243 indicating that the entity value E does not exist (step S510).

[0073] FIG. 16 is a diagram schematically illustrating an example of the result of the control shown in FIG. 15. The example in FIG. 16 shows a scene in which a scenario is edited (scenario edit mode) in which six activities Act(11) to Act(16), each of which declares a variable V, are executed in sequence. Of the activities Act(11) to Act(16), the type of the variable V declared in five activities Act(11) and Act(13) to Act(16) is character, and the type of the variable V declared in one activity, Act(12), is numeric. The variable V (string3) declared in activity Act(14) is selected as the part to be edited. The variable V whose scope includes the activity Act(14) is the variables string1, num1, and string2 of the activities Act(11), Act(12), and Act(13). However, since the type of the variable V (string3) handled in the activity Act(14) is character, the variables string1 and string2 that match this type are displayed as candidates F.

[0074] 16, the edit operation unit 311 displays on the display 243 the first activities Act(11), Act(13), Act(15), and Act(16) that are not to be edited and that declare variables string1, string2, string4, and string5 (first variables), and the second activity Act(14) that is to be edited. In this case, of the activities Act(11), Act(13), Act(15), and Act(16) that are not to be edited, the variables string1 and string2 declared in the activities Act(11) and Act(13) include the activity Act(14) that is to be edited in their scope, whereas the variables string4 and string5 declared in the activities Act(15) and Act(16) do not include the activity Act(14) that is to be edited in their scope. In response to this, the editing operation unit 311 displays variables string1 and string2 whose scope includes the activity Act(14) as candidates F for variable V(string3) used in the activity Act(14) to be edited, but does not display variables string4 and string5 whose scope does not include the activity Act(14). In this configuration, when the user sets variable V(string3) to be referenced in the activity Act(14) to be edited, only variables V(string1, string2) that can be referenced in the activity Act(14) are displayed as candidates F. This allows the user to easily set variable V.

[0075] In scenario editing mode, it is possible to selectively execute some of the activities Act out of the multiple activities Act that make up a scenario (partial execution). In particular, in the above embodiment, the entity value E of the variable V is stored in the second storage area R2. Therefore, when an activity Act that is the target of partial execution uses a variable V declared in an earlier preceding activity Act, the entity value E of the variable V can be read from the second storage area R2 and used, thereby executing only the activity Act that is the target of partial execution without executing the earlier activity Act. Next, an example of control that enables such partial execution will be described.

[0076] 17 is a flowchart showing an example of control for partial execution in scenario edit mode. In step S601, the scenario execution operation unit 312 accepts a user operation to specify an activity Act that is the target of partial execution. In step S602, the scenario execution operation unit 312 performs syntax analysis on the first line of the activity Act that is the target of partial execution. Then, the scenario execution operation unit 312 acquires a list of identifier IDs (ID list) of the variable declaration parts of variable V that has a scope that includes the first line (step S603).

[0077] The scenario execution operation unit 312 resets a count value N for counting the identifiers ID in the ID list to zero (step S604) and increments the count value N (step S605). Then, the scenario execution operation unit 312 checks whether an entity value E exists in the second storage area R2 associated with the Nth identifier ID in the list (step S606). If an entity value E exists for the Nth identifier ID (if "YES" in step S606), the scenario execution operation unit 312 generates a variable declaration activity Act that declares a variable V corresponding to the entity value E (step S607) and then proceeds to step S608. On the other hand, if an entity value E does not exist for the Nth identifier ID (if "NO" in step S606), the process skips step S607 and proceeds to step S608. In this case, the display 243 may display a message indicating that the entity value E of the identifier ID does not exist.

[0078] In step S608, the scenario execution operation unit 312 checks whether the count value N has reached the number (Nmax) of identifiers ID included in the ID list. If the count value N is less than the number Nmax ("NO" in step S608), steps S605 to S608 are repeated. On the other hand, if the count value N is the number Nmax ("YES" in step S608), the scenario execution operation unit 312 generates a partial scenario by attaching the variable declaration activity Act generated in step S607 before the activity Act that is the target of partial execution (step S609). Furthermore, the scenario execution operation unit 312 sends a scenario execution instruction Ce to the execution unit 35 requesting execution of the generated partial scenario, and the execution unit 35 executes the partial scenario in accordance with the scenario execution instruction Ce (step S610).

[0079] In step S610, the execution unit 35 executes the activity Act to be partially executed, using the entity value E of the variable V stored in the second storage area R2. Specifically, the execution unit 35 stores the entity value E read from the second storage area R2 in the first storage area R1, and uses the entity value E to execute the activity Act to be partially executed.

[0080] In this embodiment, the variable declaration activity Act generated in step S607 is executed by the execution unit 35 to declare a variable V and obtain an entity value E of the variable V. Declaring the variable V indicates that the variable V is valid at least after the activity in which the variable V is declared, that is, that the scope of the variable V exists after the activity. Furthermore, obtaining the entity value E of the variable V causes the entity value E to be stored in the first storage area R1 so as to be referenceable as the entity value of the variable V within the valid range of the variable V. In this embodiment, the variable declaration activity Act generated in step S607 is executed to obtain the entity value E of the declared variable V, and therefore the entity value E is stored in the first storage area R1 so as to be referenceable within the valid range of the variable V, which is at least the range after the variable declaration activity Act.

[0081] The control of partial execution when a user operation is received specifying the activity Act(2) shown in FIG. 10E as the activity Act to be partially executed will be described.

[0082] First, in the scenario shown in FIG. 10E, activity Act(1) corresponds to an operation of acquiring a value from an application other than the scenario management program 12. Activity Act(1) acquires the value acquired in this operation as the entity value E_t of variable V_t, and the entity value E_t is stored in the first storage area R1. Also, in the scenario shown in FIG. 10E, activity Act(2) corresponds to an operation of processing a value and is activity Act(2) that uses variable V_t included in activity Act(1). In other words, when executed by the execution unit 35, activity Act(2) is an activity that references, as the entity value E_t of variable V_t, the entity value E_t stored in the first storage area R1 as a result of the execution of activity Act(1). Note that activity Act(1) shown in FIG. 10E declares variable V_t, and therefore indicates that the scope of variable V_t is in activities subsequent to this activity, i.e., activity Act(2) and subsequent activities.

[0083] When the scenario execution operation unit 312 receives a user operation specifying activity Act(2) as the partial execution target, it generates a variable declaration activity Act that declares a variable V_t included in activity (2). The scenario execution operation unit 312 then generates a partial scenario consisting of the variable declaration activity Act that declares the generated variable V_t and activity Act(2) specified as the partial execution target, and sends a scenario execution instruction Ce that instructs execution of the partial scenario to the execution unit 35. Therefore, when the scenario execution operation unit 312 receives a user operation that specifies activity Act(2) as the partial execution target, it sends a scenario execution instruction Ce that selects the variable declaration activity Act of the variable V_t and activity Act(2) to the execution unit 35 as a scenario execution instruction Ce that specifies activity Act corresponding to activity Act(2) as the execution target. At this time, the variable declaration activity Act that declares the variable V_t is an activity Act that acquires the entity value E_t held in the second storage area R2, unlike the activity Act(1) that acquires the entity value E_t by referencing the path entered in the input field 51. That is, the variable declaration activity Act is an activity Act that references the entity value E_t held in the second storage area R2 and stores the entity value E_t of the variable V_t in the first storage area R1. After storing the entity value E_t read from the second storage area R2 in the first storage area R1, the execution unit 35 references the entity value E_t held in the first storage area R1 when executing the activity Act(2) that is the target of partial execution.

[0084] In this way, the scenario execution operation unit 312 accepts the scenario displayed in the scenario display field 45 as the scenario selected by the user, and accepts the selection of an activity Act included in the selected scenario (step S601). Furthermore, the scenario execution operation unit 312 sends a scenario execution instruction Ce to the execution unit 35, instructing the execution of an activity Act corresponding to the selected activity Act (i.e., the variable declaration activity Act and the selected activity Act). In this configuration, it is possible to partially execute an activity Act selected from multiple activities Act included in a scenario, and check the operation of that activity Act.

[0085] In a scenario that corresponds to an operation of obtaining a value from an application other than the scenario management program 12 and includes an activity Act that obtains an entity value E of a variable V as the value, and an activity Act that uses the variable V, the activity Act that uses the variable V is an activity Act that references the entity value E held in the first storage area R1. When an activity Act designated as a partial execution target includes an activity Act that references the entity value E held in the first storage area R1, the scenario execution operation unit 312 generates an activity Act that references the second storage area R2 and stores the entity value E in the first storage area R1. In this configuration, the execution unit 35 can execute the activity Act designated as a partial execution target without reference to the entity value E held in the first storage area R1. For example, when there is a difference between the entity value E held in the first storage area R1 and the entity value E held in the second storage area R2, such as when the entity value E held in the first storage area R1 is not immediately reflected in the entity value E held in the second storage area R1, an activity Act can be executed that references the entity value E in the second storage area R2.

[0086] Furthermore, in a state where there is no entity value E held in the first storage area R1, such as after the scenario creation mode ends and the first storage area R1 is released, the activities Act specified as targets for partial execution may include an activity Act that references the entity value E held in the first storage area R1 but not an activity Act that causes the entity value E to be held in the first storage area R1. In this case, the execution unit 35 stores in the first storage area R1 the entity value E held in the second storage area R2 in association with the variable V used in the activity that references the entity value E held in the first storage area R1, and then executes the activity Act that references the entity value E held in the first storage area R1. In this way, by utilizing the entity value E of the variable V held in the second storage area R2, even in a state where the entity value E is not held in the first storage area R1, the activity Act that references the entity value E held in the first storage area R1 can be partially executed without executing the activity Act that causes the entity value E to be held in the first storage area R1, which is included in the scenario.

[0087] In this embodiment, an activity Act generated by the scenario execution operation unit 312 for referencing the second storage area R2 and storing the entity value E in the first storage area R1 is executed in addition to an activity Act designated as a partial execution target. However, if an activity Act for storing an entity value E in the first storage area R1 is included in the partial execution target activities Act, an activity Act generated by the scenario execution operation unit 312 for referencing the entity value E stored in the second storage area R2 and storing it in the first storage area R1 may be executed instead of the activity Act. In this configuration, an activity Act designated as a partial execution target can be executed without executing an activity Act for storing an entity value E in the first storage area R1 in a scenario. If an activity Act for storing an entity value E in the first storage area R1 in a scenario is dependent on the execution environment, an activity Act designated independently of the execution environment can be executed. Furthermore, if an activity Act for storing an entity value E in the first storage area R1 in a scenario is dependent on the execution environment, the time required to execute the designated activity Act can be reduced. Furthermore, if an activity Act that causes the entity value E to be stored in the first storage area R1 in a scenario is an activity that has an external impact, the specified activity Act can be executed without having an external impact.

[0088] As described above, in this embodiment, the storage unit 111 of the server 11 corresponds to an example of a "recording medium" of the present invention, the scenario management program 12 corresponds to an example of a "scenario management program" of the present invention, the terminal device 2 corresponds to an example of a "scenario management device" and "computer" of the present invention, the display 243 corresponds to an example of a "display" of the present invention, the editor 31 corresponds to an example of a "management unit" of the present invention, the scenario creation unit 33 corresponds to an example of a "scenario creation unit" of the present invention, the execution unit 35 corresponds to an example of an "execution unit" of the present invention, the monitoring unit 371 corresponds to an example of a "monitoring unit" of the present invention, the retention unit 372 corresponds to an example of a "retention unit" of the present invention, the activity Act corresponds to an example of an "activity" of the present invention, the scenario execution instruction Cg corresponds to an example of a "scenario execution instruction" of the present invention, the first storage area R1 corresponds to an example of a "first storage area" of the present invention, and the second storage area R2 corresponds to an example of a "second storage area" of the present invention.

[0089] The present invention is not limited to the above embodiment, and various modifications can be made to the above without departing from the spirit of the present invention. For example, the timing at which the entity value E of the variable V is stored in the second storage area R2 is not limited to when the scenario creation mode is executed, and may be changed. That is, in the above embodiment, the entity value E acquired in the first storage area R1 when the execution unit 35 executes an activity Act in the scenario creation mode is stored in the second storage area R2. However, the entity value E of the variable V may be changed to be stored in the second storage area R2 after the scenario creation mode ends and before the scenario editing mode starts. In this modification, a scenario execution instruction Ce instructing execution of a created scenario is sent from the scenario execution operation unit 312 to the execution unit 35, and the entity value E acquired in the first storage area R1 by executing an activity Act of the scenario is stored in the second storage area R2 by the storage unit 372.

[0090] That is, the scenario execution operation unit 312 receives a scenario execution operation from the user indicating execution of a created scenario, and sends a scenario execution instruction Ce to the execution unit 35 based on the received scenario execution operation. In this configuration, by executing a created scenario, the user can obtain the entity value E of the variable V used in the activity Act included in the scenario and store it in the second storage area R2. Then, in the scenario edit mode, the entity value E read from the second storage area R2 can be confirmed on the display 243.

[0091] The specific configuration of the second storage area R2 that holds the actual value E of the variable V can be changed as appropriate. Therefore, the second storage area R2 may be secured in the storage unit 23 instead of the memory unit 22, and the actual value E of the variable V may be held in the second storage area R2 in a nonvolatile manner. In other words, the second storage area R2 may be a nonvolatile memory element.

[0092] Furthermore, it is not essential that the execution of the activity Act and the storage of the entity value E are performed in separate processes (an execution process and a storage process). Therefore, the storage unit 372 may associate the entity value E acquired in the first storage area R1 with the variable V and store it in the second storage area R2 in the same process as the execution process in which the execution unit 35 executes the activity Act. In such a configuration, for example, in FIG. 5, the execution unit 35 and the storage unit 372 are realized by a single functional block, which releases the first storage area R1 when the variable V becomes unnecessary and also secures the second storage area R2 even after the first storage area R1 is released.

[0093] Similarly, it is not necessary to execute each functional block (FIG. 5) configured in the calculation unit 21 in a separate process. Therefore, the editor 31 and the execution unit 35 may be executed in the same process, rather than in separate processes. Alternatively, conversely, one functional block may be divided into multiple blocks. For example, the editor 31 does not need to have a function for accepting user operations on the UI 24, and this function may be separated from the editor 31 and carried out by another module.

[0094] 5 do not all need to be configured in the calculation unit 21 of the terminal device 2, and some of the function blocks (for example, the execution unit 35) may be configured in the processor of the server 11. In this case, the terminal device 2 and the server 11 work together to function as the "scenario management device" of the present invention. [Industrial Applicability]

[0095] The present invention can be applied to RPA technology in general, which aims to reduce the workload of users by automating tasks that users have previously performed using computers. [Explanation of symbols]

[0096] 11...Server 111...Storage unit (recording medium) 12...Scenario Management Program 2...Terminal device (scenario management device, computer) 243...Display 311...Editing operation section 33...Scenario Creation Department 35...Executive Department 371...Monitoring Department 372...Holding part Act…Activity Cg...Scenario execution instructions R1: First storage area R2…Second storage area

Claims

1. A scenario management device that manages scenarios for automating operations on other application programs, a management unit that manages the scenario, which includes a first activity and a second activity selected from a plurality of types of activities including an activity corresponding to the operation of acquiring a value from another application program, an activity corresponding to the operation of inputting a value into another application program, and an activity corresponding to an operation of processing the acquired value; an execution unit that executes the first activity included in the scenario based on a scenario execution instruction; a first storage area that is accessed by the execution unit when executing the first activity included in the scenario, and that holds entity values ​​of variables referenced in the first activity so that the entity values ​​of variables included in the second activity included in the scenario can be referenced; a second storage area accessible by the management unit, which stores the actual values ​​of the variables stored in the first storage area in association with the variables; a storage unit that stores the actual values ​​of the variables stored in the first storage area in the second storage area; A scenario management device comprising:

2. the execution unit executes the first activity as a first process; The scenario management device of claim 1, wherein the storage unit stores the actual value acquired in the first storage area in association with the variable in the second storage area as a second process different from the first process.

3. 3. The scenario management device according to claim 1, wherein the second storage area holds the entity value even after the first storage area is released.

4. A scenario management device as described in any one of claims 1 to 3, wherein the management unit displays on a display a display indicating the content of the operation automated by the scenario, for variables included in the scenario, corresponding to the actual value stored in the second storage area in association with the variable.

5. The scenario management device according to claim 4 , wherein the management unit displays the entity value stored in the second storage area on the display as an indication of the variable corresponding to the entity value.

6. A scenario management device as described in claim 4 or 5, wherein the management unit displays on the display an indication of whether or not the variable has an entity value stored in the second storage area in association with the variable as a display of the variable corresponding to the entity value.

7. a scenario creation unit that receives settings related to the content of the operation to be automated by the activity as the creation of the scenario, and generates the activity based on the settings; The scenario management device according to claim 1 , wherein the scenario creation unit sends the scenario execution instruction to the execution unit based on the generated activity.

8. A scenario management device as described in any one of claims 1 to 7, comprising a scenario execution operation unit that accepts a selection of an activity included in the scenario from a user as an operation to instruct the execution of a scenario, and sends the scenario execution instruction to the execution unit to execute an activity corresponding to the selected activity.

9. A scenario management device described in any one of claims 1 to 8, wherein the storage unit stores the actual value of the variable in the second storage area in association with information indicating the scope, which is the valid range of the variable in the scenario.

10. the first activity corresponds to an operation of acquiring a value from the other application program, and is an activity that references the acquired value as an entity value of the variable; the second activity is an activity that uses the variable included in the first activity, When the execution unit receives an instruction to execute the scenario including the second activity, A scenario management device described in any one of claims 1 to 9, wherein the execution unit retrieves the entity value stored in the second storage area associated with the variable used in the second activity into the first storage area, and then executes the second activity.

11. The management unit When a variable designation operation that designates the variable to be displayed is received, the entity value associated with the variable is read from the second storage area and displayed on the display; When the variable is a variable that refers to the entity value that is composed of multiple values, expressing the plurality of values ​​as the entity values; A scenario management device as described in any one of claims 4 to 6, wherein when an operation specifying an arbitrary value from the plurality of values ​​is received, the activity corresponding to an operation of obtaining a value contained in the data referenced as the variable is set based on the operation.

12. the management unit displays the scenario on the display, the scenario including the first activity that declares a first variable and the second activity; A scenario management device as described in any one of claims 4 to 6, wherein the management unit displays the first variable declared in the first activity on the display as a candidate variable to be used in the second activity when the scope, which is the valid range of the first variable declared in the first activity, includes the second activity, and does not display the first variable declared in the first activity on the display as a candidate variable to be used in the second activity when the scope of the variable declared in the first activity does not include the second activity.

13. a monitoring unit that monitors the execution unit storing the actual value of the variable in the first storage area, A scenario management device as described in any one of claims 1 to 12, wherein when the monitoring unit confirms that the execution unit has stored the actual value of the variable in the first storage area, the storage unit stores the actual value stored in the first storage area in the second storage area.

14. A scenario management device as described in any one of claims 1 to 13, wherein when the execution unit executes the first activity and the first storage area stores an entity value of the variable referenced in the first activity that is different from the entity value stored in the second storage area in association with the variable, the second storage area stores the latest entity value stored in the first storage area as the entity value of the variable in association with the variable.

15. A scenario management program that causes a computer to function as the scenario management device according to any one of claims 1 to 14.

16. A recording medium on which the scenario management program according to claim 15 is recorded so as to be readable by a computer.

17. A computer-executable scenario management method for managing, as a scenario for automating an operation on another application program, a scenario including a first activity and a second activity selected from a plurality of types of activities including an activity corresponding to the operation of acquiring a value from another application program, an activity corresponding to the operation of inputting a value into another application program, and an activity corresponding to an operation of processing the acquired value, a step of executing the first activity based on a scenario execution instruction, and storing the entity values ​​of variables referenced in the first activity in a first storage area so that the entity values ​​can be referenced as entity values ​​of variables included in the second activity; a step of storing the actual values ​​of the variables stored in the first storage area in association with the variables in a second storage area accessible by a management unit that manages scenarios; A scenario management method comprising:

Images