Participant server which process documents for commerce in trading partner networks

Abstract

Participant servers in a network of customers, suppliers and other trading partners exchange machine readable documents. The participants in the network use self defining electronic documents, such as XML based documents, which can be easily understood amongst the partners. Definitions of the electronic business documents, called business interface definitions, are posted on the Internet, or otherwise communicated to members of the network. The business interface definitions tell potential trading partners the services the company offers and the documents to use when communicating with such services. Thus, a typical business interface definition allows a customer to place an order by submitting a purchase order or a supplier checks availability by downloading an inventory status report. Participants are programmed by the composition of the input and output documents, coupled with interpretation information in a common business library, to handle the transaction in a way which closely parallels the way in which paper based businesses operate.

Claims

What is claimed is:

1. A method for executing transactions among nodes in a network including a plurality of nodes which execute processes involved in the transactions, comprising:

storing a machine-readable specification of an interface for a transaction, the specification including a definition of an input document, and a definition of an output document, the definitions of the input and output documents comprising respective descriptions of sets of storage units and logical structures for the sets of storage units;

receiving data comprising a document through a communication network;

parsing the document according to the specification to identify an input document;

providing at least a portion of the input document in a machine-readable format to a transaction process which produces an output;

forming, based on the specification, an output document comprising the output according to the definition of an output document; and

transmitting the output document on the communication network.

2. The method of claim 1, including:

accessing a specification of a complementary interface provided for another node in the network for the transaction, the accessed specification including a definition of an input document for the complementary interface, and a definition of an output document for the complementary interface; and

establishing the stored specification of the interface by including at least part of the definition of the output document of the complementary interface in the definition of the input document of the interface in the stored specification.

3. The method of claim 2, including:

finding the complementary interface in the network.

4. The method of claim 2, wherein the establishing the stored specification includes accessing elements of the machine-readable specification from a repository, the repository storing a library of logical structures, schematic maps for logic structures, and definitions of documents comprising logic structures used to build interface descriptions.

5. The method of claim 2, including:

establishing the stored specification of the interface by including at least part of the definition of the input document of the complementary interface in the definition of the output document of the interface in the stored specification.

6. The method of claim 1, including providing access to the specification through the communication network to other nodes in the network.

7. The method of claim 1, including sending the specification of the interface to another node in the network, at which access to the specification is provided for other nodes in the network.

8. The method of claim 1, wherein the machine-readable specification includes a document compliant with a definition of an interface document including logical structures for storing an identifier of a particular transaction, and at least one of definitions and references to definitions of input and output documents for the particular transaction.

9. The method of claim 1, wherein the machine-readable specification includes a document compliant with a definition of an interface document including logical structures for storing an identifier of the interface, and for storing at least one of specifications and references to specifications of a set of one or more transactions supported by the interface.

10. The method of claim 9, wherein the machine-readable specification includes a reference to a specification of a particular transaction, and the specification of the particular transaction includes a document including logical structures for storing at least one of definitions and references to definitions of input and output documents for the particular transaction.

11. The method of claim 1, wherein the storage units comprise parsed data.

12. The method of claim 11, wherein the parsed data in at least one of the input and output documents comprises:

character data encoding text characters in the one of the input and output documents, and

markup data identifying sets of storage units according to the logical structure of the one of the input and output documents.

13. The method of claim 12, wherein at least one of the sets of storage units encodes a plurality of text characters providing a natural language word.

14. The method of claim 11, wherein the specification includes interpretation information for at least one of the sets of storage units identified by the logical structure of at least one of the input and output documents, encoding respective definitions for sets of parsed characters.

15. The method of claim 11, wherein the storage units comprise unparsed data.

16. The method of claim 1, wherein the transaction process has a variant transaction processing architecture, and including translating at least of portion of the input document into a format readable according to the variant transaction processing architecture of the transaction process.

17. The method of claim 16, wherein the translating includes producing programming objects including variables and methods according to the variant transaction processing architecture of the transaction process.

18. The method of claim 16, wherein the variant transaction processing architecture of the transaction process includes a process compliant with an interface description language.

19. The method of claim 1, wherein the definitions of the input and output documents comprise document type definitions compliant with a standard Extensible Markup Language XML.

20. The method of claim 1, including providing a repository of document types for use in a plurality of transactions, and wherein the definition of one of the input and output documents includes a reference to a document type in the repository.

21. The method of claim 20, wherein the repository of document types includes a document type for identifying participant processes in the network.

22. The method of claim 20, including providing a repository of interpretation information for logical structures, including interpretation information identifying parameters of transactions.

23. The method of claim 1, wherein the transaction process has variant transaction processing architecture, and including:

accessing a specification of a complementary interface, the accessed specification including a definition of an input document for the complementary interface, and a definition of an output document for the complementary interface;

establishing the stored specification of the interface by including the definition of the output document of the complementary interface as the definition of the input document of the interface in the stored specification; and

compiling in response to the definitions of the input and output documents, data structures corresponding to the sets of storage units and logical structures of the input and output documents compliant with the transaction processing architecture of the transaction process, instructions executable by the system to translate the input document to the corresponding data structures, and instructions executable by the system to translate output of the transaction process into a form compliant with the definition of the output document.

24. The method of claim 23, including:

establishing the stored specification of the interface by including the definition of the input document of the complementary interface as the definition of the output document of the interface in the stored specification.

25. The method of claim 1, wherein the transaction process has a variant transaction processing architecture, and wherein the establishing the stored specification includes accessing elements of the machine-readable specification from a repository, the repository storing a library of logical structures, schematic maps for logical structures, and definitions of documents comprising logical structures used to build interface descriptions; and including

compiling in response to the definitions of the input and output documents, data structures corresponding to the sets of storage units and logical structures of the input and output documents compliant with the transaction processing architecture of the transaction process, instructions executable by the system to translate the input document to the corresponding data structures, and instructions executable by the system to translate output of the transaction process into a form compliant with the definition of the output document.

26. Apparatus for managing transactions among nodes in a network including a plurality of nodes which execute processes involved in the transactions, comprising:

a network interface;

memory storing data and programs of instructions, including a machine-readable specification of an interface for a transaction, the specification including a definition of an input document, and a definition of an output document, the definitions of the input and output documents comprising respective descriptions of sets of storage units and logical structures for the sets of storage units;

a data processor coupled to the memory and the network interface which executes the programs of instructions; wherein the programs of instructions include

logic to receive data comprising a document through a network interface;

logic to parse the document according to the specification to identify an input document;

logic to provide at least a portion of the input document in a machine-readable format to a transaction process which produces an output;

logic to form, based on the specification, an output document comprising the output according to the definition of an output document; and

logic to transmit the output document on the network interface.

27. The apparatus of claim 26, including:

logic to access a specification of a complementary interface, the accessed specification including a definition of an input document for the complementary interface, and a definition of an output document for the complementary interface; and

logic to establish the stored specification of the interface by including the definition of the output document of the complementary interface as the definition of the input document of the interface in the stored specification.

28. The apparatus of claim 27, wherein the logic to establish the stored specification includes logic to access elements of the machine-readable specification from a repository, the repository storing a library of logical structures, schematic maps for logic structures, and definitions of documents comprising logic structures used to build interface descriptions.

29. The apparatus of claim 27, including:

logic to establish the stored specification of the interface by including the definition of the input document of the complementary interface as the definition of the output document of the interface in the stored specification.

30. The apparatus of claim 26, including logic to provide access to the specification through the network interface to other nodes in the network.

31. The apparatus of claim 26, including logic to send the specification of the interface to another node in the network, at which access to the specification is provided for other nodes in the network.

32. The apparatus of claim 26, wherein the machine-readable specification includes a document compliant with a definition of an interface document including logical structures for storing an identifier of a particular transaction, and at least one of definitions and references to definitions of input and output documents for the particular transaction.

33. The apparatus of claim 26, wherein the machine-readable specification includes a document compliant with a definition of an interface document including logical structures for storing an identifier of the interface, and for storing at least one of specifications and references to specifications of a set of one or more transactions supported by the interface.

34. The apparatus of claim 33, wherein the machine-readable specification includes a reference to a specification of a particular transaction, and the specification of the particular transaction includes a document including logical structures for storing at least one of definitions and references to definitions of input and output documents for the particular transaction.

35. The apparatus of claim 26, wherein the storage units comprise parsed data.

36. The apparatus of claim 35, wherein the parsed data in at least one of the input and output documents comprises:

character data encoding text characters in the one of the input and output documents, and

markup data identifying sets of storage units according to the logical structure of the one of the input and output documents.

37. The apparatus of claim 36, wherein at least one of the sets of storage units encodes a plurality of text characters providing a natural language word.

38. The apparatus of claim 35, wherein the specification includes interpretation information for at least one of the sets of storage units identified by the logical structure of at least one of the input and output documents, encoding respective definitions for sets of parsed characters.

39. The apparatus of claim 35, wherein the storage units comprise unparsed data.

40. The apparatus of claim 26, wherein the transaction process has variant transaction processing architecture, and including logic to translate at least of portion of the input document into a format readable according to the variant transaction processing architecture of the transaction process.

41. The apparatus of claim 40, wherein the logic to translate includes logic to produce programming objects including variables and methods according to the variant transaction processing architecture of the transaction process.

42. The apparatus of claim 40, wherein the variant transaction processing architecture of the transaction process includes a process compliant with an interface description language.

43. The apparatus of claim 26, wherein the definitions of the input and output documents comprise document type definitions compliant with a standard Extensible Markup Language XML.

44. The apparatus of claim 26, including memory accessible by the processor storing a repository of document types for use in a plurality of transactions, and wherein the definition of one of the input and output documents includes a reference to a document type in the repository.

45. The apparatus of claim 44, wherein the repository of document types includes a document type for identifying participant processes in the network.

46. The apparatus of claim 44, including providing a repository of interpretation information for logical structures, including interpretation information identifying parameters of transactions.

47. The apparatus of claim 26, wherein the transaction process has variant transaction processing architecture, and including:

logic to access a specification of a complementary interface, the accessed specification including a definition of an input document for the complementary interface, and a definition of an output document for the complementary interface;

logic to establish the stored specification of the interface by including the definition of the output document of the complementary interface as the definition of the input document of the interface in the stored specification; and

logic to compile in response to the definitions of the input and output documents, data structures corresponding to the sets of storage units and logical structures of the input and output documents compliant with the transaction processing architecture of the transaction process, to compile instructions executable by the system to translate the input document to the corresponding data structures, and to compile instructions executable by the system to translate output of the transaction process into a form compliant with the definition of the output document.

48. The apparatus of claim 47, including:

logic to establish the stored specification of the interface by including the definition of the input document of the complementary interface as the definition of the output document of the interface in the stored specification.

49. The apparatus of claim 26, wherein the transaction process has a variant transaction processing architecture, and including logic to establish the stored specification by accessing elements of the machine-readable specification from a repository, the repository storing a library of logical structures, schematic maps for logical structures, and definitions of documents comprising logical structures used to build interface descriptions; and including

logic to compile in response to the definitions of the input and output documents, data structures corresponding to the sets of storage units and logical structures of the input and output documents compliant with the transaction processing architecture of the transaction process, to compile instructions executable by the system to translate the input document to the corresponding data structures, and to compile instructions executable by the system to translate output of the transaction process into a form compliant with the definition of the output document.

Description

COPYRIGHT NOTICE

A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure as it appears in the Patent and Trademark Office patent file or records, but otherwise reserves all copyright rights whatsoever.

BACKGROUND OF THE INVENTION

1. Field of the Invention

The present invention relates to systems and protocols supporting transactions among diverse clients coupled to a network; and more particularly to systems and protocols supporting commercial transactions among platforms having variant architectures.

2. Description of Related Art

The Internet and other communications networks provide avenues for communication among people and computer platforms which are being used for a wide variety of transactions, including commercial transactions in which participants buy and sell goods and services. Many efforts are underway to facilitate commercial transactions on the Internet. However, with many competing standards, in order to execute a transaction, the parties to the transaction must agree in advance on the protocols to be utilized, and often require custom integration of the platform architectures to support such transactions. Commercial processes internal to a particular node not compatible with agreed upon standards, may require substantial rework for integration with other nodes. Furthermore, as a company commits to one standard or the other, the company becomes locked-in to a given standardized group of transacting parties, to the exclusion of others.

A good overview of the challenges met by Internet commerce development is provided in Tenenbaum, et al., "Eco System: An Internet Commerce Architecture", Computer, May 1997, pp. 48-55.

To open commercial transactions on the Internet, standardization of architectural frameworks is desired. Platforms developed to support such commercial frameworks include IBM Commerce Point, Microsoft Internet Commerce Framework, Netscape ONE (Open Network Environment), Oracle NCA (Network Computing Architecture), and Sun/JAVASoft JECF (JAVA Electronic Commerce Framework).

In addition to these proprietary frameworks, programming techniques, such as common distributed object model based on CORBA IIOP (Common Object Request Broker Architecture Internet ORB Protocol), are being pursued. Use of the common distributed object model is intended to simplify the migration of enterprise systems to systems which can inter-operate at the business application level for electronic commerce. However, a consumer or business using one framework is unable to execute transactions on a different framework. This limits the growth of electronic commerce systems.

Companies implementing one framework will have an application programming interface API which is different than the API's supporting other frameworks. Thus, it is very difficult for companies to access each others business services, without requiring adoption of common business system interfaces. The development of such business system interfaces at the API level requires significant cooperation amongst the parties which is often impractical.

Accordingly, it is desirable to provide a framework which facilitates interaction amongst diverse platforms in a communication network. Such system should facilitate spontaneous commerce between trading partners without custom integration or prior agreement on industry wide standards. Further, such systems should encourage incremental path to business automation, to eliminate much of the time, cost and risks of traditional systems integration.

Overall, it is desirable to provide an electronic commerce system that replaces the closed trading partner networks based on proprietary standards with open markets.

SUMMARY OF THE INVENTION

The present invention offers an infrastructure for connecting businesses with customers, suppliers and trading partners. Under the infrastructure of the present invention, companies exchange information and services using self-defining, machine-readable documents, such as XML (Extensible Markup Language) based documents, that can be easily understood amongst the partners. Documents which describe the documents to be exchanged, called business interface definitions BIDs herein, are posted on the Internet, or otherwise communicated to members of the network. The business interface definitions tell potential trading partners the services the company offers and the documents to use when communicating with such services. Thus, a typical business interface definition allows a customer to place an order by submitting a purchase order, compliant with a document definition published in the BID of a party to receive the purchase order. A supplier is allowed to check availability by downloading an inventory status report compliant with a document definition published in the BID of a business system managing inventory data. Use of predefined, machine-readable business documents provides a more intuitive and flexible way to access enterprise applications.

A node in the commerce network establishes an interface for transactions according to the present invention that comprises a machine-readable specification of an interface, along with a machine-readable data structure that includes interpretation information for the machine-readable specification of the interface. The machine-readable specification of the interface includes a definition of an input document and a definition of an output document, that are accepted and produced by transaction processes for which the node acts as an interface. The definitions of the input and output documents comprise respective descriptions of sets of storage units and logical structures for sets of storage units, such as according to a standard XML based document. The machine-readable data structure that includes interpretation information according to various aspects of the invention includes data type specifications (e.g. string, array, etc.) for logical structures in the definitions of the input and output documents, content models (e.g. lists of possible values) for logical structures and/or data structures that map predefined sets of storage units for a particular logic structure to respective entries in a list in order to provide a semantic definition of logical structures (e.g. mapping codes to product names).

According to other aspects of the invention, the interface includes a repository in memory accessible by at least one node in the network that stores a library of logic structures and interpretation information for the logic structures. The repository can be extended to include a library of definitions of input and output documents, a library of specifications of interfaces, and a library of specifications for participant interface nodes in the network.

Thus, a participant in the transaction framework of the present invention executes transactions amongst nodes in a network that includes a plurality of nodes executing processes involved in the transactions. The method includes storing a machine-readable specification of an interface for a transaction, the specification includes a definition of an input document and a definition of an output document. The definition of the input and output documents comprise respective descriptions of sets of storage units and logical structures for the sets of storage units. In a preferred system, the definitions are expressed in a manner compliant with a standard XML document type definition DTD, extended by semantic mapping, content modeling and data typing of some elements. The participant in the transaction receives data comprising a document through a communication network. The participant parses the document according to the specification stored for a transaction to identify an input document for the transaction. After parsing the document, at least a portion of the input document is provided in a machine-readable format to a transaction process which produces an output. An output document is formed comprising the output of the transaction process, based on the definition of an output document in the stored specification. The output document is transmitted on the communication network, typically back to the source of the input document, or elsewhere as suits the needs of a particular type of transaction.

Thus the business interface definition bridges the gap between the documents specified for example according to XML and the programs which execute on the front end of the transaction processing services at particular nodes. Such front ends are implemented for example by JAVA virtual machines, or by other common architectures providing for interconnection of systems across a network. The business interface definition provides a technique by which a transaction protocol is programmed using the business interface definition document. The program for the protocol of the transaction is established by a detailed formal specification of a document type.

The machine-readable specification of the interface of the transaction is made accessible to other platforms in the network. Participant platforms include resources to design input documents and output documents according to the transaction interface specified at a complementary node. Thus, participant nodes include resources to access the definition of an input document for the complementary interface and a definition of an output document for the complementary interface. The stored specification for the accessing participant node is established by including at least part of the definition of the output document of the complementary interface in the definition of the input document of the interface stored in the specification.

The process of establishing the stored specification of an interface according to another aspect of the invention includes accessing elements of the machine-readable specification from a repository. The repository stores a library of logic structures, content models, and schematic maps for logic structures, and definition of documents that comprise logic structures used to build interface description. A repository accessible in the network facilitates the building of interface descriptions which can be easily shared. Any differences between the input document created for a particular process and the output document expected as a return by a complementary process can be easily negotiated by communication on the network and agreeing on common logic structures to express particular information.

The machine-readable specification of an interface of a transaction according to one aspect of the invention includes a document compliant with a definition of an interface document that is shared amongst members of the network. A definition of the interface document includes logic structures for storing an identifier of a particular transaction and at least one of definitions and references to definitions of input and output documents for the particular transaction. That is, the interface description for a particular service may actually encompass a definition of the input and output documents. Alternatively, it may include pointers to a location in the repository, or elsewhere in the network, of such definitions.

According to another alternative of the invention, the machine-readable specification includes a business interface definition BID document compliant with a definition of an interface document that includes logical structures for storing an identifier of the interface, and for storing at least one of specifications and references to specifications of a set of one or more transactions supported by the interface. For each supported transaction, the document includes at least one of definitions and references to definitions of input and output documents for the particular transaction.

According to another aspect of the invention, the storage units defined in the definitions of the input and output document comprise parsed data including character data encoding text characters, and mark-up data identifying sets of storage units according to the logical structures of the input and output documents. According to another aspect of the invention, at least one of the sets of storage units encodes the plurality of text characters providing a natural language word. This facilitates the use of the definitions of input and output documents by human readers and developers of such documents.

According to another aspect of the invention, the specification of the input and output documents includes interpretation information for at least one of the sets of storage units identified by the logical structure. The interpretation information in one example encodes definitions for sets of parsed characters. In another example, the interpretation information provides for content model specifications, such as requiring a specific logic structure to carry a member of a list of codes mapped to product descriptions in a catalog. In some systems, the storage units in a logic structure of a document may include sets of unparsed data, as suits the needs of a particular implementation.

According to yet another aspect of the invention, the transaction process in a particular platform has a transaction processing architecture which is one of a plurality of variant transaction processing architectures. Thus the participant node includes resources for translating at least a portion of the input document into a format readable according to the variant transaction processing architecture of the transaction process utilizing the information. The elements of the document definition are translated into programming objects that include variables and methods according to the variant transaction processing architectures of the transaction process. For a participant having a JAVA virtual machine acting as a transaction process front end, particular fields in the documents are translated into JAVA objects, including the data as well as get and set functions associated with a JAVA object. Other transaction processing architectures supportable according to the present invention include processes compliant with an interface description language in the sense of Common Object Request Broker Architecture CORBA, Component Object Model COM, On-Line Transaction Processing OLTP, and Electronic Data Interchange EDI.

According to other aspects of the invention, a repository is provided that stores document types for use in the plurality of transactions. The machine-readable specification for a particular transaction defines at least one of the input and output documents by reference to a document type in the repository. According to another aspect, the document type included in the repository include a document type for identifying participants in the network. Such document type providing structures for identifying a participant, specifying the services supported by the participant, and specifying the input and output documents for each of such services.

In addition to the methods described above, the present invention provides an apparatus for managing transactions among nodes that includes a network interface, memory for storing data and programs of instructions including a machine-readable specification of an interface for a transaction as described above, and a data processor that is coupled with the memory and the network interface. The programs of instructions stored in the apparatus include logic to execute the processes described above for a participant in the transactions.

The present invention further provides an apparatus for establishing participant interfaces for transactions executed on a system that include a network interface and a data processing resources that execute transaction processes according to a transaction processing architecture. The apparatus includes programs of instructions that are executable by the system and stored on a medium accessible by the system that provide tools to build a definition of a participant interface for a participant in a particular transaction. The definition of a participant interface includes a definition of an input document and a definition of an output document. The definitions of the input and output documents comprise respective machine-readable descriptions of sets of storage units in logical structures for the sets of storage units, which may be compliant in one aspect of the invention with XML document type definitions.

The apparatus for establishing participant interfaces according to this aspect of the invention also includes programs of instructions stored on a medium accessible by the data processing system and responsive to the definitions of input and output documents to compile data structures corresponding to the sets of storage units and logical structures of the input and output documents that are compliant with the transaction processing architecture, to compile instructions executable by the system to translate the input document to the corresponding data structures, and to compile instructions executable by the system to translate output of the transaction processes into sets of storage units and logical structures of the output document.

The tools to build a definition of a participant interface in a preferred system include instructions executable by the system to access elements of the definition from complementary nodes and/or from a repository that stores a library of logical structures and interpretation information for logical structures used to build interface descriptions. According to various aspects of the invention, the repository includes not only a library of logical structures but definitions of documents that comprise logical structures, and formats for specifying participant interfaces. According to this aspect of the invention, tools are provided for building specifications of business interfaces according to the techniques described above in connection with the description of the participant nodes. The tools for building interfaces and the tools for compiling the interfaces into resources needed for communication with transaction processing architectures according to this aspect of the invention, are implemented in participant nodes in the preferred system, and utilized for the development and optimization of the interface descriptions as use of the network grows based on interface descriptions that define input and output documents.

Accordingly, another aspect of the invention provides an apparatus that includes memory and a data processor that executes instructions stored in the memory that include tools to build a definition of a participant interface and a compiler performing the functions described above.

According to yet another aspect of the invention, the use of the participant interface descriptions enables the operation of a market maker node. At such a node, a method for managing transactions is provided that comprises storing machine-readable specifications of a plurality of participant interfaces which identify transactions supported by the interfaces, and the respective input and output documents of such transactions. As described above, the definitions of the input and output documents comprise respective descriptions of sets of storage units and logical structures for the sets of storage units, such as according to the XML standard. In addition, the definitions of the transactions and the definitions of the participant interfaces all comprise documents specified according to a technique compliant with XML or other standardized document expression language. At such market maker node, data comprising a document is received over a communication network. The document is parsed according to the specifications to identify an input document in one or more transactions which accept the identified input document. At least a portion of the input document is provided in a machine-readable format to a transaction process associated with the one or more identified transactions. The step of providing at least a portion of the input document to a transaction process includes executing a routing process according to a processing architecture at the market maker node. The routing process in one aspect of the invention is executed according to a particular processing architecture, and at least a portion of the incoming document is translated into the format of the processing architecture of the routing process. The translating according to the preferred aspect includes producing programming objects that include variables and methods according to the processing architecture of the routing process.

According to another aspect of the invention, the market maker node also supports the repository structure. Thus, a process is included at the market maker node for allowing access by participants in the network to a repository stored at the market maker node. As described above, the repository includes definitions of logic structures, interpretation information, and document definitions for use by the participant nodes to build transaction interface documents and includes instances of business interface definitions that identify the participants, and the transactions executed by the respective participants.

The routing process includes according to various alternatives the translating of the input document into the variant processing architecture of the processes to which the document is to be routed, or routing the input document in its original document format across the network to a remote processing node, or to combinations of such processes. In alternatives, the routing process may also include techniques for transforming an input document defined according to one input document definition into a different document defined according to a different document specification for a process which has registered to watch for the input document.

Also, the market maker node is provided according to the present invention as apparatus that includes a network interface, memory storing data and programs of instructions including the specifications of the participant interfaces, and a data processor. The logic is provided with the data processor in the form of programs of instructions or otherwise to perform the market maker process as discussed above.

Accordingly, the present invention provides a foundation for electronic commerce based on the sharing of specifications of input and output documents. Documents provide an intuitive and flexible way to access business services, much simpler to implement than programming APIs. It is much easier to interconnect companies in terms of documents that are exchanged, on which such companies already largely agree, than in terms of business system interfaces which invariably differ. In addition, such documents are specified in a human readable format in the preferred embodiment. According to the present invention the business interfaces are specified in documents, such as XML documents that are readily interpretable by humans as well as by computers.

Utilization of the document based transaction architecture of the present invention involves the use of a parser which operates in basically the same way for any source of documents, eliminating much of the need for custom programs to extract and integrate information from each participant in the network. Thus, integrating enterprise information from accounting, purchasing, manufacturing, shipping and other functions can be accomplished by first converting each source to a document having an architecture according to the present invention, and then processing the parsed data stream. Each node in the system that participates in the market only needs to know about the format of its internal systems, as well as the format of the documents being specified for interchange according to the transaction. Thus, there is no need to be able to produce the native format of every other node which might want to participate in the electronic commerce network.

For complete business integration, the present invention provides a repository of standardized logical structures, like XML elements, attributes or meta data, establishing a semantic language for particular commerce communities, a means for mapping between different meta data descriptions, and a server for processing the documents and invoking appropriate applications and services. The basic building blocks of a network according to the present invention include the business interface definitions which tell potential trading partners what online services a company offers and which documents to use to invoke the services; and servers which provide the bridge to bind together the set of internal and external business services to create a trading community. The server operates to parse the incoming documents and invoke the appropriate services. Also the server according to the present invention handles the translation tasks from the format of the documents being received and transmitted, to and from the formats of the respective host systems. Thus, trading partners need only agree on the structure, content and sequencing of the business documents exchanged, and not on the details of application programmer interfaces. How a document is processed and the actions which result from receipt of a document are strictly up to the businesses providing the services. This elevates integration from the system level to the business level. It enables the business to present a clean and stable interface to its partners despite changes in its internal technology implementation, organization or processes.

The whole process of building business interface definitions and enabling servers to manage commerce according to such descriptions is facilitated by a common business library, or repository, of information models for generic business concepts including business description primitives like companies, services and products, business forms like catalogs, purchase orders and invoices, and standard measurements, including time and date, location and classification of goods.

Other aspects of the present invention can be seen upon review of the figures, the detailed description, and the claims which follow.

BRIEF DESCRIPTION OF THE FIGURES

FIG. 1 is a simplified diagram of an electronic commerce network including business interface definitions BIDs according to the present invention.

FIG. 2 is a simplified diagram of a business interface definition document according to the present invention.

FIG. 3 is a conceptual block diagram of a server for a participant node in the network of the present invention.

FIG. 4 is a flow chart illustrating the processing of a received document at a participant node according to the present invention.

FIG. 5 is a block diagram of a parser and transaction process front end for an XML based system.

FIG. 6 is a conceptual diagram of the flow of a parse function.

FIG. 7 is a simplified diagram of the resources at a server used for building a business interface definition according to the present invention.

FIG. 8 is a simplified diagram of a repository according to the present invention for use for building business interface definitions.

FIG. 9 is a flow chart illustrating the processes of building a business interface definition according to the present invention.

FIG. 10 provides a heuristic view of a repository according to the present invention.

FIG. 11 is a simplified diagram of the resources at a server providing the market maker function for the network of the present invention based on business interface definitions.

FIG. 12 is a flow chart for the market maker node processing of a received document.

FIG. 13 is a flow chart illustrating the process of registering participants at a market maker node according to the present invention.

FIG. 14 is a flow chart illustrating the process of providing service specifications at a market maker node according to the process of FIG. 9.

FIG. 15 is a diagram illustrating the sequence of operation at a participant or market maker node according to the present invention.

FIG. 16 is a conceptual diagram of the elements of a commercial network based on BIDs, according to the present invention.

DETAILED DESCRIPTION

A detailed description of the present invention is provided with respect to the figures, in which FIG. 1 illustrates a network of market participants and market makers based on the use of business interface definitions, and supporting the trading of input and output documents specified according to such interface descriptions. The network includes a plurality of nodes 11-18 which are interconnected through a communication network such as the Internet 19, or other telecommunications or data communications network. Each of the nodes 11-19 consists of a computer, such as a portable computer, a desktop personal computer, a workstation, a network of systems, or other data processing resources. The nodes include memory for storing the business interface definition, processors that execute transaction processes supporting commercial transactions with other nodes in the network, and computer programs which are executed by the processors in support of such services. In addition each of the nodes includes a network interface for providing for communication across the Internet 19, or the other communication network.

In the environment of FIG. 1, nodes 11, 12, 13, 14, 16 and 18 are designated market participants. Market participants include resources for consumers or suppliers of goods or services to be traded according to commercial transactions established according to the present invention.

In this example, nodes 15 and 17 are market maker nodes. The market maker nodes include resources for registering business interface definitions, called a BID registry. Participants are able to send documents to a market maker node, at which the document is identified and routed to an appropriate participant which has registered to receive such documents as input. The market maker also facilitates the commercial network by maintaining a repository of standard forms making up a common business library for use in building business interface definitions.

In this example, the market participant 18 is connected directly to the market maker 17, rather than through the Internet 19. This connection directly to the market maker illustrates that the configuration of the networks supporting commercial transactions can be very diverse, incorporating public networks such as the Internet 19, and private connections such as a local area network or a Point-to-Point connection as illustrated between nodes 17 and 18. Actual communication networks are quite diverse and suitable for use to establish commercial transaction networks according to the present invention.

FIG. 2 is a heuristic diagram of nested structures in a business interface definition BID which is established for market participants in the network according to the present invention. The business interface definition illustrated in FIG. 2 is a data structure that consists of logic structures and storage units arranged according to a formal definition of a document structure, such as a XML document type definition DTD. The structure of FIG. 2 includes a first logic structure 200 for identifying a party. Associated with the logic structure 200 are nested logic structures for carrying the name 201, the physical address 202, the network address or location 203, and a set of transactions for a service 204. For each transaction in the service set, an interface definition is provided, including the transaction BID 205, the transaction BID 206, and the transaction BID 207. Within each transaction BID, such as transaction BID 205, logical structures are provided for including a name 208, a location on the network at which the service is performed 209, the operations performed by the service 210, and a set of input documents indicated by the tag 211. Also, the service BID 205 includes a set of output documents indicated by the tag 212. The set of input documents 211 includes a business interface definition for each input document for which the services are designed to respond, including input document business interface definitions 213, 214, and 215. Each business interface definition for an input document includes a name 216, a location on the network at which a description of the document can be found 217, and the modules to be carried in the document as indicated by the field 218. In a similar manner, the output document set 212 includes interface definitions for output documents including the output document BID 219, output document BID 220, and output document BID 221. For each output document BID, a name 222, a location on the network or elsewhere 223, and the modules of the document 224 are specified. The business interface definition for the participant as illustrated in FIG. 2 includes actual definitions of a logic structures to be utilized for the input and output documents of the respective services, or pointers or other references to locations at which these definitions can be found.

In the preferred system, the document of FIG. 2 is specified in an XML document type definition DTD, although other document definition architectures could be used, and includes interpretation information for the logical structures used in interpretation of instances of the documents. In addition, each of the transaction BIDs, input document BIDs and output document BIDs are specified according to an XML document type definitions. The XML type document is an example of a system based on parsed data that includes mark-up data and character data. Mark-up data identifies logical structures within the document and sets of character data identify the content of the logical structures. In addition, unparsed data can be carried in the document for a variety of purposes. See for example the specification of the Extensible Mark-up Language XML 1.0 REC-XML-19980210 published by the WC3 XML Working Group at WWW.W3.ORG/TR/1998/REC-XML-19980210.

Thus in an exemplary system, participant nodes in the network establish virtual enterprises by interconnecting business systems and services with XML encoded documents that businesses accept and generate. For example, the business interface definition of a particular service establishes that if a document matching the BID of a request for a catalog entry is received, then a document matching a BID of a catalog entry will be returned. Also, if a document matching the BID of a purchase order is received, and it is acceptable to the receiving terminal, a document matching the BID of an invoice will be returned. The nodes in the network process the XML documents before they enter the local business system, which is established according to the variant transaction processing architecture of any given system in the network. Thus, the system unpacks sets of related documents, such as MIME-encoded sets of XML documents, parses them to create a stream of "mark-up messages". The messages are routed to the appropriate applications and services using for example an event listener model like that described below.

The documents exchanged between business services are encoded using an XML language built from a repository of building blocks (a common business language) from which more complex document definitions may be created. The repository stores modules of interpretation information that are focused on the functions and information common to business domains, including business description primitives like companies, services and products; business forms like catalogs, purchase orders and invoices; standard measurements, like time, date, location; classification codes and the like providing interpretation information for logical structures in the XML documents.

The business interface definition is a higher level document that acts as a schema used for designing interfaces that trade documents according to the present invention. Thus the business interface definition bridges the gap between the documents specified according to XML and the programs which execute on the front end of the transaction processing services at particular nodes. Such front ends are implemented by JAVA virtual machines, or by other common architectures providing for interconnection of systems across a network. Thus, the business interface definition provides a technique by which a transaction protocol is programmed using the business interface definition document. The program for the protocol of the transaction is established by a detailed formal specification of a document type.

An example business interface definition BID based on a market participant document which conforms to an XML format is provided below. The market participant DTD groups business information about market participants, associating contact and address information with a description of services and financial information. This business information is composed of names, codes, addresses, a dedicated taxonomic mechanism for describing business organization, and a pointer to terms of business. In addition, the services identified by the market participant DTD will specify the input and output documents which that participant is expected respond to and produce. Thus, documents which define schema using an exemplary common business language for a market participant DTD, a service DTD, and a transaction document DTD specified in XML with explanatory comments follow:

Market Participant Sample

    <!DOCTYPE SCHEMA SYSTEM "bidl.dtd">
    <SCHEMA>
    <H1>Market Participant Sample BID</H1>
    <META
    WHO.OWNS="Veo Systems" WHO.COPYRIGHT="VeoSystems"
    WHEN.COPYRIGHT="1998" DESCRIPTION="Sample BID"
    WHO.CREATED="*" WHEN.CREATED="*"
    WHAT.VERSION="*" WHO.MODIFIED="*"
    WHEN.MODIFIED="*" WHEN.EFFECTIVE="*"
    WHEN.EXPIRES="*" WHO.EFFECTIVE="*"
    WHO.EXPIRES="*">
    </META>

    <!DOCTYPE SCHEMA SYSTEM "bidl.dtd">
    <SCHEMA>
    <H1>Service Description Sample BID</H1>
    <META
    WHO.OWNS="Veo Systems" WHO.COPYRIGHT="VeoSystems"
    WHEN.COPYRIGHT="1998" DESCRIPTION="Sample BID"
    WHO.CREATED="*" WHEN.CREATED="*"
    WHAT.VERSION="*" WHO.MODIFIED="*"
    WHEN.MODIFIED="*" WHEN.EFFECTIVE="*"
    WHEN.EXPIRES="*" WHO.EFFECTIVE="*"
    WHO.EXPIRES="*">
    </META>

           import com.veo.vsp.doclet.meta.Document;
    public class AddressPhysical extends Document {
           public static final String DOC_TYPE = "address.physical";
            String mStreet;
            String mCity;
           public final static int AK = 0;
           public final static int AL = 1;
           public final static int AR = 2;
           public final static int AZ = 3;
           public final static int CA = 4;
           . . .
           public final static int WI = 48;
           public final static int WV = 49;
           public final static int WY = 50;
            int mState;
            String mPostcode;
           public final static int AD = 51;
           public final static int AB = 52;
           public final static int AF = 53;
           public final static int AG = 54;
           public final static int AI = 55;
           public final static int AM = 56;
           . . .
           int mCountry;
           public AddressPhysical( ){
                  super(DOC_TYPE);
           mStreet = new String( );
           mCity = new String( );
                  this.mState = -1;
           mPostcode = null;
                  this.mCountry = -1;
           }
           public AddressPhysical(String doc_type) {
                  super(doc_type);
           mStreet = new String( );
           mCity = new String( );
                  this.mState = -1;
           mPostcode = null;
                  this.mCountry = -1;
           }
           static public AddressPhysical initAddressPhysical(String
     iStreet,String iCity,int
    iState,String iPostcode,int iCountry){
                  AddressPhysical obj = new AddressPhysical( );
                  obj.initiaiizeAll(iStreet, iCity, iState, iPostcode,
     iCountry);
                  return obj;
           }
           public void initializeAll(String iStreet,String iCity,int
     iState,String iPostcode,int
    iCountry){
                  mStreet = iStreet;
                  mCity = iCity;
                  mState = iState;
                  mPostcode = iPostcode;
                  mCountry = iCountry;
           }
           public String getStreet( ){
            return mStreet;
           }
           public String getStreetToXML( ){
                  if (getStreet( ) == null) return null;
                  char [ ]c = getStreet( ).toCharArray( );
                  StringBuffer sb = new StringBuffer( );
                  for (int x = 0; x < c.length; x++){
                   switch(c[x]){
                   case`>`:
                   sb.append(">");
                   break;
                   case`<`:
                   sb.append("<");
                   break;
                   case `&`:
                   sb.append("&");
                   break;
                   case""":
                   sb.append(""");
                   break;
                   case ".backslash."
                   sb.append(""");
                   break;
                   default:
                   if (Character.isDefined(c[x]))
                    sb.append(c[x]);
                   }
                  }
                  return sb.toString( );
           }
           public void setStreet(String inp) {
                  this.mStreet = inp;
           }
           public void streetFromXML(String n){
                  setStreet(n);
           }
           public String getCity( ){
            return mCity;
           }
           public String getCityToXML( ){
                  if (getCity( ) == nulI) return null;
                  char [ ] c = getCity( ).toCharArray( );
                  StringBuffer sb = new StringBuffer( );
                  for (intx= 0;x < c.length;x++){
                   switch(c[x]){
                   case `>`:
                   sb. append(">");
                   break;
                   case `<`:
                   sb.append("<");
                   break;
                   case `&`:
                   sb.append("&");
                   break;
                   case """:
                   sb.append(""");
                   break;
                   case ".backslash.":
                   sb.append(""");
                   break;
                   default:
                    if (Character.isDefined(c[x]))
                   sb.append(c[x]);
                   }
                  }
                  return sb.toString( );
           }
           public void setCity(String inp) {
                  this.mCity = inp;
           }
           public void cityFromXML (String n){
                  setCity(n);
           }
           public int getState( ){
            return mState;
           }
           public String getStateToXML( ){
                  switch (mState) {
                         case AK return "AK",
                         case AL return "AL",
                         case AR return "AR";
                         case AZ return "AZ",
                         . . .
                  }
            return null;
           }
           public void setState(int inp){
                  this.mState = inp;
           }
           public void stateFromXML(String s){
                  if(s.equals("AK"))mState = AK;
                  else if (s.equals("AL"))mState = AL,
                  else if (s.equals("AR"))mState = AR,
                  else if (s.equals("AZ"))mState = AZ,
                  . . .
           }
           public String getPostcode( ){
            return mPostcode;
           }
           public String getPostcodeToXML( ){
                  if (getPostcode( ) == null) return null;
                  char [ ]c = getPostcode( ).toCharArray( );
                  StringBuffer sb = new StringBuffer( );
                  for (int x = 0; x < c.length; x++){
                   switch(c[x]){
                  case `>`:
                   sb.append(">");
                   break;
                   case `<`:
                   sb.append("<");
                   break;
                   case `&`:
                   sb.append("&");
                   break;
                   case
                   sb. append(""");
                   break;
                   case ".backslash.":
                   sb.append(""");
                   break;
                   default:
                   if (Character.isDefined(c[x]))
                    sb.append(c[x]);
                   }
                  }
                  return sb.toString( );
           }
           public void setPostcode(String inp) {
                  this.mPostcode = inp,
           }
           public void PostcodeFromXML(String n){
                  setPostcode(n);
           public int getCountry( ){
            return mCountry;
           }
           public String getCountryToXML( ){
                  switch (mCountry){
                         case AD: return "AD";
                         case AE return "AE",
                         case AF: return "AF",
                         . . .
                  }
            return null;
           }
           public void setCountry(int inp) {
                  this.mCountry = inp;
           }
           public void countryFromXML(String s){
                  if(s.equals("AD"))mCountry = AD;
                  else if (s.equals("AE"))mCountry = AE;
                  else if (s.equals("AF"))mCountry = AF;
                  else if (s.equals("AG"))mCountry = AG;
                  else if (s.equals("AI"))mCountry = AI;
                  . .
           }
    }
    package com.veo.xdk.dev.schema.test.blib;
    import com.veo.vsp.doclet.meta.Document;
    public class AddressSet extends Document {
           public static final String DOC_TYPE = "address.set";
            AddressPhysical mAddressPhysical;
            String [ ] mTelephone;
            String [ ] mFax;
            String [ ] mEmail;
            String [ ] mInternet;
           public AddressSet( ){
                  super(DOC_TYPE);
                  this.mAddressPhysical = new AddressPhysical( );
           mTelephone = null;
           mFax = null;
           mEmail = null;
           mInternet = null;
           }
           public AddressSet(String doc_type){
                  super(doc_type);
                  this.mAddressPhysical = new AddressPhysical( );
           mTelephone = null;
           mFax = null;
           mEmail = null;
           mInternet = null;
           }
           static public AddressSet initAddressSet(AddressPhysical
     iAddressPhysical,String [ ]
    iTelephone,String [ ] iFax,String [ ] iEmail,String [ ] iInternet){
                  AddressSet obj = new AddressSet( );
                  obj initializeAll(iAddressPhysical, iTelephone, iFax, iEmail,
     iInternet);
                  return obj;
           }
           public void initializeAll(AddressPhysical iAddressPhysical,String [
     ] iTelephone,String [ ]
    iFax,String [ ] iEmail,String [ ] iInternet){
                  mAddressPhysical = IAddressPhysical;
                  mTelephone = iTelephone;
                  mFax = iFax;
                  mEmail = iEmail;
                  mInternet = iInternet;
           }
           public AddressPhysical getAddressPhysical( ){
            return mAddressPhysical;
           }
           public void setAddressPhysical(AddressPhysical inp) {
           this.mAddressPhysical = inp;
           }
           public String [ ] getTelephone( ){
            return mTelephone;
           }
           public String getTelephone(int index){
                  if (this.mTelephone == null)
                   return null;
                  if (index >= this.mTelephone.length)
                   return null;
                  if (index < 0 && -index > this.mTelephone.length)
                   return null;
                  if(index >= 0) return this.mTelephone[index];
                  return this.mTelephone[this.mTelephone.length + index];
           }
           public String [ ] getTelephoneToXML( ){
                  String [ ] valArr = getTelephone( );
                  if (valArr == null) return null;
                  String [ ] nvArr = new String[valArr.length];
                  for (int z = 0; z < nvArr.length; z++){
                  char [ ] c = valArr[z].toCharArray( ),
                  StringBuffer st = new StringBuffer( ),
                  StringBuffer sb = new StringBuffer( ),
                  for (int x = 0; x < c.length; x++){
                   switch(c[x]){
                   case `>`:
                   sb.append(">");
                   break;
                   case `<`:
                   sb.append("<");
                   break;
                   case `&`:
                   sb.append("&");
                   brea