Development framework for case and workflow systems6606740Abstract A workflow processing framework provides common objects and business processes for the creation of an enterprise-wide workflow processing system. Conventional workflow, database and other platforms are accessed using standardized protocols. The use of common objects providing robust functionality while being insulated from the specific platforms used to implement the workflow processing system enable the common objects to be reused to perform many functions in many different lines of business without modification. If necessary, foundation objects are written to utilize the existing platforms more fully than permitted by standardized protocols. The business processes are generalized as much as possible, but are customized as required to fit the enterprise environment. Claims What is claimed is: Description BACKGROUND OF THE INVENTION
BL_USERPROFILE
SUSERID = juser
SUSERNAME = Joe User
BISAVAILABLE = Y
BL_PROGRAMSECURITY
SUSERID = juser
SPROGRAMNAME = Claim Processing
BL_TASKSECURITY
SUSERID = juser
SPROGRAMNAME = Claim Processing
STASKNAME = Claim1
BL_FUNCTIONSECURITY
SUSERID = juser
SPROGRAMNAME = Claim Processing
STASKNAME = Claim1
SFUNCTIONNAME = Write Custom Letter
The third level of security is the function within the task. For example, while a function such as Write Custom Letter may be included in an insurance claim application, only certain users might be allowed to access this function. Other workers would be limited to ordinary correspondence processing and customer service functions illustrated in FIG. 1, and perhaps additional functions not illustrated. BLCaseWorkList 62 retrieves a prioritized worklist for a user when a worker starts a session with a workflow processing system according to the present invention. The next case can be retrieved while simultaneously processing the current case by user interaction through a client/server GUI environment. Ordinarily a user will require a few minutes to process the work item. During that interval BLCaseWorkList prefetches the next case to the client workstation of the user. This limits the idle time of employees between and during cases and increases the output of the employee. BLCaseWorkList 62 is a multi-threaded COM object that operates in a producer-consumer environment. This object keeps track of the current and next case objects using semaphores, threads, and class member variables. The consumer thread is the normal user thread of BLCaseWorkList 62. From the consumer thread the current case is obtained from the list. The producer thread executes as long as BLCaseWorkList 62 exists in memory. Whenever the next case object is NULL, the producer thread retrieves the next available case from the database. Whenever the next case object exists, the producer thread does not try to get another case until the current case is retrieved into processing by the consumer thread. Whenever a case is retrieved from the database platform in conventional platforms 20, a prefetch of that case is completed. The prefetch function has an enumerated type which allows the system to determine what components of the case need to be prefetched. The enumerated type allows the system to filter (include or exclude) each case level component type individually in the prefetch operation. This prefetch filter value is set during worklist construction as part of the system implementation. For example, a system implementer can choose to have the case documents and the case audits prefetched, but not the case events. This enables the prefetch requirements to be tailored to the environment of each specific implementation. The worklist is determined based on user identification obtained when the worker logs into the computer system on which the workflow processing system is running. BLCaseWorkList 62 calls a collection of objects named BLWFWorkListFields 80 formed of objects each named BLWFWorkListField 82. An object is called by BLWFWorkListField 82 to access the workflow engine. The object used will depend on the workflow engine included in the conventional platforms 20. In the example illustrated in FIGS. 4A-4C, VWOWorkQuery 83 accesses the Visual WorkFlo to obtain information in the workflow platform identifying the fields used by a case, such as the name of the worker, the case number, the case type, the event that caused the case to enter the workflow, the dollar amount, etc. Once a worklist has been obtained, the user can select one of the cases on which to work. The GetCase function is called by BlCase Session and returns an object called BLCase 64. The BLCase object 64 contains several collections of objects to obtain the case information. BLCaseFields 84 is a collection of objects containing the information for a case obtained from the database platform in conventional platforms 20. For example, the information for: an insurance claim may include case identification number, incident number, date of incident, name of insured, claim dollar amount, type of claim, etc. BLWFWorkItemFields 88 is a collection of objects containing information identifying where the case is in the workflow. The information in BLWFWorkItemFields 88 is obtained from the workflow platform in conventional platforms 20. BLCaseEvents 92 is a collection of objects containing information regarding events that have or will occur during the existence of a case. The events are defined during each system implementation. For example, the receipt of a document in a case, the creation of a new case, and the expiration of an event tied to a time period may be defined as events in a system. Each system implementation is allowed to create its own events by writing an event code to the BL_CaseEvent table by using BLCase.AddPendingEvent or BLCase.AddReceivedEvent. The Events Processor does not need to be modified when new event codes are added. The received event codes are matched with the pending event codes by the Events Processor. As long as the programs writing the event code to the Events Processor are synchronized such that the program writing the pending event writes the same event code as the program writing the received event, the Events Processor will recognize and process the events. The information contained in BLCaseEvents 92 is obtained from the database platform in conventional platforms 20, in a manner similar to that used by BLCaseFields 84. The next two objects illustrated in FIGS. 4A-4C are items in a case folder. BLCaseItems 96 represents items that will not have different versions. In the preferred embodiment optical storage is used for the data and each BLCaseItem 98 obtains the information by accessing the optical storage by calling an imaging system object specifically for the type of optical storage unit used in the system. BLDraftCaseItems 100 are documents related to the case that are in process of being created and for which there may be different versions that do not need to be saved on optical storage until the final product has been determined. The information in each BLDraftCaseItem 102 is obtained from the conventional platforms 20 using the BLCase Object. BLDraftCaseFields 104 are the data values stored with a BLDraftCaseItem 102 when the item becomes permanent. In addition to calling the objects illustrated in FIGS. 4A-4C, BLCase 64 also uses several methods to perform operations itself. BLCase.AddNewItem and BLCase.AddNewDraftItem are used to create a new BLCaseItem 98 and a new BLDraftCaseItem 102, respectively. BLCaseWorkList.Prefetch performs the prefetch operations described above. BLCase.AddPendingEvent and BLCase.AddReceivedEvent are used to create events, as described below. BLCaseAuditSessions 108 are a collection of objects used to keep track of work performed on a case during the sessions on which the case is worked. BLCaseAudits 112 are a collection of objects containing information about the actions taken during a session. What information is stored in each BLCaseAudit 114 can be determined when the workflow processing system is implemented. The workflow platform in the conventional platforms 20 includes a definition of what information will be captured by BLCaseAudits 112. In the Visual WorkFlo system used in the exemplary embodiment, the definition of what information will be stored in BLCaseAudits 112 is determined by each individual system implementation, BLCaseAudit 114 defines the interface to write the audits. Each business application must define and write its own data to the audit log. As an example, a user can suspend a case awaiting a signature document using a module like the Case Manager described below with reference to FIG. 6. The Case Manager module calls the BLCase.AddPendingEvent method with the parameters (EventCode="ADD_DOC_SIGNATURE_DOC", EventDescription="Signature Document", Expire="current date+10 days", GroupID="", GroupEventCode="", OptionalEventData=""). This adds a record to the BL_CaseEvent table that indicates that the case is waiting for a signature document to be received within 10 days or it will be triggered to the user for review. When the document is received, the Case Builder module calls the BLCase.AddReceivedEvent method with the parameters (EventCode="ADD_DOC_SIGNATURE_DOC", EventDescription="Signature Document", Received="current date", CaseItemName="Doc ID", OptionalEventData=""). This adds a record to the BL_CaseEvent table that indicates that the case received a signature document. The next time the Events Processor module runs, it matches up the pending and received "Signature Document" event codes and triggers the work object to the user for review. Preferably graphical user interfaces (GUIs) in a general purpose language like Visual Basic are included in a workflow processing system according to the present invention to provide programmers with the bulk of the code necessary to implement modules like those described above. Examples are Scan, Index, System Maintenance, Case Retrieval, and Document Retrieval interfaces. After incoming documents are prepared for input and sorted into appropriate batches, operators scan documents in batches into the imaging system. The Scan interface provides a processing window that requires users to enter information specific to the current batch. The user also has the ability to set properties of the scanner. When the mandatory information is entered and the user is satisfied with the settings, the scan processing window allows the user to start and stop the actual scanning process. The Index interface provides the ability to assign data values to a document for future retrieval. The Scan process dispatches batches to an Index and Reassembly process. When a user starts the Index and Reassembly process, the process retrieves a user work list for that user and the divisions within the Index and Reassembly work step. The process loads the first batch in the user's work list onto the Index and Reassembly window. The process loads the first document of the batch into the image viewer and the document is ready for indexing. The actual index fields displayed for indexing is based on the document class and varies widely with each system implementation. Therefore, the Index process does not implement the index values control which may, for example, be an Active X control developed by the organization that uses the workflow processing system. When a user finishes indexing the document, he/she clicks the index button. The Index process saves the index values for the current document and loads the next document that has not been indexed. The Index and Reassembly process allows for the reassembly of documents in parallel with the indexing of documents. When reassembling documents within a batch, the user may have the ability to add documents, delete document separators, mark documents for rescan, move pages, copy pages, and paste pages. These capabilities are easily provided when, for example, Visual WorkFlo is used as the workflow engine. The user can view the structure of the batch in the batch reassembly tree to determine whether or not to take these reassembly actions. For example, some fax transmissions are received as one transmission but contain several documents. There is no exact method to determine the document breaks within a single transmission. The indexer reviews each batch and adds new documents as necessary. The indexer can then move pages into the newly created documents. When the user indexes all documents in the current batch, the process prompts the user to commit the batch. If the user chooses to commit the batch, then the process commits the batch and loads the next batch in the user's work list. If the user chooses not to commit the batch, the user is allowed to continue re-indexing documents or reassembling the batch until the user is ready to commit via the commit batch menu option. The System Maintenance interface is a program that is customized for each system implementation. While some of the code is very specific to an implementation, e.g., specific edit checks, some things remain the same. There is always a set of baseline tables that have a constant table structure-and there is a framework for selecting and displaying table information. Therefore code for these functions is preferably provided by a workflow processing system according to the present invention. The System Maintenance interface has two basic screens. The first is the main window, which has a picture list-box down the left-hand side and a grid control covering the remainder of the window. The window creates itself dynamically from a set of constant data structures which lists the icon to be shown in the picture list-box as well as the fields in the corresponding table to be show in the grid for that selection. The second window is a sample property-tabbed dialog that the user uses to update any of the values from the grid. No data is actually modified in the grid. BLErrorLog 72, CNativeErrorLog (not shown), BLStatLog 74, BLDebugLog 70, CNativeDebugLog (not shown), BLDBConnMgr 66 and BLProgramSecurity 76 are used. Document Retrieval is also a commonly requested interface. Although the actual window that users view from implementation to implementation differs, the basics of creating and executing a query against the imaging platform in the conventional platforms 20 are very similar. A workflow processing system according to the present invention preferably provides a program that implements the basics of taking a query and executing it against the imaging platform in the conventional platforms 20. Document Retrieval (and Case Retrieval) preferably use conventional protocols of the operating system for selecting files. An interface is preferably included in the basic workflow processing system to provide a simple search criteria window. When the user clicks Search, the program preferably uses the workflow engine in the conventional platforms 20, e.g., FileNET's OLEDB provider to retrieve a list of documents using an ADODB.RecordSet object 118 (FIG. 4A). The contents of the record set will fill the expanded window with a grid of document indices. Users may then select a document and view it in the workflow engine's native viewer interface. Document Retrieval will make full use of the BLErrorLog, CNativeErrorLog, BLStatLog, BLDebugLog, CNativeDebugLog, BLDBConnMgr and BLProgramSecurity objects. The majority of the code will be implemented in a COM object to allow other programs to include Document Retrieval capabilities within their operations. Although Case Retrieval has slightly more variation from one system implementation to another than Document Retrieval, the basics are still the same. The window in Case Retrieval will look very similar to Document Retrieval. There will be a simple search criteria window allowing the user to enter specific case data values. After clicking search, the main window will expand to show a grid with case data for any matching cases. The Index, Document Retrieval, and Case Retrieval interfaces are implemented with common functions and features and may be implemented with a basic interface control that provides sample search data capabilities. Each specific implementation modifies this interface control without changing the rest of the application or re-compiling the application. The GUI can be thought of as a standalone program, a menu option in a case management GUI, or as the beginnings of a Balance WorkLoad process, where managers multi-select from the list of found cases and reassign them or prompt them into the workflow (Unpend any PENDED items). Case Retrieval makes full use of the BLErrorLog, CNativeErrorLog, BLStatLog, BLDebugLog, CNativeDebugtog, BLDBConnMgr, BLProgramSecurity, BLCaseSession and BLCase objects. The majority of the code is preferably implemented in a COM object to allow other programs to include Case Retrieval capabilities within their operations. As discussed above, a letter generation wizard is preferably included to provide a graphical user interface that steps a user through the creation of a custom letter. It is usually called from a Case Manager process that is customized for each client. The letter generation wizard interfaces with a word processing program in the conventional platforms 20, such as Microsoft Word. It allows the user to select from a list of letter templates. Once a letter template is selected, the wizard reads the template in, e.g., Microsoft Word, for each bookmark and displays the bookmarks in a window for the user to fill in. The wizard replaces the bookmark values with the provided values and sizes the fields according to user defined size configurations for each field. Macros within the template allow the user to finish the letter and return to the Case Manager process. After the Case Manager process, the work object is sent to the Draft Letter Committal background process which commits the letter to the imaging system and adds the letter to the case folder. Illustrated in FIG. 5 is an example of how the Events Processor and Queue Assignment modules operate. When an event is detected, as indicated by Event Trigger 120, the Events Processor determines how the work item(s) 122 associated with the event should be started through the workflow and what data to start in the workflow. The workflow dictates the work step 124. The Queue Assignment module then determines to which work division 126 the work item(s) 122 should be assigned. The configuration tables are used by the Events Processor and Queue Assignment modules to perform these tasks. One example of tables that could be used in the present invention is provided below. This is merely one example of many possible ways that tables could be used to minimize the extent that programs have to be modified during system implementation. The Case table (BL CASE) is the main processing table. It stores a record for each case per work type in the system. It is accessed by BLCase 64. There can be multiple case tables in the system. The table structure is always modified for each system implementation. Below is one example.
BL_CASE
(
SCASEID VARCHAR2(16) not null,
SWORKTYPE VARCHAR2(16) not null,
SSTATUS VARCHAR2(16) not null,
SOWNERID VARCHAR2(16) null,
DCREATED DATE not null,
SLASTUPDATEUSERID VARCHAR2(16) null,
DLASTUPDATED DATE null,
SACCOUNTNUM VARCHAR2(32) null,
)
The Case Event table (BL_CASEEVENT) stores all the received and pending events associated with cases. It is written to and read from by BLCaseEvents 92.
BL_CASEEVENT
(
SWORKTYPE VARCHAR2(16) not null,
SCASEID VARCHAR2(16) not null,
SEVENTCODE VARCHAR2(32) not null,
SEVENTSTATE CHAR(1) not null,
SEVENTDESC VARCHAR2(256) not null,
DEXPIRE DATE null,
SGROUPID VARCHAR2(16) null,
SGROUPEVENTCODE VARCHAR2(32) null,
SPROCESSINGSTATUS CHAR(1) not null,
DRECEIVED DATE null,
SCASEITEMNAME VARCHAR2(64) null,
SOPTIONALEVENTDATA VARCHAR2(128) null,
DCREATED DATE not null,
)
The Case Item table (BL_CASEITEM) stores the reference to the items associated with cases. For example, the reference number for documents associated with cases are stored in the table. BLCaseItems 96 accesses the table.
BL_CASEITEM
(
SCASEID VARCHAR2(16) not null,
SWORKTYPE VARCHAR2(16) not null,
SITEMNAME VARCHAR2(64) not null,
SITEMDISPLAYNAME VARCHAR2(128) null,
IITEMTYPE NUMBER(4) not null,
DCREATED DATE not null,
)
The Draft Case Item table (BL_DRAFTCASEITEM) stores the draft items and data associated with cases. For example, the binary draft documents associated with cases are stored in the table. BLDraftCaseItems 100 accesses the table.
BL_DRAFTCASEITEM
(
SCASEID VARCHAR2(16) not null,
SWORKTYPE VARCHAR2(16) not null,
SDRAFTITEMNAME VARCHAR2(64) not null,
SDRAFTITEMDISPLAYNAME VARCHAR2(128) null,
SDOCUMENTCLASS VARCHAR2(32) not null,
SDRAFTITEMTYPE VARCHAR2(64) not null,
SINDEXVALUES VARCHAR2(2000) null,
BITEMDATA LONG RAW null,
DCREATED DATE not null,
)
The Case Lock table (BL_CASELOCK) stores the cases that are currently locked for processing by any program module. BLCaseSession 60 creates and deletes the case lock records.
BL_CASELOCK
(
SCASEID VARCHAR2 (16) not null,
SWORKTYPE VARCHAR2 (16) not null,
SUSERID VARCHAR2 (16) not null,
DLOCKED DATE not null,
)
The Case Relationship table (BL_CASERELATIONSHIP) stores the relationship between cases. It is accessed by the BLCase object using the GetChildren and GetParent methods.
BL_CASERELATIONSHIP
(
SCHILDCASEID VARCHAR2(16) not null,
SCHILDWORKTYPE VARCHAR2(16) not null,
SPARENTCASEID VARCHAR2(16) not null,
SPARENTWORKTYPE VARCHAR2(16) not null,
DCREATED DATE not null,
)
The Case Audit Session table (BL_CASEAUDITSESSION) is the parent table for all audits during a case session. It is accessed by BLCaseAuditSession 110.
BL_CASEAUDITSESSION
(
SWORKTYPE VARCHAR2(16) not null,
SCASEID VARCHAR2(16) not null,
SSESSIONID VARCHAR2(16) not null,
DCREATED DATE not null,
SUSERID VARCHAR2(16) not null,
)
The Scan Productivity table (BL_SCANPRODUCTIVITY) is a processing table-used to store the statistics to run a productivity report for scan operators. The table records are written by the Scan interface (described below) and are not modified by any other process.
BL_SCANPRODUCTIVITY
(
SBATCHNAME VARCHAR2(18) null,
BBATCHACCEPTED CHAR(1) null,
SUSERID VARCHAR2(8) null,
DRECEIVEDDATE DATE null,
IEXPECTEDCOUNT NUMBER(3) null,
IACTUALCOUNT NUMBER(3) null,
IPAGECOUNT NUMBER(3) null,
SDOCTYPE VARCHAR2(20) null,
DSCANSTARTTIME DATE null,
DSCANSTOPTIME DATE null,
)
The Index Productivity table (BL_INDEXPRODUCTIVITY) is a processing table used to store the statistics to run a productivity report for index operators. The table records are written by the Index interface (described below) and are not modified by any other process, but are used for reporting purposes.
BL_INDEXPRODUCTIVITY
(
SBATCHNAME VARCHAR2(18) null,
SUSERID VARCHAR2(8) null,
IDOCUMENTCOUNT NUMBER(3) nulI
INUMBERINDEXED NUMBER(3) null,
INUMBERRESCANNED NUMBER(3) null,
INUMBERADDED NUMBER(3) null,
INUMBERDELETED NUMBER(3) null,
DSTARTTIME DATE null,
DSTOPTIME DATE null,
)
The Rescan table (BL RESCAN) is a processing table that stores documents that need to be rescanned. The table records are written by the Index interface and are not modified by any other process.
BL_RESCAN
(
SDOCID VARCHAR2 (8) null ,
SBATCHNAME VARCHAR2 (18) null ,
SUSERID VARCHAR2 (8) null ,
INUMBERPAGES NUMBER (3) null ,
SPAGEPOSITION VARCHAR2 (25) null ,
SDOCTYPE VARCHAR2 (20) null ,
DRESCANTIME DATE null
)
The Document Type table (BL_DOCTYPE) stores the valid business document types and their associated scan settings. This table is accessed by the Scan and Index graphical user interfaces. The Scan and Index interfaces use the table to provide a list of valid document types to the user. Once a valid document type is chosen, the Scan program looks up the associated settings and template to which to attach the scan batch. This table can be modified by business users through the System Maintenance interface (described below).
BL_DOCTYPE
(
SDOCTYPE VARCHAR2 (20) not null ,
SSETTINGS VARCHAR2 (20) not null ,
STEMPLATE VARCHAR2 (20) null ,
)
The Case Audit Detail table (BL_CASEAUDITDETAIL) stores audit records created for each case. It is accessed by BLCaseAudit 114.
BL_CASEAUDITDETAIL
(
SSESSIONID VARCHAR2(16) not null,
DCREATED DATE not null,
SCATEGQRY VARCHAR2(16) not null,
SACTION VARCHAR2(16) not null,
SDESCRIPTION VARCHAR2(512) null,
SAUDITDETAIL1 VARCHAR2(64) null,
SAUDITDETAIL2 VARCHAR2(64) null,
SAUDITDETAIL3 VARCHAR2(64) null,
)
A set of baseline tables need to be configured for each implementation of the present invention. Each system implementation builds upon this framework to add its own tables. The baseline tables that need to be configured are:
BL_USERPROFILE
BL_PROGRAMSECURITY
BL_TASKSECURITY
BL_FUNCTIONSECURITY
BL_USERWORKLOAD
BL_USERWORKSTEP
BL_USERWORKSTEPDIVISION
BL_WORKTYPE
BL_WORKSTEP
BL_WORKSTEPDIVISION
BL_WORKSTEPRULE
BL_BOOKMARKCONFIG
BL_BOOKMARKMAP
BL_DOCTYPEMAP
BL_UPDATEORDER
BL_SYSTEMPARAM
BL_EVENTPROCFIELDMAP
BL_LETTER
BL_LETTERGROUP
In addition, there will almost always be a set of business specific tables at each site. The User Profile table (BL_USERPROFILE) is a reference table that stores all the users in the system and their associated characteristics. The User Distribution process accesses the User Profile table to determine whether a user is available to receive work.
BL_USERPROFILE
(
SUSERID VARCHAR2 (8) not null,
SUSERNAME VARCHAR2 (64) not null,
BISAVAILABLE CHAR (1) not null,
)
The Program Security table (BL_PROGRAMSECURITY) stores the first level of security, the program module level. BLProgramSecurity 76 accesses the table. The table records are maintained by business users through the System Maintenance interface.
BL_PROGRAMSECURITY
(
SUSERID VARCHAR2 (8) not null,
SPROGRAMNAME VARCHAR2 (16) not null,
)
The Task Security table (BL_TASKSECURITY) stores the second level of security, the task level. BLProgramSecurity 76 accesses the table. The table records are maintained by business users through the System Maintenance interface.
BL_TASKSECURITY
(
SUSERID VARCHAR2 (8) not null,
SPROGRAMNAME VARCHAR2 (16) not null,
STASKNAME VARCHAR2 (16) not null,
)
The Function Security table (BL_FUNCTIONSECURITY) stores the third level of security, the function level. BLProgramSecurity 76 accesses the table. The table records are maintained by business users through the System Maintenance interface.
BL_FUNCTIONSECURITY
(
SUSERID VARCHAR2(8) not null,
SPROGRAMNAME VARCHAR2(16) not null,
STASKNAME VARCHAR2(16) not null,
SFUNCTIONNAME VARCHAR2(16) not null,
)
The User Work Load table (BL_USERWORKLOAD) stores the relative load that each user should be assigned during the User Distribution process. The records in the table are maintained by business users through the System Maintenance interface.
BL_USERWORKLOAD
(
SUSERID VARCHAR2 (8) not null,
SWORKTYPE VARCHAR2 (16) not null,
ILOADFACTOR NUNBER (4) not null,
)
The User Work Step table (BL_USERWORKSTEP) defines the work steps that a user is allowed to access.
BL_USERWORKSTEP
(
SUSERID VARCHAR2 (8) not null,
SWORKTYPE VARCHAR2 (16) not null,
SWORKSTEP VARCHAR2 (16) not null,
)
The User Work Step Division table (BL_USERWORKSTEPDIVISION) stores the order of work step divisions in which a user receives work. BLCaseSession 60 accesses this table using the GetUserWorkList method.
BL_USERWORKSTEPDIVISION
(
SUSERID VARCHAR2(8) not null,
SWORKTYPE VARCHAR2(16) not null,
SWORKSTEP VARCHAR2(16) not null,
SWORKSTEPDIV VARCHAR2(16) not null,
IWORKSTEPDIVPRIORITY NUMBER(2) not null,
)
The Work Type table (BL_WORKTYPE) stores each different type of work in the system. A work type is defined as the data and processes associated with work. The parameters associated with each work type describe the database table and the workflow engine class that should be accessed for processing. Work Types are associated with a specific BLCase Table and the system can support multiple Work Types.
BL_WORKTYPE
(
SWORKTYPE VARCHAR2(16) not null,
SWORKTYPENAME VARCHAR2(64) not null,
SCASETABLENAME VARCHAR2(64) not null,
SWORKFLOWCLASS VARCHAR2(64) null,
BPROCESSMULTIPLEEVENTS CHAR(1) null,
)
The Work Step table (BL_WORKSTEP) stores all the work steps associated with a work type. The work steps must also correspond to the workflow engine process map. There are characteristics about work steps that are captured in this table. The table is configured initially during system implementation. It is not changed often during the life of the system.
BL_WORKSTEP
(
SWORKTYPE VARCHAR2(16) not null,
SWORKSTEP VARCHAR2(16) not null,
SWCRKSTEPNAME VARCHAR2(64) not null,
BISSYSTEMSTEP CHAR(1) not null,
BISFILTERED CHAR(1) not null,
BISEVENTALLOWED CHAR(1) not null,
SWORKFLOWPERFORMERNAME VARCHAR2(64) null,
SEVENTACTIONCODE CHAR(1) null,
)
The Work Step Division table (BL_WORKSTEPDIVISION) stores the work step divisions associated with each work type and work step combination. Work Step Divisions are segmentations of Work Steps that provide work specialization. The records are maintained by business users through the System Maintenance interface.
BL_WORKSTEPDIVISION
(
SWORKTYPE VARCHAR2(16) not null,
SWORKSTEP VARCHAR2(16) not null,
SSWWORKSTEPDIV VARCHAR2(16) not null,
SWORKSTEPDIVNAME VARCHAR2(64) not null,
IWORKSTEPDIVTYPE NUMBER(1) not null,
BISDEFAULT CHAR(1) not null,
)
The Work Step Rule table (BL_WORKSTEPRULE) stores the rules associated with work step divisions. The rules are prioritized to read and determine to which work step division a case should be assigned. These rules may be maintained by business users through the System Maintenance interface.
BL_WORKSTEPRULE
(
SWORKTYPE VARCHAR2(16) not null,
SWORKSTEP VARCHAR2(16) not null,
IWORKSTEPRULENUM NUMBER(4) not null,
SWORKSTEPRULE VARCHAR2(2000) not null,
SNEWWORKSTEPDIV VARCHAR2(16) not null,
BDISABLED CHAR(1) not null,
)
The Book Mark Configuration table (BL_BOOKMARKCONFIG) stores the height and width of each letter field. It is accessed by the Letter Generation Wizard to size each bookmarked field when presenting the data entry screen to a user. This table is optional and is managed by business users through the System Maintenance interface.
BL_BOOKMARKCONFIG
(
SBOOKMARKNAME VARCHAR2(64) not null,
IHEIGHT NUMBER(2) null,
IWIDTH NUMBER(2) null,
)
The Book Mark Map table (BL_BOOKMARKMAP) stores the association between a letter bookmark and the case field that should be assigned to it. The Letter Generation Wizard uses the table to query by the bookmark name and replace the bookmark with the specified case field value.
BL_BOOKMARKMAP
(
SBOOKMARK VARCHAR2 (64) not null,
SWORKTYPE VARCHAR2 (16) not null,
SFIELDNAME VARCHAR2 (64) not null,
IFIELDTYPE NUMBER (2) not null,
)
The Doc Type Map table (BL_DOCTYPEMAP) maps an incoming document type to a work type. This table is accessed by the Case Builder process.
BL_DOCTYPEMAP
(
SDOCTYPE VARCHAR2 (16) not null,
SWORKTYPE VARCHAR2 (16) not null,
)
The Update Order table (BL_UPDATEORDER) dictates the order in which tables should be updated for a transaction. DBConnMgr 66 accesses this table to commit records in the correct order. This table is configured during system implementation and is not changed very often during the life of the system. It is modified by a knowledgeable system administrator or programmer.
BL_UPDATEORDER
(
IORDER NUMBER not null,
STABLENAME VARCHAR2 (64) not null,
)
The System Parameter table (BL_SYSTEMPARAM) stores system wide parameters. It is accessed by each program module.
BL_SYSTEMPARAM
(
SPARAMNAME VARCHAR2 (32) not null ,
SPRAMVALUE VARCHAR2 (256) null ,
)
The Event Process Field Map table (BL_EVENTPROCFIELDMAP) stores the work object fields that are created when a work object is injected into the workflow engine. There are different mappings for each work type. The table provides a configurable method to map fields to the work object before it is injected into the workflow. This is determined at each system implementation without needing to modify code. It is accessed by the Event Processor module.
BL_EVENTPROCFIELDMAP
(
SFIELDNAME VARCHAR2(64) not null,
IFIELDTYPE NUMBER(2) not null,
SWORKITEMFIELDNAME VARCHAR2(64) not null,
SWORKTYPE VARCHAR2(16) not null,
)
The Letter table (BL_LETTER) stores all the letter templates in the system and their associated characteristics. They are associated with the Letter Group table. The Letter Generation Wizard accesses the table to retrieve all the letter templates into a list given a letter group. The table is maintained by business users through the System Maintenance interface.
BL_LETTER
(
SGROUPID VARCHAR2(16) not null,
SLETTERID VARCHAR2(16) not null,
SLETTERDISPLAYNAME VARCHAR2(128) not null,
SLETTERFILENAME VARCHAR2(32) not null,
IDISPLAYORDER NUMBER(4) not null,
)
The Letter Group table (BL_LETTERGROUP) stores the list of letter templates grouped in business groups. The Letter Generation Wizard reads this table to display the list of valid tables for the user to select from. The Letter Group table is maintained by business users through the System Maintenance interface.
BL_LETTERGROUP
(
SGROUPID VARCHAR2(16) not null,
SGROUPDISPLAYNAME VARCHAR2(128) not null,
IDISPLAYORDER NUMBER(4) not null,
)
An example of workflow processing in a workflow processing system according to the present invention is illustrated in FIG. 6. During system implementation, the base workflow process flow is defined in the workflow platform in the conventional platforms 20 using a workflow engine like FileNET Visual WorkFlo. Data Capture 130 may be a conventional process that places information to be used in electronic form. Imaging of documents, input of data from a database, input of transactional data, etc. are included. The Case Builder 132 organizes the information according to rules in the workflow platform in the conventional platforms 20 and stores links to the data in conventional databases, data warehouses, etc. where the information is stored in the conventional platforms 20 by Data Capture 130. The Events Processor 134 is initially executed to place the new case in the first work step 124. The Queue Assignment module 136 is then executed to place the case in the appropriate work queue or work step division, as discussed above with respect to FIG. 5. If the work step division requires 138 a case to be "owned" by a user, the user distribution module 140 is executed to assign ownership. Regardless of whether the case has been assigned to a particular user, Case Manager 142 could be executed next. Case Manager 142 is uniquely created for each system implementation. Case Manager 142 may be created using development tools such as Visual Basic or Visual C++. The case objects described with reference to FIGS. 4A-4C are used to quickly develop the code for Case Manager 142. If a letter is created in step 144, BLCase creates a new BLDraftCaseItem object 102. If it is desirable to convert the letter to TIFF format before committal to permanent storage on, e.g., an optical disk, the draft case item is sent to the Draft Committal process 146 for conversion of the letter to TIFF format and storage on, e.g., the optical disk. This process also changes the draft case item to a regular case item. Processing then continues as defined for the specific business application in the workflow, engine and therefore, the specific processing is not illustrated in FIG. 6. Typically, the object is suspended for additional information, destroyed because the case is done, or routed to another user. Preferably, at various times during work on a case, a check is made 148 to determine whether the case should be sent to Quality Assurance. If so, the Queue Assignment module 150 is called to place the case in a work division 126 for case quality assurance review 152. As illustrated in FIG. 7, the present invention can be implemented on a conventional general purpose computer system, including a processor 202, memory unit 204 and input/output unit 206. When implemented on an enterprise basis, there will likely be a plurality of processors, memory units and very many input/output units, such as desktop or notebook computers (not shown). These devices are likely to be networked, possibly using multiple network protocols. Any suitable conventional hardware and software can be used to provide the computer system, including distributed processing, intranets, personal computers, etc. The present invention has been described with respect to exemplary embodiments of a workflow processing framework, workflow development system and workflow processing system. However, the invention is not limited to these specific embodiments, but encompasses all of the subject matter of the following claims. The many features and advantages of the invention are apparent from the detailed specification and, thus, it is intended by the appended claims to cover all such features and advantages of the invention which-fall within the true spirit and scope of the invention. Further, since numerous modifications and changes will readily occur to those skilled in the art, it is not desired to limit the invention to the exact construction and operation illustrated and described, and accordingly all suitable modifications and equivalents may be resorted to, falling within the scope of the invention. Reference Number List Conventional platforms Foundation objects Common objects Business processes BLCaseSession BLCaseWorkList BLCase BLDBConnMgr BLConfigParam BLDebugLog BLErrorLog BLStatLog BLProgramSecurity BLCoreInstMgr BLWFWorkListFields BLWFWorkListField VWOWorkQuery BLCaseFields BLWFWorkItemFields BLCaseEvents BLCaseItems BLCaseItem BLCaseAuditSession BLDraftCaseItem BLDraftCaseFields BLCaseAuditSessions BLCaseAuditSession BLCaseAudits BLCaseAudit ADODB RecordSet Event Trigger Work item(s) Work step Work division Data Capture Case Builder Events Processor Queue Assignment Assign User? User Distribution Case Manager Letter Created? Draft Committal Send for Quality Assurance? Queue Assignment Case Quality Assurance Processor Memory Input/Output
|
Same subclass Same class Consider this |
||||||||||