WO2001037170A9 - Forms creation method and e-commerce method - Google Patents
Forms creation method and e-commerce methodInfo
- Publication number
- WO2001037170A9 WO2001037170A9 PCT/US2000/031221 US0031221W WO0137170A9 WO 2001037170 A9 WO2001037170 A9 WO 2001037170A9 US 0031221 W US0031221 W US 0031221W WO 0137170 A9 WO0137170 A9 WO 0137170A9
- Authority
- WO
- WIPO (PCT)
- Prior art keywords
- schema
- code
- data
- database
- user
- Prior art date
Links
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F40/00—Handling natural language data
- G06F40/10—Text processing
- G06F40/166—Editing, e.g. inserting or deleting
- G06F40/174—Form filling; Merging
Definitions
- the present invention relates generally to forms creation software and e-commerce, and more particularly, to a method, system and software for creating and maintaining highly scalable and fully functional, multi-step web-based forms and the creation of a multi-tiered e- commerce method and system.
- the present invention comprises an integrated development method for creating forms, including the steps of: storing at least one schema for a form in a first file at a computing resource, wherein the schema comprises minimal user interface representations; accessing at least one template of a form in at least one second file separate from the first file at a computing resource, wherein each of the templates comprises a user interface representation of the form; selecting one of the at least one template and one of the at least one schema; and creating at least one linking file that links the selected schema and the selected template.
- a method is provided to publish forms comprising the steps of: creating a schema; providing a list of predefined templates; selecting a template; selecting a publishing destination; and linking the schema to the selected template.
- a method for creating a regular expression file comprising the steps of: inputting and presenting a name for a regular expression; inputting and presenting a pattern for a regular expression that is to be used in a validation engine; inputting and presenting an error message for user inputs that do not match the pattern; inputting at least one test case; and comparing the test case to the pattern; and presenting a message in response to the comparison step.
- a navigation engine program product comprising: a computer usable medium having computer readable program code embodied therein comprising: first code for transforming data-centric hierarchical storage and retrieval mechanism data to presentation language; second code for receiving data in presentation language and converting the received data to the data-centric hierarchical storage and retrieval mechanism; third code for performing attribute based validation on the data; fourth code for providing navigation among present pages; and fifth code for saving the data in response to a command.
- a method for processing forms on a user-interface program comprising the steps of: receiving an engine and a file with a form including a schema and a template in a data-centric hierarchical storage and retrieval mechanism; transforming with the engine the form from the data-centric hierarchical storage and retrieval mechanism into presentation language and presenting the form at the user- interface program; receiving user input data in the presentation language; converting the user input data to the data-centric hierarchical storage and retrieval mechanism; performing attribute based validation on the converted user input data; incorporating any error detected in the validation step in the data-centric hierarchical storage and retrieval mechanism into the form schema or separate form schema; converting the any error into presentation language and presenting an error message associated therewith to the user; allowing the user to correct the user input data, if necessary; and saving the user input data.
- a runtime environment method for an electronic forms applications comprising the steps of: receiving a forms request from a user-interface program; determining if the user-interface program is compatible or not compatible with a data-centric hierarchical storage and retrieval mechanism; sending from a computing resource to the user-interface program, if the user-interface program is compatible with the language, a schema file containing form information to be inserted into a form template and a form navigation engine and a form input validation engine; if the user-interface program is not compatible with the storage and retrieval mechanism, sending user input information to the computing resource for processing and sending a presentation language version of form pages resulting from the computing resource processing back to the user- interface program.
- a method for creating a form file comprising the steps of: storing in a form file a path to a schema in a first file at a storage location; storing in the form file a path to a template in a second file different from the first file at a storage location; and storing the form file at a user location.
- a method for performing customized actions in a computing environment comprising the steps of: providing at least one selector file, each selector file containing at least one selector pattern and associated with an action set that contains at least one action, wherein the at least one action contains at least an eAgent ID and an associated action document ID; obtaining a document for processing from a queue; searching the document for a match to at least one of the selector patterns of the selector files; if a match is found for one of the selector patterns, executing the at least one action in the Actionset associated with the matched selector file, including loading an eAgent specified by the eAgent ID; and the eAgent reading an action document specified by said associated action document ID and performing an action specified therein.
- a system for generating forms in a computing environment comprising: a schema database; a template database separate from the schema database; at least one linkage file, each containing code to link a selected schema with a selected template; a database of validation patterns separate from the schema database and the template database; and a database of query information separate from the schema database and the template database.
- a system for performing actions on documents in a computing environment comprising: a selector file database containing a plurality of selector files; an Actionset database containing a plurality of Actionsets, wherein each selector file is associated with exactly one Actionset; an eAgent specific action document database containing a plurality of action documents that are specific to eAgents; wherein each Actionset in the Actionset database is associated with at least one action document.
- a computer program product for an integrated development environment comprising: a computer usable medium having a computer readable code embodied therein, including: presentation host code, the presentation host code including shared user interface and logic code components, code for reading a IDE configuration, and code for loading any IDE component code and business logic components code as defined in the IDE configuration; at least one IDE component code loaded by the presentation host on the user-interface program, the IDE component code including a user interface; at least one business logic component code loaded by the presentation host on the user-interface program, the business logic component code defining the interrelationships between objects represented in the user interface.
- an integrated development environment method comprising the steps of: loading onto a computer resource code in a tiered architecture comprising: a presentation host tier that includes presentation host code, the presentation host code including shared user interface and logic code components, code for reading an IDE configuration, and code for loading any IDE component code and business logic components code as defined in the IDE configuration; an IDE component tier, including at least one IDE component code loaded by the presentation host on the user-interface program, the IDE component code including a user interface; a business logic component tier, including at least one business logic component code loaded by the presentation host on the user-interface program, the business logic component code defining the interrelationships between objects represented in the user interface; a data access abstraction layer tier, including a data access abstraction layer code that allows business components code to read and write information to/from a computing resource; and communicating with a remote computing resource through use of the data access abstraction layer code.
- a computer program product comprising: a medium with machine-readable code stored thereon which gives the ability to its computer to perform form creation tasks, including: first code for facilitating a schema database; second code for facilitating a template database separate from the schema database; third code for facilitating at least one linkage file, each containing code to link a selected schema from the schema database with a selected template from the template database; fourth code for facilitating a database of validation patterns separate from the schema database and the template database; and fifth code for facilitating a database of query information separate from the schema database and the template database.
- Fig. 1 is a schematic block diagram showing the system architecture for the forms creation system and method of the present invention.
- Fig. 2 is a static block diagram of the overall invention architecture, including the forms creation system and method in combination with the e-commerce system.
- Fig. 3 is a process workflow block diagram for a client-side processing software design.
- Fig. 4 is a workflow block diagram for a server-side processing software design.
- Fig. 5 is a process workflow block diagram of a forms publishing software process.
- Fig. 6 is a static block diagram of an eAgent architecture.
- Fig. 7 is a process workflow block diagram for the eAgent architecture software.
- Fig. 8 is a static block diagram of an integrated development system for an e-commerce architecture.
- Fig. 9 is a schematic diagram of a forms schema.
- Fig 10 is a schematic diagram of a regular expressions schema.
- Fig 11 is a schematic diagram of a query schema.
- Fig 12 is a schematic diagram of a templates schema.
- Fig 13 is a schematic diagram of a template schema.
- Fig 14 is a schematic diagram of a publishing folder schema.
- Fig 15 is a schematic diagram of an integrated development environment schema.
- Fig 16 is a schematic diagram of an XML selector schema.
- Fig 17 is a schematic diagram of an Actionset schema.
- Fig 18 is a schematic diagram of an action query eAgent schema.
- Fig 19 is a schematic diagram of a queue config schema.
- Fig 20 is a schematic block diagram of a system for performing actions on documents.
- Fig 21 is a schematic diagram illustrating the publishing wizard-Publish. ASP interaction between the IDE and the server.
- the present invention in a preferred embodiment, may incorporate technologies, including:
- Extensible Markup Language both as an object store and as a data store for flexibility, extensibility and easy integration with other systems.
- Extensible Stylesheet Language XSL
- JavaScript using the XML DOM as the transformation engine, for transforming the meta data of a form into an HTML form and for transforming one XML implementation into another.
- Cascading Style Sheets for manipulating the display of the XML Data.
- Dynamic HTML for making use of client-side processing and updating page information without needing a roundtrip to the server.
- ASP Active Server Pages
- COM components for packaging complex segments of the process into more modular and scalable sections.
- JavaScript for validation and client-side navigation logic, as well as sever-side ASP code.
- MTS Microsoft Transaction Server
- a queue-based approach (using the file system or a message queue server), for maximum scalability, reliability, response time as well as integration with other systems.
- a data-centric hierarchical storage and retrieval mechanism comprises the ability to store and retrieve hierarchically organized data. It includes both the format in which the data gets stored, as well as how to access the hierarchically organized data.
- Action Document A document that defines parameters for an action in the data-centric hierarchical storage and retrieval mechanism.
- a routing document contains a document and tracks actions executed on the document by the eAgents.
- An action can contain one or more processes that may or may not be executed by an eAgent.
- An eAgent is a software component that performs the action on the routing document and on the associated action document.
- a queue can be a folder, mailbox, queue server or any computing resource capable of queuing data.
- Code for facilitating a database encompasses the ability to set up, manipulate and/or maintain a database.
- Metadata or schema are data that describe the aspects of a form that change from form to form, excluding the exact (graphical) presentation. Examples will be provided below.
- chema and metaladata are used interchangeably in this application.
- the user of the present invention who wants to fill out a form only requires a browser capable of HTML 3.2 or other presentation language and basic CSS support, e.g. Internet Explorer 4.0 or above, Netscape Communicator 4.0 or above.
- Fig. 1 there is shown a block diagram of the forms creation system of the present invention.
- the individual components shown in this figure will be described, followed by a description of how these components are controlled using flowcharts of the software of the present invention.
- the specific XML vocabularies used will be covered in a later section, that will include a tree diagram, explanation and samples.
- Meta data or schema An important aspect of the present invention is the use of Meta data or schema.
- Metadata or schema are data that describe the aspects of a form that change from form to form, excluding the exact (graphical) presentation. Examples include but are not limited to
- HTML tags for display of input controls e.g.- ⁇ INPUT > , etc.
- the schema would be created by a forms designer and stored in a schema library 10.
- the schema library 10 provides the forms designer with the ability to reuse individual sections or fields or the entire schema in other forms. Any storage configuration may be utilized including remote and/or distributed storage accessible over a network, over the Internet, or in any other convenient fashion.
- the present invention in order to present the forms designer with a list of valid entries to populate form fields, provides the ability to gather the data for list/lookup from any ODBC/OLE DB compliant database, including SQL Server, Access,
- the present invention uses a query library 12 to store queries and only references them inside the native schema of the forms by the given name of the query. This results in the ability to have a central repository 12 of all database-related queries for ease in making changes and flexibility. Queries can be changed independently of the forms that are using them, and any saved changes take immediate effect.
- the queries themselves are defined using a specific XML vocabulary, and the connection information to the databases, in a preferred embodiment, is kept in Microsoft Data Link Files (udl files).
- the present invention stores the schema in the schema library 10 in both a native schema format and a compiled format.
- the schema includes one or more links to the query library at those sections of the form fields and sections that are to incorporate a particular query therein.
- the compiled schema format is also stored and incorporates the query itself, rather than a link to the query.
- Updating a given schema with changes made to one or more queries would typically be accomplished simply by recompiling the schema. Alternatively, the updating can also be programmed to be accomplished at runtime.
- a validation library of regular expressions 14 contains a list of regular expressions.
- 'Regular expressions' is a pattern matching technology, that allows for the comparison of an input string against a pattern (regular expression), and that evaluates whether the pattern is found in the input string.
- regular expression is given a user-friendly name and is called from the schema library 14 by the forms designer using that name.
- the regular expressions library 14 may conveniently store the regular expressions in XML or other convenient data-centric hierarchical storage and retrieval mechanism.
- the native schema stored at in the schema library 10 may include one or more links to regular expressions stored in the regular expressions library 14.
- the compiled schema stored in the schema library 10 would include the particular regular expression without the link to the regular expression library 14. Accordingly, regular expressions can be updated by one central change to the regular expression library 14, which change can be propagated through all of the schema in the schema library 10 using that regular expression simply by recompiling the particular schema. Templates
- a Template is a collection of files, that may include ASP, CSS, images and other convenient items, which define the layout of the page in which the forms using that template are rendered.
- the layout typically includes the company logo and a navigation bar to allow the user to navigate to other pages of the site, plus the look and feel of the page, including colors, fonts, positioning, and other aspects.
- the present invention enables leveraging the full power of ASP/HTML/CSS to format the page most ways that the forms designer may wish to display the form.
- the template files can be designed with any tool that can create ASP/HTML/CSS, including Front Page, Visual
- the templates that are created are stored in a template library 16.
- the present invention allows the forms designer to easily select a template from the template database 16 with which to associate a schema. Display and Navigation Engine Tasks
- Also included in the system is a display and navigation engine that performs the following tasks
- Forms extractor Performs validation logic that only allows submission of valid data and notifies users of errors and what needs to be corrected. Displays a preview page for user verification of entries. Page navigation to allow moving forward and backward, including ensuring that any entered data are saved (i.e., NEXT, PREVIOUS, SUBMIT). Saves the submitted form data and relevant schema into a queue (the preferred implementation uses file system as a queue).
- the display and navigation engine 18 there are two versions of the display and navigation engine 18.
- IE 5 Internet Explorer 5
- IE 5 Internet Explorer 5
- a substantial portion of the processing may take place on the client-side (browser).
- all the processing occurs on the server.
- Both versions share some components / component logic, while some parts are specific to each version.
- This preferred embodiment using two types of display and navigation engines is utilized in order to support a substantial number of browsers.
- the display and navigation engine for IE 5 and other similar type browsers use the client-side functionality to offload processing to the client and thereby obtain improved performance (no server round trips) and higher scalability (less server processing needed) .
- Internet Explorer 5 comes with sufficient support for the XML DOM (Data Object Model), XML data islands, XSL and DHTML (Dynamic HTML), which are used to implement a client-side version of the present invention. Future browsers that support these or comparable technologies will also support client-side processing.
- Forms Translator Current browsers have no standard way of displaying any XML or other data-centric hierarchical elements in a meaningful way.
- the present invention uses a forms translator in the display and navigation engine 18 to transform the XML forms into HTML forms.
- the forms translator in the present design, is implemented primarily as XSL style sheets.
- the Extensible Stylesheet Language (XSL) allows the transformation of XML into another form of XML, HTML or any other text based format.
- the forms translator maps in a standard fashion the relevant XML elements and attributes to HTML elements and attributes, and supports multiple controls, field level help, error messages.
- a control type is a reference to the XML representation of an HTML display type, such as text box or select. This approach allows the forms designer to define custom controls, such as a date picker control, which constitutes a composition of several simple controls.
- ⁇ sectionname > and ⁇ fieldname > are the name identifiers of the section/field.
- the server-side version uses the ASP Request object to retrieve the information entered, and using the naming convention above transfers the information into XML.
- the client-side version uses DHTML, in the preferred embodiment.
- the conversion to the data-centric hierarchical storage and retrieval mechanism may occur almost simultaneously with the data entry, or may occur periodically, or may conveniently occur when the user clicks NEXT.
- the present inventive approach allows the validation to work no matter what user interface has been chosen. This is accomplished via the display and navigation engine 18 by first converting the information from the display to the XML or other data-centric hierarchical storage and retrieval mechanism, and only then performing the validation on the XML converted data.
- the same source code (or the same logic) can be used by both the client and the server-side version of the validation software, and the present invention is able to support changes in the user interface without having to change the validation logic.
- the validation logic in the display and navigation engine 18 itself also does not communicate directly with the user interface once errors have been found. Instead it flags the erroneous field/section by including an error message inside the XML-converted data. This offers the advantage of being able to customize how the error message is displayed to the end user.
- the validation component functions to check every field for all validation rules defined and stops processing that field/section once/if the first error has been found.
- attribute-based validation Another key part about the validation is the ability to use attribute-based validation.
- attribute-based validation are “required,” “maxlength,” “minlength,” “minvalue,” “maxvalue,” and “pattern.” All that the forms designer needs to do is specify a value for that attribute, and the validation component will ensure that the validation is performed accordingly, and the display engine will ensure the error is communicated to the end user.
- Preview Page The preview page for the display and navigation engine 18 is simply a read only view of the caption and values of the fields entered by the end user.
- the current implementation of the innovation uses an XSL style sheet for the display.
- Page navigation on the client is handled by local Jscript in a preferred embodiment in order to implement the NEXT, PREVIOUS, AND SUBMIT commands.
- server-side version of the display and navigation engine 18 (for nonXML compatible browsers) needs to keep track of the current section being displayed to the user. This is accomplished by passing a section number as a hidden textbox for every display.
- Maintaining state The data entered by the end user is transferred into the XML document that contains the schema. For the client-side version of the present invention, there is no other problem associated with maintaining state.
- HTTP is a connection-less protocol.
- the solution used by the present invention is to store the
- XML converted data as a file with a unique identifier on the server, and to pass this unique identifier in a hidden textbox from page to page. In this way any previously entered data is available when navigating among pages.
- the typical action in prior art designs when an end user is submitting form data is to directly and synchronously act on the data, e.g., write to the database, send emails, etc.
- This approach results in the end user being required to wait until all these actions are completed, and in case of the database being offline, the user losing all of his/her data.
- the present invention instead uses a queue-based approach, where all data entered and relevant schema are simply written to a queue, and an acknowledgement is sent to the user for his/her submission.
- the client-side version i.e., compatible with XML or other data-centric hierarchical storage and retrieval mechanism
- Use Of XML in The present invention vl.O Programmatic Creation / Reading of XML files
- the present invention provides GUI tools to edit XML files.
- the XML files themselves are never directly exposed to the forms designer. Using this approach ensures the consistent, error-free creation of the relevant XML files and facilitates use by the forms designer.
- Server- and Client- side Flowcharts
- the following figures are intended to clarify the processes that are occurring within the server-side and client-side implementations of the present invention, while highlighting the differences.
- the differences are primarily due to how the memory and instruction control and execution is partitioned differently between the different implementations. Both have functionality required of the server and client but differ in where the primary processing occurs.
- Fig. 3 there is shown a schematic flow diagram of the present invention for the client-side implementation (XML or data-centric hierarchical storage and retrieval mechanism compatible browsers).
- > Server receives ASP or other standard page request.
- the server-side software processes the request at runtime. This encompasses: > Loading the schema.
- HTML page and all associated files (XML, XSL, CSS, JavaScript, images) have been loaded, set the first page to be the active page and call step C to display it.
- Step C The client-side runtime software calls XSL style sheets to the schema file to display the active page of the form. It is here where the schema of the form is converted to HTML.
- the conversion includes form/page/section headers and help text, as well as information regarding input fields. This includes captions, different HTML controls to capture input for them, required icons, error messages in case there have been any errors, etc.
- the transformation/conversion uses dynamic HTML to change the content of the page after it has been loaded or after an end user has navigated to a new page by clicking NEXT or preview. There is no need to roundtrip to the server.
- the client-side display and navigation software awaits the activation of a navigation control.
- the client-side runtime software transfers the entered data of the page into the schema, which resides as an XML island inside of the HTML page.
- validation is executed for all sections/fields of this transferred page.
- the outcome of the validation is documented inside the schema.
- Steps FI and F2 Page calculation: (Errors?/Last Page?) > If an error has been found, then step FI causes the same page to be displayed again (step C). Otherwise in step F2 it is checked whether it is the last page. If it is the last page, then a preview page is shown, (step G)
- preview is optional. If the preview is disabled for this form instance then the data gets submitted after the last page has been filled and the submit button activated.
- Step G If there is neither an error nor the last page, the active page is being set as requested, i.e. the next or previous one and then displayed (step C) > Step G:
- the information entered in the schema is transformed to an HTML preview page and displayed.
- Step H After having clicked NEXT/SUBMIT on the preview page, the XML schema is transformed into another XML document using an XSL style sheet for this purpose. This allows, for example, reducing the size by only including needed information, digitally signing the document or transforming into any other desired format.
- the transformed XML is sent to the server. This procedure of scaling down the size of the document (deleting items such as display-related attributes, such as the control type to use, the width of the control, and validation-related attributes, such as the isvalid flag and the errormessage attribute) is used to conserve bandwidth.
- the XML is received on the server and submitted to a message queue (e.g., the file system or MSMQ).
- a message queue e.g., the file system or MSMQ.
- Optional post-processing is executed.
- an acknowledgement is sent back to the browser.
- a redirection to the next form, home page or other page is done.
- Fig. 4 there is shown a schematic diagram of the execution flow for server-side processing that will be implemented if the browser is not compatible with a data- centric hierarchical storage and retrieval mechanism such as XML.
- the server receives a request from an end user browser.
- the runtime software loads and preprocesses the schema designated in the end user request file.
- the loading and preprocessing may be in a preferred embodiment, identical to the client- side version, including the optional initialization of the schema or initialization of the values by a custom ASP script, with the following exception:
- the schema gets saved to a temporary folder on the server.
- the active page is set to be the first page.
- the runtime software applies multiple XSL style sheets in the well-known manner to convert/transform the first page of the schema from XML to HTML.
- the transformation includes form/page/section headers and help text, as well as information regarding input fields. This includes captions, different HTML controls to capture input, required icons, error messages in case there have been any errors, etc.
- two hidden textboxes that contain the globally unique ID assigned to this form instance and the active page number. As noted earlier, this unique ID allows the server to keep track of which client called.
- the server sends the resulting HTML to the browser.
- the browser displays the page. Note: there is minimal or no runtime software on the client, i.e. no JavaScript, no XML nor XSL.
- the user may now fill in the values for the fields and use the navigation buttons.
- the server runtime software then transfers page values to the designated schema using the ASP Request object to read the incoming data and the XML DOM to write to the schema.
- the server runtime software then validates the received page values against all validation rules and updates the schema with any error information.
- the schema is then saved again on the server using a unique ID.
- Steps II and 12-Page calculation (Errors? / Last Page?)
- step II causes the same page to be displayed again (with the error messages). Otherwise, if it is the last page, then step 12 causes the preview to be shown (Step J). If it is not the last page, then step 12 causes the execution to update the active page number and displays that page (Step B). Note that the preview is optional. If the preview is disabled for this form instance then the data gets submitted after the last page has been filled and the submit button activated.
- the server runtime software then uses XSL style sheet to transform schema (with data) into HTML for the preview page, as well as adding hidden textboxes for globally unique ID and active page number.
- the server then sends the transformed HTML to the browser.
- Step L Browser displays preview page.
- step N The user then clicks PREVIOUS or NEXT/SUBMIT. If the user clicked NEXT/SUBMIT, then the browser sends to the server the globally unique ID and active page number in step M. > If the user did not click NEXT/SUBMIT, then the last data entry page is shown again (step B). Otherwise it goes to final processing (step N).
- the runtime software at the server then loads the saved schema using the globally unique ID.
- the XML schema is transformed into another (typically) reduced-size XML document using an XSL style sheet for this purpose. As noted previously, this conversion reduces the size of the document by only including needed information, digitally signing the document or transforming into any other desired format.
- the resulting schema is saved to the message queue.
- a post-processing script is executed.
- the runtime software then sends an acknowledgement and/or next form/page to the browser.
- eAgent tiered processing architecture of the present invention. It should be noted that this system architecture may be used independently of the forms creation and completion processing discussed earlier.
- one or more message queues 26 communicates with a queue abstraction layer 40.
- the queue abstraction layer 40 communicates with a queue manager 42, which, in turn, communicates with an eAgent manager 44.
- the eAgent manager 44 then communicates with an eAgent action coordinator 46.
- the eAgent action coordinator 46 provides communication among a plurality of eAgents 48-60.
- Each of these elements 40-46 is a configurable XML COM component. The functions performed by these components will be discussed below.
- the configuration provides a decoupled eAgent architecture in which action components can be added without having to recompile any code, stop and restart any services, or interrupt functionality in any way.
- Fig. 7 provides an execution flowchart for the architecture disclosed in Fig. 6. > Step A:
- the eAgent manager 44 loads and reads its configuration settings documents 45.
- the configuration settings on the documents 45 include which queues 26 it should communicate with, where selector files (to be discussed below) are located, how many retries to perform for each XML document, and other initialization information.
- the eAgent manager loads and caches selector XML documents 47 for later use.
- XML selector documents inform the eAgent Manager which action sets to perform for each XML document that it receives from the Inbox.
- the selectors use a content based selection using XSL patterns.
- the eAgent manager 44 instructs the Queue Manager 42 to poll an Inbox Queue 35 in the message queues 26 for XML documents.
- the Queue Manager 42 destructively reads the XML document, and copies the document from the queue to an In-Process Queue 34 and to a log queue 37. It then sends the XML document to the eAgent Manager 44. > Note that step B and C occur periodically.
- the eAgent manager 44 now tests the incoming XML document against each selector document 47 that has been loaded into the eAgent manager 44.
- a selector document 47 contains one or more XSL selector patterns that are associated with an Actionset ID. The test involves applying the XSL selector pattern(s) to the XML document and determining if any matches were found. If matches for one or more (as configured) XSL selector pattern were found, then an Actionset designated by an Actionset ID associated with the particular selector pattern will be executed (not in this step). . If no selector pattern matches are found, then it continues to step E2. If the eAgent Manager 44 finds one or more Actionset(s) JD's for Actionset(s) to execute, it continues to Step E. In addition, the eAgent Manager 44 creates a routing document, to which it attaches the incoming document. The purpose of the routing document is to provide tracking functionality of actions performed on the XML document, in addition to routing the document itself.
- Step E If an Actionset ID is found (i.e., a match to a selector pattern has been determined), then the eAgent Manager 44 instructs the eAgent Action Coordinator 46 to load an Actionset document 49 associated with the Actionset ID associated with the matched selector pattern in step D, and execute the actions specified in this Actionset document 49.
- Step E2 If an Actionset ID is found (i.e., a match to a selector pattern has been determined), then the eAgent Manager 44 instructs the eAgent Action Coordinator 46 to load an Actionset document 49 associated with the Actionset ID associated with the matched selector pattern in step D, and execute the actions specified in this Actionset document 49.
- Step E2 If an Actionset ID is found (i.e., a match to a selector pattern has been determined), then the eAgent Manager 44 instructs the eAgent Action Coordinator 46 to load an Actionset document 49 associated with the Actionset ID associated with the matched selector pattern in step D, and execute the actions specified in this Actionset document 49
- Step F The Actionset file 49 includes at least one action, with that action containing a ProgID or
- Step G the eAgent Action Coordinator 46 loads an eAgent (48-60) specified by a ProgID for the Actionset file 49 and instructs the eAgent to perform the relevant task by passing it to the associated document ID.
- Step G the eAgent Action Coordinator 46 loads an eAgent (48-60) specified by a ProgID for the Actionset file 49 and instructs the eAgent to perform the relevant task by passing it to the associated document ID.
- the loaded eAgent reads the action document associated with the specified action document ID (from the Actionset file 49) (each eAgent has its own type of associated Action document which tells it which internal methods to call for each action specified by the eAgent Action Coordinator 46), and performs the requested tasks.
- Actionset file 49 each eAgent has its own type of associated Action document which tells it which internal methods to call for each action specified by the eAgent Action Coordinator 46
- the eAgent coordinator 46 adds information to the routing document. Typically, this information will relate to the eAgent action, and may provide information on the completion or non-completion of the action by the eAgent. The information may also include a time-stamp for the time when the eAgent commenced its action, and a time-stamp for when the eAgent completed its action. This information may include results from the action performed by the eAgent. This information may be readable from the routing document by other eAgents. Note that the time-stamp information provides a time history of activity for tracking purposes.
- the eAgent Action Coordinator 46 informs the eAgent Manager 44 that the action was not successful and passes the routing document and the attached XML document to the eAgent Manager. It will also add information relating to this non-completion to the routing document noted above. • If the action was successful, the eAgent Action Coordinator adds this information to the routing document, and checks if this was the last action specified in the Actionset.
- step F is performed again for the next action in the Actionset.
- the eAgent Action Coordinator 46 checks if the current Actionset is the last Actionset specified in the original selector file for this XML document.
- the routing document will include information on whether all the Actionsets for this XML document were successful or not. • If the Actionsets were not successful, the eAgent Manager performs step II and either writes to the error queue 30 or the retry queue 31, depending on the eAgent manager configuration settings, and removes the document from the in- process queue 34.
- the eAgent Manager 44 performs step 12, i.e., it sends the routing document with the original document and pertinent information attached to a journal queue 32, and deletes the document from the in-process queue 34.
- Step 12 If the Actionsets were successful, the eAgent Manager sends the routing document to the Error Queue 30, or to the Retry Queue 31.
- the configuration settings read in step A specify how many times an action should be retried and how long to wait between each retry. This determines whether the eAgent Manager 44 sends the XML document to the Retry Queue 31 or the Error Queue 30.
- the eAgent Manager 44 also deletes the routing document from the In-Process Queue 34 since it is no longer in process. > Step 12: If the Actionsets were successful, the eAgent deletes the XML document form the In- Process Queue, and places it in the Journal Queue, indicating success (and logging the document for auditing purposes).
- each selector file includes one or more patterns, and will be triggered when one or more of these patterns are matched in the incoming document. The selection of which and how many patterns must be matched is determined by the processing designer.
- Each selector file includes only one Actionset (although Actionsets can be nested).
- Each Actionset includes one or more actions.
- Each action includes the designation of one eAgent ID and an action document ID. It should be noted that Actionsets may include branching commands, repetition commands, parallel execution commands, and time controlled execution commands.
- the present invention also encompasses a system shown in Fig. 20 for performing actions on documents in a computing environment.
- the system comprises a selector file database 300 containing a plurality of selector files, with each selector file including one or more patterns.
- the system further comprises an Actionset database 302 including a plurality of Actionsets, with each Actionset including one or more actions that reference an eAgent ID and an action document ID.
- Each selector file is associated with exactly one Actionset (but there may be nesting of Actionsets).
- the system further includes an eAgent specific action document database 304 containing a plurality of action documents that are specific to eAgents. Note that each Actionset is associated with at least one action document.
- the system may further include at least one creation module for creating and/or manipulating entries in one or more of the databases 300-304.
- the system may further comprise a processing component 306 programmed with code for allowing a designer to select at least one of the selector files from the selector file database 300, code for allowing the designer to select at least one of the Actionsets from the Actionset database 302, code for specifying at least one eAgent specific action document from the eAgent specific action document database 304, code for linking the specified selector file from the database 300 with the specified Actionset from the database 302, and code for linking the specified Actionset with the specified action document.
- a processing component 306 programmed with code for allowing a designer to select at least one of the selector files from the selector file database 300, code for allowing the designer to select at least one of the Actionsets from the Actionset database 302, code for specifying at least one eAgent specific action document from the eAgent specific action document database 304, code for linking the specified selector file from the database 300 with the specified Actionset from the database 302, and code for linking the specified Actionset with the specified action document.
- IDE integrated development environment
- n-tier architecture that allows sharing of both user interface and business components with centralized, dynamic configuration and automatic distribution. This is described in detail in the following sections.
- tiered architecture means that a component in a given tier can communicate with other components in the same tier or with components in immediately adjacent tiers only.
- Distributed - Accessing Files/XML documents over the Internet Accessing files/XML documents is performed using a file system abstraction layer 100, an ASP File System client implementation 102 and an ASP File System server implementation 104.
- the file system abstraction layer 100 is an interface that defines and contains common file manipulation functions, such as reading, writing and deleting files/documents.
- the ASP File System client implementation 102 implements an interface and communication between the file system abstraction layer 100 and the server implementation 104 using its own XML-based simple file access protocol (SFAP).
- SFAP includes the commands as defined in the file system abstraction layer in an XML format.
- the server implementation 104 performs actual file manipulation, e.g. reading a file and communicates with the client-side implementation 102 using the SFAP.
- the user i.e., the business components of the file system abstraction layer 100 can manipulate files/XML documents over the Internet simply by using the functions of the file system abstraction layer.
- N-tiers Presentation Host Tier - IDE host N-tiers Presentation Host Tier - IDE host.
- An IDE host tier 110 is shown in the figure defines an environment into which different user interface components (IDE components) can be plugged in.
- the host does not provide any end user functionality itself, but defines a standard set of interfaces for IDE components to implement, including a) A shared library of user interface and logic elements, including treeview, listview, toolbar controls. b) A consistent navigation system, regardless of the IDE component. c) A set of "standard actions," such as new/edit/delete d) Provision to supply custom controls. e) Ability to have varying number of IDE components hosted.
- the presentation host 110 includes code for reading any IDE component code and business logic component code that may be defined by an IDE configuration 107.
- the IDE configuration block 107 stores a file for each of a plurality of different roles, with the file for each different role including the ID's and other appropriate information for the components that are to be loaded into the computing resource or browser that is to perform that given role.
- the IDE components 108 implement the interfaces defined in the IDE host 110 and are the components that actually define the interactions with the end user, and include such IDE Components as eAgent Actions code, Form Schema code, Queries code, and Regular Expressions code. They do not include the business or application logic.
- the IDE components code is typically loaded to the browser or other computing resource by the presentation host 110.
- the IDE components 108 also typically have associated custom controls. Custom controls are required for the result pane of the window (right hand side of the IDE) if some other view than the listview is to be shown.
- the business components 106 implement the business rales/application logic for that component for its associated component 108 in the presentation controller tier.
- the logic for the select query component in the business logic tier might include a selectquery class with a method "checkifvalid" that checks if all necessary information has been provided and all data entered is valid.
- the logic for the form schema component in the business logic tier might include classes for the relationships between forms, pages, sections and fields, where these classes have attributes that describe the objects, such as a caption attribute of the field class.
- This tier includes code to allow the business component code to read and write information to/from a computing resource.
- the tier includes the file system abstraction layer 100, the file system client implementation 102, and the file system server implementation 104 described above.
- This tier includes an eAgent repository 105 which includes selector files/Actionset and eAgent specific action document databases, the schema library 10, the query library 12, the validation library (regular expressions) 14, and the IDE configuration 107. These repositories/libraries are where the actaal XML documents reside. This could be in the file system or in an XML database.
- the IDE host 110 allows the sharing among components 108 of common interface elements, such as toolbar, treeview and listview. In regards to the treeview, the IDE host 110 also creates a "virtual root" for each IDE component, so that each IDE component may only see and manipulate its part of the tree.
- Sharing of IDE components allows for a lower footprint, e.g., instead of five treeview controls, only one is used. Sharing of Business Components
- the IDE host 110 has the explicit facility of using business components 106 to implement the business logic of the IDE components and the ability to share them between different IDE components. As the exact same objects/instances are shared among different IDE components there are no synchronization delays. The instancing of business components is therefore not done inside the IDE components but instead from the IDE host.
- a configuration XML document that is located in the IDE configuration component 107 defines:
- the IDE host 110 uses this information to create instances of the business components in the proper order and passes them and the relevant configuration information to the IDE components 108, which in tarn pass the relevant information to their business component(s) 106.
- the IDE host may be componentized.
- the IDE host is actually made up itself of at least 3 different components; a control component, a communications and a configuration component.
- the configuration is centralized, i.e. it is set by the Web Server or other appropriate computing resource via the IDE configuration block 107 which lists the components that are to be loaded to a given browser or other computing resource to carry out a role. Thus, there is no need to do the configuration on each client machine. This is because the configuration XML document resides on the Web Server in the IDE configuration block 107.
- any given browser or other computing resource is dynamic, i.e., the IDE host 110 does not need to be recompiled if more or less IDE components are to be loaded.
- the number of IDE (and business) components to load is determined at runtime/startup.
- an integrated development environment method comprising the steps of: loading onto a computer resource code in a tiered architecture comprising: a presentation host tier that includes presentation host code, the presentation host code including shared user interface and logic code components, code for reading a IDE configuration, and code for loading any IDE component code and business logic components code as defined in the IDE configuration; an IDE component tier, including at least one IDE component code loaded by the presentation host on the user- interface program, the IDE component code including a user interface; a business logic component tier, including at least one business logic component code loaded by the presentation host on the user-interface program, the business logic component code defining the interrelationships between objects represented in the user interface; a data access abstraction layer tier, including a data access abstraction layer code that allows business components code to read and write information to/from a computing resource; and communicating with a remote computing resource through use of the data access abstraction layer.
- Fig. 5 and Fig. 21 there is shown a workflow diagram for a forms publishing process and a schematic diagram of the IDE - server operation, respectively.
- the process is as follows:
- execution block 200 After saving a new form in execution block 200, the user is prompted in execution block 202 to publish to the web or other location. If he chooses yes, then the publishing process is initiated
- Step B The publishing wizard starts up and requests a list of templates from the "publish. asp" page. Note: this file can be named differently. Step B:
- the "publish. asp” page reads the content from templates. xml and sends the list of available templates via the publishing wizard.
- the publishing wizard presents the templates and after the user has chosen one, requests template specific questions and a list of available publishing folders from "publish. asp"
- the publishing wizard presents the template specific questions, collects the answers, presents the available publishing folders and lets the user select one.
- the user may give the published form a name and caption; the default is the name and caption of the schema.
- the "publish. asp” page packages all of the needed information into one XML document and sends it for processing. This may be synchronous as shown in the diagram, or asynchronous via a queue.
- Step G The publishing component copies (processed) template items in selected publishing folder for later display.
- Fig. 9 shows a forms schema.
- Fig. 10 shows a regular expressions schema.
- Fig. 11 Shows a select query schema.
- Figs. 12 and 13 show template schema.
- Fig. 14 shows a publishfolders schema.
- Fig. 15 shows an IDE configuration schema.
- Fig. 16 shows an XML selector schema.
- Fig. 17 shows an Actionset schema.
- Fig. 18 shows an action Query eAgent schema.
- Fig. 19 shows a Queue Config schema.
- the various element/attribute descriptions are listed below. Note: bold-faced items denote XML elements, non-bold-faced items denote XML attributes.
- Form Templates-Purpose The purpose of form templates is to have a separate repository for the look and feel of the HTML pages in which the forms will be displayed.
- Sample Folder Structure nflibrary nflibrary
- Main.asp (required file, must be there and must have that name)
- CS.ASP SS.ASP template. xml (required file, must be there and must have that name)
- a templateitem is one that needs to be copied.
- the name of the publishingfolder, where the ASP pages will be copied to, is provided by the publish.
- ASP page (the publishingfolder is the one where main. asp and all other relevant items will be copied to)
- name of the template is provided by user (earlier on)
- ASP page / form e.g. Leave. ASP
- the name of the resulting ASP page / form is provided by the end user. It does not however have to be put into the template, because this is always needed.
- Initiation 1 the user saves the form. The user will be prompted to start the publishing wizard. If yes is selected then the wizard is started. 2. User selects the form and chooses "publish to web.”
- Step 1 Present list of templates to user. User selects one.
- Step 2 If there are any parameters, present corresponding questions and let user enter them one by one.
- Step 3 If there is more than one publishing folder, present list of publishing folders.
- Step 4 Display name of the resulting form. (Default to name of schema). User clicks Publish. Note: the path to "publish. asp" is set in the config file and can also be called a different name.
- folder attribute should not be sent to the client to hide this information (e.g. use database later on instead of folders)
- the processing is implemented right away in a synchronous manner.
- this will not always be the case, e.g., when the publishing needs to be reviewed and approved before it may be published. In this case it would first get passed to the authorizing person, and only when approved would the actaal publishing be performed.
- all of the data that is required for the actaal processing of the publication is put into one XML document and passed to a "publish" function. This will allow the publishing process to remain identical when there is a switch to asynchronous processing.
- the processing that then takes place first scans and then copies the "Main.ASP" file, and then any other templateitems, and creates subfolder s as needed.
- the present invention is a unique product, which includes a rich Integrated Development Environment (IDE), and a powerful runtime environment.
- IDE Integrated Development Environment
- the invention allows users to create powerful web based applications using, by way of example, a 4GL Rapid Application Development (RAD) environment.
- RAD 4GL Rapid Application Development
- the invention is unique in a variety of important aspects which include the following:
- GUI hierarchical graphical user interface
- One aspect of the invention is the ease of creation AND maintenance of applications, and allows for easy reuse of form pages/sections/elements metadata, and presentation information as well as easy maintenance of these items.
- One aspect of the invention focuses on complete separation of tiers in every aspect of the product. This is done to enable independent creation and maintenance of distinctly separate parts of an application. It allows non-technical people to develop the metadata of web based applications, leaving a minimal amount of work for the web developers (templates and regular expressions) and the database developers (database queries).
- each of the following is stored in a different XML document and is accessed from different tools in the IDE. Each can therefore be performed by different people, and can be maintained separately:
- the invention uses two different presentations of the same metadata to support XML- enabled browsers and non-XML-enabled browsers without any additional development effort by users of the program.
- XML-enabled browsers perform most processing on the client and, due to less roundtrips to the server, have greatly improved response times.
- the invention uses a queue-based n-tier architectare to increase scalability and reliability.
- the invention uses the eAgent Architectare on the back end to perform multiple scalable and customizable actions and work flows using data obtained from the Invention applications.
- the Inventive Integrated Development Environment allows users to quickly create and maintain web-based applications.
- the IDE uses a Microsoft Management Console- style interface in one embodiment with a tree view representing the form applications, queries, regular expressions and eAgents.
- the IDE architecture is unique. i) The User Interface configuration for individual users is stored in an XML file.
- This information specifies which parts of the IDE to load at run time (for example, the configuration file can specify that only the Forms designer part of the IDE should be loaded, and leaving the Regular Expression, Queries, and eAgent sections out of the IDE for that user. ii) Substantially only Form schema is stored in a unique XML file
- the design stores substantially only the metadata/schema in the XML file used to represent the form.
- the presentation data is separately stored in a combination of CSS (cascading style sheet), XSL, and ASP files.
- ASP files are used to store the 'templates' of one or more forms, and these templates form the surrounding graphical presentation of the form.
- CSS files and XSL files are used to convert the XML metadata to HTML for presentation. The advantage of this is that it is very easy to change the entire look and feel of a form. This can be done without touching the
- XML metadata file b) Graphic User Interface i) The IDE runs over the web or a network - i.e. users can develop forms remotely. ii) The IDE determines which components of the IDE should be loaded at runtime.
- Actions (eAgent actions such as emailing form data and inserting data into the database
- Action Queries database action queries such as insert, update and delete
- Actions/eAgent section iii A method is provided to create a form using a hierarchy of icons with attributes. Each form/application is represented as an icon with attributes. The attributes allow the user to specify the following:
- Each form page is represented as an icon one level below the form icon in the IDE tree view.
- the page attributes allow the user to specify the following:
- Section level validation Each section element is represented as an icon under the section icon.
- the section element attributes allow the user to specify the following: the location of the element within the section element's name and caption a valid example of what a user can fill in for this element the maximum length of this element whether this element has a list or not a default value for this element help text for this element whether the element is required (must the user complete this element in order to submit the form?) the data type of the element (int, float, etc.)
- Database queries are used to populate dynamic pull-down menu choices on the form.
- the database queries are stored in the metadata/schema that describes the form.
- Database queries are defined in a separate section of the IDE and stored in separate XML files. database queries can be pre-processed (run at design time) - i.e. the results stored in the metadata/schema document that describes the form.
- the list is not populated from the database, the list values to be used for this list. • Whether the control used for this element should be displayed on a new row or not.
- a method is provided to publish forms to the web using a wizard which lists predefined templates and allows a user to select a template for the form, as well as a folder location for the form.
- the basic task of the publishing wizard is to create ASP pages and associated files in a publishing folder that associates/links a form schema with a template.
- Template files may have custom parameters/questions that are displayed inside the publishing wizard which allows for flexible on-the fly customization of templates just by answering the questions inside the publishing wizard.
- a method is provided to save, create, test and retrieve regular expressions using XML files for storage and retrieval.
- Each Regular Expression may be a set of ASCII characters that describes valid inputs
- the IDE allows users to import Regular Expressions from an outside data file • This will allow the sales of Regular Expressions on the Web or network and their seamless incorporation into the IDE.
- Database queries may be represented as icons in the GUI
- Each Database Query is a custom SQL query that is able to interact with relational databases.
- Database connections are described separately - allowing the Database Query to be directed at multiple databases.
- the database could be MS Access, MS SQL Server, Oracle, or other database - the user does not need to specify beforehand and can switch at any time without affecting the form.
- a method is provided to store and retrieve form elements and form sections in a library. For example:
- the Invention Runtime Environment is a highly scalable, maintainable, and reliable runtime environment that uses data created using the IDE or by other means to serve sophisticated web based applications to users with both XML-compatible and non-XML-compatible browsers. a) Runtime Environment Architecture
- the Invention runtime environment is unique and includes a variety of aspects including: i) A method to serve two or more distinct versions of the form/application using only one form/application description file.
- the design automatically creates and maintains two versions of each application using only one form in the IDE.
- This version includes sending the schema XML file, and any XSL files, CSS files, and JavaScript files for navigation and validation to the browser for processing.
- a method is provided (folder architectare) to store web files for ultimate ease of maintainability and reuse of application.
- An important aspect is the fact that the final form files can have minimal size (less than 10 lines) because of the fact that they only have the values that differentiate them from other forms and LINKS to both a form schema and a template.
- What makes this possible is the combination of a standardized folder structure with Server-Side Includes (SSI) that use absolute paths.
- SSI are a programmatic construct of Active Server Pages that allow the inclusion of content from another file into the existing file at the server.
- the advantage of this approach is the ability to change both the schema and the look and feel independently both at the time of creation and after the form has been published. There is no need to republish the form for these changes take effect; they take immediate effect.
- n:m relationship between a template and a schema i.e., one template can be used with multiple schemas and one schema can be used with multiple templates.
- a company can have a standardized look and feel defined for all its forms or a subset of them, and easily associate schemas with this template. If the company wishes to change the standardized look and feel, e.g., the name and logo of the company changed, the change has to be done only in the template and takes immediate effect for all the forms that are associated with this template.
- An application service provider may develop and sell a set of standardized schemas for work processes.
- Several companies/customers may wish to use these standardized schemas, however they may wish to have their own look and feel with the schemas.
- the ASP provides customized templates for each customer, and associates the resulting forms with the customized templates and the standard schemas. If there is a need to change the schema, e.g., another field is required, then the ASP only needs to change the standardized schema and the change takes immediate effect for all forms that link to this standardized schema.
- a further aspect of the invention is the eAgent architecture. It uses a set of COM components and configurable XML files in a preferred embodiment to determine appropriate actions, and to perform these actions for each XML document received in the queue system. Some of the important aspects include: i) Pattern-content based selection of actions to be performed - an eAgent manager determines which Actionset to perform by searching each incoming XML document for previously cached XSL patterns. Using XSL patterns, a component (the eAgent Manager) determines the type of each incoming XML document, and determines which Actionset to perform based on the type of XML document involved. The component knows which patterns to search for based on the cached XML selector documents.
- a hot-pluggable eAgent component architecture An architecture in which 'action' components can be added without having to recompile any code, stop and restart any services, or interrupt the functionality in any way. More eAgents (with corresponding action files) can be added to the system at any time without interruption. All that is needed is that any Actionset file which will utilize the new eAgent be updated with the new ProgID of the eAgent, and which actions to perform. Since Actionset files are XML documents, this does not require the stopping and starting or recompiling of any code or code components.
- a business rules system which is changeable at run-time (without interrupting normal operation) - the eAgent architectare includes several components that implement the system business rules or work flow. These are the eAgent Manager, the eAgent Action Coordinator, and the eAgents, in a tiered architecture. However, the business rules themselves are defined in XML documents which can be changed without recompiling any code, and in fact can be changed during run-time. (Prior art systems typically would at the very least require the system to be stopped and restarted, and in many cases a complete recompile of the code would be required).
- a decoupled action set system The eAgents in the system are self aware only.
- the eAgent Action Coordinator calls an eAgent function and passes the eAgent a copy of the routing document, which incorporates both the incoming XML document and the results of execution from previous eAgents. It receives back the result of the processing as an XML document/element, which it adds to a routing document attached to the original XML document, before passing the original XML document and the routing document to the next eAgent specified in the Actionset.
- Another advantage of this is that there is no possibility for an eAgent to corrupt the original message. But more importantly, eAgents need not be designed to work in tandem with any other code or components other than the eAgent Action Coordinator.
- Action-Query eAgent
- the Action-Query eAgent allows the system to insert, update and delete data in any ODBC and/or OLE DB compatible database.
- the data from the incoming XML document can be mapped to fields in the database tables.
- the mapping is defined in Action-Query documents and the eAgent uses this and the incoming
- XML document to insert, update and/or delete data in the database.
- the schema eAgent allows the system to automatically create and update database tables and action queries based on the incoming XML document. Using this automation facility radically simplifies the development of XML to database mapping.
- the PDF eAgent populates an empty PDF form template with data from the incoming XML document.
- the PDF eAgent action document defines the template to use and other relevant parameters.
- a naming convention is used to map the information from the incoming XML document to the fields inside the PDF form template.
- the eMail eAgent allows the system to send eMails to multiple recipients with a subject, a body, and zero or more attachments.
- the eMail eAgent action document constitates the template for the eMail, and is used in coordination with the incoming XML document to construct the eMail.
- the script eAgent allows an ActiveScript, such as one written in VBScript,
- JavaScript or Perl to perform any action on the incoming XML document.
- these scripts have access to COM components on the system, including the database, file system, eMail and other components, these scripts offer an enormous amount of flexibility.
- the access to the incoming XML document is simplified by providing an object model for the script to use.
- the time for processing of "request for leave” forms must be improved.
- the HR manager wants to be immediately notified of new requests for leave. S/he also wants a database of all requests so s/he can view leave-related reports. In addition, due to company policies, s/he also needs the requests in writing, signed by the person requesting the leave. Ideally, the data should only be entered once.
- the form "Request For Leave” is filled out in the browser by the person requesting the leave.
- the request for leave application (XML document) is submitted to a queue.
- the queue manager 42 picks it up from the queue and passes it on to the eAgent manager 44, which determines the corresponding Actionset.
- the Actionset encompasses four actions:
- the first action is passed to the Action-Query eAgent with the document ID of "insertLeave".
- the Action-Query eAgent reads the action document and then inserts the relevant data from the XML document into the database and returns execution to the eAgent Action Coordinator 46, indicating that it has successfully completed it's task. In this way, all requests are recorded in a database which can be utilized for analysis and reporting purposes.
- the eAgent Action Coordinator 46 then calls the PDF eAgent with the "leave" action ID.
- the PDF eAgent reads the action document, finds the location and parameters of the PDF form template and using a naming convention, fills all fields in the template with the corresponding parts of the XML document and saves the resulting PDF document. In addition to returning a success code, it documents the location of this PDF document in the routing document for later use.
- the third action involves sending the person who submitted the leave request an eMail with the PDF document as an attachment that was created in the previous action.
- the eMail eAgent is called with the "leaveAck" action document ID.
- the eMail eAgent loads this action document and constructs an eMail, which contains the person who submitted the leave request as a recipient and contains the PDF form as an attachment.
- the eMail eAgent then sends this eMail to the person requesting the leave.
- that person can then print out the PDF form, sign it and pass it on to the HR department. There is no need to enter the data a second time.
- the eAgent returns a success code to the eAgent Action coordinator 46.
- the fourth action involves sending the HR manager an eMail.
- the eMail eAgent is called by the eAgent Action Coordinator 46 with the "leaveHR" action document ID.
- the eMail eAgent reads the action document and constructs and sends the eMail to the HR manager.
- the eAgent tiered configuration described as one aspect of the present Invention, possesses the unique capability to provide an unlimited volume and variety of lowest-cost transactions between any vendor and any supplier, through an online transaction clearinghouse.
- this aspect of the present invention fulfills a specific niche that has not, until now, been successfully addressed.
- this aspect of the invention allows the receipt and processing of intelligent business-to-business (b2b) transaction and workflow instructions, including purchase orders, payment and fulfillment instructions, and price and inventory requests.
- b2b business-to-business
- This aspect of the present invention facilitates seamlessly integrating all transactions, and will guarantee the distribution of correct transaction instructions, regardless of the ERP systems, legacy systems, or databases used by suppliers and merchants involved in the transaction.
- the online transaction clearinghouse facilitated by the present invention is a complete supply-side transaction solution designed to maximize accessibility, reliability, responsive service and speed of fulfillment.
- E-commerce Web sites and/or Forms web sites will send secure, XML-formatted transactions to a global array of Message Queue (MQ) Servers, all poised to capture each e-commerce transaction and forward it to the closest facility. If one MQ Server goes off-line, any of the others will step in to seamlessly take its place.
- MQ Message Queue
- the Business Rules Package The E-commerce Web site' transaction instructions and Forms environment will contain business rules, in addition to the basic transaction that will be executed using the described eAgent workflow engine.
- This aspect of the Invention will use the eAgent architectare to transfer orders and data requests (such as status of order) to a merchant's back-end system and receive information, as appropriate.
- This e-commerce aspect of the present Invention is the only solution to fully address all four major sources of transaction costs:
- the asynchronous systems architecture and intelligent eAgent technology of this e- commerce aspect of the invention together provide an unlimited capacity to receive, store and process information. This unique combination of capabilities engenders near- zero marginal quantitative and qualitative costs of new transactions.
- This e-commerce aspect of the Invention assures transaction reliability, on-time payment and low charge-back rates.
- This e-commerce aspect of the present invention provides timely market intelligence and an online adjustable 'smart' business logic vehicle, which combine to enable instant reactions to market fluctuations.
- This e-commerce aspect of the present Invention drives transaction services and buyer- supplier relationships toward perfect competition, continually reducing the 'asset specificity' portion of the transaction cost.
- This e-commerce aspect of the Invention enables enterprises to create a universally accessible value web of increasingly complex, interlocking products and cross-selling arrangements.
- Intranet/Internet without the need to have any know-how in the areas of HTML/ASP/XML/XSL/CSS/Regular Expressions/JavaScript etc.
- the present Invention can be developed and deployed by non-programmers in a short period of time, and over the Internet or over a network. Changes to forms (maintenance) can be made even more quickly than form creation (again over the Internet).
- the present invention supports all of the major browsers and is highly scalable, fast and maintainable. And, by having the submitted data available as XML, the results can be easily integrated into any other system. Before the present invention, developing online forms with fields, validation, a preview page, and separate versions for IE5.0 and Netscape would have taken a fully qualified programmer several weeks. Maintaining such an application would have taken the same programmer far longer.
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Health & Medical Sciences (AREA)
- Artificial Intelligence (AREA)
- Audiology, Speech & Language Pathology (AREA)
- Computational Linguistics (AREA)
- General Health & Medical Sciences (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
- Management, Administration, Business Operations System, And Electronic Commerce (AREA)
Abstract
Description
Claims
Priority Applications (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
AU14881/01A AU1488101A (en) | 1999-11-19 | 2000-11-15 | Forms creation method and e-commerce method |
Applications Claiming Priority (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US44337899A | 1999-11-19 | 1999-11-19 | |
US09/443,378 | 1999-11-19 |
Publications (3)
Publication Number | Publication Date |
---|---|
WO2001037170A2 WO2001037170A2 (en) | 2001-05-25 |
WO2001037170A3 WO2001037170A3 (en) | 2002-02-28 |
WO2001037170A9 true WO2001037170A9 (en) | 2002-03-28 |
Family
ID=23760560
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
PCT/US2000/031221 WO2001037170A2 (en) | 1999-11-19 | 2000-11-15 | Forms creation method and e-commerce method |
Country Status (2)
Country | Link |
---|---|
AU (1) | AU1488101A (en) |
WO (1) | WO2001037170A2 (en) |
Cited By (1)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20130067321A1 (en) * | 2003-12-19 | 2013-03-14 | Emergis Inc. | Method and system for creating and providing a multi-tier networked service |
Families Citing this family (32)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20050119992A1 (en) | 1995-05-19 | 2005-06-02 | Martino Rocco L. | Telephone/transaction entry device and system for entering transaction data into databases |
US6973477B1 (en) | 1995-05-19 | 2005-12-06 | Cyberfone Technologies, Inc. | System for securely communicating amongst client computer systems |
US7334024B2 (en) | 1995-05-19 | 2008-02-19 | Cyberfone Technologies, Inc | System for transmission of voice and data over the same communications line |
US7770102B1 (en) | 2000-06-06 | 2010-08-03 | Microsoft Corporation | Method and system for semantically labeling strings and providing actions based on semantically labeled strings |
US7712024B2 (en) | 2000-06-06 | 2010-05-04 | Microsoft Corporation | Application program interfaces for semantically labeling strings and providing actions based on semantically labeled strings |
US7716163B2 (en) | 2000-06-06 | 2010-05-11 | Microsoft Corporation | Method and system for defining semantic categories and actions |
US7788602B2 (en) | 2000-06-06 | 2010-08-31 | Microsoft Corporation | Method and system for providing restricted actions for recognized semantic categories |
US7778816B2 (en) | 2001-04-24 | 2010-08-17 | Microsoft Corporation | Method and system for applying input mode bias |
US7707496B1 (en) | 2002-05-09 | 2010-04-27 | Microsoft Corporation | Method, system, and apparatus for converting dates between calendars and languages based upon semantically labeled strings |
US7742048B1 (en) | 2002-05-23 | 2010-06-22 | Microsoft Corporation | Method, system, and apparatus for converting numbers based upon semantically labeled strings |
US7707024B2 (en) | 2002-05-23 | 2010-04-27 | Microsoft Corporation | Method, system, and apparatus for converting currency values based upon semantically labeled strings |
US7827546B1 (en) | 2002-06-05 | 2010-11-02 | Microsoft Corporation | Mechanism for downloading software components from a remote source for use by a local software application |
US7356537B2 (en) * | 2002-06-06 | 2008-04-08 | Microsoft Corporation | Providing contextually sensitive tools and help content in computer-generated documents |
US7716676B2 (en) | 2002-06-25 | 2010-05-11 | Microsoft Corporation | System and method for issuing a message to a program |
US7209915B1 (en) | 2002-06-28 | 2007-04-24 | Microsoft Corporation | Method, system and apparatus for routing a query to one or more providers |
EP1387291A3 (en) | 2002-07-30 | 2005-10-19 | Canon Kabushiki Kaisha | Apparatus, method, recording medium and program for form processing |
US7783614B2 (en) | 2003-02-13 | 2010-08-24 | Microsoft Corporation | Linking elements of a document to corresponding fields, queries and/or procedures in a database |
US7711550B1 (en) | 2003-04-29 | 2010-05-04 | Microsoft Corporation | Methods and system for recognizing names in a computer-generated document and for providing helpful actions associated with recognized names |
US7739588B2 (en) | 2003-06-27 | 2010-06-15 | Microsoft Corporation | Leveraging markup language data for semantically labeling text strings and data and for providing actions based on semantically labeled text strings and data |
JP2005032047A (en) * | 2003-07-08 | 2005-02-03 | Yoshihide Kobayashi | Device, method, program and storage medium for automatically generating file |
US7464331B2 (en) | 2003-08-18 | 2008-12-09 | Microsoft Corporation | System and method for validating hierarchically-organized messages |
US7747940B2 (en) * | 2004-07-30 | 2010-06-29 | Barclays Capital Inc. | System and method for data collection and processing |
CN1835507A (en) | 2005-03-17 | 2006-09-20 | 国际商业机器公司 | Method for the server side processing of user interactions with a web-browser |
US7992085B2 (en) | 2005-09-26 | 2011-08-02 | Microsoft Corporation | Lightweight reference user interface |
US7788590B2 (en) | 2005-09-26 | 2010-08-31 | Microsoft Corporation | Lightweight reference user interface |
GB0807296D0 (en) | 2008-04-22 | 2008-05-28 | Thunderhead Ltd | Template author and method of driving data capture in document templates |
US8887078B2 (en) | 2010-12-13 | 2014-11-11 | Microsoft Corporation | Configuration of custom controls in data-driven environments |
US9971849B2 (en) * | 2011-09-29 | 2018-05-15 | International Business Machines Corporation | Method and system for retrieving legal data for user interface form generation by merging syntactic and semantic contraints |
EP3329366B1 (en) * | 2015-07-31 | 2021-07-07 | WiseTech Global Limited | Systems and methods for executable content and executable content flow creation |
CN105468355B (en) * | 2015-11-13 | 2018-09-28 | 上海斐讯数据通信技术有限公司 | Realization method and system of the WEB management platforms under MVC pattern |
CN111241089B (en) * | 2019-10-11 | 2023-03-24 | 上海海典软件股份有限公司 | ERP system secondary development method, system, device and readable storage medium |
US12039349B1 (en) * | 2023-04-28 | 2024-07-16 | Paypal, Inc. | Artificial intelligence (AI) engine for dynamic content distribution and management |
Family Cites Families (7)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
EP0481784B1 (en) * | 1990-10-19 | 1997-05-28 | Moore Business Forms, Inc. | Form automation system |
US5283856A (en) * | 1991-10-04 | 1994-02-01 | Beyond, Inc. | Event-driven rule-based messaging system |
IL110811A0 (en) * | 1993-09-07 | 1994-11-11 | Jetform Corp | Electronic forms generation system and method |
EP0702294A3 (en) * | 1994-09-13 | 1997-05-02 | Sun Microsystems Inc | Method and apparatus for diagnosing lexical errors |
US5913214A (en) * | 1996-05-30 | 1999-06-15 | Massachusetts Inst Technology | Data extraction from world wide web pages |
US5995756A (en) * | 1997-02-14 | 1999-11-30 | Inprise Corporation | System for internet-based delivery of computer applications |
US6023684A (en) * | 1997-10-01 | 2000-02-08 | Security First Technologies, Inc. | Three tier financial transaction system with cache memory |
-
2000
- 2000-11-15 AU AU14881/01A patent/AU1488101A/en not_active Abandoned
- 2000-11-15 WO PCT/US2000/031221 patent/WO2001037170A2/en active Application Filing
Cited By (1)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20130067321A1 (en) * | 2003-12-19 | 2013-03-14 | Emergis Inc. | Method and system for creating and providing a multi-tier networked service |
Also Published As
Publication number | Publication date |
---|---|
WO2001037170A3 (en) | 2002-02-28 |
WO2001037170A2 (en) | 2001-05-25 |
AU1488101A (en) | 2001-05-30 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
WO2001037170A9 (en) | Forms creation method and e-commerce method | |
US6990636B2 (en) | Enterprise workflow screen based navigational process tool system and method | |
US7979377B2 (en) | Method and system of deploying server-based applications | |
US6356920B1 (en) | Dynamic, hierarchical data exchange system | |
US7007266B1 (en) | Method and software system for modularizing software components for business transaction applications | |
US6560633B1 (en) | Method for creating network services by transforming an XML runtime model in response to an iterative input process | |
US6718515B1 (en) | Method of populating a dynamic HTML table from a set of data objects through a common interface | |
US6418400B1 (en) | Representation and processing of EDI mapping templates | |
US6662199B1 (en) | Method and apparatus for customized hosted applications | |
US6016394A (en) | Method and system for database application software creation requiring minimal programming | |
US7013289B2 (en) | Global electronic commerce system | |
US6744447B2 (en) | Method and system for compiling and using placebot agents for automatically accessing, processing, and managing the data in a place | |
US9122669B2 (en) | Flat schema integrated document oriented templates | |
US6950981B2 (en) | Method and system for providing task information in a place | |
US20050165829A1 (en) | Systems, Methods and Computer Program Products for Developing Enterprise Software Applications | |
US20100251143A1 (en) | Method, system and computer program for creating and editing a website | |
US20070288501A1 (en) | Method and system for importing HTML forms | |
US20080086736A1 (en) | Information messaging and collaboration system | |
US20060074967A1 (en) | Visual query modeling for configurable patterns | |
US8126937B2 (en) | Visual database modeling | |
US20040187090A1 (en) | Method and system for creating interactive software | |
US20100161558A1 (en) | Computer-based data processing system and method of processing data objects | |
US20100057760A1 (en) | Generic data retrieval | |
US20110246535A1 (en) | Apparatus and Method for Constructing Data Applications in an Unstructured Data Environment | |
US20040111424A1 (en) | Data-driven web application generator and server |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
AK | Designated states |
Kind code of ref document: A2 Designated state(s): AE AG AL AM AT AU AZ BA BB BG BR BY BZ CA CH CN CR CU CZ DE DK DM DZ EE ES FI GB GD GE GH GM HR HU ID IL IN IS JP KE KG KP KR KZ LC LK LR LS LT LU LV MA MD MG MK MN MW MX MZ NO NZ PL PT RO RU SD SE SG SI SK SL TJ TM TR TT TZ UA UG US UZ VN YU ZA ZW |
|
AL | Designated countries for regional patents |
Kind code of ref document: A2 Designated state(s): GH GM KE LS MW MZ SD SL SZ TZ UG ZW AM AZ BY KG KZ MD RU TJ TM AT BE CH CY DE DK ES FI FR GB GR IE IT LU MC NL PT SE TR BF BJ CF CG CI CM GA GN GW ML MR NE SN TD TG |
|
121 | Ep: the epo has been informed by wipo that ep was designated in this application | ||
DFPE | Request for preliminary examination filed prior to expiration of 19th month from priority date (pct application filed before 20040101) | ||
AK | Designated states |
Kind code of ref document: A3 Designated state(s): AE AG AL AM AT AU AZ BA BB BG BR BY BZ CA CH CN CR CU CZ DE DK DM DZ EE ES FI GB GD GE GH GM HR HU ID IL IN IS JP KE KG KP KR KZ LC LK LR LS LT LU LV MA MD MG MK MN MW MX MZ NO NZ PL PT RO RU SD SE SG SI SK SL TJ TM TR TT TZ UA UG US UZ VN YU ZA ZW |
|
AL | Designated countries for regional patents |
Kind code of ref document: A3 Designated state(s): GH GM KE LS MW MZ SD SL SZ TZ UG ZW AM AZ BY KG KZ MD RU TJ TM AT BE CH CY DE DK ES FI FR GB GR IE IT LU MC NL PT SE TR BF BJ CF CG CI CM GA GN GW ML MR NE SN TD TG |
|
AK | Designated states |
Kind code of ref document: C2 Designated state(s): AE AG AL AM AT AU AZ BA BB BG BR BY BZ CA CH CN CR CU CZ DE DK DM DZ EE ES FI GB GD GE GH GM HR HU ID IL IN IS JP KE KG KP KR KZ LC LK LR LS LT LU LV MA MD MG MK MN MW MX MZ NO NZ PL PT RO RU SD SE SG SI SK SL TJ TM TR TT TZ UA UG US UZ VN YU ZA ZW |
|
AL | Designated countries for regional patents |
Kind code of ref document: C2 Designated state(s): GH GM KE LS MW MZ SD SL SZ TZ UG ZW AM AZ BY KG KZ MD RU TJ TM AT BE CH CY DE DK ES FI FR GB GR IE IT LU MC NL PT SE TR BF BJ CF CG CI CM GA GN GW ML MR NE SN TD TG |
|
COP | Corrected version of pamphlet |
Free format text: PAGES 1-59, DESCRIPTION, REPLACED BY NEW PAGES 1-55; PAGES 60-76, CLAIMS, REPLACED BY NEW PAGES 56-71; PAGES 1/21-21/21, DRAWINGS, REPLACED BY NEW PAGES 1/17-17/17; DUE TO LATE TRANSMITTAL BY THE RECEIVING OFFICE |
|
REG | Reference to national code |
Ref country code: DE Ref legal event code: 8642 |
|
122 | Ep: pct application non-entry in european phase |