Patent Application
20130268834
Business applications enable enterprises to execute and optimize business strategies and perform essential, industry-specific, and supporting processes. They are usually designed to work with different types of software. Organizations are increasing demand for working with a variety of tools that support their daily working activities. The support for executing end-to-end business processes allows them to operate more efficiently and effectively. Business scenarios depict interactions with external agents. For example customers, suppliers, competitors, agents from the regulatory environment, etc. Managing enterprise data gives users the ability to define, integrate and retrieve data from internal and external applications or communication.
Working with an application and performing interactions with it can be time-consuming Some business applications imply a high level of complexity. Entering data and navigating through the user interface (UI) of a business application can be facilitated by providing an interactive form for data entry. Interactive forms can be used for automating and streamlining form-based communication with applications.
Various embodiments of systems and methods for creating interactive forms from applications' user interface are described herein. In one embodiment, the method includes generating an interactive form container and establishing communication between the UI of the application and the interactive form container. Interactions with the UI of the application that are related to execution of a task associated with the application are received. The processor is recording a script. The script is descriptive of the interactions with the UI of the application for the execution of the task. The method also includes adding copies of UI objects from the UI of the application to the interactive form container to create a UI of the interactive form. The UI objects that are copied are associated with execution of the task. The UI of the interactive form in association with the recorded script are stored to create the interactive form. Upon processing the interactive form, the script is executed and uses filled in data via the UI of the interactive form to accomplish the task associated with the interactive form.
In another embodiment, the system includes at least one processor for executing program code and memory, comprising a generating module to generate an interactive form container and to communicate with the UI of the application. A receiving module connected with the generating module receives data from interactions with the UI of the application. The interactions are in association with a task execution with the UI of the application. A script module records a script descriptive of the interactions with the application. A UI creation module in communication with the script module creates the UI of the interactive form by adding copies of UI objects from the UI of the application to the interactive form container. The added copies of the UI objects are associated with the task execution. A storing module communicates with both the script module and the UI creation module and stores the UI of the interactive form and the recorded script and thus creates the interactive form.
These and other benefits and features of embodiments of the invention will be apparent upon consideration of the following detailed description of preferred embodiments thereof, presented in connection with the following drawings.
The claims set forth the embodiments of the invention with particularity. The invention is illustrated by way of example and not by way of limitation in the figures of the accompanying drawings in which like references indicate similar elements. The embodiments of the invention, together with its advantages, may be best understood from the following detailed description taken in conjunction with the accompanying drawings.
Embodiments of techniques for creating interactive forms from applications' user interface are described herein. In the following description, numerous specific details are set forth to provide a thorough understanding of embodiments of the invention. One skilled in the relevant art will recognize, however, that the invention can be practiced without one or more of the specific details, or with other methods, components, materials, etc. In other instances, well-known structures, materials, or operations are not shown or described in detail to avoid obscuring aspects of the invention.
Reference throughout this specification to “one embodiment”, “this embodiment” and similar phrases, means that a particular feature, structure, or characteristic described in connection with the embodiment is included in at least one embodiment of the present invention. Thus, the appearances of these phrases in various places throughout this specification are not necessarily all referring to the same embodiment. Furthermore, the particular features, structures, or characteristics may be combined in any suitable manner in one or more embodiments.
Interactive forms may be designed to assist and support regularly executed tasks in a complex application. They can be modeled based on the UI of an external application, for example, a business application. Thus, interactive forms present a simple model for communication with an application by providing a UI and recording a script that can be executed. The script can be used to automate the processing of the interactive form that is designed to accomplish a specific task. Creating an interactive form covers generating an interactive form container that is in communication with the UI of the application, recording a script corresponding to received interactions with the UI, and creating a UI of the interactive form. In addition, the script describes the interactions made when performing a task using the UI of the application. The UI of the interactive form is created when adding copies of UI objects from the UI of the application to the interactive form container when executing the task with the UI. The created UI and the script are stored in association and create the interactive form.
In one embodiment, an interactive form can be created, for example, to simplify and automate the change of a position title of an employee in the application 100. In one embodiment, creating the interactive form for changing of a position title of an employee searched by the employee ID includes generating an interactive form container where a UI for the interactive form can be created and a script can be recorded. The interactive form container can establish communication with the UI of the application. In one embodiment, the container may be used to create the UI, based on the UI of an application, and to store a record of a script descriptive of the steps that can be done in the application to perform a task. Creating the UI of the interactive form is based on UI objects from the application 100. The UI of the interactive form can be created by adding copies of UI objects from the UI of the application 100. The UI objects from the application 100 can come from different screens from the UI of the application 100. These screens can be the screens that a user visits when performing a task, such as changing the position title of an employee. The UI objects that are copied are associated with performing a task that can include a couple of steps to be accomplished. For example, changing the position title of an employee may have several steps such as searching for an employee, editing the position title of the employee and saving the change in the application 100.
To change a position title for an employee in the application 100, the employee should be found. Then, the detailed information for the employee can be presented and edited to reflect the change of the position title of the employee. In one embodiment, to find and display information about an employee in the application 100, Tab2110 is selected and on the main screen there are fields for searching employees. For example, a search can be made based on the employee ID. For example, part of the UI for such an interactive form can be such as a UI 140 which is displayed in a Designer view 145. In the Designer view 145, there is a UI object 150 “Employee ID” that corresponds to the UI object 120 from the application 100. The UI object 150 is a copy of the UI object 120. The UI Object 120 from the application 100 can be added to the Designer view 145. The employee ID can be filled in the UI object 120 “Employee ID”. The UI object 120 is a text field that is labeled with the name “Employee ID”. If you search for an employee with an employee ID—“MC6571”, the search criteria “MC6571” can be entered in the text box and then a push button “Go” 130 can be selected. Thus, creating the UI of the interactive form includes a UI object for searching of an employee in the application 100 with employee ID equal to “MC6571”.
In one embodiment, by recording a script, the steps of navigation and definition of search criteria in the UI of the application 100 are stored. In a Recorder view 160, there is a script that records the steps that can be made in the UI of the application 100. These steps include searching for an employee with the ID “MC6571”. These steps follow the navigation through tabs in the UI, entering search criteria into a field in the UI, and selecting a push button (e.g. the push button “Go” 130). The steps that can be recorded in a script are not limited to the given examples. When changing the position title of an employee in application 100, additional steps are performed for editing the employee's position title. After filling data about the position title of the employee that should be updated (changed), the filled in data can be stored thus saving the new employee's information. The steps include interactions with the application 100 that are executed during processing of the task. In one embodiment, when an interactive form is created, there is a UI associated with a recorded script that can represent and simulate task execution in an application, such as the application 100.
In one embodiment, in a Player view 170, the interactive form for changing the position title of an employee using the employee ID in the application 100 is presented in an executable format. An interactive form 190 is displayed with the UI of the interactive form that is created in the Designer view 145 with copied UI objects from an application, such as the application 100. In one embodiment, the interactive form 190 can be processed by selecting the button Play 180 that can activate the execution of the script based on the data that is filled in the UI of the interactive form. The user of the interactive form can change the position title of an employee with an employee ID defined in the UI object 195 “Employee ID” in the Player view 170. For example, the search criteria can be “MC6666”. In one embodiment, the user may enter “MC6666” in the text box and process the form by the button Play 180. The processing of the interactive form can execute the steps from the recorded script and apply the data entered in the UI of the interactive form.
In one embodiment, the UI 320 of the application 315 is used to create the UI of the interactive form. Different applications may implement different UI technologies for building a UI layer. For example, eXtensible HyperText Markup Language (xHTML); HyperText Markup Language (HTML); Active Server Pages (ASP) by Microsoft Corporation, Redmond, Wash., United States; Web Dynpro for ABAP™ developed by SAP A G, Walldorf, Germany; Flash® originally developed by Macromedia Inc., San Francisco, Calif., United States, Flex® provided by Adobe Systems Inc., San Jose, Calif., United States. Different UI technologies would require the usage of different manners of communication between applications. In one embodiment, the UI 320 of the application 315 may be a GUI.
The script module 335 records a script describing the interactions with the UI 320. The script module 335 is in association with a receiving module 330. In one embodiment, the interactions with the UI 320 that are described in the script can be related to navigation through the UI 320 of an application 315. Also, the interactions may include actions that are performed for executing a task. In one embodiment, such interactions may be following a menu path provided in the UI and performing actions. For example, such actions can be providing commands, selecting fields, pushing buttons, opening tabs, moving scrollbars, defining search criteria, filling in text boxes, etc. In another embodiment the performed actions can be user actions. According to an embodiment, the interactions may be provided from a keyboard, movement of the computer mouse, selection through a touchscreen, etc. In one embodiment, the interactive form generator 305 can be associated with hardware, software, and data resources. In one embodiment, the interactive form generator 305 is associated with a Central Processing Unit (CPU) 350 and a repository 360 to assist the process of creation of interactive forms. The CPU 350 is used to execute the program code. In one embodiment, the repository 360 is used for storing the interactive forms in a file format.
In one embodiment, the interactive form generator 305 includes a UI creation module 340 and a storing module 345. The UI creation module 340 is associated with the script module 335 and receives copies of UI objects from a UI 320 of an application 315. The UI creation module 340 adds copies of UI objects from the UI 320 of the application to an interactive form container to create the UI of the interactive form. The UI objects that are copied and added in the interactive form container are used for accomplishing a task that can be executed with the application 315 through the UI 320. For example, transferring UI objects from the UI 320 of the application 315 can be done by a drag and drop operation, or some other instructions that allow movement of UI objects. The UI of the interactive form may include graphical user interface (GUI) objects.
In one embodiment, copied UI objects transfer information about the design of the UI objects. For example, UI object 120 that is copied in an interactive form container has the same design as the UI object 150. In addition, the copied UI objects contain information about the data model of the original UI objects. In one embodiment, adding a copied UI object into the UI of an interactive form may insert a field with the design of a text field and a data model such as a data model for a date data value. In an embodiment, the UI creation module 340 may receive an action of filling in the interactive form thus providing content in it. Examples of actions for filling in content in the interactive form can be inserting numbers, characters or text in input fields; inserting check marks in check boxes; selecting items from a drop-down list, etc. In one embodiment, the filled in content can be validated. For instance, if the model for entering date data values is specified as “YYYY-MM-DD” and the received action with filled in content is “02-02-2012”, the validation of the filled in content may determine that the content does not comply with the data model and may require the content to be changed to “2012-02-02”.
According to an embodiment of the system 300, the interactive form generator 305 is further operable to edit the UI of the interactive form. For example, the UI objects from the UI 320 of the application 315 when copied and added to the interactive form container to create the interactive form can be rearranged, resized, etc. In an embodiment, additional UI elements, not part of the application 315, may be inserted into the UI of the interactive form. Their form, size and appearance may be changed as well.
In one embodiment, the interactions with the UI that are recorded in the script, can be going through different screens, navigating with menus, selecting buttons, entering data, checking options, etc. The copied and added UI objects can contain information about design and data model of the UI objects. In one embodiment, after recording the script and storing the UI with the script, an action can be received for filling in the interactive form with content. The content that is filled in may be validated according to the data model defined for the UI objects that are added in the interactive form container from the UI of the application. In one embodiment, the interactive form can be saved as a file with a data schema. In one embodiment, the file can be in an eXtensible Markup Language (XML) format. For example, the saved files can be stored in a repository, such as repository 355. The saved interactive forms can be invoked and filled in with data to request an execution of a task with the application and thus accomplishing the task by the form's execution. The UI of the interactive form can be edited, for example, it can be rearranged. In one embodiment, the UI of the interactive form includes UI objects that are inserted from different sources, apart from an application, such as application 315. In one embodiment, the UI objects can be GUI objects.
Some embodiments of the invention may include the above-described methods being written as one or more software components. These components, and the functionality associated with each, may be used by client, server, distributed, or peer computer systems. These components may be written in a computer language corresponding to one or more programming languages such as, functional, declarative, procedural, object-oriented, lower level languages and the like. They may be linked to other components via various application programming interfaces and then compiled into one complete application for a server or a client. Alternatively, the components maybe implemented in server and client applications. Further, these components may be linked together via various distributed programming protocols. Some example embodiments of the invention may include remote procedure calls being used to implement one or more of these components across a distributed programming environment. For example, a logic level may reside on a first computer system that is remotely located from a second computer system containing an interface level (e.g., a graphical user interface). These first and second computer systems can be configured in a server-client, peer-to-peer, or some other configuration. The clients can vary in complexity from mobile and handheld devices, to thin clients and on to thick clients or even other servers.
The above-illustrated software components are tangibly stored on a computer readable storage medium as instructions. The term “computer readable storage medium” should be taken to include a single medium or multiple media that stores one or more sets of instructions. The term “computer readable storage medium” should be taken to include any physical article that is capable of undergoing a set of physical changes to physically store, encode, or otherwise carry a set of instructions for execution by a computer system which causes the computer system to perform any of the methods or process steps described, represented, or illustrated herein. Examples of computer readable storage media include, but are not limited to: magnetic media, such as hard disks, floppy disks, and magnetic tape; optical media such as CD-ROMs, DVDs and holographic devices; magneto-optical media; and hardware devices that are specially configured to store and execute, such as application-specific integrated circuits (“ASICs”), programmable logic devices (“PLDs”) and ROM and RAM devices. Examples of computer readable instructions include machine code, such as produced by a compiler, and files containing higher-level code that are executed by a computer using an interpreter. For example, an embodiment of the invention may be implemented using Java, C++, or other object-oriented programming language and development tools. Another embodiment of the invention may be implemented in hard-wired circuitry in place of, or in combination with machine readable software instructions.
A data source is an information resource. Data sources include sources of data that enable data storage and retrieval. Data sources may include databases, such as, relational, transactional, hierarchical, multi-dimensional (e.g., OLAP), object oriented databases, and the like. Further data sources include tabular data (e.g., spreadsheets, delimited text files), data tagged with a markup language (e.g., XML data), transactional data, unstructured data (e.g., text files, screen scrapings), hierarchical data (e.g., data in a file system, XML data), files, a plurality of reports, and any other data source accessible through an established protocol, such as, Open DataBase Connectivity (ODBC), produced by an underlying software system (e.g., ERP system), and the like. Data sources may also include a data source where the data is not tangibly stored or otherwise ephemeral such as data streams, broadcast data, and the like. These data sources can include associated data foundations, semantic layers, management systems, security systems and so on.
In the above description, numerous specific details are set forth to provide a thorough understanding of embodiments of the invention. One skilled in the relevant art will recognize, however that the invention can be practiced without one or more of the specific details or with other methods, components, techniques, etc. In other instances, well-known operations or structures are not shown or described in details to avoid obscuring aspects of the invention.
Although the processes illustrated and described herein include series of steps, it will be appreciated that the different embodiments of the present invention are not limited by the illustrated ordering of steps, as some steps may occur in different orders, some concurrently with other steps apart from that shown and described herein. In addition, not all illustrated steps may be required to implement a methodology in accordance with the present invention. Moreover, it will be appreciated that the processes may be implemented in association with the apparatus and systems illustrated and described herein as well as in association with other systems not illustrated.
The above descriptions and illustrations of embodiments of the invention, including what is described in the Abstract, is not intended to be exhaustive or to limit the invention to the precise forms disclosed. While specific embodiments of, and examples for, the invention are described herein for illustrative purposes, various equivalent modifications are possible within the scope of the invention, as those skilled in the relevant art will recognize. These modifications can be made to the invention in light of the above detailed description. Rather, the scope of the invention is to be determined by the following claims, which are to be interpreted in accordance with established doctrines of claim construction.
