Method and apparatus for web-based, schema-driven application-server and client-interface package using a generalized, data-object format and asynchronous communication methods without the use of a markup language.

• US 20060047780A1
• Filed: 11/08/2005
• Published: 03/02/2006
• Est. Priority Date: 11/08/2005
• Status: Abandoned Application

• Current Assignee: Gregory Patnude
• Original Assignee: Gregory Patnude
• Inventors: Patnude, Gregory Philip
• Application Number:
  US11/164,051
• Publication Number:
  US 20060047780A1
• Time in Patent Office: Days
• US Class Current: 709/219
• CPC Class Codes: H04L 67/01 Protocols
• CPC Class Codes: H04L 67/02 based on web technology, e.g. hypertext transfer protocol [HTTP]

Abstract

Web-based applications provide an alternative approach to client-server computing using the internet or intranet as the transport mechanism. The invention uses the schema and system catalogs of a relational database to contain and describe the methods, features, functions, and operation of a web-based application. In the invention, a generalized object format is used to minimize bandwidth consumption and substantially improve system performance. Data is converted to and from this generalized object format by both the application server and by the client-side view controller. Formatting of the generalized data object does not rely on or use any form of markup language, markup tags, or DTD'"'"'s. Transmission of the generalized data object occurs asynchronously over the internet.

Claims

1. An article of manufacture consisting of methods and mechanisms for an asynchronous, bidirectional client-server system used for the development and deployment of web-based applications using a variation of the Model-View-Controller, or MVC paradigm, where

the invention uses a relational database, or RDBMS to store data, which is generally referred to as the “

Model”

, or “

data model”

; and

the invention incorporates an object-oriented client software package and source code to manage and manipulate the visual presentation layer, generally referred to as the “

View controller”

, “

client-controller”

, or “

client-interface”

; and

the invention incorporates proprietary, executable application source code for operation as the application server, which functions as the primary interface between the view controller and data model, thus comprising the “

Controller”

or “

application”

portion of the MVC paradigm.

2. Wherein the general statements of claim 1, the view controller, or client-interface portion of the invention

uses an object-oriented presentation layer as the primary View Controller;

and

contains the client-executable code and instructions necessary for operation as the client-interface to the application server; and

uses the well-known internet transfer protocols such as HTTP and HTTPS and the XMLHttpRequest mechanism for asynchronous communication with the application server;

where

the first implementation of the client invention, as stated within these claims, consists of a series of object-oriented class libraries, written in the JavaScript language, thus making the client-controller package platform neutral, and capable of running in the context of a modern web browser software package; and

that future or alternative implementations of the client-controller package may or not be limited to running within the context of the traditional web-based, or internet model.

3. The statements of claim 1, wherein said proprietary software of the application server executes and operates as a web-based application server;

and the further of

the server software is written in the Java programming language, thus making it capable of operating or executing on any computer with a Java Virtual Machine; and

the server software executes and operates as an HTTP servlet; and

the server software manages and maintains connections to said database or data model; and

the server software while executing, operates as the application layer, or Controller; and

the invention further uses well-known internet transfer protocols such as HTTP and HTTPS and the XMLHttpRequest mechanism for asynchronous communications with the client-interface; and

further transmits a pure data object over the internet using a generalized object structure without incurring the overhead of HTML, SGML, UML, XML, or any markup languages or tags.

4. Wherein the general methods of claim 3 the invention further comprises the steps of reading an incoming HTTP or HTTPS request or query string, and

logging or storing a copy of the incoming request into a perpetual storage container, or said database;

and

further decoding the incoming request from its generalized object format into a language specific object structure and request parameters; and

further performing security checks and validation of the requester or requesting client against an access control list or ACL; and

further determining the nature of the client request and dynamic routing of the decoded request parameters to a series of internal method or process, or to a loadable or external application method or process; and

further encoding the output or response of the application server into a generalized object structure for transmission to the requesting client.

5. The method of claim 4 wherein said decoding of the request further consists of retrieving the incoming HTTP(S) request from the input stream using well known methods and mechanisms of an internet web server, where

the incoming request is formatted as a stringified or serialized version of the generalized data object;

and

said conversion or mapping of the serialized version of the generalized data object into a normalized language object consists of several additional steps; and

converting the re-created normalized language object into a parameter list suitable for processing by the application server; and

storing or otherwise preserving and preparing the language dependent object format for additional processing or application of computing methods within the application server namespace.

6. The method of claim 4 wherein said security validation and authentication checks on the request which further comprises the steps of validating the client IP address against an internal listing of IP addresses which are known to be authorized;

and

during initial login, performing initial validation of the user against an internal listing of authorized system users by comparing the user supplied account name to the stored account name; and

generating a 32 bit session id or security key and storing it in said database for future reference; and

comparing a user supplied password to an internally stored password; and

comparing the current client IP address, supplied in the HTTP request header to the IP address stored when the client originally logged in to the system; and

validating the 32 bit session id or security key supplied against a previously stored and authenticated session key; and

storing the user credential along with the query string of the request in said RDBMS; and

verifying that the user credential is not expired or invalidated by comparing the security key to a previously stored expiration date and timestamp for the security key; and

further logging the state or status of user authentication into an internal security tracking and request logging table within said RDBMS; and

further generating an internal ACL, or access control list for the validated account or user name or otherwise confirming that the requested process is authorized for the validated user.

7. The method of claim 4 wherein said steps of identifying the nature of the request and dynamic routing of the request consists of the further steps of

querying said database for configuration information related to the request;

and

locating or obtaining access to an internal or core method of the application;

or

locating, loading, and instantiating an external method; and

further executing the methods of the request; and

further capturing the data output of the method for further processing or eventual transmission to the requester.

8. The method of claim 4 wherein said encoding of the server response object further comprises internal methods and mechanisms for converting a language dependent data structure or object into the generalized data object (the generalized response data object) format for further transmission to the client workstation as a stringified, or serialized form of a name-value pair generally comprising the name:

value format, where the value component may be composed of any arrangement of;

an object { }, where an object can contain a further number of embedded objects, arrays, or name-value pairs;

or

an array [ ], where an array can contain a further number of embedded objects, embedded arrays, or name-value pairs;

or

a string generally comprising the name;

“

value”

format;

or

a number generally comprising the name;

1.001 format, where a number can represent whole numbers (integers) or a real numbers (floats, real, etc.) in varying mathematical notation;

or

a date generally comprising the name;

“

date”

format wherein a date is generally represented in one of many ISO formats, such as timestamp, datetime, or universal-time-code (UTC).

9. An article of manufacture consisting of methods and mechanisms for a schema-based, or database-driven web-based applications technology and application server comprising the steps of

reading said elements of said database and corresponding schema definitional elements to determine values of said elements and their relationships;

wherein

said reading step further comprises generating a generalized data object based upon an inversion or translation of said database; and

assembling a list of the values of said elements and their relationship into a generalized view of said database;

wherein

the methods and mechanisms for converting and serializing data into a generalized, language independent data-object format (a response object) and vice-versa are identified in claim 8, above;

where the generalized response object is encoded or decoded and formatted according to the methods and structures identified in the prior claims.

13. The method of claim 4 wherein said conversion of the derived schema into the generalized object format previously identified in claim 8, above, includes preparing and storing the generalized object schema in the application server'"'"'s output buffer or client response buffer for later transmission to the requestor or for further internal processing.

14. The method of claim 9 wherein said generalized view of relational data consists of the further steps of

dynamically generating SQL constructs to retrieve data from RDBMS table(s) or view(s) identified in the client request;

and

dynamically generating SQL constructs or processing limitations to further filter or restrict access to those columns identified as available to the requestor by the ACL generated during the authentication steps of claim 6.

16. The method of claim 9 wherein said generalized set of instructions may further consist of server requests or information transmitted to the client software application, wherein additional server requests or information may include, but are not limited to

requests to perform or execute a process internal to the client application software;

or

requests for the client software application to submit or post additional data to the application server;

or

additional instructions or information to the client software package to log out or invalidate the user, to redraw or refresh the user interface, or to perform any other operation available in the client-interface.

17. An article of manufacture consisting of methods and mechanisms to automatically store, insert, or update database records in response to client-submitted requests, wherein,

said storage of client-supplied data further consists of the steps of identifying the target storage table within the RDBMS for the requested storage process;

and

confirming that the requestor authenticated during the validation process of claim 6 has appropriate rights and privileges in the ACL to perform the requested operation; and

dynamically generating an SQL statement to perform the insert, update, or deletion of the user-supplied data; and

performing an automatic save of the original, unchanged database record(s) into a virtual rollback system for future recovery or audit; and

executing the dynamically generated SQL statement, thusly performing the requested operation; and

further generating an application server response object indicating completion status and success/failure of the operation.

10. Where stated in theses methods and claims, the generalized application server output or response object may further comprise any combination of

a generalized schema definition;

and

a generalized view of the relational data; and

a generalized set of instructions; and

additional data or identification of additional processes to be invoked by the client.

11. The method of claim 9 wherein said generalized schema definition consists of a method of using information from the RDBMS system catalogs to develop a generalized object schema that describes the format of the generalized data object, where developing the generalized object schema consists of the further steps of

identifying the columns to which the requesting client is allowed access or view based upon the ACL and security authorization of the client, as previously identified in the prior claims;

and

identifying the column name from the RDBMS catalogs; and

identifying ANSI SQL data-type of the column from the RDBMS catalogs; and

identifying the universal data type or UDT of the column; and

identifying the field labels or display context of the column, and whether the column is viewable or editable in the requesting client'"'"'s context; and

identifying whether the column is the primary key or sequence key of the table; and

identifying data integrity constraints, referential integrity constraints, null or not null constraints, and default values of the column.

12. The method of claim 11 wherein said identification as to whether the column is a foreign key reference or lookup table, that, if the column is determined to be a foreign key reference to another table within said RDBMS;

and further

retrieving and formatting the lookup data or picklist data for the column into an embedded generalized object format as described in claim 8, above; and

appending the generalized view of the lookup data into the generalized schema generated subsequent to any process of claim 11.

15. The method of claim 4 wherein said dynamic routing of the decoded request further includes

executing the dynamically generated SQL construct or query against the RDBMS to retrieve data;

and

capturing the resultant recordset from the SQL query; and

converting or encoding the resultant recordset into the generalized object structure using the processes and methods of claim 8 and the universal data types or UDT'"'"'s for the tabular data, from the generalized schema generated for the process as identified in claim 10;

and

preparing and storing the generalized recordset in the application server'"'"'s output buffer or client response buffer for later transmission to the requester or for further internal processing.

18. An article of manufacture consisting of methods and mechanisms for a template-driven client view-controller package that allows a client workstation running standard web-browser software to receive the serialized, generalized data object (the response object), wherein

said client-controller further comprises the steps and processes of converting client-side data and data objects into the generalized object format (a request object) supported by the application server and to make requests on, initiate a server process, or to retrieve responses from the application server using the generalized object format, and vice-versa;

and

said client-controller includes the methods and mechanisms that utilize the language specific data object or structure for visual rendering, display, or other manipulation on the client-workstation; and

said client-controller includes the methods and mechanisms to encode and decode said generalized data structure(s) to and from the client-request format; and

said client-controller includes the methods and mechanisms to encode and decode said generalized data structure(s) to and from the server-response format; and

said client-controller includes the methods for rendering of the reconstructed data object in various GUI formats; and

said client-controller provides methods and mechanisms that include the ability to edit or otherwise modify the data; and

said client-controller includes the methods and mechanisms for communicating changes to the data object back to the server; and

said client-controller includes the methods and mechanisms for initiating any available server process using the described request object and transfer mechanisms.