Abstract:
The system for workflow analysis and response performs labor studies and operations research in cross-platform systems involving software usage and electronic data interchange. The workflow system is able to integrate built-in tools of the respective platform components, and facilitate the implementation of analysis add-on packages and interfaces as they are developed.  
     The workflow system provides users with workflow records and processed displays and reports. The system provides a variety of Gantt chart reports to summarize work activity. Management sets parameters for notification when limits are exceeded. Analysis and response are performed in real-time and interactively.

Description:
FIELD OF THE INVENTION  
         [0001]    The present invention relates generally to software-based systems, and specifically to software for performing labor studies and operations research in working environments where most of the workflow is carried out as software usage and electronic data interchange.  
         BACKGROUND OF THE INVENTION  
         [0002]    Manual time measurement, the existing method for performing labor studies and operations research, is not suitable for the environments of computer software usage and electronic data interchange, as it calls for very close examination by, and a lot of attention from, the person conducting the measurements, in order to closely determine the screen usage statistics of the computer system. On the other hand, attempting to rely on data collected by the software being used has its own drawbacks, and is useful only as long as the persons being monitored use only one type of system (or resource), but often workflow progresses through a multi-platform environment, and integrating the different sources of workflow information calls for substantial manual effort.  
           [0003]    A commercial, cross-platform workflow data source is not known, and therefore, neither is any software package designed to analyze such data.  
           [0004]    Usually, workflow analysis applications may be performed in one of two ways:  
           [0005]    (a) by being a part of the system which provides the workflow design and resulting business applications, providing workflow analysis as a byproduct; or:  
           [0006]    (b) by being a part of a general purpose expert system, which after proper mapping of the different data sources into its own database, could perform analysis with its own expert-system capabilities.  
           [0007]    A common course of action, when a comprehensive display of complex workflows is needed, is to produce analysis reports for purposes of resource planning, re-engineering etc. Specialized consultants are hired to conduct a research project, collect and analyze information manually and expensively, and turn out a summary report. A major drawback of this method is that it is a one-time effort, producing historical data. In many cases, by the time such a report reaches its intended users, it has already become obsolete.  
         SUMMARY OF THE INVENTION  
         [0008]    Accordingly, it is a principal object of the present invention to overcome the limitations of existing workflow analysis and response systems and to provide improved methods and apparatus for implementing measurement systems.  
           [0009]    It is a further object of some aspects of the present invention to provide improved methods and apparatus for cross-platform labor and resource analysis measurement systems.  
           [0010]    It is a still further object of some aspects of the present invention to provide improved methods and apparatus for implementation of built-in workflow analysis and response measurement tools available within the systems being analyzed, thus making full use of the data collected.  
           [0011]    It is yet a still further object of some aspects of the present invention to provide improved methods and apparatus permitting the establishment of an infrastructure for the implementation of analysis add-on packages and interfaces as they are developed.  
           [0012]    A method for processing user resources, including the steps of:  
           [0013]    receiving the said user resources on a user multi-platform computer system;  
           [0014]    monitoring the workflow;  
           [0015]    automatically analyzing the processing of said resources to gather information, measure the results and respond to the workflow; and  
           [0016]    outputting decision-support data.  
           [0017]    Apparatus for processing user resources residing on a multi-platform system, which product includes:  
           [0018]    a system server to provide access to the required information;  
           [0019]    a system database for the storage of the said information required for the said system;  
           [0020]    a system administrator to edit information required for the operation of the said system; and  
           [0021]    a system consultant for advanced analysis of historical data.  
           [0022]    The workflow analysis and response system provides users with workflow records and processed displays and reports, while minimizing manual work and integration effort. Only an initial one-time expenditure of programming resources is required for the creation of appropriate code in the corporate information systems, or similar, joining together the corporate systems and the analysis system. This can be done by loading and using the system server interface from within specified Intervention Points inside the corporate system source code or scripting (customization) code. Furthermore, a unique feature of the analysis system is the way in which different elements, (including software engineering technologies, industrial engineering methodologies and mathematical concepts) are brought together to produce outputs which were either previously unobtainable or obtainable at a much higher effort and cost, and in a way which restricted their usefulness. In general, the programming tools provide the input to the system and the management tools provide its output. The abovementioned elements, their mode of functioning, and their outputs, are described hereinbelow.  
           [0023]    Hereinafter, the term “classification” refers to an attribute of operation, used to describe its outcome, sub-type or any other categorization. A classification is selected from a list of allowed classification types.  
           [0024]    Hereinafter, the term “event” refers to a meaningful point in time during the progress of an operation, whose event type describes that meaning. Several events may be recorded during a single operation.  
           [0025]    Hereinafter, the term “operation” refers to a part of a work process, carried out by a specific user, characterized by an operation type.  
           [0026]    Hereinafter, the term “state” refers to an attribute of operation, used to describe its current stage, status, or completion level. A state is selected from a specific state set.  
           [0027]    Hereinafter, the term “state set” refers to a list of possible states through which an operation proceeds.  
           [0028]    Hereinafter, the term “tag” refers to an attribute of operation, used to store any user-defined information string.  
           [0029]    Hereinafter, the term “type” refers to a predefined description of operation, classification or event, consisting of a unique numerical index, a unique string key, and a descriptive name.  
           [0030]    Hereinafter, the term “user” refers to a specific person selected from a fixed list of known users, carrying out an operation. A user may carry out several operations simultaneously.  
           [0031]    Hereinafter, the term “agent” refers to an employee being monitored by the workflow system.  
           [0032]    Hereinafter, the term “rule” refers to the definition of a reaction taken when a certain condition occurs.  
           [0033]    Hereinafter, the term “library” refers to a collection of related rules.  
           [0034]    The analysis system is a software package serving specifically as a workflow analysis and response system, and provides development tools for programmers. The analysis system can be integrated with existing business applications. It then counts, sorts and measures times of activities and events related to the usage of these applications by the business applications users. The system provides programmers with the interfaces necessary to embed the system “engine” within corporate or other information systems. The interfaces implemented, either in the development stage of new applications, or during integration with existing software, through customization tools such as VBA sold by Microsoft, or VB Script licensed by Microsoft. 
       
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0035]    In order to understand the invention and to see how it may be carried out in practice, a preferred embodiment will now be described, by way of non-limiting example only, with reference to the accompanying drawings, in which:  
         [0036]    [0036]FIG. 1 is a schematic illustration of the workflow control and analysis system, in accordance with a preferred embodiment of the present invention;  
         [0037]    [0037]FIG. 2 is a schematic illustration of the operational tables and their interaction with the actual workflow, in accordance with a preferred embodiment of the present invention;  
         [0038]    [0038]FIG. 3 is a schematic illustration of the functions of the system model, in accordance with a preferred embodiment of the present invention;  
         [0039]    [0039]FIG. 4 is a schematic illustration of how the system administrator participates in system operation, in accordance with a preferred embodiment of the present invention;  
         [0040]    [0040]FIG. 5 is a flow chart that schematically illustrates how the system organizes the security interactions, in accordance with a preferred embodiment of the present invention;  
         [0041]    [0041]FIG. 6 is a schematic illustration of the functions of the system supervisor, in accordance with a preferred embodiment of the present invention;  
         [0042]    [0042]FIG. 7 is a schematic illustration of the functions of the system reactor, in accordance with a preferred embodiment of the present invention;  
         [0043]    [0043]FIG. 8 is a computer screen image of a dialog box illustrating the reactor dialog, in accordance with a preferred embodiment of the present invention;  
         [0044]    [0044]FIG. 9 is a computer screen image illustrating the creation of a time-dependent “event,” in accordance with a preferred embodiment of the present invention;  
         [0045]    [0045]FIG. 10 is a computer screen image illustrating a notice message, in accordance with a preferred embodiment of the present invention;  
         [0046]    [0046]FIG. 11 is a flow chart that schematically illustrates how the function of the callflow analyzer, in accordance with a preferred embodiment of the present invention;  
         [0047]    [0047]FIG. 12 is a graph that schematically illustrates the function of a Gantt chart, in accordance with the prior art;  
         [0048]    [0048]FIG. 13 is a schematic illustration of the functions of the callflow analyzer, in accordance with a preferred embodiment of the present invention;  
         [0049]    [0049]FIG. 14 is a computer screen image illustrating the main window of the CFA user interface, in accordance with a preferred embodiment of the present invention;  
         [0050]    [0050]FIG. 15 is a computer screen image illustrating the “roll” and “filter” features of the main window of the CFA user interface, in accordance with a preferred embodiment of the present invention.  
         [0051]    [0051]FIG. 16 is a set of computer screen images illustrating the full sub-windows of the CFA user interface, in accordance with a preferred embodiment of the present invention.  
     
    
     DETAILED DESCRIPTION OF PREFERRED EMBODIMENTS  
       [0052]    Reference is now made to FIG. 1, which illustrates the workflow control and analysis system  10 , in accordance with a preferred embodiment of the present invention. A computer  18  stores the corporate information systems source code  22  and a communications module  24  to initiate calls to the systems interface. Mainframe  18  interacts with the system components through a system server object library  26 . The system  10  provides supervisory users with the following components stored on the system database  28 :  
         [0053]    a “System Administrator”  30  for setting up initial workflow parameters, users and security;  
         [0054]    a “System Supervisor”  32  for producing real-time workflow monitoring screens;  
         [0055]    a “System Reactor”  34  for defining and activating alert and response rules;  
         [0056]    a “System Executive”  36  for creating and distributing analysis reports; and  
         [0057]    a “System Consultant”  38  for advanced analysis of historical data.  
         [0058]    Database  28  includes various kinds of tables. “Operational tables” concern the actual workflow information. By contrast, “administrative tables” contain information regarding security, system information, etc.  
         [0059]    [0059]FIG. 2 is a schematic illustration of the operational tables  40  and their interaction with the actual work flow, in accordance with a preferred embodiment of the present invention. Operational tables  40  interact with the actual workflow information, as opposed to the “administrative tables”, which contain information regarding security, system information etc., as described hereinbelow. Table I illustrates the details of some of the operational tables.  
                           TABLE I                       Table   FieldName   Description   Type                   AllowedOperations   Opindex   Operation Identifier Index   integer       42   OpKey   Operation Applicative Key   string           OpName   Operation Descriptive Name   string       AllowedClassifica-tions   ClIndex   Classification Identifier Index   integer       44   ClKey   Classification Applicative Key   string           ClName   Classification Descriptive Name   string       AllowedEvents 46   EvIndex   Event Identifier Index   integer           EvKey   Event Applicative Key   string           EvName   Event Descriptive Name   string       StateSets 48   SsIndex   State Set Identifier Index   integer           SsKey   State Set Applicative Key   string           SsName   State Desriptive Name   string       AllowedStates 50   StIndex   State Identifier Index   integer           StKey   State Applicative Key   string           StName   State Descriptive Name string   string           StSsIndex   State Set Index   integer           StOrder   State Order In Set   integer       AllowedUsers 52   UsIndex   User Identifier Index   integer           UsKey   User Applicative Key   string           UsName   User Name   string           UsGrIndex   User Group Index   integer       AllowedGroups 54   GrIndex   Group Identifier Index   integer           GrName   Group Descriptive Name   string           GrWeekHr   Group Work Hours per Week   byte           GrCostHr   Group Cost per Hour   integer       TimedOperations 56   TiIndex   Timer Identifier Index   long           TiOpIndex   Timer Operation Index   integer           TiUsIndex   Timer User Index   integer           TiClIndex   Timer Classification Index   integer           TiStOrder   Time State Order in Set   integer           TiSsIndex   Timer State Set Index   string           TiStart   Timer Starting Time date   time           Time           TiFinish   Timer Finishing Time date   time           Time           TiLinked   Timer Linked Record Index   long           Index           TiPaused   Timer is Paused   bit       TimedEvents 58   TvIndex   Timed Event Identifier Index   long           TvTiIndex   Timed Event Timer Index   long           TvEvIndex   Timed Event Event Index   integer           TvTime   Timed Event Occurance Time date   time       TaggedOperations 60   TgTiIndex   Tag Timer Index   long           TgString   Tag String   string                  
 
         [0060]    [0060]FIG. 3 is a schematic illustration of the functions of the system model  70 , in accordance with a preferred embodiment of the present invention. The system server  72  uses a hierarchy of classes, which together form a COM library called “SYSTEMLib”. System server  72  contains a set of objects which perform the actual workflow data collection. These objects can be manipulated by programmers through a Component Object Modeling (COM) interface, from within any instruction code set that recognizes COM. The entire functionality of system server  72  is available to the programmer/user through the classes of the SYSTEMLib library.  
         [0061]    The main function of system server  72  is to provide system information, as well as access to, or initiation of, lower level objects. SyOperations  74  and SyOperation  76  are where most activity occurs, i.e., where ongoing operations, which have started in the current session, are stored.  
         [0062]    The low level objects, SyEvents  78  and SyEvent,  80  store information regarding events, which have occurred during ongoing operations. Each member of SyOperations, e.g., those related to a specific ongoing operation, provides access to SyEvents containing events related to that operation.  
         [0063]    The classes of system server  72  are sorted in a generally descending order according the hierarchy of FIG. 3:  
         [0064]    system server  72 ;  
         [0065]    system operations  74 ;  
         [0066]    system operation  76 ;  
         [0067]    system events  78 ; and  
         [0068]    system event  80 .  
         [0069]    Members within a class are sorted alphabetically.  
         [0070]    Table II is a set of seven sub-tables, TABLE IIA through TABLE IIG, illustrating the details of the hierarchy of system server classes.  
                                                                                                                         TABLES II                           Preferred system server class: TABLE IIA                       ClassificationKeys   A SyAllowedClassifications collection of allowed           classification codes.                  ContinueOperation (Index)   Adds to Operations an operation previously paused.           Returns new SyOperation.                  EventKeys   A SyAllowedEvents collection of allowed event keys.                  OperationKeys   A SyAllowedOperations collection of allowed           operation keys.                  Operations   Collection of ongoing SyOperations.                  StartOperation(OpKey,   Adds a new Operation to Operations. Returns new       [UsKey], [StateSet,   SyOperation.       [InitialState]])                  StateSetKeys   A SyAllowedStateSets collection of allowed state           Keys.                  Time   Returns server clock time.                  CheckVersion (Major, Minor)   Returns true if current System version is compliant           with the version specified.            Preferred system server operations class: TABLE IIB                       Count( )   Returns number of ongoing           Operations.                  FindOperation(Index)   Returns Operation by TimedOperations index.                  Item(Index)   Returns an Operation from the collection.                  PauseUser(UsKey)   Pauses all of user&#39;s ongoing operations.                  StopUser(UsKey)   Stops all of user&#39;s ongoing operations.            Preferred system server operation class: TABLE IIC                       AddEvent(EvKey)   Adds a new Event to Events. Returns new SyEvent.                  Chain (OpKey, StateSet,   Stops current operation and Starts a new one, linking       [InitialState]])   the two. Returns new SyOperation.                  Classification   Set/returns Classification key.                  Events   A collection of Event objects for operation.                  Index   Returns ongoing operation index.                  NextState( )   Increases state by 1. Returns state prior to change.                  OperationKey   Returns Operation key identifier.                  Pause( )   Removes operation from Operations, without           marking a finishing time.                  PreviousState( )   Decreases state by 1. Returns state prior to change.                  StartedTime   Returns starting time.                  State   Sets/returns State key.                  StateSet   Returns State Set Key.                  Stop( )   Removes operation from Operations, marking its           finishing time.                  Tag   Sets/returns Operation tag.                  UserKey   Returns User Key identifier.            Preferred system server events class: TABLE IID                       Count( )   Returns number of events.                  Item(Index)   Returns an Event from the collection.            Preferred system server event class: TABLE IIE                       Index   Returns Index.                  Key   Returns Event Key.                  Time   Returns Time of event.            System key collection classes: SyAllowedEvents, SyAllowedClassifications,       SyAllowedStateSets, SyAllowedOperations: TABLE IIF                       Count( )   Returns number of items.                  Item(Index)   Returns item of matching index.            System key item classes: SyAllowedEvent, SyAllowedClassification,       SyAllowedStateSet, SyAllowedOperation: TABLE IIG                       Index   Index number of item.                  Key   Key string of item.                  Name   Full name string of item.                  
 
         [0071]    Normally, operation&#39;s attributes are not set as free-text values (with the exception of the Tag). Rather, the operation&#39;s type, user, classification, state, event types etc. are selected from lists of “allowed values”, such as AllowedOperations, AllowedUsers, and so on.  
         [0072]    This selection may be done directly using an allowed key that is known to the programmer, for instance:  
         [0073]    MYOPERATION.CLASSIFICATION=“SUCCESSFUL” 
         [0074]    or via the key item classes, for instance:  
         [0075]    MYOPERATION.CLASSIFICATION=SYSERVER.ALLOWEDCLASSIFICATIONS. ITEM(CLNUMBE R). KEY  
         [0076]    The System Administrator  
         [0077]    System administrator  30  edits information required for the operation of system  16 . This includes mainly user authorizations and workflow parameters. User permissions are defined using a scheme described hereinbelow. According to this scheme, each system “document” (i.e. an “Executive” report, a “Supervisor” online screen etc.) can be assigned to a group and/or security level. Only then is the document accessible by users with appropriate security level and group designation on the specific application (“Executive”, “Supervisor” etc.). The same scheme is applied for non document-specific permissions, such as logging in into an application.  
         [0078]    The workflow parameters tables  92  contain most of the information included in the “operational tables”, described hereinabove (system database  28 ), with the exception of TimedOperations, TaggedOperations and TimedEvents, which record actual workflow execution  94  and are automatically created by system server  26 .  
         [0079]    [0079]FIG. 4 is a schematic illustration of how system administrator  30  participates in system operation  90 , in accordance with a preferred embodiment of the present invention.  
         [0080]    The Preferred System Security Scheme  
         [0081]    [0081]FIG. 5 is a flow chart that schematically illustrates how the system organizes the security interactions  100 , in accordance with a preferred embodiment of the present invention.  
         [0082]    Table III illustrates the details of the of the security parameters corresponding to the table elements of FIG. 5.  
                           TABLE III                       Table Elements   Field Name   Description   Type                   AdminUsers   AdIndex   Administrative User Index   integer       102   AdName   Administrative User Name   string           AdPassword   Administrative User Password   string           AdMachine   Administrative User MSMQ Site   string           AdMail   Administrative User E-Mail   string       UserRoles   UrAdIndex   Administrative User Index   integer       104   UrArIndex   Administrative Role Index   integer       AdminRoles   ArIndex   Administrative Role Index   integer       106   Name   Administrative Role Name   string       RolePermits   RpArIndex   Administrative Role Index   integer       108   RpApIndex   Administrative Permit Index   integer       AdminPermits   ApIndex   Administrative Permit Index   integer       110   ApName   Administrative Permit Name   string           ApApp   Administrative Permit   string               Application                  
 
         [0083]    [0083]FIG. 6 is a schematic illustration of the system supervisor functions  120 , in accordance with a preferred embodiment of the present invention.  
         [0084]    The System Supervisor  
         [0085]    The system supervisor  32  is a monitoring tool designed to enable authorized personnel to watch online workflow information using a web (Internet/intranet) browser  122 . System supervisor  32  is in essence a set of two separate applications:  
         [0086]    The System Supervisor-e  124  is the editor, with which online pages are created and configured; and:  
         [0087]    The System Supervisor-i  126  is a viewer, an applet which is run on browser  122  and with which pages are viewed and populated with online data.  
         [0088]    Supervisor-i  126  components have a cross-platform capability, so that system  16  online data pages can be displayed from any operating system. This is achieved by putting together a wide range of available software technologies, the most notable of which are Java licensed by Sun, the Java DataBase Connectivity (JDBC) licensed by Sun and Extensible Markup Language (XML) supported by Microsoft and other vendors. XML Document Object Module (DOM)  128  is a specification for application program interfaces for accessing the content of XML documents. DOM is used because it provides the expected format for relational, hierarchical and non-symmetric data representation. Java programming language, being robust, secure, and automatically downloadable on a network, is an optimal basis for cross-platform database applications. JDBC driver  130  is the mechanism for talking from Java to remote data sources.  
         [0089]    Supervisor-i Data Flow.  
         [0090]    The Supervisor-i Java applet is preferably loaded into a client browser in this preferred embodiment invoking suitable components such as Swing Java components (licensed from Sun). This process may require the Plug-In for Java  2  that downloads automatically upon a browser&#39;s request. Said applet establishes a connection to the system database  28  by invoking a JDBC Driver  130  Manager. A Connection object is used to pass SQL statements to main system database  128 . The applet does not need to know which SQL statements are being sent, and is not involved in their generation. All SQL statements transferred to JDBC Driver  130  are obtained from the corresponding XML file  132 . A security layer may be applied, if so desired, so that the open database port is safe. The exact security means (such as a Virtual Private Network (VPN) or other methods) are transparent to system  16  and are not further elaborated. VPN is the use of encryption in the lower protocol layers to provide a secure connection through the otherwise insecurity of Internet operations.  
         [0091]    Supervisor-e  124  is a Windows application whose main function is to create, edit, publish and grant permissions to the XML files  132 , which represent different online pages. Editing is done in the normal windows fashion—Drag &amp; Drop, Cut &amp; Paste to place objects on the screen; mouse clicking on objects (or menu selection) to change properties. Editing mode does not have to be “pixel precise”: it is left up to supervisor-i  126  applet to do the final arrangement of objects in the browser, according to window size.  
         [0092]    Some of the objects that may be placed on the screen are:  
         [0093]    Table Display—preferably a grid, which supervisor-i  126  applet can populate with system database  28  information;  
         [0094]    Label—plain text, which may be assigned a hyperlink; and  
         [0095]    Image—a web graphic (such as Graphics Interchange Format (GIF, a service mark of CompuServe) or Joint Photographic Experts Group (JPG) format), which may be assigned a hyperlink.  
         [0096]    The table display may be chosen among one of the following basic types, to which additional types could be added on. Each type has its own unique set of columns, row selection options, row order options and summary options, such as:  
         [0097]    The User Cumulative Time Display displays for each user/operation, the number of operations this user performed and their duration, since any selectable time such as midnight, beginning of month, etc;  
         [0098]    The User Current Display displays for each user its current operation and time since any selectable time such as midnight, beginning of month, etc, based on selecting his latest unfinished operation;  
         [0099]    The Operation Display displays for each operation or classification the number of operations performed by that classification and their duration, since any selectable time such as midnight, beginning of month, etc; and  
         [0100]    The Event Display stores for all the events that took place since any selectable time such as midnight, beginning of month, etc, their time of occurrence, their destination (###) and the operation during which they took place.  
         [0101]    User Selectable Time Period such as Daily Display  
         [0102]    The following columns are among those that are available in this display:  
         [0103]    User Name;  
         [0104]    Group Name;  
         [0105]    Operation;  
         [0106]    Count;  
         [0107]    Average Length;  
         [0108]    Minimum Length; and  
         [0109]    Maximum Length.  
         [0110]    The following row selections are among those that can be made:  
         [0111]    User(s) or all;  
         [0112]    Group(s) or all; and  
         [0113]    Operation(s) or all.  
         [0114]    The preferred sort order for the rows is: first—group, then-user and last—operation.  
         [0115]    User name, group and operation can be selected (on run-time) as filters; Count, average length, minimum length and maximum length can be used to set color codes.  
         [0116]    The following summaries are among those that are available in this display:  
         [0117]    User Name—none;  
         [0118]    Group Name—none;  
         [0119]    Operation—none;  
         [0120]    Count—sum(count);  
         [0121]    Average Length—sum(count*average length)/sum(count);  
         [0122]    Minimum Length—min(minimum length); and  
         [0123]    Maximum Length—max(maximum length).  
         [0124]    An Exemplary User Current Display  
         [0125]    The following columns are among those that are available in this display:  
         [0126]    User Name;  
         [0127]    Group Name;  
         [0128]    Operation;  
         [0129]    State Order;  
         [0130]    State Name; and  
         [0131]    Time.  
         [0132]    The following row selections can be made  
         [0133]    User(s) or all;  
         [0134]    Group(s) or all;  
         [0135]    Operation(s) or all;  
         [0136]    State Order(s) (value for ongoing or 0 if finished) or all; and  
         [0137]    State Name(s) (state name for ongoing or “[finished]”) or all.  
         [0138]    The sort order for the rows is preferably: first—group then—user.  
         [0139]    User name, group, operation and state can be selected (on run-time) as filters.  
         [0140]    Time and status can be used to set color codes.  
         [0141]    The following summaries are among those available in this display:  
         [0142]    User Name—none;  
         [0143]    Group Name—none;  
         [0144]    Operation—none;  
         [0145]    State Order—none;  
         [0146]    State Name—none; and  
         [0147]    Time—count(*).  
         [0148]    An Examplary Operation Display  
         [0149]    The following columns are available in this preferred display:  
         [0150]    Operation;  
         [0151]    Classification;  
         [0152]    Count;  
         [0153]    Average Length;  
         [0154]    Minimum Length; and  
         [0155]    Maximum Length.  
         [0156]    The following row selections can be made in this preferred display:  
         [0157]    Operation(s) or all; and  
         [0158]    Classification(s) or all.  
         [0159]    The preferred sort order for the rows is: first—operation then—classification.  
         [0160]    Classification and operation can be selected (on run-time) as filters.  
         [0161]    Count, average length, minimum length and maximum length can be used to set color codes.  
         [0162]    The following summaries are among those available in this display:  
         [0163]    Operation—none;  
         [0164]    Classification—none;  
         [0165]    Count—sum(count);  
         [0166]    Average Length—sum(count 
         [0167]    average length)/sum(count);  
         [0168]    Minimum Length—min(minimum length); and  
         [0169]    Maximum Length—max(maximum length).  
         [0170]    Event Display  
         [0171]    The following columns are among those available in this display:  
         [0172]    Day Time;  
         [0173]    Event Name;  
         [0174]    User Name;  
         [0175]    Group Name; and  
         [0176]    Operation.  
         [0177]    The following row selections are among those that can be made:  
         [0178]    User(s) or all;  
         [0179]    Group(s) or all;  
         [0180]    Events(s) or all; and  
         [0181]    Operation(s) or all.  
         [0182]    The preferred sort order for the rows is decreasing time from a selectable event.  
         [0183]    User name, group, operation and event can be selected (on run-time) as filters; event and operation can be used to set color codes.  
         [0184]    The following summaries are among those available in this display:  
         [0185]    Day Time—count(*);  
         [0186]    Event Name—none;  
         [0187]    User Name—none;  
         [0188]    Group Name—none; and  
         [0189]    Operation—none.  
         [0190]    An Exemplary Table Display Appearance  
         [0191]    The following is how an exemplary display object is preferably arranged by Supervisor-i  126  to appear in the browser, depending on the options selected. The parameters shown in Italic font are all part of the object&#39;s property page, which is user editable via Supervisor-e  124 .  
         [0192]    If DisplayBorder is on, the object is surrounded by a border, with the color defined in the page properties.  
         [0193]    Inside, if ShowTitle is on, the title is displayed on the row, justified according to page properties.  
         [0194]    Below the title, the display itself is displayed, with a grid if DisplayGrid is on.  
         [0195]    The top row (two below the title) holds column names, if ShowColumnNames is on, for all SelectedColumns. Names are displayed in bold text with the page properties background color as their background.  
         [0196]    Below, all values that match the row selection is displayed, if Show Values is on. If EnableColorCodes is also on, a colored background appears behind each value in the relevant column.  
         [0197]    If either EnableRuntimeFilters or ShowSummaries is on, two additional rows are displayed:  
         [0198]    In the first row, with bold text and the page properties background color as background, are displayed the following: “Avg.”, “Min”, “Max”, “Count”, “Sum” for summary columns. A “Filter” button for filter columns. Pressing that button prompts for a filter value.  
         [0199]    In the second row, for all summary columns, the summary value is displayed (calculated for all selected/filtered rows); for all filter columns, the filter is displayed, or “*” if none is selected. Other fields remain empty.  
         [0200]    The System Reactor  
         [0201]    [0201]FIG. 7 is a schematic illustration of the functions of the system reactor  140 , in accordance with a preferred embodiment of the present invention. System Reactor  140  is an alert management tool. It is designed to enable authorized personnel to define specific workflow conditions as alert rules, and specify how to respond when these conditions occur; and it includes various software components, which perform the actual testing of conditions and execution of responses.  
         [0202]    Reactor Components  
         [0203]    The following components form an exemplary system reactor  140 , as shown in FIG. 7:  
         [0204]    The Rules Editor  142  is an application that enables the user to visually create, edit and publish rules. Several “wizards” are included to make rule creation easier and more intelligent, as described in the following pages.  
         [0205]    Reactor Triggers  144  are a set of database  28  triggers, activated upon insertion into the TimedOperations and TimedEvents, or updating (by adding FinishTime) to TimedOperations table, which supply the initial data for some of the condition tests  
         [0206]    The System Span  146  checks conditions for rules with a fixed testing time (unlike rules which are constantly being checked by triggers). Span  146  is initiated when necessary by the operating system task scheduler  148  (like Windows Task Scheduler).  
         [0207]    The System Herald  150  is a service that receives alerts from various sources (Span  146 , triggers  144 ) and performs the required action, as defined by the appropriate rule. The reaction may be notifying users, executing a program etc. User notification may either be via e-mail (by SMTP  152 ) or with System&#39;s own “Notice”.  
         [0208]    The System Notice  154  is a pop-up message agent. Notice  154  receives Herald messages that are buffered by a local operating system Herald queuing service  156  (like Microsoft&#39;s MSMQ). This can be used to differentiate Reactor alerts from regular e-mail.  
         [0209]    Rules Editor  142  is a windows-based application, which can be installed on system server  26  hardware or on any remote PC. Working with the product is handled via a main menu, and using an “explorer” style GUI.  
         [0210]    The main menu options are:  
         [0211]    File;  
         [0212]    Edit;  
         [0213]    Tools;  
         [0214]    Help; and  
         [0215]    File Menu.  
         [0216]    The “files” referred to are in fact rules, as they appear in the reactor “explorer” screen.  
         [0217]    The file menu options are:  
         [0218]    Load Rules;  
         [0219]    Publish Rules;  
         [0220]    Load Local . . . ;  
         [0221]    Save Local . . . ;  
         [0222]    New Library;  
         [0223]    New Rule;  
         [0224]    . . .  
         [0225]    Print . . . ; and  
         [0226]    . . .  
         [0227]    Exit.  
         [0228]    “load rules” loads the set of active rules from the server database, preventing them from being altered by another user for the duration of the editing session. “publish” updates the server with the edited rules.  
         [0229]    “load local” and “save local” allow the user to maintain a local copy or backup of the set of rules; this set is not actually used until published on the server.  
         [0230]    A “library ” is a collection of related rules.  
         [0231]    The library sub-menu is:  
         [0232]    Operation;  
         [0233]    Classification;  
         [0234]    State; and  
         [0235]    Work Group.  
         [0236]    A library can be created directly under the main library, or under an existing library. A library is preferably a different type than its parent libraries.  
         [0237]    When “new library&gt;Operation” is selected, a window pops up where the user can select one or more operations, by its name, from the operations table predefined by the administrator.  
         [0238]    Similarly, “new library&gt;Classification” opens a window which lists predefined classification types. “new library&gt;State” opens a window where a state set and value can be selected.  
         [0239]    “new library&gt;Work Group” opens a window which lists predefined groups.  
         [0240]    A “rule” is hereby referred to as the definition of a reaction taken when a certain condition occurs. Rules always relate to the libraries in which they reside. Exemplary relations may be, but need not always be, of the following forms:  
         [0241]    General rule: if a rule is created inside the main (1st level) library, it relates to every operation performed by any person in the organization.  
         [0242]    2nd degree rule: if a rule is created inside a 2nd level library, it relates to it, e.g., operations of a certain type.  
         [0243]    3rd degree rule: if a rule is created inside a 3rd level library, it relates to it and its parent library, e.g., operations of a certain type performed by a specific group.  
         [0244]    4th degree rule: if a rule is created inside a 4th level library, it relates to all parent libraries: operations of a certain type, performed by a specific group and given a particular classification.  
         [0245]    The rule sub-menu is:  
         [0246]    Timer;  
         [0247]    Event; and  
         [0248]    Quota.  
         [0249]    When a timer rule is selected, a window opens with the following tabs:  
         [0250]    Time selection—where the user is required to enter the operation length, which initiates a reaction.  
         [0251]    Reaction—where the user selects the type of reaction taken.  
         [0252]    Selecting an event rule opens a window with the following tabs:  
         [0253]    Event selection—where the user can select an event from the events table predefined by the administrator.  
         [0254]    Reaction—where the user selects the type of reaction taken.  
         [0255]    When a quota rule is selected, a window opens with the following tabs:  
         [0256]    Quota selection—where the user is required to enter the time of day when to check quota, the quantity to check for, and whether to invoke reaction if quantity is &gt;,&gt;=, =, &lt;&gt;, &lt;=, or &lt; than quota.  
         [0257]    Reaction—where the user selects the type of reaction taken.  
         [0258]    Edit Menu  
         [0259]    Some of the possible edit menu options are:  
         [0260]    Change Library . . . ;  
         [0261]    Change Rule . . . ;  
         [0262]    Active;  
         [0263]    . . .  
         [0264]    Cut;  
         [0265]    Copy;  
         [0266]    Paste;  
         [0267]    . . .  
         [0268]    Delete; and  
         [0269]    Select All.  
         [0270]    “Change library” reopens the library selection window (with either the operations, classifications or work groups table). “Change rule” opens the rule setting window, with the “reaction” tab on. “Active” can be marked on (default) or off, indicating whether a rule or a library is to be applied.  
         [0271]    Tools Menu  
         [0272]    Some of the possible the tools menu options are:  
         [0273]    Libraries Wizard . . . ;  
         [0274]    Rules Wizard;  
         [0275]    Rules Analyzer;  
         [0276]    . . .  
         [0277]    Arrange Icons; and  
         [0278]    . . .  
         [0279]    View All.  
         [0280]    “libraries wizard” opens up a series of windows that allow the user to quickly create a full set of libraries which match the predefined administrative tables. This option can be applied to the main library, to a specific 2nd or 3rd level library, or to a group of libraries of the same level (2nd or 3rd ), type and parent libraries type. The “create libraries” wizard works through the following steps, each with “next”/“previous”/“cancel” options:  
         [0281]    Step  1 : the wizard informs the user of the initial level of creation, parent libraries and how many levels could be created. For instance “2nd level: Workgroup. 3rd level: current  2  levels may be added.” 
         [0282]    Step  2 : the wizard asks for the type of library to create on the current level (operations, classifications or work group—but not a type which exists as a parent library). The user can also select whether to create libraries for all records in the administrative table, or only for those in use, i.e. for which records exist in the TimeSummary table (operations and classifications) or UserIndex table (work groups).  
         [0283]    Step  3 : if more than 1 level can be added, step  3  is similar to step  2 . A “skip” option can be used to skip to step  5 .  
         [0284]    Step  4 : if a third level can be added, the wizard informs the user of the library type which is created. For instance “4 th level: Classification”. The user selects whether to create libraries for all records or only for those in use. The “skip” option can be used.  
         [0285]    Step  5 : the program queries database  28  for all libraries as requested; when finished, a list of all the resulting libraries appears (each row in the form “Operation: OpName/Classification: CIName/Group: GrName”). All rows are initialy selected; the user may deselect rows. A “create” option can be used to create the selected libraries.  
         [0286]    The rules sub-menu options are:  
         [0287]    Timers . . . ;  
         [0288]    Events . . . ; and  
         [0289]    Quotas . . .  
         [0290]    These options can be applied to the main library or to any number of lower level libraries.  
         [0291]    The “timer” wizard works through the following steps, each with “next”/“previous”/“cancel” options:  
         [0292]    Step  1 : the wizard asks the user to select a minimum value, maximum value and interval (in selectable units such as minutes).  
         [0293]    Step  2 : similar to the “reaction” tab in the new/change-rule options.  
         [0294]    Step  3 : the wizard asks the user whether to create rules in all levels selected, or only in lowest level of each branch. A “create” option can be used to create the defined rules.  
         [0295]    For instance, if the user chooses minimum=10, maximum=20, interval=5, than rules for “10:00”, “15:00” and “20:00” are created in each of the selected libraries.  
         [0296]    The “event” wizard performs the following steps, each with “next”/“previous”/“cancel” options:  
         [0297]    Step  1 : the program queries the database for all event types; when finished, a list of all the resulting event names. All rows are initially selected; the user may deselect rows, or mark “only in use” (i.e., only events which have records in the “timed events” table).  
         [0298]    Step  2 : similar to the “reaction” tab in the new/change-rule options.  
         [0299]    Step  3 : the wizard asks the user whether to create rules in all levels selected, or only in lowest level of each branch. A “create” option can be used to create the defined rules.  
         [0300]    A “quota” rule-wizard performs the following steps, each with “next”/“previous”/“cancel” options:  
         [0301]    Step  1 : the wizard asks the user to select a minimum value, maximum value and interval (in minutes) for day-time hours to check for quota.  
         [0302]    Step  2 : the wizard asks the user to select a starting and interval values for quantities to check for at each quota “checkpoint hour”, and a logical operator with which to perform the check.  
         [0303]    Step  3 : similar to the “reaction” tab in the new/change-rule options.  
         [0304]    Step  4 : the wizard asks the user whether to create rules in all levels selected, or only in lowest level of each branch. A “create” option can be used to create the defined rules.  
         [0305]    The “arrange icons” menu preferred options are:  
         [0306]    By Type;  
         [0307]    By Name; and  
         [0308]    Enabled.  
         [0309]    If “by type” is selected, all icons appear sorted by type, libraries first. If “by name” is chosen, icons appear sorted by name, numerical values (like “5:00”) coming first. If “enabled” is chosen, icons are sorted with full libraries first, empty libraries second, enabled rules third and disabled rules last.  
         [0310]    The “Display All” option is selected by default; if deselected, libraries which do not contain any rules become invisible.  
         [0311]    An Exemplary “Reaction” Dialog  
         [0312]    [0312]FIG. 8 is a computer screen image of a dialog box  160  illustrating the reactor dialog, in accordance with a preferred embodiment of the present invention. A similar form appears in the timer/event rule setting windows and in the timer/event rule wizards.  
         [0313]    The user may set one or more reaction types to be activated when the timer/event condition is met.  
         [0314]    The “Pop Up”  162  feature is utilized using the “notice”  154 , installed on the client PC&#39;s. The control displays a message  164  on the screen (using the text entered in appropriate field in the reaction dialog), whenever the preset conditions are met.  
         [0315]    The “Mail” option  166  sends a notification of the event or time, together with the type of operation, classification and user for whom the conditions were met, to a specified mail recipient. More than one recipient may be selected using the “To . . . ” button  168 .  
         [0316]    The “log”  170  option can be used to write a notice as a line in the log table, with the specified message, for later reference.  
         [0317]    The “Execute”  172  option may be used to activate an executable program. The program may reside on a network library, accessible to all clients. Alternatively, the program may be run from the client local hard disk, in which case it is necessary for all clients to have the program located in the same local library.  
         [0318]    A “browse”  174  button can be used to locate the executable.  
         [0319]    The “Event”  176  option initiates an event, from the predefined list of events in the EventIndex table. The event is registered for the ongoing operation (for a “timer” rule  178  only). This option may be used to create time-dependant events, without having to hard-code them in the application.  
         [0320]    An Exemplary Rule Editor Screen  
         [0321]    [0321]FIG. 9 is a computer screen image illustrating the creation of a time-dependent “event”  180 , in accordance with a preferred embodiment of the present invention. In the example above, the “angry customer” rule which appears in the right pane  182 , relates to an event called “angry customer” which occurs during a “telemarketing” operation classified as “upgrade”.  
         [0322]    In the left pane  184  can be seen some rules, set to be checked when a “telemarketing” operation is classified “cross sale”. The “30:00” rule  186 , however, relates to any “telemarketing” operation that reaches 30 minutes. The “&lt;=10 by 12:00” rule  188 , which appears in the right pane, describes an operation that takes place if no more than 10 telemarketing operations classified “upgrade” occur by 12:00.  
         [0323]    Clicking on an icon selects it. Multiple choice through “shift” or “ctrl” keys is available.  
         [0324]    Double-clicking on a library or rule icon is equivalent to “change library” or “change rule”, respectively.  
         [0325]    Right-clicking an icon opens a floating “edit menu”. Right-clicking the “tree display” pane displays a floating “tools menu”. Right-clicking the “workspace” pane displays a floating menu with “new library “new rule ”, “paste”+the “tools” menu options.  
         [0326]    An Exemplary Rule Analyzer Sub Menu  
         [0327]    The sub-menu options are:  
         [0328]    Timers . . . ;  
         [0329]    Events . . . ; and  
         [0330]    Quotas . . .  
         [0331]    These options can be applied to the main library or to any number of lower level libraries. The analysis relates to all rules within these libraries. Analysis takes place according to the two-phase method described below.  
         [0332]    Two Phase Rule Analysis  
         [0333]    Rule analysis takes place in two phases—analysis of existing rules, and proposing new ones. The two phases are separate actions as far as the user is concerned, although they are related and may share some data.  
         [0334]    Phase 1—Analyze Existing Rules  
         [0335]    This phase has to do with examining database records and assessing the supposed frequency of alerts for the period examined, based on the current configuration of rules. This does not necessarily imply that such alerts have happened, and it is possible to check newly created rules against old data.  
         [0336]    Phase 2—Proposing New Rules  
         [0337]    This phase involves examining database records and calculating reasonable filters that create rules that produce the right amount of alerts, that is—not too much and not too little.  
         [0338]    The exact thresholds are based on desired percentage of events, operations or employees to be pointed at by alerts.  
         [0339]    Analysis &amp; Proposal Scheme  
         [0340]    The general scheme for analysis &amp; proposal are as follows:  
         [0341]    The user selects the  library  to be analyzed, in the Reactor explorer (for multiple libraries, the following is repeated for each library separately).  
         [0342]    The user selects the  rule type  to be analyzed from the menu.  
         [0343]    The user is prompted for the  period  for analysis.  
         [0344]    The user is prompted for additional  rule type  specific  parameters .  
         [0345]    A  rule type  specific query selects data relevant to  library  and  period  into a temporary  table .  
         [0346]    A query selects all rules belonging to  library  and  rule type  into  rules .  
         [0347]    A  rule type  specific analysis procedure tests  table  against  rules  and  parameters , producing a  report .  
         [0348]    A rule type specific proposal procedure tests  table ,  rule type  and  parameters , producing a  proposal .  
         [0349]    The user is asked to select rules to be removed out of  rules , and rules to be selected from a  proposal  and inserted into  rules .  
         [0350]    Examplary Timer Rules  
         [0351]    Below is a breakdown of the 2-phase scheme for Timer rules.  
         [0352]    Timer prompt            
         [0353]    how many operations should fit rule Percentage→ 
         [0354]    use quick proposal procedure? Quick→ 
         [0355]    Timer Query            
         [0356]    SELECT TiIndex, (TiFinishTime-TiStartTime) AS Length FROM TimedOperations  
         [0357]    WHERE  
         [0358]    (TimedOperations.TiOpIndex= Library .OpIndex OR  Library .OpIndex IS NULL) AND  
         [0359]    (Timedoperations.TiCIIndex= Library .CIIndex OR  Library .CIIndex IS NULL) AND  
         [0360]    (TimedOperations.TiStIndex= Library .StIndex OR  Library .StIndex IS NULL) AND  
         [0361]    (TimedOperations.TiGrIndex= Library .GrIndex OR  Library .GrIndex IS NULL)  
         [0362]    AND  
         [0363]    (TimedOperations.TiStartTime IN  Period )  
         [0364]    AND  
         [0365]    (TimedOperations.TiFinishTime IS NOT NULL).  
         [0366]    TiStIndex and TiGrIndex are virtual fields calculated by selecting the matching AllowedStates.StIndex and AllowedUsers.UsGrIndex, respectively. Length represents the operation length.  
         [0367]    Timer Query Report  
         [0368]    First calculate the total number of operations in the  table , then count number of operations that match all  rules  and calculate percentage.  
         [0369]    Total= 
         [0370]    SELECT count(*) from  Table   
         [0371]    SELECT Rules.RuleID, count(*) as Number, (Number/Total*100%) as Percent, (Percent-Parameters. Percentage) as Difference  
         [0372]    FROM Rules, Table WHERE  
         [0373]    (Table.Length&gt;Rules.TimeLength)  
         [0374]    GROUP BY Rules.RuleID  
         [0375]    Timer Query Proposal  
         [0376]    Proposal preparation depends on the selection of  Parameters .Quick. If quick method is requested, the proposed TimeLength is calculated according to the mean and standard deviation of the  Table  population. If not, the Table is searched, and a value for TimeLength is sought that satisfies the percentage.  
         [0377]    Quick Method:  
         [0378]    Mean=AVG ( Table .Length)  
         [0379]    Dev=SDEV ( Table .Length)  
         [0380]    ErlangK=ROUND (Mean{circumflex over ( )}2/Dev{circumflex over ( )}2)  
         [0381]    ErlangL=Mean/Dev{circumflex over ( )}2  
         [0382]    [0382] Proposal =InvertErlang (percentage,ErlangK,ErlangL)  
                                                                                                                                                                                                 Slow (actual sampling) Method: ‘Accompanied by Progress Bar Display       ‘Dim Bar as New ProgressBar       Initialize: ‘Bar.Min = 0                Total = SELECT count(*) from Table           Mini = MIN (Table.Length) ‘Bar.Max = Log(Total)/.           Maxi = MAX (Table.Length) ‘ Log(2) + 1           Guess = MINI + (MAXI - MINI) * (Parameters.Percentage / 100%)           Add = 0 ‘Bar.Value = 0            Start_Loop:                Number = SELECT count(*) FROM Table WHERE                (Table.Length &gt; Guess)                Percent = ((Number+Add)/Total*100%)                ‘Bar.Value = Bar.Value + 1                If ABS(Percent - Parameters.Percentage) &lt; 1% then                Goto End_Proposal                If Percent &gt; Parameters.Percentage) then                Table =           SELECT Table.Length FROM Table WHERE                (Table.Length =&gt; Mini) AND (Table.Length &lt; Guess)                Add = Add + Number + 1           Maxi = Guess           Guess = (Guess + Mini) / 2            Else                Table =           SELECT Table.Length FROM Table WHERE                (Table.Length &gt; Guess) AND (Table.Length &lt;= Maxi)                Mini = Guess           Guess = (Guess + Maxi) / 2            Goto Start_Loop       End_Proposal:       Proposal = Guess ‘Bar.Value = Bar.Max                    
         [0383]    Event Rules  
         [0384]    Below is a breakdown of the 2-phase scheme for Event rules.  
         [0385]    Event Prompt Parameters.  
         [0386]    how many events (per operation) should fit rule Percentage  
         [0387]    →how many events (a day) should fit rule Daily→ 
         [0388]    Event Query Table  
         [0389]    SELECT EvIndex, count(*) AS Number FROM TimedEvents, TimedOperations  
         [0390]    WHERE  
         [0391]    (TimedOperations.TiOpIndex= Library .OpIndex OR  Library .OpIndex IS NULL) AND  
         [0392]    (Timedoperations.TiCIIndex= Library .CIIndex OR  Library .CIIndex IS NULL) AND  
         [0393]    (TimedOperations.TiStIndex= Library .StIndex OR  Library .StIndex IS NULL) AND  
         [0394]    (TimedOperations.TiGrIndex= Library .GrIndex OR  Library .GrIndex IS NULL)  
         [0395]    AND  
         [0396]    (TimedOperations.TiStartTime IN  Period )  
         [0397]    AND  
         [0398]    (TimedOperations.TiFinishTime IS NOT NULL)  
         [0399]    AND  
         [0400]    (TimedOperations.TiIndex=TimedEvents.TvTiIndex)  
         [0401]    GROUP BY TimedEvents.EvIndex  
         [0402]    TiStIndex and TiGrIndex are virtual fields calculated by selecting the matching AllowedStates.StIndex and AllowedUsers.UsGrIndex, respectively. Length represents the operation length.  
         [0403]    Event Query Report  
         [0404]    For each event in Rules, it is pointed out if its frequency (according to Table) is within boundary of Percentage and Daily.  
         [0405]    Temp=TimerQuery. Table   
         [0406]    Operations=(SELECT count(*) from Temp)  
         [0407]    Days=(DATEDIFF (dd,  Period .Start,  Period .End)+1)  
         [0408]    SELECT  Rules .RuleID,  Table .Number, ( Table .Number/Operations) as PerOp, (PerOp-Parameters. Percentage) as DifferencePerOp, (Table.Number/Days) as PerDay, (PerDay- Parameters .Daily) as DifferencePerDay  
         [0409]    FROM  Rules , Table WHERE  
         [0410]    ( Table .EvIndex= Rules .EvIndex).  
         [0411]    Specification Page 32  
         [0412]    Event Query Proposal  
         [0413]    The proposed events is selected so that both the daily and per-operation conditions are met.  
         [0414]    SELECT EvIndex FROM  Table  WHERE  
         [0415]    ((Number/Operations)&lt; Parameters .Percentage)  
         [0416]    AND  
         [0417]    ((Number/Days)&lt; Parameters .Daily)  
         [0418]    Quota Rules  
         [0419]    Below is a breakdown of the 2-phase scheme for Quota rules.  
         [0420]    Quota Prompt Parameters  
         [0421]    how many users (out of total users in group) should fit rule Percentage  
         [0422]    how           (a day) should fit rule Daily→ 
         [0423]    Quota Query Table  
         [0424]    SELECT TiIndex, TiUsIndex,  
         [0425]    CONVERT(DATE,TiFinishTime,3) AS Day ‘Style 3=dd/mm/yy  
         [0426]    CONVERT(DATE,TiFinishTime,8) AS Time ‘Style 8=hh:mi:ss  
         [0427]    FROM TimedOperations WHERE  
         [0428]    (Timedoperations.TiOpIndex= Library .OpIndex OR  Library .OpIndex IS NULL) AND  
         [0429]    (TimedOperations.TiCIIndex= Library .CIIndex OR  Library .CIIndex IS NULL) AND  
         [0430]    (TimedOperations.TiStIndex= Library .StIndex OR  Library .StIndex IS NULL) AND  
         [0431]    (TimedOperations.TiGrIndex= Library .GrIndex OR  Library .GrIndex IS NULL)  
         [0432]    AND  
         [0433]    (Timedoperations.TiStartTime IN  Period )  
         [0434]    AND  
         [0435]    (Timedoperations.TiFinishTime IS NOT NULL)  
         [0436]    TiStIndex and TiGrIndex are virtual fields calculated by selecting the matching AllowedStates.StIndex and AllowedUsers.UsGrIndex, respectively.  
         [0437]    Quota Query Report  
         [0438]    For each rule in  Rules , the average number of users creating alerts is counted(according to Table) and check if it is within boundary of Percentage and Daily. A preliminary (not visible) report contains for combinations of rules &amp; dates, how many alerts actually occurred every day.  
         [0439]    Users=(SELECT count(DISTINCT UsIndex) from  Table )  
         [0440]    Temp=SELECT  Rules .RuleID,  Table .Day,  Table .TiUsIndex, Count( Table .TiIndex) as  
         [0441]    Amount FROM Rules, Table WHERE  
         [0442]    [0442] Table .Time&lt; Rules .DayTime  
         [0443]    GROUP BY  Rules .RuleID,  Table .Day,  Table .TiUsIndex  
         [0444]    Preliminary=SELECT  Rules .RuleID,  Table .Day, Count(*) as Alerts FROM  Rules ,  
         [0445]    Temp  
         [0446]    WHERE  
         [0447]    ( Rules .RuleID=Temp.RuleID) AND  
         [0448]    ((Amount&gt;Quantity AND Operator=‘&gt;’) OR  
         [0449]    (Amount&gt;=Quantity AND Operator=‘&gt;=’) OR  
         [0450]    (Amount&lt;Quantity AND Operator=‘&lt;’) OR  
         [0451]    (Amount&lt;=Quantity AND Operator=‘&lt;=’))  
         [0452]    GROUP BY  Rules .RuleID,  Table . Day  
         [0453]    Report= 
         [0454]    SELECT RuleID, Avg(Preliminary.Alerts) as PerDay, (PerDay/Users) as PerUs, (PerUs- Parameters .Percentage) as DifferencePerUs, (PerDay- Parameters .Daily)  
         [0455]    as DifferencePerDay  
         [0456]    FROM Preliminary  
         [0457]    GROUP BY  Rules .RuleID  
         [0458]    Quota Query Proposal  
         [0459]    The proposed quantities is selected so that both the daily total and per-user conditions are met. Note that the algorithm uses parameters &amp; tables defined in the previous steps, as if they were not de-allocated (or are global).  
         Limit=MlN(Parameters.Percentage*Users, Parameters.Daily).  
         [0460]    Proposal preparation is as follows: since there may be several quota rules in a single library (for different hours), loop on each rule; then scan all days in period; for each day, sort users by their operation count, and find a daily quota that satisfies the limit; at the end, average all daily quotas, to find the rule quota; then, update the Proposal table.  
                                                                                                                                                                                 ‘Accompanied by Progress Bar Display       initialize: ‘Dim Bar as New ProgressBar                RuleCount = (SELECT count(DISTINCT RuleID) from Temp)           DayCount = (SELECT count(DISTINCT Day) from Temp)            ‘Bar.Min = 0       ‘Bar.Max = RuleCount       Proposal = SELECT RuleID, 0 AS Proposed FROM Temp       GROUP BY Rules.RuleID ‘Bar.Value = 0       Journal = SELECT Day FROM Temp GROUP BY Day       DECLARE ProposalCursor CURSOR FOR       SELECT RuleID FROM Proposal       DECLARE JournalCursor CURSOR FOR       SELECT Day FROM Journal       Loop rules:                FETCH NEXT FROM ProposalCursor INTO Rule           IF @@fetch_status&lt;0 GOTO End_proposal           FETCH FIRST FROMJournalCursor INTO Jour           IF @@fetch_status&lt;0 GOTO End_journal           DayTotal = 0 ‘Bar.Value = Bar.VaIue + 1           Loop_days:                Op = SELECT Operator FROM Rules           WHERE Rules.RuleID = Rule           IF Op IN (‘&gt;’,‘&gt;=’) THEN                DECLARE SearchCursor CURSOR FOR           SELECT Amount FROM Temp           WHERE RuleID = Rule AND Day = Jour           ORDER BY Temp DESCENDING                IF Op IN (‘&lt;’,‘&lt;=’) THEN                DECLARE SearchCursor CURSOR FOR           SELECT Amount FROM Temp           WHERE RulelD = Rule AND Day = Jour           ORDER BY Temp                IF Op IN (‘&gt;=’,‘&lt;=’) THEN                FETCH ABSOLUTE Limit FROM SearchCursor           INTO TempQuota                ELSE                FETCH ABSOLUTE Limit+1 FROM SearchCursor           INTO TempQuota                IF @@fetch_status&lt;0                FETCH LAST FROM SearchCursor           INTO TempQuota                DEALLOCATE SearchQuota           DayTotal = DayTotal + TempQuota           FETCH NEXT Day INTO Jour           IF @@fetch_status=0 GOTO End_journal           GOTO Loop_days            End_journal:       UPDATE Proposal SET Proposed = INT(DayTotal / DayCount)       WHERE RuleID = Rule       GOTO Loop_rules       End_Proposal:       Proposal = Proposal ‘Bar.Value = Bar.Max                  
 
         [0461]    The Reactor Triggers  144   
         [0462]    Rule Structure  
         [0463]    The rule is defined by many parameters, generally grouped as following:  
         [0464]    Library information (to which operations the rule applies;  
         [0465]    Alert information (under which conditions an alert is activated); and  
         [0466]    Response information (what action to take when alert is activated).  
         [0467]    Detailed below are library and alert information, as the processing of these takes place (in part) at database  28  level. Response information is completely up to the “Herald” service  156 , and does not require database  28  implementation other then reading it.  
         [0468]    Library Information  
         [0469]    Library information includes these data fields:  
         [0470]    Operation;  
         [0471]    Classification;  
         [0472]    User Group; and  
         [0473]    State.  
         [0474]    With any of the above, a NULL value functions as a wild card. For a rule to be tested, an operation must comply with all non-NULL values.  
         [0475]    Alert Information  
         [0476]    Alert information includes these data fields:  
         [0477]    Rule Type;  
         [0478]    Delay;  
         [0479]    Event;  
         [0480]    Day Time;  
         [0481]    Quantity; and  
         [0482]    Logical Operator.  
         [0483]    [0483] Rule type  may either be T, E, Q or C for Timer, Event, Quota or Counter, respectively. Delay determines the length of the operation for testing by a Timer rule;  Event  determines the event type to be tested by an Event rule;  Day Time ,  Quantity  and  Logical Operator  define a Quota rule; Quantity and Logical Operator also define a Counter rule.  
         [0484]    Event Rules  
         [0485]    Event rules is tested by a trigger. A successful testing by this trigger directly leads to an alert activation (that is intercepted by the “herald” service).  
         [0486]    Event Trigger: The trigger is set upon an INSERT to the TimedEvents table.  
         [0487]    The test for an Inserted row is:  
         [0488]    [0488] Logic : return the timed operation that “contains” the event, and any rule that applies to this event (there may be more than one rule, for instance—one rule for all operations of a certain type, and a more restricted rule for a specific user group).  
         [0489]    SQL:  
         [0490]    SELECT TiIndex,RuleID FROM Inserted, Timedoperations,SyRules WHERE  
         [0491]    Inserted.TvTiIndex=Timedoperations.TiIndex AND  
         [0492]    Inserted.TvEvIndex=SyRules.EvIndex AND  
         [0493]    (TimedOperations.TiOpIndex=SyRules.OpIndex OR SyRules.OpIndex IS NULL)  
         [0494]    AND  
         [0495]    (TimedOperations.TiCIIndex=SyRules.CIIndex OR SyRules.CIIndex IS NULL) AND  
         [0496]    (Timedoperations.TiStIndex=SyRules.StIndex OR SyRules.StIndex IS NULL) AND  
         [0497]    (TimedOperations.TiGrIndex=SyRules.GrIndex OR SyRules.GrIndex IS NULL)  
         [0498]    TiStIndex and TiGrIndex are virtual fields calculated by selecting the matching AllowedStates.StIndex and AllowedUsers.UsGrIndex, respectively.  
         [0499]    Event Alert  
         [0500]    An alert is set off by sending “Herald”  156  the results of the above trigger.  
         [0501]    Timer Rules  
         [0502]    Timer rules is tested by a trigger  144 . A successful testing by trigger  144  initiates a timer within “herald”  156 . This timer&#39;s alarm leads to an alert activation. Cancellation is also tested by a trigger  144 .  
         [0503]    Timer Trigger  
         [0504]    Trigger  144  is set upon an INSERT to the TimedOperations table. The test for an Inserted row is Logic: return the timed operation and any rule that applies to this operation.  
         [0505]    SQL:  
         [0506]    SELECT TiIndex,RuleID FROM Inserted, SyRules WHERE  
         [0507]    (TimedOperations.TiOpIndex=SyRules.OpIndex OR SyRules.OpIndex IS NULL)  
         [0508]    AND  
         [0509]    (TimedOperations.TiCIIndex=SyRules.CIIndex OR SyRules.CIIndex IS NULL) AND  
         [0510]    (TimedOperations.TiStIndex=SyRules.StIndex OR SyRules.StIndex IS NULL) AND  
         [0511]    (TimedOperations.TiGrIndex=SyRules.GrIndex OR SyRules.GrIndex IS NULL)  
         [0512]    TiStIndex and TiGrIndex are virtual fields calculated by selecting the matching AllowedStates.StIndex and AllowedUsers.UsGrIndex, respectively.  
         [0513]    Timer Alert  
         [0514]    A timer (or timers) are activated by sending “Herald”  156  the results of the above trigger  144 .  
         [0515]    This timer ticks for a specified length of time, or until it is deactivated by a cancelation trigger  144 . When the timer finishes ticking, it sets off the actual alert.  
         [0516]    Timer Cancelation  
         [0517]    The cancelation trigger is set upon an UPDATE to the TimedOperations table. The test for an Inserted row is:  
         [0518]    Logic: return the timed operation(s) finished.  
         [0519]    SQL:  
         [0520]    SELECT TiIndex FROM Inserted WHERE  
         [0521]    Timedoperations.TiFinishTime IS NOT NULL  
         [0522]    Quota Rules  
         [0523]    Quota rules is tested by a scheduled “Span”  146  component. The component queries for compliant users; users passing the test leads to an alert activation.  
         [0524]    Quota Schedule  
         [0525]    A scheduling or timer mechanism is activated for each rule, according to the DayTime column in the SyRules table.  
         [0526]    Quota Query  
         [0527]    Logic: step  1 —return each user&#39;s count of operations (only those started and finished today) of the type tested by the rule. Step  2 —return users for whom the rule has been met; step  2  is determined according to the Operator &amp; Quantity columns in the SyRules table (there may be more than one user returned by the query).  
         [0528]    Unlike Timer &amp; Event rules, here the specific rule tested is given, and we first define a few parameters based on it.  
                                                                   SQL:                @Op is the rule&#39;s allowed operation index tested           @Cl is the rule&#39;s allowed classification index tested           @Gr is the rule&#39;s allowed group index tested           @St is the rule&#39;s allowed state index tested           @Qt is the rule&#39;s test quantity           @Lo is the rule&#39;s logical operator            SELECT @step1 =                SELECT TiUsIndex,count(TiIndex) AS Amount FROM           TimedOperations WHERE           (TimedOperations.TiOpIndex = @Op OR @Op IS NULL) AND           (TimedOperations.TiClIndex = @Cl OR @Cl IS NULL) AND           (TimedOperations.TiStIndex = @St OR @St IS NULL) AND           (TimedOperations.TiGrIndex = @GrIndex OR @Gr IS NULL) AND           (TimedOperations.TiStartTime &gt;= GetDAte( ) ) AND           (TimedOperations.TiFinishTime IS NOT NULL)            GROUP BY TiUslndex                  
 
         [0529]    TiStIndex and TiGrIndex are virtual fields calculated by selecting the matching AllowedStates.StIndex and AllowedUsers. UsGrIndex, respectively.  
         [0530]    SELECT @step 2 = 
         [0531]    SELECT TiUsIndex FROM @Step 1  WHERE  
         [0532]    (Amount&gt;@Qt AND @Op=‘&gt;’) OR  
         [0533]    (Amount&gt;@Qt AND @Op=‘&gt;=’) OR  
         [0534]    (Amount&lt;@Qt AND @Op=‘&lt;’) OR  
         [0535]    (Amount&lt;=@Qt AND @Op=‘&lt;=’)  
         [0536]    Quota Alert  
         [0537]    A timer (or timers) is activated by sending “Herald”  156  the results of the above query. Each user returned is to be considered an “alert source”, and for each—a separate message is sent.  
         [0538]    Dataflow Between Reactor Components  
         [0539]    Rules Editor  142  scans SyRules Table in the System main database to visually represent the existing rules to end-user. Rules Editor  142  refers to XML file  152  named “ rules.xml ” to obtain the hierarchical structure of the rules and organizes them into “libraries”. It is required that this file is placed at the same directory as Rules Editor  142  is located. In order to perform this step Rules Editor  142  uses DOM  128  to access the XML and ADO to access database  28 .  
         [0540]    Rules Editor  142  allows the creation and publishing of the rules. This action affects both SyRules Table, that actually stores the rule details and “rules.xml” file that contains the rule hierarchical relationship. If a “quota” rule is created, Rules Editor  142  establishes the connection with Windows Task Scheduler Service to set up the System Span Task. For Timed and Event rules no further Editor  142  action is needed.  
         [0541]    Newly created Rules are stored in Rules Table (“SyRules”) of main system database  28 . The added record number is passed to the triggered task as an execution parameter (e.g. command line parameter). The following code from Rules Editor  142  demonstrates this technique:  
         [0542]    //EXECUTE INSERT SQL STATEMENT  
         [0543]    //THE CODE IS OMITTED FOR BREVITY  
         [0544]    //GIVE THE INSERTED RECORD NUMBER  
         [0545]    _RECORDSETPTR PRESULTRST=PCNN→EXECUTE(L“SELECT @@IDENTITY”, NULL, ADCMDTEXT);  
         [0546]    IF(PRESULTRST)  
         [0547]    { 
         [0548]    LRULENUM=PRESULTRST→FIELDS→GET_ITEM(OL)→GET_VALUE( );  
         [0549]    PRESULTRST→CLOSE( );  
         [0550]    } 
         [0551]    //SEND THIS NUMBER AS COMMAND LINE PARAMETER TO SCHEDULER TASK  
         [0552]    WCHAR_T WSZTEMP[8];  
         [0553]    LPCWSTR PWSZPARAMETERS=::_LTOW(LRULENUM, WSZTEMP, 10);  
         [0554]    HR=PITASK→SETPARAMETERS(PWSZPARAMETERS);  
         [0555]    System span  146  receives the Rule number as command line parameter from Windows Task Scheduler. Given this number, system span  146  returns to SyRules with stored procedure “sp_Span” sending to it this number as parameter.  
         [0556]    “sp_Span” procedure is depicted here:  
         [0557]    Create Procedure sp_Span  
         [0558]    @RuleID integer  
         [0559]    WITH RECOMPILE  
         [0560]    As  
         [0561]    DECLARE @St integer  
         [0562]    DECLARE @StO integer  
         [0563]    DECLARE @StI integer  
         [0564]    DECLARE @Gr integer  
         [0565]    DECLARE @OpIndex integer  
         [0566]    DECLARE @CIIndex integer  
         [0567]    Get Rule details  
         [0568]    SELECT @OpIndex=OpIndex FROM SyRules WHERE RuleID=@RuleID  
         [0569]    SELECT @CIIndex=CIIndex FROM SyRules WHERE RuleID=@RuleID  
         [0570]    SELECT @St=StIndex FROM SyRules WHERE RuleID=@RuIeID  
         [0571]    SELECT @Gr=GrIndex FROM SyRules WHERE RuleID=@RuleID  
         [0572]    SELECT @StO=StOrder FROM AllowedStates WHERE StIndex=@St  
         [0573]    SELECT @StI=StSsIndex FROM AllowedStates WHERE StIndex=@St  
         [0574]    SELECT TiUsIndex, COUNT(TiIndex) AS Amount  
         [0575]    FROM TimedOperations, AllowedUsers  
         [0576]    WHERE  
         [0577]    (TiOpIndex=@OpIndex OR @OpIndex IS NULL) AND  
         [0578]    (TiCIIndex=@CIIndex OR @CIIndex IS NULL) AND  
         [0579]    ((TiStOrder=@StO AND TiSSIndex=@StI)OR @St IS NULL ) AND  
         [0580]    (TiUsIndex=AllowedUsers.UsIndex) AND ((AllowedUsers.UsGrIndex=@Gr)  
         [0581]    OR (@Gr IS NULL)) AND  
         [0582]    (DATEDIFF(dd, TiStartTime, GETDATE( ))=0) AND  
         [0583]    TiFinishTime IS NOT NULL  
         [0584]    GROUP BY TiUsIndex  
         [0585]    This stored procedure produces Table IV in following format:  
                           TABLE IV                                   Column Name   Type                           TiUsIndex   Integer           Amount   Integer                      
 
         [0586]    Table IV is returned back to system span  146  executable as an ADO recordset. According to gathered rule details, system span  146  analyzes the data from a table trying to detect whether the rule was met. If so, system herald  150  is invoked.  
         [0587]    When invoked, system herald  150  refers to relevant tables of the main database to obtain the notification details it needs to send a message. The notification recipient is preferably extracted as well as the transport (media) selected for every recipient. The following SQL statement is used through ADO to accomplish this task:  
         [0588]    SELECT AdMachine, AdMail, RrMedia  
         [0589]    FROM AdminUsers, RuleRecipients  
         [0590]    WHERE AdminUsers.AdIndex=RuleRecipients.RrAdIndex  
         [0591]    AND RrRuleID=@RuleID  
         [0592]    Here @RuleID is expanded to the actual rule number being executed.  
         [0593]    System herald  150  refers to the SyRules table once again in order to format the message being transferred. The message coding convention that is used for this process is defined below. Depending on detected transport (media) system herald  150  uses O/S message queue (like MSMQ) or SMTP to send the formatted message to all recipients.  
         [0594]    An Exemplary Message Formatting  
         [0595]    Whether by E-mail or Notice, the definition of the text message is the same. If both E-Mail and Notice channels are chosen as a response for a certain rule, both convey the same message.  
         [0596]    The message can contain plain text and codes for different data items, and an exemplary list follows in Table V:  
                           TABLE V                                   Code   Data Item                           [op]   Operation Name for Rule           [cl]   Classification Name for Rule           [gr]   User Group Name for Rule           [st]   State Name for Rule           [rt]   Rule Type Name           [tl]   Time Length for Alert           [ev]   Event Name for Alert           [dt]   Day Time for Alert           [qt]   Quantity for Alert           [lo]   Logical Operator for Alert           [pu]   Pop Up Address for Response           [em]   E-Mail Address for Response           [lg]   Message to Log for Response           [ep]   Execute Path for Response           [ce]   Create Event for Response           [us]   User Name*           [ti]   Time of Occurance*           [in]   Timed Operation Index*           [he]   Herald Server Name*                      
 
         [0597]    These values are derived from the SystemDB.SyRules table (either as written in the table, or as reference to other tables) except the ones marked by (*), which are determind at execution time by the “Herald” service  150 .  
         [0598]    E-Mail Messaging  
         [0599]    An E-Mail message consists of the following data:  
         [0600]    [0600] From : [he] 
         [0601]    [0601] To : [em] 
         [0602]    [0602] Subject : [rt] rule activated by user: [us] 
         [0603]    [0603] Message : user defined  
         [0604]    “Notice” Messaging  
         [0605]    A Notice message consists of the following data:  
         [0606]    [0606] Source : [us] 
         [0607]    [0607] Message : user defined  
         [0608]    “Notice” Example Screen  
         [0609]    [0609]FIG. 10 is a computer screen image illustrating a notice message  190 , in accordance with a preferred embodiment of the present invention.  
         [0610]    The software component of system  10  provides the infrastructure for a methodology of employee management. This methodology assumes that:  
         [0611]    a manager is to be notified when any of a set of business-specific conditions occur in the work process;  
         [0612]    with this notification the manager can access certain data that can help him handle the situation; and  
         [0613]    the manager, based on the data, assists the “agent” (an employee being monitored by system  10 ) in the work process.  
         [0614]    The provisions of System Notice  154  are designed to help the manager exchange data with the agent and with database  28 :  
         [0615]    to support the act of notification;  
         [0616]    for data access; and  
         [0617]    for agent assistance.  
         [0618]    System Notice  154  is the front end of an “executive messaging channel” that is independent of e-mail. This channel is used to support the management methodology described. The channel supports the following functions:  
         [0619]    1. Creates an Alert Message by System Reactor  34 .  
         [0620]    2. Sends a New Message by a manager.  
         [0621]    3. Displays an incoming Alert or New message sent by a manager or agent.  
         [0622]    4. Temporarily stores incoming messages locally.  
         [0623]    5. Replies to an Alert or New message sent by a manager or agent.  
         [0624]    6. Retrieves Workflow Data, relevant to an Alert Message, sent by a manager.  
         [0625]    7. Retrieves Screen-shots, relevant to an Alert Message, that were sent by a manager.  
         [0626]    Notice  154  provides functions 2-5 and 7. Function 1 is handled by “Herald”  150  component of System Reactor  34 . Notice  154  activates the Callflow Analyzer for function 6, as described hereinbelow, beginning on page 81.  
         [0627]    “Notice” vs. E-Mail  
         [0628]    Notice is the preferred alert-handling front end to notify the employees [agents] themselves in real-time, whereas ‘mail’ is used to alarm supervisors, managers etc.  
         [0629]    The difference between agents and managers is in the functions accessible by the each. An agent is only allowed to access functions 3-5, while a manager can access function 2 (permission granted by system administrator  30 ), and functions 6-7 (accessible by installing additional software components at the manager&#39;s workstation).  
         [0630]    E-Mail can also be used as an alternative/additional means of sending alerts—especially to remote, or mobile users, who do not have System Notice  154  nearby.  
         [0631]    If the user is an agent, the “send” button  194  is normally disabled. If the user is a manager, he may use it to create a new message (function 2) or to forward/reply to an incoming message currently displayed (function 5). An agent may only reply to an incoming message  192 , and may not create a new message. Pressing “send”  194  opens window  196 .  
         [0632]    Retrieving Workflow Data With “Notice” 
         [0633]    A manager may install the Callflow Analyzer on his workstation, in which case Notice  154  can interact with the Callflow Analyzer in the following way:  
         [0634]    1. Callflow Analyzer is put into “alert” mode.  
         [0635]    2. Notice  190  pops-up when an incoming message  192  arrives.  
         [0636]    3. If message  192  is an alert (direct or forwarded by another user), the relevant workflow data will appear on the Callflow Analyzer window as message  192  is displayed.  
         [0637]    4. If a message  192  stored earlier is selected for reviewing, its workflow data appears on the Callflow Analyzer window.  
         [0638]    To enable this, when message  192  is displayed on Notice  154  which has alert charateristics (alert source and time of creation), these characteristics are sent over to Callflow Analyzer, for retrieval and display of the relevant data.  
         [0639]    Retrieving Screenshots With “Notice” 
         [0640]    A manager with a sufficient security status, may use Notice  154  to retrieve an agent&#39;s screenshot in the following way:  
         [0641]    1. A request arrives at an agent&#39;s workstation where Notice  154  is installed.  
         [0642]    2. The request identifies the manager.  
         [0643]    3. If the manager is recognized as having the requisite security status, Notice  154  takes a picture of the agent&#39;s screen and sends it over to the manager.  
         [0644]    The screenshot is taken using the Windows Applications Program Interface (WinAPI32).  
         [0645]    In workflow system  10 , the request is initiated by the manager through his Callflow Analyzer. After performing the described process, the screenshot displayed on the manager&#39;s workstation, again through the Callflow Analyzer.  
         [0646]    System Executive  
         [0647]    System executive  36  is an application designed for the executive levels of the organization, to set up and print reports based on the system operational database  28 .  
         [0648]    System executive  36  is a windows-based application, which can be installed on system server  26  itself, or on any remote PC. Working with the product is done by main menu, through which the various executive options can be reached.  
         [0649]    The main menu options are:  
         [0650]    File;  
         [0651]    Scenarios;  
         [0652]    Options;  
         [0653]    Window; and  
         [0654]    Help.  
         [0655]    File Menu  
         [0656]    The “files” referred to are definitions that include a report template, and a set of values matching the parameters expected by the report.  
         [0657]    The file menu options are:  
         [0658]    New . . . ;  
         [0659]    Open . . . ;  
         [0660]    Close;  
         [0661]    . . .  
         [0662]    Save;  
         [0663]    Save As . . . ;  
         [0664]    . . .  
         [0665]    Preview;  
         [0666]    Destination . . . ;  
         [0667]    Run; and  
         [0668]    . . .  
         [0669]    Exit.  
         [0670]    [0670] 
         [0671]    When a new file is created, the user is first asked to select a template from the available report types. After a selection is made, the file is presented in the form of a window with the various fields required by the template, to be filled in by the user.  
         [0672]    The actual reports are beyond the scope of this document, as they may vary, and templates could be added to the application freely.  
         [0673]    When a report is saved, the user may choose whether date-type fields are to be used with absolute or relative values, relative indicating that the difference between current date and selected date should always be the same. A report is saved with the destination (printer, file, e-mail, screen).  
         [0674]    Reports is saved to local files, with ”.set” indicating system executive  36  templates, ”.ser” indicating reports.  
         [0675]    Options Menu  
         [0676]    The options menu options are:  
         [0677]    Report Levels;  
         [0678]    Executables . . . ; and  
         [0679]    Templates . . .  
         [0680]    Report levels are handled like regular tables. Setting them enables a user to create and open only reports of a level equal to or lower than his own security level.  
         [0681]    Choosing the Templates option opens an explorer window, which enables the user to set the library (local or network) where ”.set” files is searched for by default.  
         [0682]    “Executables” are ”.sxr” files which, when “clicked”, open and run pre-defined reports without entering the executive application. When this option is selected, an explorer window opens with multiple choice available. The selected report set is then given a name and an (optional) expiration date.  
         [0683]    ”.sxr” files, when run, access database  28  through a unique account and password. They can be distributed to “non-sophisticated users” for simple production of common reports, without having to enter a user-name and password. These executables only work until their expiration date arrives.  
         [0684]    “report levels” and “executables” options are only available to users with write permissions.  
         [0685]    Scenario Menu  
         [0686]    The “files” referred to are in fact definitions that include a report template, and a set of values matching the parameters expected by the report.  
         [0687]    The Scenario menu options are:  
         [0688]    Scenarios; and  
         [0689]    Details.  
         [0690]    Scenarios are handled in exactly the same format as the tables editing windows in the “Administrator” application: scenarios refer to the “ScenarioInfo” Table VIA; Operations refer to the “ScenarioDetails” Table VIB.  
                           TABLE VIA                       Table   Feild Name   Description   Type                   ScenarioInfo                   TABLE VIA   ScKey   Scenario Identifier Key   integer           ScName   Scenario Descriptive Name   string           ScBaseFrom   Scenario Calculation Base Start   date           ScBaseTo   Scenario Calculation Base End   date           ScEff   Scenario General Efficiency   integer               factor       ScenarioDetails       TABLE VIB   SdScKey   Scenario Detail Scenario Id Key   integer           SdOpKey   Scenario Detail Operation Key   integer           SdClKey   Scenario Detail Classification   integer               Key           SdWkFreq   Scenario Detail Weekly   integer               Frequency           SdEff   Scenario Detail Efficiency factor   integer                  
 
         [0691]    These values can later be referred to by scenario-related reports. In such reports, usage of a specific scenario is possible by selecting the scenario from a list of available ones. Such reports are used for performing calculations where instead of using actual historical system  16  records, data is modified as follows:  
         [0692]    values for operation lengths and quantities are averaged on base period (start to end dates);  
         [0693]    all lengths are multiplied by general efficiency factor;  
         [0694]    for specified operations and classifications (in details), lengths are multiplied again by detail efficiency factor.  
         [0695]    Scenario related reports may use the calculated operation lengths together average frequencies, or with stated Weekly Frequency, for purposes of resource planning.  
         [0696]    System Consultant  
         [0697]    System consultant  38  is an application designed for the engineers and operations research staff of the organization, to set up and print special analysis reports based on system  16  operational database  28 .  
         [0698]    Standard consultant  38  reports are as follows:  
         [0699]    The Workflow Trees report examines the operations and their linked keys, over a specified period of time. It sorts them into groups of chained operations, then goes over each group, counting how often a certain type of operation, leads to another certain type of operation, on a specific node of the chain. By transforming these summaries into percentages, it builds a diagram in the form of a probability tree, showing how operations form complete tasks, statistically.  
         [0700]    The Trend Tracer is a collection of reports designed to point out trends in parameters obtainable from the “TimeSummary table”, which is designed for fast queries.  
         [0701]    The Advanced Resource Planning (ARP) report takes into account nonlinear elements in the workflow using more complex mathematics (queuing methods) than the simple linear arithmetic of the resource planning report included in the basic package. This enables users to design resources for departments where the workflow is stochastic. ARP also uses user-defined scenarios to improvise on database  28  statistics.  
         [0702]    Workflow Trees  
         [0703]    This report examines the operations and their linked keys, over a specified period of time. It sorts them into groups of chained operations, then goes over each group, counting how often a certain type of operation leads to another certain type of operation, on a specific node of the chain.  
         [0704]    By transforming these summaries into percentages, it builds a diagram in the form of a probability tree, showing how operations form complete tasks, statistically. On the arcs, a notation is made as to how long, on average, an operation takes to complete, when carried out from that specific node, that is, after a given preceding operation.  
         [0705]    An intermediate level of processing is performed in order to cluster operations into trees, dividing unrelated operation clusters into separate trees. To achieve this, a minimal percentage threshold is set, under which a node is considered a breaking point. Branches emerging from a breaking point are separated into new distinct trees, marked as “broken” trees.  
         [0706]    Should any broken trees be found, a final step of processing is taken to merge these trees into existing trees which begin with the same operation. In the merging process, percentages are recalculated according to the total summaries of the merged trees.  
         [0707]    The report supplies the user with a default threshold value 0.05); a value of 0 means, no breaking points are to be declared.  
         [0708]    Advanced Resource Planning  
         [0709]    Advanced resource planning refers to nonlinear elements in the workflow which require calculating a level of service and, therefore, more complex mathematics than the simple linear arithmetic of the resource planning report included in the basic package.  
         [0710]    ARP performs a scenario-based analysis, like the basic resource planning (RP). Here the two applications take different courses. Basic RP simply groups together operations for specific workgroups, and according to the specific scenario, calculates how many of these operations take place in the forecast period and how long they take. It then is able to plan the resources needed for that volume of work.  
         [0711]    ARP works for one workgroup at a time. It first requires the user to mark up operations which form that group&#39;s on-line services. It then asks for the user to set a service level requirement, in terms of waiting time, availability percentage or similar parameters of queueing theory. All these settings are saved as part of the ”.ser” file.  
         [0712]    ARP then calls up the Queue Plan Interface (QPI) component, described hereinbelow. QPI accepts a service time (comprising the service operations) and off-line time (comprising of all other operations), and the required level of service. QPI then returns the number of employees required for that group.  
         [0713]    Variations on this calculation include Monthly, Weekly, Daily or Hourly ARP reports.  
         [0714]    Trend Tracer  
         [0715]    The trend tracer is a collection of reports designed to point out evident trends in parameters obtainable from the “TimeSummary table”, which is designed for fast queries.  
         [0716]    The trend tracer creates a table, which is split into time periods. The size of the periods can be selected by the user for Monthly, Weekly or Daily reports. The user selects a range of dates for the report, and may also mark up selected users, groups or operations to examine.  
         [0717]    In that table, the following parameters are being examined:  
         [0718]    Number of operations, for each operation type;  
         [0719]    Number of operations per user, for each operation type; and  
         [0720]    Average length of operation, for each operation type.  
         [0721]    In addition, the “classification trend tracer” also checks the percentage of classification, for each classification under an operation.  
         [0722]    For each parameter, the trend tracer searches for a pat tern based on some basic statistical regression methods. Only parameters with significant trends appear in the final report produced, along with the trend line formula.  
         [0723]    The report definition screen supplies the user with a default confidence level (95%), which could be altered by the user.  
         [0724]    QPI Interface  
         [0725]    The QPI interface is a part of system  16  resource planning engine. At its heart is a calculation method (the main subroutine of which is listed hereinbelow) which accepts as input the parameter fServers (which represents the number of employees doing a given set of activities), and based on activity data (provided as various properties of the object setting) calculates properties of the process output (such as service level) and throughput.  
         [0726]    This calculation is a numerical approximation of a statistical formula that describes the behavior of a service queue interwoven with offline activities. That enables the system  16  ARP report to plan resources based on service level, as well as on simple multiplication of operation time and quantity.  
         [0727]    PUBLIC SUB RUNMODEL(FSERVERS As INTEGER)  
         [0728]    ON ERROR GoTo ERRTRAP  
         [0729]    DIM LA( ) As DOUBLE  
         [0730]    DIM MU( ) As DOUBLE  
         [0731]    DIM P( ) As DOUBLE  
         [0732]    DIM CUM( ) As DOUBLE  
         [0733]    DIM SW( ) AS DOUBLE  
         [0734]    DIM ABW( ) AS DOUBLE  
         [0735]    DIM AB( ) As DOUBLE  
         [0736]    DIM SPR( ) AS DOUBLE  
         [0737]    DIM AW( ) AS DOUBLE  
         [0738]    DIM I As INTEGER, J As INTEGER, K As INTEGER  
         [0739]    DIM s As DOUBLE, T AS DOUBLE, Q As DOUBLE, R As DOUBLE  
         [0740]    DIM PAB As DOUBLE, EEN As DOUBLE  
         [0741]    DIM EAB As DOUBLE, PIS As DOUBLE  
         [0742]    DIM AWS As DOUBLE, ESE As DOUBLE  
         [0743]    DIM AWW As DOUBLE, AWV As DOUBLE  
         [0744]    DIM AWAB As DOUBLE, RO As DOUBLE  
         [0745]    DIM WT As DOUBLE, ST As DOUBLE  
         [0746]    DIM UB AS INTEGER  
         [0747]    DIM XX As DOUBLE  
         [0748]    DIM DIVIDER As DOUBLE  
         [0749]    DIM FARRIVALS AS DOUBLE  
         [0750]    DIVIDER=TIMESLICE/60  
         [0751]    IF FRMBRANCH.PNLRESULTSTITLE.CAPTION=”         ” AND FSERVERS&gt; 
         [0752]    CURRENTLINESNUMBER  
         [0753]    THEN  
         [0754]    CURRENTLINESNUMBER=GETTOZAOT  
         [0755]    ENDIF  
         [0756]    IF SETTING.GETLINESASSIGNMENTMETHOD=1 THEN  
         [0757]    IF NOT (CURRENTLINESNUMBER/SETTING.GETLINESSERVERSRATIO)=CINT(FSERVERS) THEN  
         [0758]    CURRENTLINESNUMBER=CINT(FSERVERS)  
         [0759]    SETTING.GETLINESSERVERSRATIO  
         [0760]    ENDIF  
         [0761]    END IF  
         [0762]    IF SETTING.GETLINESASSIGNMENTMETHOD=2 THEN  
         [0763]    IF NOT (CURRENTLINESNUMBER/(SETTING.GETLINESMAXWAITINGTIME/  
         [0764]    SETTING.GETAVERAGESERVICETIME+1))=CINT(FSERVERS) THEN  
         [0765]    CURRENTLINESNUMBER=(SETTING.GETLINESMAXWAITINGTIME/  
         [0766]    SETTING.GETAVERAGESERVICETIME+1)  
         [0767]    CINT(FSERVERS)  
         [0768]    END IF  
         [0769]    END IF  
         [0770]    IF FSERVERS&gt;CURRENTLINESNUMBER THEN  
         [0771]    EXITCODE=−10  
         [0772]    EXITMESSAGE=“         ” 
         [0773]    EXIT SUB  
         [0774]    END IF  
         [0775]    IF FSERVERS&lt;=0 THEN  
         [0776]    EXITCODE=−11  
         [0777]    EXITMESSAGE=“         ” 
         [0778]    EXIT SUB  
         [0779]    END IF  
         [0780]    REDIM LA(CURRENTLINESNUMBER+1)  
         [0781]    REDIM MU(CURRENTLINESNUMBER+1)  
         [0782]    REDIM P(CURRENTLINESNUMBER+1)  
         [0783]    REDIM CUM(CURRENTLINESNUMBER+1)  
         [0784]    REDIM SW(CURRENTLINESNUMBER+1)  
         [0785]    REDIM ABW(CURRENTLINESNUMBER+1)  
         [0786]    REDIM AB(CURRENTLINESNUMBER+1)  
         [0787]    REDIM SPR(CURRENTLINESNUMBER+1)  
         [0788]    REDIM AW(CURRENTLINESNUMBER+1)  
         [0789]    FARRIVALS=ARRIVALS*(FORECASTFACTOR/SETTING.GETKP)  
         [0790]    LA(CURRENTLINESNUMBER)=0  
         [0791]    MU(0)=0  
         [0792]    UB=CURRENTLINESNUMBE−1  
         [0793]    FORI=0 TO UB  
         [0794]    LA(I)=FARRIVALS  
         [0795]    NEXT I  
         [0796]    FOR I=1 TO FSERVERS  
         [0797]    MU(I)=SERVICERATE*I  
         [0798]    NEXT I  
         [0799]    XX=FSERVERS*(SERVICERATE-ABANDONRATE)  
         [0800]    FOR I=FSERVERS+1 To CURRENTLINESNUMBER  
         [0801]    MU(I)=XX+ABANDONRATE*I  
         [0802]    NEXT I  
         [0803]    s=1  
         [0804]    T=1  
         [0805]    FORK=1 To CURRENTLINESNUMBER  
         [0806]    T=T*LA(K−1)/MU(K)  
         [0807]    S=S+T  
         [0808]    NEXTK  
         [0809]    P(0)=1/s  
         [0810]    FOR K=1 To CURRENTLINESNUMBER  
         [0811]    P(K)=P(K−1)*LA(K−1) MU(K)  
         [0812]    NEXT K  
         [0813]    R=0  
         [0814]    UB=FSERVERS−1  
         [0815]    FOR I=0 To UB  
         [0816]    AB(I)=0  
         [0817]    SPR(I)=1  
         [0818]    R=R+P(I)  
         [0819]    AW(I)=0  
         [0820]    CUM(I)=0  
         [0821]    NEXT I  
         [0822]    PIS=R  
         [0823]    s=0  
         [0824]    T=0  
         [0825]    R=0  
         [0826]    UB=CURRENTLINESNUMBER−1  
         [0827]    FOR I=FSERVERS To UB  
         [0828]    Q=ABANDONRATE/MU(I+1)  
         [0829]    AB(I)=Q+(1−Q)*AB(I−1)  
         [0830]    AW(I)=Q/ABANDONRATE+(1−Q)*AW(I−1)  
         [0831]    SPR(I)=(1−Q)*SPR(I−1)  
         [0832]    CUM(I) CUM(I−1)+1/MU(I)  
         [0833]    SW(I)=SPR(I)*CUM(I)  
         [0834]    T=T+P(I)*AW(I)  
         [0835]    S=S+P(I)*AB(I)  
         [0836]    R=R+P(I)*SW(I)  
         [0837]    NEXT I  
         [0838]    PAB=s  
         [0839]    EAB=PAB*FARRIVALS  
         [0840]    EEN=(1−P(CURRENTLINESNUMBER))*FARRIVALS  
         [0841]    AWS=3600*R/(1−P(CURRENTLINESNUMBER)-PIS-PAB)  
         [0842]    ESE=EEN-EAB  
         [0843]    AWW=3600*T/(1−PIS-P(CURRENTLINESNUMBER))  
         [0844]    AWV=3600*T/(1−P(CURRENTLINESNUMBER))  
         [0845]    AWAB=3600*(T-AWS*(1−P(CURRENTLINESNUMBER)-PIS-PAB)/3600) PAB  
         [0846]    RO=((1−P(CURRENTLINESNUMBER)-PAB)*FARRIVALS)/(FSERVERS*SERVICERATE)  
         [0847]    PARAMETERS.SETPARAMETERVALUE UCAVREAGEWAITINGTIME, AWV  
         [0848]    PARAMETERS.SETPARAMETERVALUE WAITTIME4WAITING, AWW  
         [0849]    PARAMETERS.SETPARAMETERVALUE WAITTIME4ABANDON, AWAB  
         [0850]    PARAMETERS.SETPARAMETERVALUE WAITTIME4SERVICED, AWS  
         [0851]    PARAMETERS.SETPARAMETERVALUE EXTARRIVALRATE, (ARRIVALS*FORECASTFACTOR)* DIVIDER  
         [0852]    PARAMETERS.SETPARAMETERVALUE EFFARRIVALRATE, EEN*DIVIDER  
         [0853]    PARAMETERS.SETPARAMETERVALUE MAXSERVICERATE, FSERVERS*SERVICERATE*DIVIDER  
         [0854]    PARAMETERS.SETPARAMETERVALUE EFFSERVICERATE, ESE*DIVIDER  
         [0855]    PARAMETERS.SETPARAMETERVALUE BUSYSIGNALRATE, (FARRIVALS-EEN)*DIVIDER  
         [0856]    PARAMETERS.SETPARAMETERVALUE PERCBUSYSIGNAL, P(CURRENTLINESNUMBER)*100  
         [0857]    PARAMETERS.SETPARAMETERVALUE PERCIMMEDIATESERVICE, PIS*100  
         [0858]    PARAMETERS.SETPARAMETERVALUE PERCWAITING, 100*(1−PIS-P(CURRENTLINESNUMBER))  
         [0859]    WT=100*(1−PIS-P(CURRENTLINESNUMBER))*EXP(-SETTING.GETTHRESHOLDVALUE/AWW)  
         [0860]    PARAMETERS.SETPARAMETERVALUE PERCWAITMORETHAN_T, WT  
         [0861]    PARAMETERS.SETPARAMETERVALUE PERCWAITLESSTHAN_T, 100*(1−P(CURRENTLINESNUMBER)-PIS)-WT  
         [0862]    PARAMETERS.SETPARAMETERVALUE CABANDONRATE, EAB*DIVIDER  
         [0863]    PARAMETERS.SETPARAMETERVALUE PERCABANDONING, 100*PAB  
         [0864]    ST=100*(1−PIS-P(CURRENTLINESNUMBER)-PAB)*EXP(-SETTING.GETTHRESHOLDVALUE/AWS)  
         [0865]    PARAMETERS.SETPARAMETERVALUE PERCSERVEDAFTERWAIT_T, ST  
         [0866]    PARAMETERS.SETPARAMETERVALUE PERCABANDONAFTERWAIT_T, WT-ST  
         [0867]    PARAMETERS.SETPARAMETERVALUE EFFTRAFICINTENSITY, RO*DIVIDER  
         [0868]    PARAMETERS.SETPARAMETERVALUE PERCOFAVAILABILITY, 100*(1−RO)  
         [0869]    PARAMETERS.SETPARAMETERVALUE IMMEDIATEANDLESSTHAN_T, (PIS*100)+(100*(1−P(CURRENTLINESNUMBER)-PIS)-WT)  
         [0870]    PARAMETERS.SETPARAMETERVALUE TOTALINBRANCHTIME, SETTING.GETAVERAGESERVICETIME*(1−PAB-P(CURRENTLINESNUMBER))+AWV  
         [0871]    EXITCODE=0 ‘OK  
         [0872]    EXIT SUB  
         [0873]    ERRTRAP:  
         [0874]    EXITCODE=-ERR.N UMBER  
         [0875]    EXITMESSAGE=ERROR  
         [0876]    END SUB  
         [0877]    The Callflow Analyzer  
         [0878]    [0878]FIG. 11 is a flow chart that schematically illustrates the callflow analyzer function  200 , in accordance with a preferred embodiment of the present invention.  
         [0879]    The software component of system  10  provides the infrastructure for a methodology of employee management. This methodology assumes that:  
         [0880]    a manager is to be notified when any of a set of business-specific conditions  212  are derived from the workflow data  220  stored on database  28 , causing notifications  214  to be sent to the manager workstation component of system notice  154 A;  
         [0881]    with notification  214  the manager can access visualizing data  216  that can help him handle the situation; and  
         [0882]    the manager, based on data  216 , exchanges messages  218  with the “agent” (an employee being monitored by system  10 ) system notice component  154 B to assist the agent in the work process.  
         [0883]    The Callflow Analyzer  210  (CFA) is a primary tool for visualizing part of the relevant workflow data, and is activated  222  by Notice  154 .  
         [0884]    CFA is a system for analyzing the information stored in System Database  28 , in a way that produces Gantt charts.  
         [0885]    [0885]FIG. 12 is a graph that schematically illustrates the function of a Gantt chart  230 , in accordance with the prior art.  
         [0886]    The Gantt chart is a basic means of visually presenting a project program. Essentially a bar chart, it is a useful summary of where the project stands.  
         [0887]    Each bar  232  constitutes an aggregate of numerous sub-tasks, which are each continued in their own Gantt chart. A hierarchy of Gantt charts can therefore be built up. The Gantt chart is often used as the benchmark by which a project&#39;s progress is measured, and is commonly circulated to all team leaders.  
         [0888]    Gantt charts can describe either a specific set of logically linked operations (which are referred to as a “case”) or a historical summation of multiple cases.  
         [0889]    [0889]FIG. 13 is a schematic illustration of the functions of the callflow analyzer  240 , in accordance with a preferred embodiment of the present invention.  
         [0890]    The CFA system&#39;s structure is a unique combination of data analysis procedures, display techniques, and interaction of various software components, in a way that supports the proposed management methodology.  
         [0891]    The various sub-components of the CFA, are described as follows:  
         [0892]    CFA Stored Procedures  
         [0893]    CFA stored procedures  210 A generally return a table containing Gantt chart data  210 D, based on certain parameters given to them. Gantt chart data  210 D is returned as rows, each row relating to a different activity  232  and containing the following these columns:  
         [0894]    1. Label: the description of the activity  234   
         [0895]    [0895] 2 . X1: beginning of activity  236   
         [0896]    [0896] 3 . X2: ending of activity  238   
         [0897]    [0897] 4 . Number: number of operations sampled  
         [0898]    There are several variations of stored procedures, used by the system for different types of queries. These are:  
         [0899]    1. Sy_VAW_Ca: returns a Gantt with activities aggregated to “categories” (families of similar types of operations) for low-resolution analysis.  
         [0900]    [0900] 2 . Sy_VAW_Op: returns a Gantt with activities aggregated to “operations” for high resolution analysis.  
         [0901]    [0901] 3 . Sy_VAW_Ca_Us: returns a Gantt with categories, with each user&#39;s data shown seperately. To differentiate users, an additional column ‘Series’ is returned.  
         [0902]    [0902] 4 . Sy_VAW_Ca_Gr: returns a Gantt with categories, with each user-group&#39;s data shown seperately. To differentiate groups, an additional column ‘Series’ is returned.  
         [0903]    [0903] 5 . Sy_VAW_Op_Us: returns a Gantt with operations, with each user&#39;s data shown separately. To differentiate users, an additional column ‘Series’ is returned.  
         [0904]    [0904] 6 . Sy_VAW_Op_Gr: returns a Gantt with operations, with each user-group&#39;s data shown seperately. To differentiate groups, an additional column ‘Series’ is returned.  
         [0905]    [0905] 7 . Sy_VAW_Us: returns a Gantt for a specific user, for a single case of operations.  
         [0906]    Procedures 1-6 are given the following parameters:  
         [0907]    1. UserIndex: selects a specific user for query, or (if NULL) all users.  
         [0908]    2. GroupIndex: selects a specific group for query, or (if NULL) all groups.  
         [0909]    3. Case: selects a specific case for query, or (if NULL) all cases.  
         [0910]    4. OperationIndex: selects a specific operation for query, or (if NULL) all operations.  
         [0911]    5. CategoryIndex: selects a specific category for query, or (if NULL) all categories.  
         [0912]    6. FromDate: earliest time for query or (if NULL) since first entry.  
         [0913]    7. ToDate: latest time for query or (if NULL) until last entry.  
         [0914]    8. Live: if equals 1, query includes currently ongoing activity.  
         [0915]    Procedure 7 is given these parameters:  
         [0916]    1. UserIndex: selects a specific user for query, or (if NULL) all users.  
         [0917]    2. Date: selects a specific time to query.  
         [0918]    These procedures all follow the same core logic:  
         [0919]    1. For procedures 1-6: Select operations matching input parameters.  
         [0920]    2. For procedure 7: locate an operation which took place in the specified time, find its case, and select operations of the same case.  
         [0921]    3. Group together operations belonging to a similar case (identified by the TiCase column in the TimedOperations  56  of Table I).  
         [0922]    4. For procedures 1,3-4: Group those operations again, as categories, with each category starting with the earliest-starting operation in that category, and ending with the latest-finishing operation in the category.  
         [0923]    5. In each case, find the earliest activity (operation or category), and mark its start as zero-time of the case.  
         [0924]    6. compute all operation beginning and finishing times relative to zero-time of the case.  
         [0925]    7. For every activity, compute the average beginning and finishing relative times, over the different cases.  
         [0926]    8. For procedures 3-6: compute the averages over different users or groups, as well.  
         [0927]    The SQL script for these procedures (MS T-SQL version) is attached at the end of this document.  
         [0928]    CFA Middle Tier  
         [0929]    The CFA middle tier  210 B has the task of receiving various inputs, indicating the type of querying required, running the appropriate stored procedures and delivering the data returned to Gantt display  210 D.  
         [0930]    From the user interface, CFA gets query definitions that are selected specifically by the user. From System Herald  150 , CFA gets additional notification on incoming alerts, that are transformed into appropriate query definitions.  
         [0931]    The following query definitions are handled by the middle tier:  
         [0932]    1. Aggregation method: selects which of procedures 1-6 to use.  
         [0933]    2. “Watch” mode: selects procedure 7, with Date=NULL (current time).  
         [0934]    3. “Live” mode: queries run with Live=1.  
         [0935]    4. “Auto Refresh” mode: queries are executed repeatedly  
         [0936]    5. Time period: date and time are combined to FromDate and ToDate.  
         [0937]    6. User multiselection: transformed to a series of queries for each User.  
         [0938]    [0938] 7 . Group multiselection: transformed to a series of queries for each Group.  
         [0939]    [0939] 8 . Operation multiselection: transformed to a series of queries for each Operation.  
         [0940]    [0940] 9 . Category multiselection: transformed to a series of queries for each Category.  
         [0941]    [0941] 10 . User multiselection: transformed to a series of queries for each user.  
         [0942]    [0942]FIG. 14 is a computer screen image illustrating the main window of the CFA user interface  250 , in accordance with a preferred embodiment of the present invention.  
                                                                                                             Main Query Control:                  252 Runs query.           258 opens the “print” dialog.                  254A indicates “live” view,           254B = “no live”. Switched                by clicking.                       256A indicates auto refresh (“live” only),           256B = no auto                refresh. Switched by clicking.                       (in “users”[274 pane) indicates “watch” mode,                           264 = “watch off”. Switched by clicking.            Main Notice Control:                  266 (in “alerts” 282 pane) indicates “alert” mode,                           = “alert off”. Switched by clicking.                       260 Shows “notice” window.                  262A indicates auto keep, z,811  262B = no auto keep.                Switched by clicking.                      
 
         [0943]    [0943]FIG. 15 is a computer screen image illustrating the “roll” and “filter” features of the main window of the CFA user interface, in accordance with a preferred embodiment of the present invention.  
         [0944]    Roll Up/Down:  
         [0945]    A click on the Roll icon  290  switches between rolled-up and rolled-down pane.  
         [0946]    Double-click on the Roll-Down icon rolls the pane down while rolling all others up.  
         [0947]    Filter On/Off:  
         [0948]    A click on the Filter icon  292  switches between filter-off (same as selecting “ALL”) and filter-on (previously selected from the list, or currently being selected). Filter is switched on when selection is in progress.  
         [0949]    Pane Space Allocation:  
         [0950]    All rolled-down panes occupy the same space when not in selection: whatever space is allowed by the size of the main form, minus the height of all rolled-up panes, is divided between all rolled-down panes.  
         [0951]    Cursor Shape:  
         [0952]    [0952]          Normal state  
         [0953]    [0953]          Waiting for query results  
         [0954]    [0954]          Mouse over “clickable” button  
         [0955]    Keyboard Shortcuts:  
         [0956]    F5=Run Query;  
         [0957]    CTRL+N=Show Notice;  
         [0958]    CTRL+P=Open “Print” Dialog;  
         [0959]    CTRL+W=Toggle “Watch” Mode; and  
         [0960]    CTRL+A=Toggle “Alert” Mode.  
         [0961]    Pane Contents:  
         [0962]    The following “clickable” entry sub-windows are available on the CFA:  
         [0963]    Aggregation  270 ;  
         [0964]    Groups  272 ;  
         [0965]    Users  274 ;  
         [0966]    Categories  276 ;  
         [0967]    Operations  278 ;  
         [0968]    Period  280 ;  
         [0969]    Alerts  282 ; and  
         [0970]    Legend  284 .  
         [0971]    [0971]FIG. 16 is a set of computer screen images illustrating the full sub-windows of the CFA user interface, in accordance with a preferred embodiment of the present invention. FIG. 16 shows each of the CFA full sub-windows that are displayed when the corresponding entry sub-window is clicked on CFA user interface  250 .  
         [0972]    The following full sub-windows are displayed accordingly:  
         [0973]    Aggregation  302 ;  
         [0974]    Groups 304 ;  
         [0975]    Users  306 ;  
         [0976]    Categories  308 ;  
         [0977]    Operations  310 ;  
         [0978]    Period  312 ;  
         [0979]    Alerts  314 ; and  
         [0980]    Legend  316 .  
         [0981]    Also, when “print” dialog  258  is opened, print dialog box  318  is displayed.  
         [0982]    “Click to Query”:  
         [0983]    Some of the query parameter selection is available by direct manipulation of the Gantt chart. The manager clicks on elements of the chart with the mouse, thereby changing the parameters accordingly and he then re-queries the information. The “Click to Query” rules are as follows:  
         [0984]    1. Zoom on Category: if activity is aggregated by Categories, and a manager right-clicks on a specific bar of a Category, a new query is run with the selected Category as filter and activity aggregated by Operations.  
         [0985]    2. Zoom on Group: if agents are aggregated by Groups, and a manager left-clicks on a specific bar of a Group, a new query is run with the selected Group as filter and agents aggregated by Users.  
         [0986]    3. Zoom on Total: if agents are aggregated as Total, and a manager left-clicks on a specific bar of a Category/Operation, a new query is run with the selected Category/Operation as filter and agents aggregated by Groups.  
         [0987]    4. Zoom Out Categories: if activity is aggregated by Operations, and a manager right-clicks on the chart (not on a bar), a new query is run with activity aggregated by Categories.  
         [0988]    5. Zoom Out Groups: if agents are aggregated by Users, and a manager left-clicks on the chart (not on a bar), a new query is run with agents aggregated by Groups.  
         [0989]    6. Zoom Out Total: if agents are aggregated by Groups, and a manager left-clicks on the chart (not on a bar), a new query is run with agents aggregated as Total.  
       Script of CFA Stored Procedures  
       [0990]    CREATE PROCEDURE Sy_YAW_Ca  
         [0991]    @UserIndex int, @GroupIndex int, @Case varchar(20), @OperationIndex int, @CategoryIndex int, @FromDate datetime, @ToDate datetime, @Live int AS SET NOCOUNT ON CREATE TABLE #res (label int, X int, L int) DECLARE @tg varchar(30), @first datetime, @prev varchar(30), @label int, @t datetime, @x int, @I int, @n datetime SELECT @prev=“SELECT @n=getdate( ) DECLARE thru CURSOR local forward_only FOR SELECT OpCaIndex, MIN(TiStartTime) AS Start, datediff (ss, MIN(TiStartTime), MAX (CASE WHEN TiFinishTime IS NULL THEN @n ELSE TiFinishTime END)) AS diff, TiCase AS tag FROM TimedOperations, AllowedOperations, Allowed Users WHERE TiOpIndex=OpIndex AND (NOT(TiFinishTime IS NULL) OR @Live=1) AND TiUsIndex=UsIndex AND NOT (TiCase IS NULL) AND (UsIndex=@UserIndex OR @UserIndex IS NULL) AND (UsGrIndex=@GroupIndex OR @GroupIndex IS NULL) AND (OpIndex=@OperationIndex OR @OperationIndex IS NULL) AND (OpCaIndex=@CategoryIndex OR @CategoryIndex IS NULL) AND (TiCase=@Case OR @Case IS NULL) AND (TiStartTime&gt;=@FromDate OR @FromDate IS NULL) AND (TiStartTime&lt;=@ToDate OR @ToDate IS NULL) GROUP BY TiCase, OpCaIndex ORDER BY Tag, Start OPEN thru FETCH next FROM thru INTO @label, @t, @I, @tg WHILE @@fetch_status&lt;&gt;−1 BEGIN IF @tg&lt;&gt;@prev BEGIN SELECT @prev=@tg SELECT @first=@t END SELECT @x=datediff (ss, @first, @t) INSERT #res VALUES (@label, @x, @I) FETCH next FROM thru INTO @label, @t, @I, @tg END CLOSE thru SELECT label, AVG(x) AS x1, AVG(x+1) AS x2,COUNT(x) AS number FROM #res GROUP BY label ORDER BY x1DROP TABLE #res  
         [0992]    CREATE PROCEDURE Sy_VAW_Ca_Gr  
         [0993]    @UserIndex int, @GroupIndex int, @Case varchar(20), @OperationIndex int, @CategoryIndex int, @FromDate datetime, @ToDate datetime, @Live int AS SET NOCOUNT ON CREATE TABLE #res(series int, label int, X int, L int) DECLARE @tg varchar(30), @first datetime, @prev varchar(30), @label int, @t datetime, @x int, @I int, @n datetime, @series int SELECT @prev=” SELECT @n=getdate( ) DECLARE thru CURSOR local forward_only FOR SELECT OpCaIndex, MIN(TiStartTime) AS Start, datediff(ss, MIN(TiStartTime), MAX(CASE WHEN TiFinishTime IS NULL THEN @n ELSE TiFinishTime END)) AS diff, TiCase AS tag, UsGrIndex AS series FROM TimedOperations, AllowedOperations, AllowedUsers WHERE TiOpIndex=OpIndex AND (NOT (TiFinishTime IS NULL) OR @Live=1) AND TiUsIndex=UsIndex AND NOT (TiCase IS NULL) AND (UsIndex=@UserIndex OR @UserIndex IS NULL) AND (UsGrIndex=@GroupIndex OR @GroupIndex IS NULL) AND (OpIndex=@OperationIndex OR @OperationIndex IS NULL) AND (OpCaIndex=@CategoryIndex OR @CategoryIndex IS NULL) AND (TiCase=@Case OR @Case IS NULL) AND (TiStartTime&gt;=@FromDate OR @FromDate IS NULL) AND (TiStartTime&lt;=@ToDate OR @ToDate IS NULL) GROUP BY TiCase, OpCaIndex, UsGrIndex ORDER BY Tag, Start OPEN thru FETCH next FROM thru INTO @label, @t, @I, @tg, @series WHILE @@fetch_status&lt;&gt;−1 BEGIN IF @tg&lt;&gt;@prev BEGIN SELECT @prev=@tg SELECT @first=@t END SELECT @x=datediff(ss, @first, @t) INSERT #res VALUES (@series, @label, @x, @I) FETCH next FROM thru INTO @label, @t, @I, @tg, @series END CLOSE thru SELECT series, label, AVG(x) AS x1, AVG(x+1) AS x2, COUNT(x) AS number FROM #res GROUP BY series, label ORDER BY series, label DROP TABLE #res  
         [0994]    CREATE PROCEDURE Sy_VAW_Ca_Us  
         [0995]    @UserIndex int, @GroupIndex int, @Case varchar(20), @OperationIndex int, @CategoryIndex int, @FromDate datetime, @ToDate datetime, @Live int AS SET NOCOUNT ON CREATE TABLE #res (series int, label int, X int, L int) DECLARE @tg varchar(30), @first datetime, @prev varchar(30), @label int, @t datetime, @x int, @l int, @n datetime, @series int SELECT @prev=“SELECT @n=getdate( ) DECLARE thru CURSOR local forward_only FOR SELECT OpCaIndex, MIN(TiStartTime) AS Start, datediff (ss, MIN(TiStartTime), MAX (CASE WHEN TiFinishTime IS NULL THEN @n ELSE TiFinishTime END)) AS diff, TiCase AS tag, UsIndex AS series FROM TimedOperations, AllowedOperations, Allowed Users WHERE TiOpIndex=OpIndex AND (NOT(TiFinishTime IS NULL) OR @Live=1) AND TiUsIndex=UsIndex AND NOT (TiCase IS NULL) AND (UsIndex=@UserIndex OR @UserIndex IS NULL) AND (UsGrIndex=@GroupIndex OR @GroupIndex IS NULL) AND (OpIndex=@OperationIndex OR @OperationIndex IS NULL) AND (OpCaIndex=@CategoryIndex OR @CategoryIndex IS NULL) AND (TiCase=@Case OR @Case IS NULL) AND (TiStartTime&gt;=@FromDate OR @FromDate IS NULL) AND (TiStartTime&lt;=@ToDate OR @ToDate IS NULL) GROUP BY TiCase, OpCaIndex, UsIndex ORDER BY Tag, Start OPEN thru FETCH next FROM thru INTO @label, @t, @I, @tg, @series WHILE @@fetch_status&lt;&gt;−1 BEGIN IF @tg&lt;&gt;@prev BEGIN SELECT @prev=@tg SELECT @first=@t END SELECT @x=datediff (ss, @first, @t) INSERT #res VALUES (@series, @label, @x, @I) FETCH next FROM thru INTO @label, @t, @I, @tg, @series END CLOSE thru SELECT series, label, AVG(x) AS x1, AVG(x+I) AS x2,COUNT(x) AS number FROM #res GROUP BY series, label ORDER BY series, label DROP TABLE #res  
         [0996]    CREATE PROCEDURE Sy_YAW_Op  
         [0997]    @UserIndex int, @groupIndex int, @Case varchar(20), @OperationIndex int, @CategoryIndex int, FromDate datetime, @ToDate datetime, @Live int AS SET NOCOUNT ON CREATE TABLE #res (label int, x int, I int) DECLARE @tg varchar(30), @first datetime, @prev varchar(30), @label int, @t datetime, @x int, @I int, @n datetime SELECT @prev=” SELECT @n=getdate( ) DECLARE thru CURSOR local forward only FOR SELECT OpIndex, TiStartTime, CASE WHEN TiFinishTime IS NULL THEN datediff (ss, TiStartTime, @n) ELSE datediff (ss, TiStartTime, TiFinishTime) END AS diff, TiCase AS tag FROM TimedOperations, AllowedOperations, Allowed Users WHERE TiOpIndex=OpIndex AND NOT (TiFinishTime IS NULL) OR @Live=1) AND TiUsIndex=UsIndex AND NOT (TiCase IS NULL) AND (UsIndex=@UserIndex OR @UserIndex IS NULL) AND (UsGrIndex=@GroupIndex OR @GroupIndex IS NULL) AND (OpIndex=@OperationIndex OR @OperationIndex IS NULL) AND (OpCaIndex=@CategoryIndex OR @CategoryIndex IS NULL) AND (TiCase=@Case OR @Case IS NULL) AND (TiStartTime&gt;=@FromDate OR @FromDate IS NULL) AND (TiStartTime&lt;=@ToDate OR @ToDate IS NULL) ORDER BY Tag, TiStartTime OPEN thru FETCH next FROM thru INTO @label, @t, @I, @tg WHILE @@fetch_status&lt;&gt;−1 BEGIN IF @tg&lt;&gt;@prev BEGIN SELECT @prev=@tg SELECT @first=@t END SELECT @x=datediff (ss, @first, @t) INSERT #res VALUES (@label, @x, @I) FETCH next FROM thru INTO @label, @t, @I, @tg END CLOSE thru SELECT label, AVG(x) AS x1, AVG(x+I) AS x2, COUNT(x) AS number FROM #res GROUP BY label ORDER BY x1 DROP TABLE #res  
         [0998]    CREATE PROCEDURE Sy_VAW_Op_Gr  
         [0999]    @UserIndex int, @groupIndex int, @Case varchar(20), @OperationIndex int, @CategoryIndex int, @FromDate datetime, @ToDate datetime, @Live int AS SET NOCOUNT ON CREATE TABLE #res (series int, label int, X int, L int) DECLARE @tg varchar(30), @first datetime, @prev varchar(30), @label int, @t datetime, @x int, @l int, @n datetime, @series int SELECT @prev=“SELECT @n=getdate( ) DECLARE thru CURSOR local forward_only FOR SELECT OpIndex, TiStartTime, CASE WHEN TiFinishTime IS NULL THEN datediff (ss, TiStartTime, @n) ELSE datediff (ss, TiStartTime , TiFinishTime) END AS diff, TiCase AS tag, UsGrIndex AS series FROM TimedOperations, AllowedOperations, AllowedUsers WHERE TiOpIndex=OpIndex AND (NOT(TiFinishTime IS NULL) OR @Live=1) AND TiUsIndex=UsIndex AND NOT (TiCase IS NULL) AND (UsIndex=@UserIndex OR @UserIndex IS NULL) AND (UsGrIndex=@GroupIndex OR @GroupIndex IS NULL) AND (OpIndex=@OperationIndex OR @OperationIndex IS NULL) AND (OpCaIndex=@CategoryIndex OR @CategoryIndex IS NULL) AND (TiCase=@Case OR @Case IS NULL) AND (TiStartTime&gt;=@FromDate OR @FromDate IS NULL) AND (TiStartTime&lt;=@ToDate OR @ToDate IS NULL) ORDER BY Tag, TiStartTime, UsGrIndex OPEN thru FETCH next FROM thru INTO @label, @t, @I, @tg, @series WHILE @@fetch_status&lt;&gt;−1 BEGIN IF @tg&lt;&gt;@prev BEGIN SELECT @prev=@tg SELECT @first=@t END SELECT @x=datediff (ss, @first, @t) INSERT #res VALUES (@series, @label, @x, @I) FETCH next FROM thru INTO @label, @t, @I, @tg, @series END CLOSE thru SELECT series, label, AVG(x) AS x1, AVG(x+I) AS x2,COUNT(x) AS number FROM #res GROUP BY series, label ORDER BY series, label DROP TABLE #res  
         [1000]    CREATE PROCEDURE Sy_VAW_Op_Us  
         [1001]    @UserIndex int, @groupIndex int, @Case varchar(20), @OperationIndex int, @CategoryIndex int, @FromDate datetime, @ToDate datetime, @Live int AS SET NOCOUNT ON CREATE TABLE #res (series int, label int, X int, L int) DECLARE @tg varchar(30), @first datetime, @prev varchar(30), @label int, @t datetime, @x int, @I int, @n datetime, @series int SELECT @prev=” SELECT @n=getdate( ) DECLARE thru CURSOR local forward_only FOR SELECT OpIndex, TiStartTime, CASE WHEN TiFinishTime IS NULL THEN datediff (ss, TiStartTime, @n) ELSE datediff (ss, TiStartTime, TiFinishTime) END AS diff, TiCase AS tag, UsIndex AS series FROM TimedOperations, AllowedOperations, AllowedUsers WHERE TiOpIndex=OpIndex AND (NOT(TiFinishTime IS NULL) OR @Live=1) AND TiUsIndex=UsIndex AND NOT (TiCase IS NULL) AND (UsIndex=@UserIndex OR @UserIndex IS NULL) AND (UsGrIndex=@GroupIndex OR @GroupIndex IS NULL) AND (OpIndex=@OperationIndex OR @OperationIndex IS NULL) AND (OpCaIndex=@CategoryIndex OR @CategoryIndex IS NULL) AND (TiCase=@Case OR @Case IS NULL) AND (TiStartTime&gt;=@FromDate OR @FromDate IS NULL) AND (TiStartTime&lt;=@ToDate OR @ToDate IS NULL) ORDER BY Tag, TiStartTime, UsIndex OPEN thru FETCH next FROM thru INTO @label, @t, @I, @tg, @series WHILE @@fetch_status&lt;&gt;−1 BEGIN IF @tg&lt;&gt;@prev BEGIN SELECT @prev=@tg SELECT @first=@t END SELECT @x=datediff (ss, @first, @t) INSERT #res VALUES (@series, @label, @x, @I) FETCH next FROM thru INTO @label, @t, @I, @tg, @series END CLOSE thru SELECT series, label, AVG(x) AS x1, AVG(x+I) AS x2,COUNT(x) AS number FROM #res GROUP BY series, label ORDER BY series, label DROP TABLE #res  
         [1002]    CREATE PROCEDURE Sy_YAW_Us  
         [1003]    @UserIndex int, @Date datetime AS SET NOCOUNT ON CREATE TABLE #res (label int, x int, I int) DECLARE @tc varchar(20) DECLARE @tg varchar(30), @first datetime, @prev varchar(30), @label int, @t datetime, @x int, @I int, @n datetime IF @Date is null SELECT @Date=@n SELECT @prev=“ SELECT @n=getdate( ) SELECT @tc=TiCase FROM TimedOperations WHERE (TiCase IS NOT NULL) AND (TiPaused is NULL) AND (TiUsIndex=@UserIndex OR @UserIndex IS NULL) AND (TiStartTime&lt;=@Date) AND (TiFinishTime&gt;=@Date OR (TiFinishTime IS NULL and DATEDIFF (hh, TiStartTime, @Date)&lt;12)) DECLARE thru CURSOR local forward_only FOR SELECT TiOpIndex, TiStartTime, CASE WHEN TiFinishTime IS NULL THEN datediff (ss, TiStartTime, @n) ELSE datediff (ss, TiStartTime, TiFinishTime) END AS diff, TiCase AS tag FROM TimedOperations WHERE TiCase=@tc ORDER BY Tag, TiStartTime OPEN thru FETCH next FROM thru INTO @label, @t, @I, @tg WHILE @@fetch_status&lt;&gt;−1 BEGIN IF @tg&lt;&gt;@prev BEGIN SELECT @prev=@tg SELECT @first=@t END SELECT @x=datediff (ss, @first, @t) INSERT #res VALUES (@label, @x, @I) FETCH next FROM thru INTO @label, @t, @I, @tg END CLOSE thru SELECT label, AVG(x) AS x1, AVG(x+I) AS x2, COUNT(x) AS number FROM #res GROUP BY label ORDER BY x1 DROP TABLE #res