Introduction

This article focuses on a way to build a generic case management asset with FileNet P8 and how you can use that asset to provide a case management solution. The article shows you how to utilize the asset to build an Energy & Utility (E&U) Claims Management Solution. An E&U damage claim is created when a utility property, such as a pole, is damaged in an accident. The owning utility company can potentially recoup the cost of repairing the property from the parties involved in the accident or their insurance providers. After that, an Energy & Utility (E&U) scenario highlights the configuration of the asset along with its functionality.

Case management refers to a solution that coordinates services such as health, legal, or financial on behalf of a party through a goal oriented process around what is typically called a case file. When you build a case management solution, you need to represent a case file where case managers and a case team can collaborate on unstructured information in order to ultimately achieve a predetermined goal. The sample case management solution described in this article automates the collection of all relevant information into a case to provide context for the business actions taken in regard to the claim. The solution dramatically increases efficiency of claims processing while providing more accurate information during the claims process.

From an ECM technology perspective, you can think of a case file as a representation of documents, data, activities, state, business process, rules, and roles all related to each other by a common business context. The work that the case manager and the case team perform is typically much more dependent on human decision making and managing the content than other traditional business processes. In addition to the collaborative element, ECM is best applied to the case file in order to exploit the business value locked up in the contents of the case file. For example, you will most likely want to be able to use ECM analytic technology against your case file content. Or, you may want to have some participants access just the content of the case file through their separate content-enabled business application.

The sample case management asset in the Download section is provided as an example. It was built using IBM FileNet P8 public APIs.

The terminology and technical descriptions within this article assume you are familiar with IBM FileNet P8.

Case management model

In typical case management solutions, a case provides context for making a business decision such as funding a loan or paying an auto insurance claim. The case typically contains a set of related documents such as accident pictures, the investigation report, and estimates to repair the damage. The case also contains a set of metadata or information about the case. This metadata typically includes auditing information such as who created the claim, when the claim was created, the status of the claim, and the policy under which the claim was filed. The state of a claim can be modeled as a lifecycle. Typically, this lifecycle model is a directed graph that depicts the life of the claim and the state changes that are allowed.

Modeling a case on IBM FileNet P8 results in the following components:

• Data model in P8
• Case template for defining behavior of the case
• Diary that contains the history of actions and events on the case
• Business logic (event actions)

The following sections describe the components of the sample case management asset. The Download section provides a link you can use to obtain the source code for the sample asset.

Data model

The core part of a case (folder) consists of:

• Case metadata
• Case name
• Case identifier
• Related documents

In the IBM FileNet P8 system, the Folder class definition is the ideal starting point. The Folder class supports customized metadata and containing documents. So in order to model cases in IBM FileNet, the sample asset uses a CaseFolder class definition. The CaseFolder class is then subclassed to create distinct types of case definitions, such as DamageClaim. The CaseFolder class has the following properties:

• CaseIdentifier — a string property that is created to hold the identifier.
• FolderName — a string property that contains the name of the case.
• CaseSecurityProxy — an object value property (OVP) that is restricted to a custom object class, CaseSecurity. This property is set automatically on new instances of a CaseFolder to the CaseSecurity object in the case template folder. This property inherits the security defined in the case template for the case type.
• CaseState — contains the current state of the case and is modeled as a string property. As the case progresses either via business process flows or manually, this property is updated to reflect the current state of the case.

Identifiers and naming

Cases typically have strict identifier patterns that include a part of the date, such as the year or month, plus a sequence number. For example, a case may use the pattern YYYY-## for its identifier. So for example, a particular identifier conforming to this pattern might be: 2010-20. The name of a case typically includes the identifier. So for a damage claim, the name of a case might be: Damage Claim 2010-20.

The sample asset handles the naming part of the data model by setting the configuration of the new case type on the CaseConfig object in the case template. Internally, the case management asset sample code stores the sequence number on the CaseNumber custom object.

Filing

Because folders are used to model the case file, the data model needs to handle the folder parent. This is the location in the object store of each folder that represents a case. It is important for performance reasons, in addition to being able to quickly navigate to a case file, that the parent be hashed out. For example, when a case file (folder) is created, automatically file the folder in a folder representing the year, month, and day. The location then becomes: /E&U Claims/Damage /2010/01/Damage Claim 2010-20. Because the location can be variable, the starting folder needs to be specified. In this example, the starting folder is: /E&U Claims/Damage.

The CaseConfigXML property on the CaseConfig object in the Templating folder controls the filing behavior.

Case metadata

Cases have additional metadata that describe certain aspects of the case specific to the business solution domain. For the damage claim example this might include the policy for the claim, the driver name, the location of the damage, etc.. This information is added to the sub-class definition representing that case type under the case folder. An example would be a DamageClaim sub-class definition of CaseFolder.

Case state

Cases typically move from an initial state, such as New, to intermediate states representing progress of the case. The state eventually moves to an end state, such as Closed. Typically, companies implement a business flow that automates the process of moving a case from New to Closed. At the end state, the business process typically completes. However, there may be other process flows to re-open the case.

As shown in the example in Figure 1, a lifecycle is much simpler than a process flow and only contains the major states of the case and the transitions that are allowed between the major states.

In this model, the state is represented by the CaseState property. The management of the lifecycle is embedded in the FileNet BPM process that automates processing the case from the New to the Closed state. At the appropriate points in the business process, the process flow sets the CaseState property to the required state.

Business process flow

Even though cases may at times be very collaborative and ad-hoc, some portion of processing the case can benefit from automating, for example, routing the case to the right people. This model provides the ability to launch a business process when a new case is created. You can use the standard IBM FileNet BPM step processors and ECM widgets in the business process. When a business process is launched by the sample code, the CaseIdentifier and CaseFolder fields are set automatically. This is used in the E&U example to launch the E&U Damage Claim workflow.

In addition to the auto-launching of business processes upon creation of a new case, subscriptions to the case type can be used with "out of the box" applications such as WorkplaceXT to model additional processes on the case, for example, a process to re-open the case.

Template structure

When a new CaseFolder type is created, an event action named NewCaseClass, creates the template structure for the case type (the NewCaseClass event action is part of the case management asset). This template configuration is stored in the object store under /Configuration/CaseManagement/<CaseTypeName>.

Case configuration

The configuration for the case type is stored in the template directory on the CaseConfig object. This object has the following properties:

• CaseStartingFolder (OVP, Controls location of new cases) — if set, this property controls where the new case (an instance of the CaseFolder sub-class) is filed upon creation. If this property is not set, the case is left at its current location.
• CaseConfig — a binary property that contains a Java® property file. The property file is read into memory and controls the behavior of the case. This can be extended as necessary to add additional functionality to the case management assets.
  • createYearFolders — controls whether or not folders representing the current year are created
    Valid values: true, false
  • createMonthFolders — controls whether or not folders representing the current month are created
    Valid values: true, false
  • createDayFolders — controls whether or not folders representing the current day are created
    Valid values: true, false
  • identifierFormat — controls the format of the identifier
    Valid values: string
    Patterns:
    • ${year} is replaced with the current year
    • ${month} is replaced with the current month
    • ${day} is replaced with the current day of the month
    • ${number} is replaced with the current number for the sequence
    • ${property:<property>} is replaced with value of the property <property> on the instance of the CaseFolder sub-class
  • nameFormat — controls the format of the name replacing the name specified in the createFolder API call
    Valid values: string
    Patterns:
    • ${year} is replaced with the current year
    • ${month} is replaced with the current month
    • ${day} is replaced with the current day of the month
    • ${number} is replaced with the current number for the sequence
    • ${property:<property>} is replaced with the value of the property <property> on the instance of the CaseFolder sub-class
  • launchOnCreate — controls which workflows to launch on new instances of this case type. On launch, the event action sets the workflow field CaseAttachment to the instance of the CaseFolder sub-class (instance of the case) and CaseIdentifier to the value of the identifier for this case instance. These workflows must be transferred to launch. The event action launches the latest version that is transferred.
    Valid values: space separated list of workflows

  Listing 1 shows the default value for the CaseConfig property.

createYearFolders true
createMonthFolders true
createDayFolders false
identifierFormat ${year}${month}-${number}
nameFormat Claim ${year}${month}-${number}
diaryName Timeline

Case configuration folders

The case template for the case type contains folders to store the assets used to create a case management solution with Agile ECM. These folders are:

• Storing CodeModules (CodeModules)
• Storing Forms (Forms)
• Storing Business Processes (Workflows)

In addition, the configuration contains folders that control what documents and custom objects are populated in new cases:

• Storing Documents to be filed into cases (FileIn)
• Storing Documents to be created as new documents in cases (CreateIn)

Plus, there are two more that are created by default:

• Instances are the default location for storing new instances of that type of case. You can change this by modifying the configuration object for the case.
• Series stores the instances of the CaseNumber objects. If you would like to reset a sequence or change the next number, update or remove the CaseNumber object representing that series as appropriate.

Security

The model defines security at the following locations:

• Case template for all instances of the case type
• Case instance for all objects contained in the case
• Per object in the case

When the case template is initially created, a CaseSecurityObject is created in that template. The security on this object is inherited from all case type instances using a partial security proxy. When the NewCase event action is triggered, it sets the security proxy property on the case instance to the CaseSecurityObject. This allows the security to be a union of the case instance and the CaseSecurityObject.

You can set additional security on each case instance. This provides you the ability to further secure each case as appropriate.

Items in the case use security inheritance from the folder (case instance). You can apply additional security to these objects as necessary.

The diagram in Figure 2 outlines the security model used in the sample case management asset.

The sample provides a flexible security model. In the example later in the article, the model is used to provide one place you can set security for all information in all damage claims regardless of the type of information used in the claim. As such, the model allows the example to set the security based on roles particular to that case on one object (CaseSecurityObject) and have all objects in a case inherit from that object.

Diary

A central part of a case, is the history, or diary, associated with the case. This typically includes any actions taken on the case, along with any content that is added or updated. The diary also includes all actions for objects in the case.

In this sample case management model, each case instance contains a folder named Diary. This folder contains a set of documents of type CaseDiaryObject, which is a Document object. It can also be a Custom object, but is a Document object so that the diary entries can be displayed in the Content List ECM Widget as well as WorkplaceXT.

The CaseDiaryObject contains the following properties:

• CaseDiaryAction — contains the action performed.
• CaseDiaryActor — contains the person who performed the action.
• CaseDiaryCustomObject, CaseDiaryDocument, or CaseDiaryFolder — contain a link to the modified object . Only one of these properties is set depending on the type of the object.
• CaseDiaryDate — contains the date the action occurred.
• CaseDiaryPath — contains the case relative path of the object modified.
• CaseIdentifier — contains the case identifier of the case.
• CaseObject — contains a reference to the case folder.

Event actions

The case management asset defined by the sample code consists of a data model and three event actions. These event actions perform the core case management functions in the platform.

The event actions are in the package org.ibm.ecm.industry.casemanagement.eventactions.

NewCaseClass

This event action listens for new class definitions. Upon finding a new class definition under CaseFolder, this event action creates the case type template configuration under /Configuration/CaseManagement.

The onEvent method of the NewCaseClass event action calls the code shown in Listing 2.

if (cd.describedIsOfClass(CaseUtil.CLASSDEFINITIONS.CASEFOLDER.value())) {
	InitialSetup.createCaseManagementFolders(os);
} else {
	debug("Not a subclass of Case Folder: " + cd.get_SymbolicName());
}
debug("Creating a new case config for : " +
cd.get_SymbolicName());

The heart of this event action calls InitialSetup.createCaseManagementFolders(os). This method creates the template configuration for the new case type.

NewCase

This event action listens for new instances of a case folder. This is the main part of the case management asset. Upon finding a NewCase instance, this event triggers the following actions:

• Moves the folder to the appropriate location
• Sets the identifier based on the appropriate sequence and the pattern
• Sets the name based on the pattern
• Files the documents in the FileIn folder in the template to the new instance
• Creates new documents for each document in the CreateIn folder in the template to the new instance
• Launches the latest version of the defined workflows

The core of the event action calls the code in Listing 3.

f = (Folder) P8Util.validateProperty(f, PropertyNames.PATH_NAME, P8Util.PF_FOLDER);
 CaseType cf = new CaseType(os, f.get_ClassDescription());
 
// Create a new case
Case c = Case.newCase(os, cf, f);

CaseDiary

This is the diary event action. Once a case is created, this event action listens for additions to the case. It then creates subscriptions to those objects allowing any document class to be added to a case and then participate in the diary.

This is accomplished by the code shown in Listing 4.

// see if folder
if (obj instanceof Folder) {
	Folder fNew = (Folder) obj;
	Folder f = P8Util.getFolder(os, fNew.get_Id().toString());
	subscribeFolder(os, f, event);
}

subscribe(os, obj, true, event);

Once the diary is subscribed to the object, it listens for updates. When an update occurs, the diary logs the event with this line of code:

logEvent(obj, MSG_UNFILE, event.get_InitiatingUser(), event.getClass().getCanonicalName());

In the logEvent method, the diary identifies all the case folders that contain this object and then creates the log entry with the code shown in Listing 5.

if (myCase == null) {
	debug("Could not find case for Folder " + f.get_PathName());
} else {
	myCase.logEvent(obj, msg, user, action, fic.getPath());
}

Installing the case management asset

The case management asset contains an install.bat file. Before using the file, edit it and set the variables for connecting to FileNet and pointing to the correct directories as follows:

• USER — the user ID you use to log into the FileNet object store
• PASS — the password you use when logging in as the above user
• URI — the FileNet Content Engine URL
• JAAS — the JAAS Context to use for login
• OBJECTSTORE — the object store to install the case management asset
• CELIB — the directory that contains the FileNet P8 Content Engine API Libraries including Jace.jar
• CEWSI — the directory that contains the FileNet P8 Content Engine API WSI.

Once you have properly configured the install.bat file, you can run it simply by issuing the following command:

install

This installs the data model, event actions, and the subscriptions. Installation of the case management asset in the object store creates a subclass of CaseFolder, which then creates the template for the new case type.

The install runs the code shown in Listing 6.

InitialSetup.createSchema(osObj);
InitialSetup.createInitialEventActions(osObj);
InitialSetup.createInitialFolders(osObj);

A case management example — E&U damage claim

To illustrate the case management assets, let's look at a claims processing example from the Energy & Utility industry. Specifically, let's look at the damage claim case. A damage claim is created when a utility property is damaged in an accident. In these circumstances, the utility company can potentially recoup the cost of repairing the property.

The case would be created by the business system that creates the work order to repair the property. Typically this system would be SAP or a similar system. This system invokes an IBM FileNet process (most likely via a Web service) that creates an instance of DamageClaim CaseFolder with the appropriate metadata such as location and the work order number.

The creation of the CaseFolder kicks off the claim management case.

You can install the data model by editing and running the euinstall.bat file from the case management asset. The steps in the following sections outline how to configure the case management asset to run this scenario. Some configuration has been left out to simplify the article.

To install the E&U scenario simply issue the following command:

euinstall

Configuring the E&U damage claim

Creating the DamageClaim subclass

The first thing to do is create a subclass of the CaseFolder class definition. To do this, bring up Enterprise Manager. Next. navigate to the object store with the case management asset installed, and then to the CaseFolder class as shown in Figure 3.

Under this class, create a new class called DamageClaim with the following properties:

• EULocation
• EUDepartment
• EUAccountNumber
• EUAccidentZip
• EUAccidentDate
• EUEstimatedCost
• EUActualCost

At this point, the case management asset creates the template folder at /Configuration/CaseManagement/DamageClaim.

Configuring the CaseFolder type

In the template folder, modify the CaseConfigObject to put the new cases under /E&U Claims/Damage. Follow these steps:

• Create /E&U Claims as a generic folder.
• Create /E&U Claims/Damage as a generic folder.
• Modify the CaseStartingFolder to point to /E&U Claims/Damage.

Then modify the CaseConfig property to what is shown in Listing 7.

createYearFolders true
createDayFolders true
identifierFormat ${year}${month}-${number}
nameFormat Damage Claim ${year}${month}-${number}
diaryName Timeline
launchOnCreate EUNewDamageClaim
createMonthFolders false

After this, create the workflow and the sample documents.

Creating a business process

In the damage claim workflow, there is a small set of actors who collaborate in the context of the damage claim. These actors are: claim support group, claim specialist, claims manager, and legal.

The simple storyboard in Figure 4 shows how these actors collaborate on the damage claim.

Create the workflow and transfer it as EUNewDamageClaim. The sample workflow is located in resources/claims/.

Creating documents

In this sample scenario the claims specialist fills out an accident report for each new claim. For the accident report, create a Word document like the one shown in Figure 5 (the sample source code contains this same sample document).

Save this report into the CreateIn folder. Upon creation of new instances of DamageClaim, this document is copied as a new document into each new claim.

Creating a new damage claim

This process is started when a new instance of DamageClaim is created. It is started by the event subscription on CaseFolder for the NewCase event action. This event action sets up the new case and launches the EUNewDamageClaim workflow. Once the workflow is launched, the task appears in the inbox of the claims support group as shown in Figure 6.

Field support clicks on the task and enters values for the estimated cost and the location as shown in Figure 7.

The field specialist clicks on attachments, and navigates to the accident report. The field specialist then completes the form and saves it back into the repository. This navigation and updating could also be done through IBM FileNet Office Integration or WebDAV depending on how the customer wants to access and manage this information.

After completing the form, the field specialist updates the document in FileNet P8 and completes the task. The process then moves on to the claim specialist.

The claim specialist gathers more data and shepherds the claim submission to the insurance company. The specialist opens the claim and updates the field for the actual cost as shown in Figure 8.

Once the document is saved back to the repository, the CaseDiary event action is notified and a new diary entry is created for the update.

At that point, the claim looks good and the specialist submits the claim. The claim then moves onto the claims manager who remains responsible for the claim until a payment is received or the claim needs to be litigated. The claims manager can watch the claim via his inbox or by a query using Workplace or Agile ECM that searches for instances of the DamageClaim class with a status of Open.

Once the claims manager receives a payment, he opens the damage claim, changes the payment status to PAID and enters the date of the payment as shown in Figure 9.

The claims manager then completes the claim. The financial system is updated with the information and the financial reserves are adjusted. At the end of the workflow, the state of the damage claim is updated to Closed and the case is declared as a record as appropriate. This can be done with "out of the box" BPM Component steps. The workflow then completes. At this point, the claim is persisted in the P8 Content Engine with full traceability of the outcome and how that decision was reached.

Summary

This article and the accompanying sample code introduce you to how you can implement case management functionality using the IBM FileNet P8 Platform. The sample demonstrates how you can use the full power and flexibility of the P8 Platform in a case management solution. The FileNet P8 platform offers capabilities such as Content Engine folders, event actions, and security, as well as Office Integration, Workplace XT, FileNet BPM, and ECM Widgets. These capabilities provide a significant time to value for any case-centric solution built on FileNet P8.

Back to top

Download

Information about download methods

Resources

Learn

• IBM FileNet P8 Platform and Architecture: This IBM Redbooks® publication provides an overview of FileNet P8 and describes the core component architecture.
  
  
• Learn about the Advanced Case Management strategy from IBM.
  
  
• Learn about IBM ECM Industry Solutions.
  
  
• Find details on the IBM FileNet P8 platform and its related components in the IBM FileNet P8 information center.
  
  
• In the ECM Zone on developerWorks, get the resources you need to advance your skills on IBM Enterprise Content Management products.
  
  

Discuss

• Participate in the discussion forum.
  
  
• Join the ECM Community.
  
  
• Check out developerWorks blogs and get involved in the developerWorks community.
  
  

About the author

Al Brown is an architect at IBM in the Industry Solutions group of IBM Enterprise Content Management. He has worked on several ECM standards for the last six years. Prior to coming to IBM, Al founded a Web content management company named eGrail. In 2002 eGrail was acquired by FileNet and Al became a Director in the FileNet CTO office where he worked on Compound Documents, Business Content Services, Web Content Management strategy, and Active Storage and Retrieval. When IBM acquired FileNet in 2006, Al began his IBM career. Al has a Bachelor of Science degree in Mathematics and Computer Science from Colorado School of Mines, and holds an MBA from the University of Southern California. He currently hold two patents and has other patent applications in the works.

Rate this article

Comments

Back to top

Table of contents

• Introduction
• Case management model
• Installing the case management asset
• A case management example E&U damage claim
• Summary
• Download
• Resources
• About the author
• Comments

Local resources

• IBM Innovation Center - Austin, TX
• IBM Innovation Center - Chicago, IL
• IBM Innovation Center - Dallas, TX
• IBM Innovation Center - San Mateo, CA
• IBM Innovation Center - Waltham, MA
• Technical Briefings in North America

Dig deeper into Information Management on developerWorks

Try IBM PureSystems. No charge.

Experience today!

---

Get started with the cloud-based trial and pattern development kit.

Special offers