JP2023034112A - Information processing device, information processing method, and program - Google Patents

Abstract

To provide an information processing device, an information processing method, and a program which reduce rework of application development.SOLUTION: An information processing device includes: acquisition means to acquire first information which shows an item which is an output destination of output data outputted according to a specified event in response to an operation of a user, the output data being predetermined irrespective of correspondence processing corresponding to the specified event and second information which shows an item which is an output destination of output data outputted according to the specified event, the output data being corresponding to the correspondence processing; and display control means to perform control so that a display based on comparison between the first information and the second information is performed.SELECTED DRAWING: None

Description

The present invention relates to an information processing apparatus, an information processing method, and a program for confirming development status.

When creating application software (hereinafter referred to as an application) for a customer, if the customer's needs are first comprehended and the application created, rework can be reduced and development efficiency can be improved.

In particular, screens and operation procedures differ from internal logic and work as desired by the user, resulting in increased customer satisfaction.

Japanese Patent Laid-Open No. 2002-200000 proposes to determine the requirements according to the user's request while at the same time generating and completing the source code of the application program that can be used on the actual machine on the spot.

JP 2015-210639 A

Although the above invention can generate a mockup application, verify whether the behavior of the application during development or after development based on the mockup application has the same specifications as the mockup application. not expected to do so.

An object of the present invention is to reduce rework in development.

According to the present invention, output data to be output in response to a specific event in response to an operation from a user, and an item to be an output destination of predetermined output data irrespective of a corresponding process corresponding to the specific event. and second information, which is output data to be output in response to the specific event and indicates an item to be an output destination of the output data in response to the corresponding process. and display control means for controlling display based on comparison between the first information and the second information.

According to the present invention, it is possible to reduce development rework.

1 is a system configuration diagram according to an embodiment; FIG. 1 is a block diagram showing an example of each hardware configuration applicable as a program development device, an application server, a database server, and an application client according to this embodiment; FIG. It is an example of the functional configuration of the present embodiment. It is an example of the functional configuration of the present embodiment. 4 is a flow chart of generating a prototype application according to the embodiment; 8 is a flowchart of screen definition input reception processing according to the embodiment; 6 is a flowchart of prototype data input acceptance processing according to the present embodiment; 4 is a flowchart of prototype application source code generation processing according to the present embodiment; 4 is a flowchart of processing when executing a prototype application according to the embodiment; It is a display example according to the present embodiment. It is a display example according to the present embodiment. It is a display example according to the present embodiment. It is a display example according to the present embodiment. It is a figure which shows an example of the screen definition 402 which concerns on this embodiment. 4 is an example of a portion of a prototype application generated in this embodiment; 4 is a flowchart of logic check processing according to the embodiment; It is a display example according to the present embodiment. 3A and 3B are diagrams showing an example of a screen definition and an example of prototype data according to the embodiment; FIG. It is an example of part of the screen definition 402 according to the present embodiment. . It is an example of the data of the logic check result which concerns on this embodiment. It is a display example of a check result according to the present embodiment.

Hereinafter, embodiments of the present invention will be described in detail with reference to the drawings.
<First Embodiment>
FIG. 1 is a system configuration diagram of this embodiment. This system includes a program development device 101 (an information processing device operated by a developer to generate a web application), an application server 102 , a database server 103 and an application client 104 .

The program development device 101 defines screen layouts, database search instructions, and the like according to the developer's operation. The program development device 101 generates programs and applications.

In this embodiment, the application generated by the program development apparatus 101 is a web application, but the application is not limited to this. , the application does not have to use communication by Web technology.

The application server 102 executes applications developed by the program development device 101 . Also, it is possible to operate by connecting to the database server 103 .

The database server 103 is a database used by the developed application, and may also be used for operation confirmation when developing the application in this embodiment. For example, for use by developers, the database server 103 may consist of the same device as the program development device 101 and the application server 102, or may be arranged in a network 105 such as a LAN.

The application client 104 (information processing device) is an end-user input terminal that operates an application program developed by the program development device 101 in cooperation with the application server 102 . The application client 104 may be an information processing device such as a mobile terminal.

Any one of the program development device 101, the application server 102, the database server 103, and the application client 104 may be arranged on the Internet such as a cloud, or several information processing devices may be arranged as one housing. good too.

FIG. 2 is a block diagram showing an example of hardware configurations applicable to the program development device 101, application server 102, database server 103, and application client 104 according to the present invention.

In FIG. 2, a CPU 201 centrally controls each device connected to a system bus 204 .

The ROM 203 or the external memory 211 also stores an operating system (OS), which is a control program for the CPU 201, and programs for realizing various functions of information processing apparatuses such as servers, clients, and apparatuses, which will be described later.

A RAM 202 functions as a main memory, a work area, a temporary save area, and the like for the CPU 201 .

The input controller 205 controls input from the input unit 209 . Examples of the input unit 209 include a keyboard, a pointing device such as a mouse, and a touch panel in the information processing apparatus.

If the input unit 209 is a touch panel, the user can give various instructions by pressing (touching with a finger or the like) an icon, cursor, or button displayed on the touch panel.

Also, the touch panel may be a touch panel, such as a multi-touch screen, capable of detecting positions touched by a plurality of fingers.

The output controller 206 controls the display of the output section 210 . Examples of the output unit 210 include a CRT, a liquid crystal display, and the like. It should be noted that the display of the notebook computer integrated with the main body is also included. Also, it may be a projector.

An external memory controller 207 controls access to an external memory 211 that stores boot programs, various applications, font data, user files, edit files, printer drivers, and the like. The external memory 211 stores various tables and parameters for realizing various functions of each server, client, device, and the like. Examples of the external memory 211 include a hard disk (HD), flexible disk (FD), compact flash (registered trademark) connected to a PCMCIA card slot via an adapter, smart media, and the like.

It should be noted that the CPU 201 enables display on the output unit 210 by executing outline font expansion (rasterization) processing to a display information area in the RAM 202, for example. The CPU 201 also allows the user to issue instructions with a mouse cursor (not shown) or the like on the output unit 210 .

A communication I/F controller 208 executes communication control processing with external devices via a network. For example, communication using TCP/IP is possible.

A program 212 for realizing the present invention is recorded in the external memory 211 and is executed by the CPU 201 by being loaded into the RAM 202 as necessary.

FIG. 3 is a software block diagram of the program development device 101. As shown in FIG. FIG. 4 is a software block diagram of the application server 102 and the application client 104. As shown in FIG.

The program development device 101 comprises a repository definition section 400 , a prototype application generation section 410 and a repository definition editor section 420 . Note that the prototype application of this embodiment is different from an application that searches data from a database or draws a diagram based on calculated data results, as in a production environment. etc., and the application as a mockup that imitates screen transitions, display changes, etc. like an actual application.

Program development device 101 generates prototype application 440 by prototype application generation unit 410 . The developer in this embodiment refers not only to a contracted application developer, but also to a wide range of people who use the program development apparatus 101, such as business users and sales representatives.

The repository definition unit 400 stores an application definition 401 , a screen definition 402 , a screen part definition 403 , a screen transition definition 404 , an action 405 linked to the screen part definition 403 , and prototype data 406 linked to the action 405 . Prototype data refers to the data displayed on the application screen when the prototype application is executed. It refers to a value or figure preset by a person. These 401-406 definitions are input or placed by the developer through the application development tool.

The application definition 401 holds settings for the entire application developed by the developer.

The screen definition 402 holds information of various screen component definitions 403 and screen transition definitions 404 arranged on each screen included in the application. The screen definition 402 includes information on actions 405 set for various components and prototype data 406 associated with the actions 405 .

A prototype application generation unit 410 analyzes the repository definition unit 400 set by the developer and generates a prototype application. Also, the application server 102 is activated after the prototype application is generated. When the activated prototype application is accessed from the web browser 450 of the application client 104, the screen of the generated prototype application is displayed.

The repository definition analysis unit 411 analyzes the repository definition unit 400 set by the developer.

The prototype code generation unit 412 generates the source code of the prototype application according to the analysis result of the repository definition analysis unit 411 .

The source code compilation unit 413 compiles the source code generated by the prototype code generation unit 412 and deploys it to the application server 102 .

The repository definition editor section 420 is an example of a procedure for setting the repository definition 400 by the user. The repository definition editor section 420 includes a screen definition editor section 421 , a screen property editor section 422 , a component palette section 423 , an action selection section 424 and a prototype data input section 425 .

The screen definition editor unit 421 is a graphical editor for intuitively creating a desired screen layout by the developer.

The screen property editor unit 422 is an editor for setting properties for each screen component arranged by the developer.

The component palette section 423 is a list of components (items) for the developer to place desired screen components on the screen by drag-and-drop.

Action selection unit 424 is a functional unit that allows the developer to select an action for which prototype data 406 is to be set.

A prototype data input unit 425 is a graphical editor for intuitively setting prototype data 406 associated with a specific action 405 .

Application server 102 is a device for executing prototype application 440 generated by prototype application generation unit 410 .

Prototype application 440 is an application generated by prototype application generator 410 . The prototype application 440 is a mockup application for a developer to easily check the display content, operation, etc. of the application generated by the program development apparatus 101 . Prototype application 440 includes screen module 441 , action control module 442 and prototype data 443 .

A screen module 441 is a module of the prototype application 440 that has a user interface function.

The action control module 442 is a module that receives a user's action execution request from the screen module 441 and controls operations associated with the action. The action control module 442 controls which data out of a plurality of prototype data set by the developer is displayed at what timing when the prototype application 440 is executed. In addition, the action control module 442 controls actions associated with actions of components arranged on the screen. In other words, prototype data is associated with an action (action event).

Prototype data 443 is data read by action control module 442 and displayed on screen module 441 . Here, the prototype data 443 refers to data displayed on the screen in order for the developer to confirm the display contents and operation of the prototype application 440 . A screen for displaying data may be the Web browser 450 or the screen definition editor.

Also, although not shown, it also has an application code generator that actually operates instead of a prototype application. The application code generation unit reads and analyzes the application definition 401 , the screen definition 402 , the separately defined database definition, the data model definition, and the business process definition from the repository definition unit 400 by the repository definition analysis unit 411 . The Web application code generation unit uses the code generation rules stored in the external memory 211 and the contents analyzed by the repository definition analysis unit 411 to generate compiled Java (registered trademark) files via the source code compilation unit 413 . Generate a web application module containing code and HTML/JSP/JavaScript.

A procedure for generating a web application and a prototype application for the web application will be described with reference to FIGS. 5 to 15 below. 5 to 8 are executed by the CPU 201 of the program development apparatus 101 executing a program recorded in the ROM 203 and developed in the RAM 202. FIG.

FIG. 5 is a diagram showing an example of a flowchart of a part related to the prototype application generation process in the Web application generation process.

In step S501, the program development apparatus 101 receives an input of the screen definition of the web application by the developer. This process is a process of receiving instructions from the user as to what kind of screen parts should be arranged (layouted) at what positions on the screen of the generated Web application and what kind of functions each screen part should have. The details of step S501 will be described later with reference to the flowchart of FIG.

In step S502, program development apparatus 101 determines whether or not a request for input of prototype data 443 has been received. FIG. 10A shows an example of a screen displayed on the display of the output unit 210 in the Web application generation process for designing the component layout of the screen of the Web application to be generated. The screen definition editor section 421 and the component palette section 423 are as described above. As a result of inputting the screen definition in S501, FIG. 10A shows two text input fields (an ID input field displaying “ID” and A name input field displaying "name") and a registration button 1005 for registering an ID and a name are arranged. By right-clicking on the screen component arranged in the screen definition editor unit 421, for example, the registration button 1005, a prototype data setting button 1021a for the registration button 1005 is displayed as shown in FIG. 10(c). If the prototype data setting button 1021a is operated and then an option 1021b ("when clicked") displayed in the pulldown is selected, it is determined that the prototype data input request has been met. Alternatively, even if the prototype setting button 1022 is pressed while a component having an action is selected, it is determined that a similar prototype data input request has been met. The program development device 101 accepts the press to specify which action the prototype data to be input by the developer is associated with. If it is determined in step S502 that there is a prototype data input request, the process proceeds to step S503. On the other hand, if there is no prototype data input request in step S502, the process proceeds to step S504.

In step S503, program development apparatus 101 accepts input of prototype data from the user. Details of the processing in step S503 will be described later with reference to FIG.

In step S504, the program development apparatus 101 determines whether a screen definition save request has been received. If it is determined that there is a screen definition save request, the process proceeds to step S505, and if there is no screen definition save request, the process proceeds to step S506.

In step S<b>505 , the program development apparatus 101 saves the screen definition in the repository definition section 400 .

In step S506, program development apparatus 101 determines whether a prototype generation request has been received. If it is determined that a prototype generation request has been made, the process proceeds to step S507. On the other hand, if there is no prototype generation request, the process transitions to step S501.

In step S507, program development device 101 generates the source code of the prototype application. Details of the processing in step S507 will be described later with reference to FIG.

At step S508, the program development apparatus 101 compiles the source code generated at step S507.

In step S509, the program development device 101 deploys the prototype application compiled in step S508 to the application server 102. FIG.

This completes the description of FIG. Processing after S509 will be described later with reference to FIG.

Next, details of the processing in step S501 will be described with reference to FIG.

FIG. 6 is a diagram showing an example of a flowchart for accepting input of a screen definition of a Web application. .

In step S601, the program development apparatus 101 receives placement of screen components by the developer. Specifically, it accepts the placement of parts by drag & drop 1003 from the parts palette section 423 of FIG. 10A to the screen definition editor section 421 . 10A shows an example of dragging and dropping a button component from the component palette section 423 to the screen definition editor section 421. FIG. The method of arranging screen components is not limited to drag and drop from the component palette section 423 to the screen definition editor section 421, but may be a method of moving an already placed component or a method of duplicating an already placed component by copy and paste. may Also, it may be possible to delete a part that has been placed once.

In step S<b>602 , the program development apparatus 101 determines whether a component including an action event has been placed in the screen definition editor section 421 . If it is determined that the part containing the action event has been placed, the process proceeds to step S603, and if the part containing the action event has not been placed, the process proceeds to step S604.

In step S603, the program development apparatus 101 registers the action set for the part containing the action event. Specifically, in the case of a component having an action of onClick in the source code of the component, the action is registered. In the screen definition 402 of FIG. 14, which is an example of the screen definition 402, a definition 1452 of "actions" corresponding to the production environment and a definition 1453 of "examples" corresponding to the prototype application are written. In the example of FIG. 14, the format of data retention is a json file, but the format of data retention may be a file of other formats or a database. In the case of FIG. 10A, a registration button 1005 for registering an ID and a name in a database is registered in the screen component layout example 1004 .

In step S604, the program development apparatus 101 determines whether there is a property input request. Specifically, it is determined whether the property input request button 1011 (FIG. 10B) of the selected part has been pressed. A property input request button 1011 is an icon that is displayed when a predetermined time elapses after the mouse cursor is placed on an already-placed part or when the mouse is right-clicked. . If it is determined that there is a property input request, the process proceeds to step S605, and if there is no property input request, the screen definition input reception processing ends.

In step S605, the program development apparatus 101 receives property input for the screen component by the developer. Specifically, in response to the property input request, the screen property editor section 422 of FIG. 10B is displayed to accept the input of the property setting of the screen component (registration button 1005). In the example of FIG. 10B, the screen property editor section 422 is displayed near the target part (registration button 1005) in order to realize intuitive operation by the developer. It may be secured as the screen property editor section 422 . Also, the screen property editor section 422 may be displayed in a modal dialog.

This completes the description of FIG.

Next, details of the processing in step S503 will be described with reference to FIG.

FIG. 7 is a diagram showing an example of a flowchart for accepting input of prototype data to be displayed on the screen when generating a prototype application for a Web application.

In step S701, the program development apparatus 101 reads the setting of the action item designated by the developer in step S502 of FIG. Specifically, the following two measures will be implemented. First, the component definition 1451 in FIG. 14 corresponding to the registration button 1005 (action item) in the screen component layout example 1004 in FIG. 10A is read. A component definition 1451 is a screen component definition of a screen component (registration button 1005 ) selected by the developer who is the user, and is an example of the screen component definition 403 . It is assumed that the data of the component definition 1451 has been input from the screen property editor section 422 of FIG. 10B in step S605 of the flowchart of FIG. Next, the "actions" definition 1452 corresponding to the production environment of the screen component selected by the developer and the "examples" definition 1453 corresponding to the prototype application are read.

In step S702, the program development apparatus 101 determines whether the setting of the action item read in step S701 involves screen transition. Specifically, in the component definition 1451, a value is set in the "nextUi" property (next screen property that is the value of the item described as "next screen" in the screen property editor section 422) which is the screen transition definition 404. Determine whether or not In the example of the part definition 1451, since the value "sampleUi002" is set in the screen transition definition "nextUi", it is determined that the value is set. Although the program development apparatus 101 holds the screen transition definition 404 in the screen component definition 403 in this embodiment, it may hold it in the action definition 405 . If it is determined that the action item settings read in step S701 involve screen transitions, the process proceeds to step S703. If the action item settings read in step S701 do not involve screen transitions, step S704. transition to

In step S703, the program development apparatus 101 displays a transition destination screen for screen transition accompanying setting of the action item read in step S701. Specifically, the screen 1100 of FIG. 11A including the transition destination screen 1102 corresponding to "sampleUi002" set to "nextUi" which is the screen transition definition 404 is displayed. Note that the transition destination screen 1102 in FIG. 11A is also set in advance by the user's operation (step S601). A screen such as the transition destination screen 1102 may be displayed by rewriting the screen definition editor section 421 displayed before the transition, or by activating a new screen definition editor section 421 . Also, since FIG. 11 is a screen displayed for setting prototype data, 1101 is written as "prototype setting". That is, transition destination screen 1102 also serves as prototype data input section 425 .

In step S703, the action specified by the developer becomes the action of the pre-transition screen (for example, when transitioning from FIG. 10C to FIG. 11A, the registration button 1005 in FIG. 10C). The prototype data 443 of the transition destination screen is set to the specified action (for example, pressing the registration button 1005) in step S706, which will be described later.

In step S704, the program development apparatus 101 detects the prototype data already set in the action read in step S701 (for example, if data such as 1551 in FIG. 15 is already set, the data) on the screen. It is assumed that nothing is set as the initial value.

Next, in step S705, the program development apparatus 101 accepts the developer's selection of the output destination part of the prototype data. Here, the prototype data output destination component is a display component that displays data (prototype data) when the prototype application is operated. In the example of FIG. 11A, output destinations 1103 to 1105 of a transition destination screen 1102 displayed on the screen definition editor section 421 can be selected as output destination components. Note that the dashed rectangles shown in the output destinations 1103 to 1105 are shown to indicate areas, and are not displayed. Of the display parts included in the transition destination screen 1102, for example, the edit button 1111 of the edit button 1111 and the table input button 1112 in FIG. is pressed, the output destination 1104 corresponding to the "Name" column is selected as the output destination of the prototype data. Also, if you want to input list data as a list, when the table input button 1112 is pressed, multiple output destinations (output destinations corresponding to multiple columns of the list) are selected as the output destinations of the prototype data, Multiple prototype data can be input collectively as a list.

In step S706, program development apparatus 101 accepts input of prototype data by the developer. Specifically, an input dialog is displayed as the prototype data input section 425a (an example of the prototype data input section 425) in FIG. 11(c). The prototype data input section 425a is a prototype data input dialog displayed when the "Name" column is specified by right-clicking and the edit button 1111 is pressed in FIG. 11(b). FIG. 11(c) shows an example in which the user inputs prototype data "Noriyuki Tanigawa" in the "Name" column to the prototype data input section 425a. For example, when the prototype data "Noriyuki Tanigawa" is entered in the "Name" column and the input is confirmed, "Noriyuki Tanigawa" is displayed in the output destination 1104 of the "Name" column as shown in FIG. 12(a). Generates a prototype application with a given name.

As another example of step S706, an example of the prototype data input section 425 when the table input button 1112 is pressed will be described with reference to FIG. 12(b).

A prototype data input section 425b in FIG. 12B is an example of the prototype data input section 425, and is an input dialog for inputting prototype data. The text input field 1201 accepts input of a group of data to be displayed as prototype data in the output destinations 1103 to 1105 of the first line of the registrant list (list) and the output destinations of the second and subsequent lines. In the example of the text input field 1201 in FIG. 12(b), the first line is "(blank)", "Tanigawa Noriyuki", "(blank)", and the second line is "1001", "Hori Ai", " 2019/10/10", and data "1002", "Ruriko Yamamura", and "2019/09/18" are input in the third line. By selecting a CSV file or a spreadsheet file from a file selection screen (not shown) displayed by pressing the file selection button 1202, the contents of the file may be adapted to these data inputs.

In step S706, locale designation may be accepted in order to switch the prototype data to be displayed depending on the language. Moreover, although a method of displaying a modal dialog is shown as a prototype data input acceptance method, the input acceptance method may be a method of accepting direct input to the display component selected by the developer in S705. , may be batch input by an external file.

In step S707, the program development apparatus 101 determines whether the prototype data input by the developer has been confirmed. Specifically, it is determined whether the OK button in the prototype data input section 425a in FIG. 11(c) or the OK button 1203 in FIG. 12(b) has been pressed. In the input reception method of step S706, when a direct input to a component is received, determination is made based on whether the component is out of focus. If it is determined that the prototype data input has been finalized, the process proceeds to step S708, and if it is determined that the prototype data input has not been finalized, the process proceeds to step S706.

At step S708, the program development apparatus 101 writes the prototype data input by the developer to the screen definition 402. FIG. Specifically, it is written to 1551 which is an example of the prototype data 406 linked to the action 405 of the screen definition 402 .

In this method, it is not possible to change the data displayed on the post-transition screen by the action to be executed. This is because the prototype data is held in the initial display action of the screen after transition, but by holding the prototype data to be displayed on the screen after transition on the action side to be executed, it is displayed on the screen after transition by the action to be executed. It may be possible to change the data. Specifically, by holding the objects below 1551 "onLoad" below 1453 "onClick", the screen transitions to the original button (for example, the registration button 1005 placed at 1000 in FIG. 10). Data to be displayed on the subsequent screen may be provided.

In this way, the screen displaying the prototype data is displayed on the prototype application by transitioning the screen for each action event. You can get an idea of how it works as a mockup before making it. This concludes the explanation of FIG.

Next, details of the processing in step S507 will be described with reference to FIG.

FIG. 8 is an example of a flowchart for explaining the flow of processing for generating the source code of the prototype application of the Web application.

The flowchart in FIG. 8 is a flow of processing that is started when the process transitions to step S507 in the flowchart in FIG.

In step S<b>801 , the program development apparatus 101 reads the application definition 401 specified by the developer from the repository definition unit 400 . The repository definition analysis unit 411 analyzes the read definitions and stores them in the ROM 203, and the analyzed definitions are appropriately referred to by each generation unit.

At step S802, the program development apparatus 101 reads the screen definition 402 included in the application definition 401 read from the repository definition unit 400 at step S801.

In step S803, the program development apparatus 101 reads from the repository definition unit 400 the screen component definition 403 included in the screen definition 402 read in step S802.

In step S804, the program development apparatus 101 reads from the repository definition unit 400 the screen transition definition 404 included in the screen definition 402 read in step S802.

In step S805, program development apparatus 101 reads prototype data 406 included in screen definition 402 read in step S802 from repository definition unit 400. FIG. The data in the screen definition 402 read here is the data of FIG. 14 "examples" corresponding to the prototype data, and does not use "actions", that is, data for the production environment.

In step S806, program development apparatus 101 causes prototype code generation unit 412 to generate the source code of the prototype application based on the information read in steps S801 to S806. The generated source code is then deployed to application server 102 . Note that the source code and the deployed program may be an application deployed as an SPA (Single Page Application) that runs on the client. When deployed as an SPA, the SPA downloaded to the application client 104 can execute a prototype application without communicating with the server. has the effect of confirming

FIG. 15 shows an example of the prototype application 440 generated in FIG. 8 as described above. The action setting 1552 is the content described based on the screen transition definition 404 . The prototype data 1551 is the content described based on the data of "examples" in FIG. The prototype application 440 is designed to process based on the prototype data 1551 shown in FIG. 15 without accessing the database. This makes it possible to reproduce screen changes and transitions without describing the processing that the production application acquires from the database (for example, the processing that is specifically described in action 1452). Even salespeople and business users who don't know how to do it will be able to reproduce just the behavior of the application.

This completes the description of FIG.

Next, a flowchart describing the operation of the prototype application 440 in the application server 102 after the prototype application generation process of FIG. 5 will be described with reference to FIG. Note that FIG. 9 describes an example that operates on the application server 102, but the application generated in this embodiment may be an SPA.

FIG. 9 is an example of a flow chart showing an example of the operation of the prototype application 440 deployed in step S509 of FIG. The processing in FIG. 9 is implemented by CPU 201 of application server 102 ( 430 ) executing the program of prototype application 440 . When the application generated in FIG. 5 is SPA, the CPU 201 of the application client 104 executes the process. Since the response of the prototype application is better in the SPA, the SPA is more suitable as an execution environment for the prototype application for checking the operation image.

The flowchart in FIG. 9 is a flow of processing that is started after the prototype application 440 is deployed on the application server 102 and is accessed by the user from the web browser 450 of the application client 104 .

5 is SPA, the application is downloaded from the application server 102 to the application client 104 before executing the flowchart of FIG. 9, and the application client 104 starts processing. Subsequent processing is also executed by the application client 104 instead of the application server 102 .

In step S901, the application server 102 first reads the locale information of the browser. With this locale information, it is possible to switch the display language of the prototype data.

In step S902, screen 1300 by prototype application 440 shown in FIG. The application server 102 then accepts an action execution request from the user.

In step S903, the application server 102 determines whether the user has issued an action execution request. Specifically, it is determined whether the registration button 1301 in FIG. 13A, which is an example of the generated screen component, has been pressed. At this time, since the purpose of the user is to confirm the operation for reproducing the image when using the application, the input by the user is not necessarily required in the "ID" input field 1302 and the "Name" input field 1303. isn't it.

If it is determined in step S903 that there has been an action execution request (the registration button 1301 has been pressed), the process proceeds to step S904, and if there is no action execution request by the user, the process returns to step S902.

In step S904, the application server 102 reads the setting 1552 of the requested action. For example, in the case of the action setting 1552, the settings under "examples" of 1551 are read and the process is executed. In addition, in the application generated for the production environment (production application), the processing below 1552 "actions" is performed, but the processing below this "actions" is done by the developer after the mockup application is created. It is coded to work specifically.

In step S905, the application server 102 determines whether the action read in step S904 involves screen transition. If it is determined that the action involves screen transition, the process proceeds to step S906, and if the action does not involve screen transition, the process proceeds to step S907.

In step S906, the application server 102 displays the transition destination screen set for the action read in step S904.

In step S907, the application server 102 displays the prototype data set in the action read in step S904. As a specific display example of prototype data, a registrant list 1311 displaying values based on prototype data is displayed on the transition destination screen 1310 in FIG. 13(b).

Note that the display language of the prototype data set in the action read in step S904 may be set according to the locale information of the browser read in step S901. Also, a default locale may be set in case there is no prototype data for the relevant locale information. Alternatively, a user's language specification may be received from the screen component, and the prototype data may be displayed accordingly. Locale support for the display language of these prototype data has the effect of making it easier for multinational sales personnel and business users to understand the operation of the system.

This completes the description of FIG.

Through the above-described processing, it becomes possible for a sales person who makes a proposal to a customer, a business user, or the like to intuitively create a prototype of an application desired by the customer.

Further, since this is a process in the middle of a procedure in a program development apparatus having a function of generating a production application, the prototype application generated in this embodiment has the same appearance and screen transitions as the production application.

In other words, the sales representative presents the input/output items and transition screens of the same screen as the production application to the customer. Can ask for correction instructions. Then, the requests and correction instructions can be fed back to the developer to modify the production application under development. This has the effect of preventing discrepancies between the developer and the person in charge of sales or the business user, and suppressing the occurrence of rework in development.

When the prototype application is created, the developer refers to its screen (UI) and screen transitions, and generates a logic part (also called business logic) that governs the operation of the application so that the application can operate. The logic part is, for example, a processing part that outputs a predetermined search key to a database, receives database search results from the database, and displays the received results on the same screen or a different screen.

However, when a developer develops a logic part, he/she may forget to implement information that he/she originally wants to output. For example, screens 1741 and 1761 in FIG. 17 are display examples of a prototype application of screens for outputting mailing list results, adding mail addresses to the mailing list, and deleting mail addresses. A salesperson or business user wants to display a search result list 1762 and a search result message 1763 as shown in the screen 1761 in response to pressing (clicking) of the search button 1701 on the screen 1741 (search action). Suppose you requested.

If the developer implements only the logic for outputting the search result list 1762 and forgets to implement the logic for outputting the search result message 1763, the part that is not implemented can only be checked by visual inspection. If you continue to generate the next program without checking in , you will end up with problems such as rework in development and the creation of an application that does not meet the customer's needs.

This embodiment is an embodiment for solving the above problems. This embodiment will be described with reference to FIG. 16 and subsequent figures.

FIG. 16 is a flow chart showing an example of logic check processing of a Web application, and each step of the flow chart is executed by the CPU 201 of the program development device 101 .

The processing in FIG. 16 is assumed to start after executing the processing up to S505 in FIG. 5 and storing the action 405 of the screen definition 402 and the prototype data 406 by the developer.

In step S1600, program development apparatus 101 acquires screen definition 402 (including action 405 and prototype data 406). Note that the action 405 and the prototype data 406 may be stored in the application server 102 instead of in the program development apparatus 101 (for example, stored in the application server as SPA). A display example displayed based on the screen definition 402 is shown in FIG. 1840 in FIG. 18 shows an example of the contents defined in the screen definition 402 here.

The item name column (first column) in FIG. 18 corresponds to the item name on the screen definition, and the IO definition name column (second column) is the name of the IO definition in JSON code. The item type column (third column) is data defining the type of input/output item, action, list output, and the like. The search result message line 1840 in FIG. 18 is an invisible message column displayed on the screen 1743 of the screen 1741 in FIG. 17 when there is no data.

FIG. 19 shows an example of the action 405 and prototype data 406 portions of the screen definition 402 acquired in S1600. The prototype data definition part 1921 is an example of the prototype data 406, the action binding definition part 1922 is an example of the action 405, and the action binding for acquiring data from an external database (that is, business logic, processing that operates in the production application). ) is defined. Note that the action binding definition portion 1922 may be an arithmetic definition of the acquired data, and the action binding definition portion 1922 describes code for operating the production application shown in FIG. Note that the prototype data definition portion 1921 and the action binding definition portion 1922 are registered in the same screen definition 402 . Since the prototype data definition and the production application definition are registered in the same definition information, there is an effect that the UI of the prototype application and the production application can be made common.

In step S1601, the program development apparatus 101 reads and analyzes the screen definition information from the received application, and counts the number of actions (processes after pressing a button or processing after pressing a link text) registered in the screen definition. confirm. For example, in the case of FIG. 18, there are three actions: search (press the search button 1701), add (press the add button 1702), and delete (press the delete button 1703), so the number of actions is three.

In step S1602, the program development apparatus 101 repeats steps S1603 to S1607 by the number of actions confirmed in step S1601. In the case of FIG. 18, since there are three actions, it is repeated three times.

In step S1603, the program development device 101 acquires prototype data associated with each action. When obtaining the prototype data corresponding to the search action in row 1841 in the example of FIG. get. This value is obtained by obtaining the variable searchData 1923 pointing to the prototype data predetermined as the value to be displayed in the output destination item "query_result" key (search result), and obtaining the output destination item "result_msg" key (search result). Get the prototype data of the registered character string "4 hits" as the value to be displayed in the message). An example of the variable searchData 1923 is pre-registered data such as 1860 in FIG.

In step S1606, the program development apparatus 101 extracts and registers, as a change item list, items on which the prototype data is reflected by the action specified in step S1602. In the example of FIG. 19, since the value of the "query_result" key (search result) and the value of the "result_msg" key (search result message) have been changed, these two places are registered in the change item list. An example of data to be registered will be described with reference to FIG.

FIG. 20 is an example of data in which results of check actions according to this embodiment are registered. A change item list 2022 is an example stored as a change item list. The variable item list 2022 is a list of variable items in the "SEARCH" action (search action) (a list of output destination items to which prototype data values are output). In the "diffItems" key of the variable item list 2022, "query_result" and "result_msg" indicating the items of the output destination where the prototype data is displayed in FIG. 19 are registered as values. Returning to the description of the flowchart in FIG.

In step S1607, the processing from step S1603 to step S1606 is repeated by the number of actions of the application.

In step S1608, the program development apparatus 101 acquires the business logic definition of each action (definition for acquiring data from an external database, etc.). The business logic of each action is the code (part) in the action binding definition part 1922 in the example of FIG. The JSON code of the action binding definition (a part of the business logic definition) of the action binding definition part 1922 in FIG. 19 will be explained.

An action binding definition portion 1922 in FIG. 19 is an example of an extracted portion of the action binding definition portion, in which the developer describes specific processing contents. The value of the "restCall" key of 1924 specifies, for example, the URI, ID, and password of the database to be connected, and various search conditions. output item) $ui. Substitution in the query_result column (1925) and output (1926). Returning to the description of the flowchart in FIG.

Next, in step S1609, the program development apparatus 101 repeats the processes of steps S1610 to S1613 for the number of items registered in the changed item list 2022 of each action in the check action data 2021 registered in step S1606. .

In step S1610, the program development apparatus 101 compares the output item output in step S1608 with the change item registered in step S1606.

In step S1611, the program development apparatus 101 divides the process depending on whether the output item output in step S1608 matches the change item registered in step S1606 as a result of the comparison in step S1610. Whether the output item in step S1608 matches the change item in step S1606 is determined based on whether the change item changed in step S1606 is the output item target in step S1608. If the two items match (that is, if they are both change and output targets), the process transitions to step S1613, and the two items do not match (for example, if the business logic of the action is defined). not), the process transitions to step S1612.

In step S<b>1612 , the program development apparatus 101 registers in the undefined item list 2023 that the item of the prototype data and the business logic result of the action do not match in the check action data 2021 .

On the other hand, in step S 1613 , the program development apparatus 101 registers in the defined item list 2024 the items of the check action data 2021 whose prototype data items and the output results of the business logic of the action match.

The processing of steps S1612 and S1613 will be described with reference to FIGS. 20 and 19. FIG.

In an application that has a prototype data definition such as the prototype data definition portion 1921 in FIG. 19 and an action bind definition (business logic definition) such as the action bind definition portion 1922, the prototype data In the definition part 1921, like 1926, two keys, a "query_result" key (search result) and a "result_msg" key (search result message), are output. On the other hand, in the action binding definition, the output associated with the "SEARCH" key is only query_result ($ui.query_result) like 1925, and the business logic for outputting result_msg ($ui.result_msg) is omitted. Therefore, the undefined item list 2023 in FIG. 20 registers that "result_msg" is undefined, and the defined item list 2024 registers that "query_result" is already defined. Of the changing items, if there is a changing item that is neither a defined item nor an undefined item, for example, if there is an item with an action binding defined in a place where the binding is not defined in the prototype, that item will be detected. , may be registered as the error definition item 2025 . Returning to the description of the flowchart in FIG.

In step S1614, the processing from step S1610 to step S1613 is repeated by the number of change item lists.

In step S1615, the program development device 101 acquires check action data 2021, which is the result of the logic definition check. At this stage, if there is a definition error in the acquired data (such as when an undefined item is registered in the undefined item list 2023 or an error definition item is registered in the error definition item 2025), there is another definition error. may be output to the output unit 210.

In step S<b>1616 , the program development device 101 calculates logic check results from the check action data 2021 .

In step S1617, the logic check result calculated in step S1616 is output to the output unit 210 (displayed on the display of the output unit 210). An example of the output screen will be described with reference to FIG.

FIG. 21 is a screen display example of the logic check result output to the output unit 210 of the program development device 101 (displayed on the display). An execution result display dialog 2101 displays an outline of the execution result as the contents of the logic check. According to the execution result summary 2102, it can be seen that there is one undefined number 2105 in which the logic is not defined for the three confirmation target actions. To confirm the details of the logic check, the [Detail] button 2103 is pressed.

When the [Detail] button 2103 is pressed, a detailed screen of the execution results such as the detailed screen 2121 in FIG. 21 is output. The area 2122 displays the same data as the contents displayed in the execution result summary 2102, and the areas 2123 and 2124 display details of the logic check. A region 2123 displays a list of actions targeted for the logic check. When a search action with a cross mark 2127 is selected from the list in area 2123 , detailed check results for the selected action are displayed in area 2124 .

Area 2124 displays the number of changed items for the search action, items whose display items are correct, and incorrect items (NG notation). The incorrect items are the "search result message" column (result_msg). is displayed. This description enables the developer to grasp the items whose definitions have not been completed.

Also, in area 2124, it is displayed that the logic check result of the search action is 1/2 successful. This display allows the developer to grasp the ratio of how much logic definition information has been generated. Since this ratio can be calculated, the developer can know the progress of the work by executing the process of FIG. 16 even in the middle of the logic definition (uncompleted state).

According to the processing described above, the program development apparatus 101 generates the prototype data 406 indicating the item to be the output destination of the prototype data to be output in response to a specific event (action) according to the user's operation, and the Acquire the action 405 indicating the item to be the output destination of the data obtained. Based on these comparisons, a comparison result such as that shown in FIG. 21 is displayed. The prototype data 406 searches the database 103, which is processing corresponding to a search action when a specific event (for example, a search action in response to pressing the search button 1701) occurs in the prototype application corresponding to the production application. This is predetermined output data that is output without performing the process of doing (corresponding process corresponding to the event). Prototype data 406 is also information indicating items that are output destinations on screen 1761 in the prototype application. Specifically, it is 1926, and the change item list 2022 is generated based on this information. The action 405 is information indicating an item to be an output destination on a screen corresponding to the screen 1761 of the prototype application, which is a screen in the production application when there is also a search action in the application of the present application corresponding to the prototype application. is. Specifically 1925. In the output destination of this production application, the value of the result of the process of searching the database 103, which is the corresponding process corresponding to the search action, is displayed. With the above processing, it is possible to quickly detect omissions and omissions in the output result of the production application from the difference between the prototype application and the developed production application, and reduce rework in development. Further, by performing the above-described processing for an application that is in the process of being developed, it is also possible to check the progress of the development status. That is, the efficiency of program development work can be improved.

As described above, a recording medium recording a program for realizing the functions of the above-described embodiments is supplied to a system or device, and the computer (or CPU or MPU) of the system or device reads the program stored in the recording medium. Needless to say, the object of the present invention can also be achieved by reading and executing.

In this case, the program itself read from the recording medium implements the novel functions of the present invention, and the recording medium recording the program constitutes the present invention.

Examples of recording media for supplying programs include flexible disks, hard disks, optical disks, magneto-optical disks, CD-ROMs, CD-Rs, DVD-ROMs, magnetic tapes, non-volatile memory cards, ROMs, EEPROMs, silicon A disk or the like can be used.

Further, by executing the program read by the computer, not only the functions of the above-described embodiments are realized, but also based on the instructions of the program, the OS (operating system) and the like running on the computer are actually executed. Needless to say, a case where part or all of the processing is performed and the functions of the above-described embodiments are realized by the processing are included.

Furthermore, after the program read from the recording medium is written in the memory provided in the function expansion board inserted into the computer or the function expansion unit connected to the computer, the function expansion board is read according to the instruction of the program code. It goes without saying that a case where a CPU or the like provided in a function expansion unit performs part or all of the actual processing and the functions of the above-described embodiments are realized by the processing.

Moreover, the present invention may be applied to a system composed of a plurality of devices or to an apparatus composed of a single device. Further, it goes without saying that the present invention can be applied to the case where it is achieved by supplying a program to a system or apparatus. In this case, by loading a recording medium storing a program for achieving the present invention into the system or device, the system or device can enjoy the effects of the present invention.

The program may be in the form of object code, program code executed by an interpreter, script data supplied to an OS (operating system), or the like.

Furthermore, by downloading and reading out the program for achieving the present invention from a server, database, etc. on the network using a communication program, the system or device can enjoy the effects of the present invention. It should be noted that all configurations obtained by combining each of the above-described embodiments and modifications thereof are also included in the present invention.

101 Program development device 102 Application server 103 Database server 104 Application client 105 Network

Claims (15)

A first output data to be output in response to a specific event in response to an operation from a user, which indicates an item to be an output destination of predetermined output data irrespective of a corresponding process corresponding to the specific event; information and
second information that is output data to be output in response to the specific event and indicates an item to be an output destination of the output data in response to the response process;
an obtaining means for obtaining a
display control means for controlling display based on comparison between the first information and the second information;
An information processing device comprising: The first information is information indicating an item to be an output destination on the first screen of the first application when the specific event occurs in the first application,
The second information is an output destination on a screen corresponding to the first screen in the second application when the specific event occurs in the second application corresponding to the first application. 2. The information processing apparatus according to claim 1, wherein the information is information indicating an item. 3. The information processing apparatus according to claim 2, wherein said acquisition means acquires said first information and said second information from definition information of said second application. 4. The information processing according to claim 2, wherein said second information is information indicating an output destination of output data according to corresponding processing defined when said second application is generated. Device. 5. The information processing apparatus according to claim 2, wherein the first information is information input by a user when generating the second application. 6. The information processing apparatus according to claim 2, wherein said first application is a prototype application of said second application. 7. The information processing apparatus according to claim 2, wherein said second application is a production application. 8. The information processing apparatus according to claim 1, wherein said first information is information registered in advance as information to be output according to said specific event. 9. The information processing apparatus according to any one of claims 1 to 8, wherein the corresponding processing is at least one of database access processing and arithmetic processing of acquired data. 10. The output data according to the correspondence process is data that changes according to at least one of information registered in the database, acquired data, and a result of arithmetic processing of the acquired data. The information processing device according to . 1. The predetermined output data is data that does not change even if any of information registered in a database, acquired data, and the result of arithmetic processing of the acquired data changes. 11. The information processing device according to any one of 10. 3. The display control means controls to display at least one of the number and ratio of different items between the items indicated by the first information and the items indicated by the second information. 12. The information processing device according to any one of 11. 13. The method according to any one of claims 1 to 12, wherein the display control means displays information specifying different items between the item indicated by the first information and the item indicated by the second information. The information processing device described. An information processing method in an information processing device,
A first output data to be output in response to a specific event in response to an operation from a user, which indicates an item to be an output destination of predetermined output data irrespective of a corresponding process corresponding to the specific event; information and
second information that is output data to be output in response to the specific event and indicates an item to be an output destination of the output data in response to the response process;
a obtaining step that obtains
a display control step of performing control to perform display based on a comparison between the first information and the second information;
An information processing method characterized by having A program for causing a computer to function as each means of the information processing apparatus according to any one of claims 1 to 13.

Images