Abstract:
A system for creating user defined software interface contracts for sending host system data to any external system. The external systems can reside on any type of hardware platform. The invocation of a contract is controlled by a set of user defined conditions known as an event. The creation of event and contracts is completely under the control of the users of the external systems with little or no support of the host system developers to establish new interfaces to the external systems.

Description:
This application is a continuation of Ser. No. 08/245,313 filed May 18, 1994, now abandoned. 
    
    
     TECHNICAL FIELD OF THE INVENTION 
     The present invention relates to a software system for dynamically defining interface contracts for extracting data from a host system containing the data and transmitting the data to one of a plurality of external systems requesting the data. 
     BACKGROUND OF THE INVENTION 
     In order to operate today&#39;s modern telecommunications systems sophisticated operations support systems are needed to manage the vast quantities of data that are necessary for the operation of the business. The operations support systems may be provided by a plurality of vendors where data must flow from one system to another for processing. One such system is the Work Force Administration (WFA) system developed by Bell Communications Research Inc. of Livingston, N.J. The WFA system essentially creates and tracks work orders with due dates for the provisioning and repair of telecommunication services. One sub-system within the WFA system is the Work Force Administration/Dispatch Out (WFA/DO) subsystem which communicates the work order data to other systems that have a need for the data. For example, within Southwestern Bell Telephone company there is a report generating software system called the Statistical Management Analysis Report Tracking System (SMARTS) which produces many statistical reports used to measure the installation work. In order for SMARTS to complete its functions it requires specific data from WFA/DO. However, SMARTS does not and should not receive all data generated by WFA/DO. Instead, only a subset of the data as defined by specified fields is required upon the happening of a specified event. These fields and events that define the data flow from WFA/DO to SMARTS are specified in what is known in the art as an interface contract. 
     An interface contract is a subset of data fields that are related and that are to be transmitted from the host system to a remote system upon the occurrence of a set of conditions. In the current art, interface contracts are customized hard coded software modules that are linked to each release of the software. In other words, with each new release of host system software there may be a need to update the interface contract software because there may be new fields in the data or data fields may be renamed. Furthermore, each receiving software system also evolves with the introduction of new software releases which may require a different subset of data from the host system. Such changes necessitate changes in the interface contract software. 
     Additionally, the data communicated from the host to the external system is transmitted according to a syntax defined by the communications protocol between the two systems. The naming conventions for the data in both the host and receiving systems may be different and may also change. 
     When there is a situation with a plurality of external systems requiring data from a host system there is then a plurality of interface contract software modules that require constant maintenance and modification. Such constant maintenance and modification support is expensive, and not very flexible. 
     Accordingly, it is one object of the present invention to create a system for dynamically creating interface contracts that are not dependent upon host system or external system software releases so that changes in either systems&#39; software doesn&#39;t require a programmer to rewrite the interface contract code. It is a further object of our invention to allow a user of a external system to generically define the data needed from the host and then have the system dynamically create an interface contract between the host and the user system using the users names for the data fields for requesting the information from the host. 
     SUMMARY OF THE INVENTION 
     Applicants&#39; invention is an method and system for dynamically creating user defined contracts between a host application and a receiving application requiring host data. Applicants&#39; event processing facility is comprised of an event table sub-system (ETS) module, event trigger (ETR) module, and event contract interface (ECI) module. The ETS subsystem module receives user supplied names for the host system data and events and stores this information in tables. The ETR monitors the host system database for change statements analyzing the change statement to see if a change occurred in all fields related to a dynamic condition. The ECI is the module that formats all messages and handles all requests for data. Simply stated, the ETR notifies the ECI when a possible condition defining an event may have occurred. The ECI then accesses the data in the ETR to verify if a user defined event has occurred and if so, it formats the data in accordance with the data requirements in the ETS tables and then sends the required data in the proper format to the external system. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     FIG. 1 illustrates the overall functional architecture of our invention. 
     FIG. 2 depicts the functional architecture of the event tabling sub-system. 
     FIG. 3 illustrates a field definition screen. 
     FIG. 4 illustrates a contract definition screen. 
     FIG. 5 illustrates an event definition screen. 
     FIG. 6 illustrates an event/contract invocation screen. 
     FIG. 7 depicts the location of the event trigger sub-system within the host system and its relationship with the other subsystems. 
     FIG. 8 depicts the location of the event contract interface sub-system and its relationship with the other subsystems. 
    
    
     DETAILED DESCRIPTION 
     Applicants&#39; invention can be applied to any situation where there is a need to establish a gateway between a host system and a plurality of external systems requiring data from the host system. Applicants herein describe in detail their invention as implemented within Bell Communications Research&#39;s Work Force Administration (WFA) System. This embodiment of our invention is known as the Event Processing Facility (EPF) within WFA and accordingly will be referred to as EPF throughout the remainder of this specification. This description is meant to be an illustrative embodiment and not a limitation on the invention&#39;s applicability to other similar situations that would be recognized by those skilled in the art. 
     FIG. 1 illustrates the functional architecture of our invention. The EPF 10 is a software implemented capability included within the WFA/DO system 12 where it is interposed between the database accessor 22 of WFA/DO 12 and the communications control module 24 which provides the gateway to a plurality of external operations systems 14 requiring WFA/DO data. Our invention is comprised of three main sub-systems: the event table sub-system 16, the event contract interface subsystem 18, and the event trigger sub-system 20. 
     The interrelationships between these subsystems can best be explained by describing an example data flow within our invention based on WFA data. In order to describe the data flow it is important to have a common understanding of the terms used. All data fields are related in some fashion into a domain. For example a WORKREQ domain defines all data fields for a work request. Within a domain, subsets of fields are related at a lower level into objects. For example, within the WORKREQ domain there is the object ORD that defines all the work order level fields within a work request. A TAG is the lowest entity in the data hierarchy; it is the name of a field within an object within a domain. For example, the tag DUEDATE is the name of a field within the ORD object further within the WORKREQ domain. 
     Processing of the data is contingent upon the happening of conditions which trigger events. A condition is a user defined rule which is defined in terms of values of a single tag. There are two types of conditions; static conditions and dynamic conditions. A static condition is a condition that occurs when a data field (i.e. tag) equals a specified value. A dynamic condition occurs when there are changes to a field. It is an important aspect of our invention that these conditions are specified by the users of the external systems by entering the rules into our invention via the event table sub-system 16. A set of one or more conditions within a domain defines an event. Our invention allows the user to generically define events that trigger the creating of an interface contract for communicating tag values from the host system (WFA) to the appropriate external system. 
     The discussion that follows will first describe the data flow and processing that occurs within our invention. Then the structure of each of the main sub-systems will be defined. 
     General Description of the Data Flow and Processing 
     The starting point for the operation of our invention is the ability of the user to associate names of a data fields used by the external system to the names of fields used internally by the host system. This is accomplished by the user entering data through the terminal 26 into the event table sub-system (ETS) 16 where the data is stored in a table within the table database 17 for the defined domain. The user would also use terminal 26 to enter event definitions into ETS 16 which would also be stored in the table database 17. The user would also use terminal 26 to enter contract definitions into ETS 16 and contract invocation rules into ETS 16 which both would be stored in tables in the table database for the each domain. Once the table have been populated by the user, our invention is ready to process data and dynamically create contracts for the external system for which the user had entered the data. 
     In general, our invention works as follows. The database accessor 22 monitors the host system database and communicates host system database changes to the event trigger (ETR) sub-system 20. What is communicated between the database accessor 22 and the ETR subsystem 20 is a message containing two images of the record that had changed in the database. One image would be of the record before the change the other image would be of the record after the change. The ETR sub-system 20 compares the two images within the record to the information within the &#34;clue&#34; module 24 looking for the occurrence of dynamic conditions. The clue module 24 is a table of only the dynamic conditions entered into the ETS system earlier. The clue module in our implementation is always loaded in resident memory to allow for fast processing. If the event trigger sub-system 20 finds that there has been changes to the fields defined in the &#34;clue&#34; 24 as indicating the possibility of an event, the ETR sub-system 20 sends a message containing the two record images to the event contract interface sub-system 18. The event contract interface (ECI) sub-system 18 analyzes the records received against the event definition table stored in the ETS 16. It rechecks all dynamic conditions and also checks all static conditions. If all the conditions have occurred then an event has occurred. Upon the determination that an event has occurred, the ECI sub-system 18 checks the event/contract invocation tables to see which contracts must be invoked. The ECI sub-system then retrieves all contract information that is stored in the contract definition tables within ETS 16. From the contract definition information, the ECI sub-system builds a message with the routing requirements and tag values as defined in the contract definition table and sends the contact message to the communications module 24 for forwarding to the appropriate external system 14. 
     What follows is a more detailed description of each sub-system. 
     Event Table Sub-system 
     FIG. 2 depicts in more detail the event table sub-system architecture. The ETS 30 is a screen based data entry system which presents the user at terminal 32 a series of screens for entering the appropriate data. The ETS 30 is pre-loaded with a directory of internal field names 34 for the host system data. This directory of field names 34 is used for creating four main types of tables which are than stored in the database 36. The ETS 30 also acts as a gateway to the database 36 for the ECI sub-system 40. All activity in the ETS 30 is controlled by control process 38. 
     Using the example of the EPF, one of the first screens the user would access is depicted in FIG. 3. This is the field directory screen. Under the column marked &#34;Internal Name&#34; 42 are a listing of all field names 44 from the field directory (item 34 of FIG. 2) for the domain WORKREQ 46 and object ORD 48. Associated with each field are certain characteristics such as length 50 in bytes, type of field 52 (i.e. binary, character, etc.), offset 53 (which indicates the position of the field from the beginning of the record), and Occ# 51 (which is the number of occurrences of this field in the record). This information is also provided by the field directory of the host system, in this case the WFA/DO system. The user then enters, under the TAG heading 56, the names 58 the external system that are to be associated to the host field names 44. For example, the internal field name SUB1Q 60 is known as LMOS --  SUB 62 by the external system in this example. The association is entered into the database by the the user entering LMOS --  SUB 62 and U 64 under command 66 indicating an update to the database. When the user finishes entering all the appropriate information the information is stored in a table in the tag value database 36a. Once the user completes the field definitions for all domains and objects that the user is interested in, the user moves on to contract definition. 
     FIG. 4 depicts the contract definition screen used by our invention in the WFA/DO implementation. Again, for the domain WORKREQ 46 and object ORD 48 the ETS presents the TAG names 70 entered by the user in the screen shown in FIG. 3. At this point in the process the user names the contract, in this example DUEDATE1 74 . The user then proceeds to define the routing criteria at locations 72 and 76. Finally, the user than selects the field (i.e. TAGs), the user would like to send to the location in the routing criteria when the DUEDATE1 contract is to be invoked. The user designates the fields by placing an X 78 next to the TAG names 70 under the CMD (command) heading 80. The user completes a contract definition for each contract the user requires to be sent to the external system from the host. These contract definitions are stored in contract definition tables 36b in the ETS database 36. 
     Next the user defines events that are used later in the process to invoke contracts. FIG. 5 depicts an example event definition screen from our WFA/DO implementation of our invention. This screen defines the user entitled event &#34;DUED --  EVT&#34; 82 for domain WORKREQ and object CKL 84. The conditions shown in lines 86 and 88 are entered by the user. Line 86 shows a static condition. The static condition occurs when JOBTYPE=&#34;I***&#34;. Line 88 depicts a dynamic condition. The dynamic condition occurs whenever the COMIT --  TD TAG changes. The event occurs whenever either of these conditions occur. If the user wanted the event to occur whenever both conditions happen, the user would enter an &#34;and&#34; instead of an &#34;or&#34; in location 90. Once the user defines all the appropriate events, these event definitions are stored in event definition tables 36c within database 36. Furthermore, once all the events are defined, applicants invention uses a clue generator software module (15 from FIG. 1) to read all the event tables stored in database 36 and extract all the dynamic conditions to create the CLUE module 24 which is loaded into the event trigger sub-system 20. 
     The final step in the set-up process is for the user to associate the user defined contracts to the user defined events. In our illustrative embodiment of our invention, this association is created by the user entering the appropriate information on a Event/Contract Invocation screen as illustrated in FIG. 6. As shown for the domain WORKREQ 46 the user associates contracts DUEDATE1 94 and DUEDATE2 96 to event DUED --  EVT 92. The contracts are associated by the add command 98 entered next the contract names. Similar to the other definitions, the event contract association information is stored in database 36 in the event/contract invocation tables 36d. 
     The ETS database with all these user defined tables are a key feature of our invention in that it divorces the external systems data naming conventions from that of the internal host system conventions. Therefore, when the host system is updated and an internal field name is changed, host system developers only have to change the name in the field definition directory and all the interface contracts for all the internal systems will be updated and will not have to be recorded. The opposite is also true. When an external system is modified, the external system administrator can make the modifications in the tables to update the contracts without having the host system developers rewrite the interface code. These benefits are a substantial saving in time and money while providing the users with increased flexibility in using the information. 
     The use of the user defined tables in the operation of our inventive system is further described in the detailed descriptions of the event trigger sub-system and the event contract interface sub-system described in the sections that follow. 
     Event Trigger Sub-system 
     The location of the event trigger sub-system within the host system and its relationship with the other sub-systems is depicted in FIG. 7. The event trigger sub-system 100 is composed of two modules. There is an event trigger control process 102 and the clue module 104. The event trigger control process 102 accepts input from the database accessor 106 for the host system 110. The database accessor is a software process created using well known techniques in the art from basic database access calls that are contained within a computer operating system. The database accessor 106 is created to send all records in the database with add, update, or delete activity to the event trigger control process 102. The message sent to the event trigger control process 102 contains an image of the database record prior to the change and an image of the database record after the change. The event trigger control process 102 calls the clue module 104 to load a table of the dynamic conditions for the data domain indicated by the records sent from the database accessor. As we recited earlier, the clue module 104 contains tables of the dynamic conditions defined by the user and stored in the event table sub-system database 112. The clue module tables are generated by a batch process 114 and are stored in active memory for easy access by the event trigger sub-system process. 
     The event trigger control process 102 compares the two images sent from the database accessor and identifies what has changed using the field&#39;s offset and length information. The identified change is then compared to the dynamic conditions contained within the clue module table for the appropriate domain to see if the dynamic conditions have occurred to indicate the occurrence of a possible event. 
     The purpose of using the event trigger control process is to drastically reduce the number of I/O requests to the event table sub-system database. There is going to be a large number of host system database changes that do not trigger events and therefore the event trigger control process and clue module acts as a pre-processor and buffer between the host system database changes and our invention&#39;s tables of conditions and events. 
     When it is determined a possible event has occurred, the event trigger process will insert the two images of the record to outgoing message queue to be sent to the event contract interface sub-system 108. 
     Event Contract Interface Sub-system 
     The location of the event contract interface (ECI) subsystem within the host system and its relationship with the other sub-systems is depicted in FIG. 8. The event contract interface sub-system 120 receives messages from the event trigger sub-system 122 which contains two images of the database record where the event trigger sub-system has determined that a possible event has occurred. The event contract interface sub-system calls the ETS control processor 123 to request the condition definition tables for the appropriate domain from the ETS table database 124. The ECI sub-system 120 calls an internal event analysis process 126 to analyze the two record images received from the ETR process 122. The event analysis process 126 identifies all tags and compares the tag values to the event conditions for a true or false determination. If the conditions are true then the event is deemed to have occurred and the event analysis process passes control of the processing back to the general control process of the ECI sub-system 120. The ECI sub-system then calls the event contract invocation table from the ETS table database 124 to determine which contracts should be invoked at the occurrence of an event (see FIG. 6). Once the ECI sub-system determines which contracts are to be invoked the ECI sub-system requests from the ETS database 124 the contract definition tables (see FIG. 4). The ECI sub-system then builds a outgoing message using tag value pairs, which are well known in the art, and sends the message to a communications control module 128 for forwarding to the appropriate external system. Flexible Computer Interface Format (FCIF) is an example of message construct using tag value pairs. 
     In our illustrative embodiment, the user has the option of batch processing the creation and sending of the outgoing contract messages instead of conducting the processing in real time. In the deferred mode, once it is determined that an event has occurred the records are stored until the user defined time when the contracts are created and then sent. 
     It is to be understood that the system and method described herein are not limited to the specific forms disclosed and illustrated, but may assume other embodiments limited only by the scope of the appended claims.