Use IBM Entity Analytic Solutions to analyze watch lists

Avoid hiring the bad actors!

In this article, see how IBM® Relationship Resolution can be utilized in a scenario where a bank has to filter job candidates through automated and intelligent mining of information on job applicants and known criminal entities. To aid this scenario, see also how IBM Relationship Resolution is configured to load and maintain biographical information on criminal entities, automatically detect relationships between job candidates and criminals on a watch list using fuzzy matching techniques, and determine the strength of such relationships based on a set of organization specific rules. Included with this article is a Web application and sample (fictitious) biographical data on criminal entities used to showcase the use of Web service APIs exposed by IBM Relationship Resolution product.

Share:

Nick Dhupia, Software Engineer, IBM

Nick DhupiaNick Dhupia works with the High Performance On Demand Solutions (HiPODS) group at IBM Silicon Valley Lab. His job involves creating innovative solutions in areas such as trusted identity solutions, cloud computing, virtualization, content management, enterprise architecture, and Web 2.0 technologies. He has a Masters in Computer Engineering from San Jose State University and Bachelors in Computer Science and Economics from Knox College.



02 October 2008

Introduction

Many governments and large private organizations maintain confidential information on people who are considered a security threat. Examples include the FBI terror watch list or a company's non-rehire list. The organization often uses such information to filter people from being part of a trusted group or to bring them to justice. A familiar use case involves investigating biographic information of a person before hiring them in a trusted organization such as a bank. As part of the hiring process, the system must analyze the available data to detect possible links between the job applicant and criminals on a watch list.

IBM Entity Analytic Solutions can help organizations recognize exactly who they are doing business with. It provides real time identity and relationship recognition and resolution in context with business applications. The solutions offered are IBM Identity Resolution, IBM Relationship Resolution, and IBM Anonymous Resolution. Entity Analytic Solutions runs on major operating system platforms such as IBM AIX®, Linux®, and Microsoft Windows, and supports major database products such as IBM DB2®, Oracle, and Microsoft SQL Server. For detailed system requirements, see the Relationship Resolution Information Center (see Resources).

This article presents a bank scenario that showcases the use of IBM Relationship Resolution to:

  • Create and maintain watch lists in a trusted environment
  • Detect underlying relationships based on fuzzy matching techniques
  • Determine the strength of such relationships to ensure better security monitoring in a trusted environment

The scenario is based on IBM Relationship Resolution, Version 4.2.0 with hotfix 489.

This article assumes certain basic knowledge of Web services and Java development, and familiarity with the IBM Relationship Resolution product.

Definitions

  • proofing: Involves verification and validation of various attributes of an identity. These attributes may be composed of biographical, biometric data, or trusted documents.
  • watch list: Used interchangeably with black list in this article. Refers to a list that contains biographical information used by government or business organizations to monitor people.
  • black list: Same as watch list for the purposes of this article.
  • biographical data: Textual representation of the attributes of a person that constitute their identity, such as name, address, social security number, data of birth, and so on.
  • identity: A set of attributes that constitute a person. A person can potentially have multiple representation of their identity from different information sources such as social security record, driver license record, birth certificate, military identification, and so on.
  • entity: A person that is uniquely identified and represented in the EAS entity database. All identities of a person resolve to the same entity in the entity database.
  • entity resolution: An automated process based on a set of rules that is used to merge an identity to an entity.
  • relationship score: A number between 0-100 that represents the strength of the relationship based on biographical data of two entities.
  • resolution score: A number between 0-100 that represents the likeliness of a match of an identity to an entity.

Watch list scenario

Bankcorp, a nationally recognized bank could lose millions of dollars from insider fraud such as money laundering. To alleviate such threats, Bankcorp is working with law enforcement to obtain a watch list containing information on people who are a potential threat to the bank. The information may include biographic characteristics of people such as their name, aliases, current and past addresses, social security number (in U.S.), data of birth, place of birth, citizenship, and so on. Bankcorp intends to use this information during its hiring process to filter candidates with potential links to a criminal network.

Job applicants use a secure and confidential online application form to apply for a position at Bankcorp. Because the bank receives a large number of job applications, it must:

  • Verify if the biographic information submitted by each applicant matches him with people on the watch list
  • Uncover potential relationships that the applicants may have with people on the watch list
  • Determine the strength of the relationship, if any, based on a set of predefined rules that were created by Bankcorp's security personnel

To accomplish these goals, Bankcorp decides to use IBM Relationship Resolution to intelligently mine watch list information.

The above scenario can be implemented by:

  • Configuring Relationship Resolution using the console:
    • Start and stop Relationship Resolution
    • Customize data sources, add relationship resolution rules, add number types, and modify date format
  • Loading a sample watch list:
    • Programmatically, using the process Web service
    • Using the visualizer applet
    • Using the command line interface
  • Implementing Web service APIs to identity relationships:
    • Implementing checkBlackListRelationship method
    • Implementing getBlackListEntityIds method
    • Implementing getEntityDetails method

Configuring Relationship Resolution using the console

This section shows how to configure Relationship Resolution for the watch list scenario.

Useful commands

Start Relationship Resolution

  • Start Relationship Resolution AppServer:
    /usr/opt/eas_4.2.0/startEAS.sh
  • Start the pipeline:
    /usr/opt/eas_4.2.0/bin/pipeline -s -n wspipeline

Stop Relationship Resolution

  • Stop the pipeline:
    /usr/opt/eas_4.2.0/bin/pipeline -e -n wspipeline
  • Stop Relationship Resolution AppServer:
    /usr/opt/eas_4.2.0/stopEAS.sh

Customize metadata in Relationship Resolution

Log in to the Relationship Resolution configuration console at the following Web address:

http://eas-ip-address:13510/console/

Check Edit configuration. 13510 is the default port for the Relationship Resolution configuration console.

Add data sources

Data sources contain the identities that you want to process for entity resolution and loading into the entity database. Data sources contain identifying data (unique, personal identifiers for an identity) and non-identifying data (other attributes and data points for an identity).

Entity information retrieved from the entity database will contain information from all the data sources. For the watch list scenario, add two data sources, one for applicant data (ENR) and one for data regarding individuals on selected watch lists (BLOCKED):

  1. Select Setup > Sources.
  2. Select Data Sources, then select New.
  3. Select General.
  4. Enter Code: BLOCKED.
  5. Enter Description: BLOCKED.
  6. Click on Entity Resolution.
  7. Select Entity Resolution Configuration: Default.
  8. Select Candidate Builder Configuration: Default w/Name only.
  9. Select Name Manager Match Level: Default.
  10. Use the same procedure to add additional data source with Code/Description: ENR/ENR.
Figure 1. Add data sources
Add data sources

See the full version of Figure 1.

Add custom number types

Relationship Resolution provides basic number types such as social security number (SSN). When adding applicant information to the database, you need a way to gather the enrollment number, so you add a custom number type called ENR.

  1. Select Setup > Sources.
  2. Select Numbers, then select New.
  3. Click on General.
  4. Enter Type: ENR.
  5. Enter Description: ENR.
  6. Choose Class: PID.
  7. Choose Unique: Yes.
  8. Choose Keep History: Yes.
  9. Click on Format.
  10. Enter Min Length: 0.
  11. Enter Max Length: 25.
  12. Enter Hash Length: 0.
  13. Click on Save.
Figure 2. Add custom number types
Add custom number types

See the full version of Figure 2.

Modify date format

IBM Relationship Resolution recognizes a variety of date formats. This example shows how to add a date format.

  1. Select Setup > UMF > DQM Rules, then select Segment: Attribute.
  2. In the Function column, click on 204 - Date Validation and Format.
  3. Then, click on Parameters, next to General.
  4. Click on Add parameter, and add two parameters:
    MM/DD/YYYY and MM/DD/YY
Figure 3. Modify date format
Modify date format

See the full version of Figure 3.

Change relationship scoring

IBM Relationship Resolution allows the administrator to add or change rules that determine a relationship score. Here, you change Rule 10 in Relationship Resolution to say, "If the name and address of an entity matches another entity, then the base relationship score will be set to 100, while the base resolution score is set to 85." Also, because two people may have the same name and address, you do not want to automatically trigger a resolve with the matched entity.

  1. Select Setup > Resolution, then select Resolution Config: Default.
  2. Click on Rule 10 (Name and Address), then change the following:
    • Resolution Confidence: 85
    • Relation Confidence: 90
    • Triggers Resolve: No
  3. Do the same with Rule 5 (Name and Other Number).

Add a resolution rule

Here, you add a new resolution rule, which says, "If the date of birth (DOB) and a unique number (such as SSN) between two entities match, then consider them to be the same entity." The base relationship and resolution score is set to 100 because they are the same entity.

  1. In the General tab, set the following:
    • Enter Order: 2
    • Description: DOB and Unique Number
    • Resolution Confidence: 100
    • Resolution Confidence: 100
    • Trigger Resolve: Yes
    • Denials Enabled: Yes
    • Characteristic Denials Enabled: Yes
  2. In the Candidate Threshold tab, select Unique Number Threshold: 1: Single matching value.
  3. In the Confirm/deny tab, select Date of Birth Threshold: Custom Match(95).
Figure 4. Add a resolution rule
Add a resolution rule

See the full version of Figure 4.

Loading data into Relationship Resolution

There are several ways to load identity data into the Relationship Resolution entity database. Listing 1 provides a sample UMF (universal message format) entity that can be loaded into Bankcorp's entity database after the configuration is complete:

Listing 1. Sample UMF entity
<UMF_ENTITY>
	<DSRC_CODE>ENR</DSRC_CODE>
	<dsrc_action>A</dsrc_action>
	<dsrc_acct>123947185</dsrc_acct>
	<dsrc_ref>123947185</dsrc_ref>
	<NAME>
		<NAME_TYPE>M</NAME_TYPE>
		<LAST_NAME>THOMPSON</LAST_NAME>
		<FIRST_NAME>James</FIRST_NAME>
		<MID_NAME>Scott</MID_NAME>
	</NAME>
	<NUMBER>
		<NUM_TYPE>SSN</NUM_TYPE>
		<NUM_VALUE>123947185</NUM_VALUE>
	</NUMBER>
	<NUMBER>
		<NUM_TYPE>ENR</NUM_TYPE>
		<NUM_VALUE>565653445</NUM_VALUE>
	</NUMBER>

	<ATTRIBUTE>
		<ATTR_TYPE>DOB</ATTR_TYPE>
		<ATTR_VALUE>3/17/1936</ATTR_VALUE>
	</ATTRIBUTE>
	<ATTRIBUTE>
		<ATTR_TYPE>GENDER</ATTR_TYPE>
		<ATTR_VALUE>M</ATTR_VALUE>
	</ATTRIBUTE>
	<ATTRIBUTE>
		<ATTR_TYPE>POB</ATTR_TYPE>
		<ATTR_VALUE>Angels Camp,IA</ATTR_VALUE>
	</ATTRIBUTE>
	<NUMBER>
		<NUM_TYPE>DL</NUM_TYPE>
		<NUM_VALUE>723488</NUM_VALUE>
	</NUMBER>
	<NUMBER>
		<NUM_TYPE>PH</NUM_TYPE>
		<NUM_VALUE>2172315034</NUM_VALUE>
	</NUMBER>
	<ATTRIBUTE>
		<ATTR_TYPE>CIT</ATTR_TYPE>
		<ATTR_VALUE>US</ATTR_VALUE>
	</ATTRIBUTE>
	<ADDRESS>
		<ADDR_TYPE>H</ADDR_TYPE>
		<ADDR1>33 ACCESS ROAD A ROAD</ADDR1>
		<CITY>Angels Camp</CITY>
		<state>IA</state>
		<POSTAL_CODE>90193</POSTAL_CODE>
		<country>US</country>
	</ADDRESS>
</UMF_ENTITY>

Using command line interface

Listing 2 provides a single command-line command to run in a UNIX®-based installation.

Run the following command as easadmin from the UNIX terminal. Change the path as needed for your environment.

Listing 2. UNIX-based installation command
java -jar /usr/opt/eas_4.2.0/was_ee/webservice/wsutil.jar 
--load=http://localhost:13510/easws/services/SRDWebService 
--input=EASInput.txt 
--output=EASOutput.txt

EASInput.txt: This is an XML data file containing sample (fictitious) biographical data (watch list) for 2000 unique criminal entities.

EASOutput.txt: This is the output file to store results after running the command above.

Using the visualizer

Relationship Resolution provides a visualizer applet that can be used to upload entity data. To upload UMF data using the applet:

  1. Log in to visualizer.
  2. Select UMF in the sidebar panel.
  3. Click on File Load, and select the UMF file.

Using the Web service API

See "Listing 3. Sample Java code for calling the process Web service method" below on how to programmatically load UMF data.


Implementing biographic proofing using Web services

Relationship Resolution provides the flexibility to integrate its functionality into a broader solution through its Web services interface. It comes with a wsdl definition file (srd.wsdl) that can be used to generate a Web service client. The wsdl can be found at this Web address:

http://eas-host:port/easws/resources/wsdl/srd.wsdl

Use IBM Rational Application Developer to generate a Java-based Web services client. Ensure Web service capability is enabled in Rational Application Developer, then:

  1. Create a new Web project named srdClient and import the srd.wsdl file into WebContent/wsdl.
  2. Right-click on srd.wsdl, and select Generate Web Service Client.
  3. Copy the generated Java classes to your application.

Relationship Resolution exposes the following Web services:

  • String process (String umfRequestDocument)
  • LoadResult loadRecord(String umfEntity) [for backwards compatibility only]
  • String score(String scoreDefinition) [for backwards compatibility only]
  • String basicQuery(String umfSearch) [for backwards compatibility only]

This article uses the process Web service method. The process method accepts a UMF input document as a string and returns a UMF output document as a string. This article uses these types of UMF input documents:

  • UMF_QUERY: The collection of UMF segments that structure the incoming data to query a specific entity in the entity database.
  • UMF_ENTITY: The collection of UMF segments that structure the incoming identity data.

For a complete list of supported documents, see the "Default UMF Specification", listed in the Reference section of the IBM Relationship Resolution Information Center (see Resources).

Listing 3. Sample Java code for calling the process Web service method
public static String process(String umfRequest)
{
	// This proxy class is generated from the SRD wsdl using RAD
	SRDWebServiceProxy sws = new SRDWebServiceProxy();
	String umf_response = “”;
	
	//Replace this url based on your environment
	String srdServiceEndpoint = “http://eas-ws-endpoint-url”;
	
	//Setting the endpoint to the web service proxy
	sws.setEndpoint(srdServiceEndpoint);

	//Calling the process method
	try{
		umf_response=sws.process(umfRequest);
	}
	catch (RemoteException e) {
		e.printStackTrace();
	}
	
	
	return umf_response;
}

Sample XML query to get entity information from the entity database

This XML query requests details of an entity with entity id set to 1.

Listing 4. Sample request UMF
<UMF_QUERY>
	<FORMAT_CODE>WS_DETAIL</FORMAT_CODE>
	<DSRC_CODE>1589</DSRC_CODE>
	<DSRC_REF>0</DSRC_REF>
	<ENTITY_ID>1</ENTITY_ID>
</UMF_QUERY>
Listing 5. Sample response UMF
<ENTITY>
	<SOURCE>
		<DSRC_ACCT_ID>65</DSRC_ACCT_ID>
		<DSRC_DESC>ENR</DSRC_DESC>
		<DSRC_ACCT>1217895258031</DSRC_ACCT>
		<NAME>
			<NAME_TYPE>Main</NAME_TYPE>
			<NAME_TYPE_CODE>M</NAME_TYPE_CODE>
			<LAST_NAME>Baker</LAST_NAME>
			<FIRST_NAME>Carol</FIRST_NAME>
		</NAME>
		<NAME>
		<ADDRESS>
			<ADDR_TYPE>Home</ADDR_TYPE>
			<ADDR_TYPE_CODE>H</ADDR_TYPE_CODE>
			<ADDR1>123 A Street</ADDR1>
			<CITY>San Jose</CITY>
			<STATE>CA</STATE>
			<POSTAL_CODE>95123</POSTAL_CODE>
			<COUNTRY>US</COUNTRY>
			<DLV_PROB>0</DLV_PROB>
		</ADDRESS>
		<NUMBER>
			<NUM_DESC>SSN</NUM_DESC>
			<NUM_TYPE>SSN</NUM_TYPE>
			<NUM_VALUE>456-78-9123</NUM_VALUE>
		</NUMBER>
		<ATTRIBUTE>
			<ATTR_DESC>DOB</ATTR_DESC>
			<ATTR_TYPE>DOB</ATTR_TYPE>
			<ATTR_VALUE>1940-01-12</ATTR_VALUE>
		</ATTRIBUTE>
		<ATTRIBUTE>
			<ATTR_DESC>Gender</ATTR_DESC>
			<ATTR_TYPE>GENDER</ATTR_TYPE>
			<ATTR_VALUE>M</ATTR_VALUE>
		</ATTRIBUTE>
	</SOURCE>
	<SYS_CREATE_DT>2008-08-04 18:09:12</SYS_CREATE_DT>
</ENTITY>

Sample XML query requesting relationship details

This XML query requests relationship details of an entity with entity id set to 1.

Listing 6. Sample request UMF
<UMF_QUERY>
	<FORMAT_CODE>WS_RELATION</FORMAT_CODE>
	<DSRC_CODE>1589</DSRC_CODE>
	<DSRC_REF>0</DSRC_REF>
	<ENTITY_ID>1</ENTITY_ID>
</UMF_QUERY>
Listing 7. Sample response UMF
<WS_RELATION>
		<RELATION>
			<DISCLOSED>0</DISCLOSED>
			<ENTITY_ID>2012</ENTITY_ID>
			<LIKE_SCORE>35</LIKE_SCORE>
			<REL_SCORE>40</REL_SCORE>
			<ER_ID>4058</ER_ID>
			<MOST_RECENT_ADDR_ID>4012</MOST_RECENT_ADDR_ID>
			<MOST_RECENT_NAME_ID>4012</MOST_RECENT_NAME_ID>
			<MOST_RECENT_DOB_ID>16044</MOST_RECENT_DOB_ID>
		</RELATION>
		<RELATION>
			<DISCLOSED>0</DISCLOSED>
			<ENTITY_ID>2011</ENTITY_ID>
			<LIKE_SCORE>40</LIKE_SCORE>
			<REL_SCORE>50</REL_SCORE>
			<ER_ID>4058</ER_ID>
			<MOST_RECENT_ADDR_ID>4011</MOST_RECENT_ADDR_ID>
			<MOST_RECENT_NAME_ID>4011</MOST_RECENT_NAME_ID>
			<MOST_RECENT_DOB_ID>16040</MOST_RECENT_DOB_ID>
		</RELATION>
		<ENTITY_ID>1</ENTITY_ID>
		<SYS_CREATE_DT>2008-06-13 03:00:06</SYS_CREATE_DT>
</WS_RELATION>

As shown, the process Web service exposed by Relationship Resolution can be used to load entity data, query entity details, and retrieve relationship information for a given entity from the entity database. Based on the exposed Web service, you can write custom code to gather information to aid Bankcorp's hiring process.

Figure 5 illustrates a sample hiring process used by Bankcorp:

Figure 5. Sample hiring process used by Bankcorp
Sample hiring process used by Bankcorp

The job applicant submits a confidential pre-hire online application form. The identity information in the form is loaded into Relationship Resolution's entity database. Next, the checkBlackListRelationship method is called to verify whether the applicant has a relationship to any of the entities in the black list based on the set of rules defined by Bankcorp.

If one or more relationships are found, the highest score indicating the strength of the relationship is evaluated.

If the score is less than 25, the relationship is deemed insignificant, and the applicant follows the normal hiring process.

If the score if greater than 75, the applicant is rejected because of a significant relationship with watch list entities.

If the score is between 25 and 75, an in-depth interview is conducted to determine if the applicant is a business threat. The interviewer makes use of the relationship score and related entity information to make an intelligent decision.

The process diagram (Figure 5) shows three methods being called:

  • String getEntityDetails (String entityId)

    Summary: This method returns a UMF-based XML string containing details for the given entity id. The information returned contains name, address, social security number, data of birth, and so on.

  • int checkBlackListRelationship (String entityId)

    Summary: Given an entity id, verify if the person is related to someone in the black list. If multiple relationships exist, return the highest relationship score.

  • String[] getBlackListEntityIds(String entityId)

    Summary: Given an entity id, verify if the person is related to person on a black list. Return all watch list entity ids that are related to the given entity.


Sample Implementation logic and tools

  • String getEntityDetails (String entityId)
    • Summary: This method returns a UMF-based XML string containing details for the given entity id. The information returned contains name, address, social security number, data of birth, and so on.
    • Input: Auto generated entity id of person in Relationship Resolution entity database.
    • Output: A returned UMF XML string representing the entity details of a person.
    • Side effects: None.
    • Assumptions: Entity id exists in the entity database.
    • Exception: Exception thrown if entity id does not exist in Relationship Resolution entity database.
Listing 8. String getEntityDetails (String entityId)
public String getEntityDetails(String entityId) throws ProofingException {

		if ((entityId == null) || (entityId.equals(""))) {
			ProofingException pe = new ProofingException("ERROR",
			"getEntityDetails" + " input is null or empty");
			throw pe;
		}
		
		String result = process(this.UMF_REQUEST_HEAD + entityId + 
					this.UMF_REQUEST_TAIL);
		return result;
	}
  • int checkBlackListRelationship (String entityId)
    • Summary: Given an entity id, verify if the person is related to someone in the black list. If multiple relationships exist, return the highest relationship score.
    • Input: The entity id of the person as in the entity database.
    • Output: An integer between 0 and 100, representing the relationship score with a black-listed entity. If multiple entities match, then return the highest score.
    • Side effects: None.
    • Assumptions: Entity id exists in the entity database.
    • Exceptions: Exception is thrown if entity id does not exist in Relationship Resolution.
Listing 9. int checkBlackListRelationship (String entityId)
public int checkBlackListRelationship(String entityId)
			throws ProofingException {
		
	if ((entityId == null) || (entityId.equals(""))) {
		ProofingException pe = new ProofingException("ERROR",
			"checkBlackListRelationship input is null or empty");
			throw pe;
		}
	String ws_relation = process(this.UMF_RELATION_HEAD + entityId
				+ this.UMF_RELATION_TAIL);
	WSRelationParser parser = new WSRelationParser();
	return parser.getHighestScore(ws_relation);

	}
  • String[] getBlackListEntityIds(String entityId)
    • Summary: Given an entity id, verify if the person is related to person on a watch list. Return all watch list entity ids that are related to the given entity.
    • Input: The entity id of the person as in the entity database.
    • Output: An array of entity ids that are related to the given entity.
    • Side effects: None.
    • Assumptions: Entity id exists in the entity database.
    • Exceptions: Exception is thrown if entity id does not exist in Relationship Resolution.
Listing 10. String[] getBlackListEntityIds(String entityId)
	public java.lang.String[] getBlackListEntityIds(java.lang.String entityId)
				throws ProofingException {
	
	if ((entityId == null) || (entityId.equals(""))) {
		ProofingException pe = new ProofingException("ERROR",
			"getBlackListEntityIds input is null or empty");
				throw pe;
			}
	
	String ws_relation = process(this.UMF_RELATION_HEAD + entityId
					+ this.UMF_RELATION_TAIL);
	WSRelationParser parser = new WSRelationParser();
	return parser.getBlacklistEntities(ws_relation);

Service data object tooling

The above methods can be implemented by creating a UMF request and parsing data in the UMF response. Java technology enables several APIs to parse XML data. However, customers using IBM Rational® Application Developer, Version 6 or later can easily generate a service data object (SDO) based on UMF document type. The generated SDOs can assist you in converting an XML stream directly into a Java object and retrieve data from objects using getter methods. SDOs can also be used to create XML strings from the objects.

To create an SDO:

  1. Right-click on a sample XML file, select Generate, then click on XML Schema.
  2. Right-click on generated XML schema file, select Generate Java, choose SDO Generator, select Container and Package then select Finish.

To use an XML SDO:

  1. In the generated SDO classes, look for xxxResourceUtil.java in the xxxResourceUtil package.
  2. To convert an XML string to a SDO object, use the following:
xxxResourceUtil instance = xxxResourceUtil.getInstance();
DocumentRoot dr = instance.load(inputXMLStr.getBytes());

where "xxx" represents the name generated by the SDO generator.

When a handle to a document root is obtained, all XML data can be accessed by traversing the SDO using its getter methods. See the UMFParser.java in the attached WatchListService project for an example on how to traverse and retrieve data from an SDO (see Downloads).


Testing the scenario

After you configure Relationship Resolution and implement the methods to meet the scenario requirements, you must create identity data for job applicants. Let's assume that Relationship Resolution is already configured and the entity database is populated with watch list data from EASInput.txt.

When the applicant applies for a position at Bankcorp, all relevant data is collected and loaded in the entity database. To simulate this process, you manually load applicant data (in UMF format) to the entity database and capture the resultant entity id. Relationship Resolution relates and resolves the incoming identity data in real time based on the resolution rules specified earlier.

The file SampleApplicants.xml contains sample data for five job applicants: Alice, Bob, Berenice, Carol, and Daryl. Load this data into Relationship Resolution using the command line interface or the visualizer applet and record the generated entity id for each. Use the entity id as arguments to the three methods created earlier.

The WatchListService project included as a download with this article contains the three methods exposed as Web services. Therefore, you can simply use Rational Application Developer's Web service test explorer to run the test.

Figure 6. Web service test
Web service test

See the full version of Figure 6.

The following results can be verified when the included WatchListService EAR application (see Downloads) is deployed on a Java 2 Enterprise Edition server such as IBM WebSphere® Application Server:

Table 1. Web service test results
Entity name (First Last)Matches entityRelationship scoreMatch reason
Alice Baker Jailynn Whitley 40 Address matches
Bob Carter Averie Noel 40 SSN matches
Carol Dana Emily Vang 50 Address and Driver License number matches
Daryl Cook Marin Cooke 100 SSN and Date Of Birth matches
Berenice Velazquez Velazquez Berenice 65 Weak Name and Phone Number matches

Conclusion

Government and private organizations can use IBM Entity Analytic Solutions products such as IBM Relationship Resolution to protect people and businesses by making intelligent decisions based on known information. IBM Relationship Resolution provides a Web-based interface to specify organization-specific rules and data, a visualizer applet to view data, and a flexible Web service interface to integrate with other enterprise-centric applications and processes.


Acknowledgements

Many thanks to Susan Holic for providing editorial contributions to this article. Thanks to Chris Roach, Jose Vargas, Peter Huber, and the IBM HiPODS Trusted Identity team for their support.


Downloads

DescriptionNameSize
Sample job applicant data in UMF formatSampleApplicants.xml5KB
Watchlist data in UMF format, for sample entitiesEASInput.txt1.9MB
WatchListService project source codeeasProject.zip355KB
Packaged EAR file for server deploymentWatchListServiceEAR.ear173KB

Resources

Learn

Get products and technologies

  • Build your next development project with IBM trial software, available for download directly from developerWorks.

Discuss

Comments

developerWorks: Sign in

Required fields are indicated with an asterisk (*).


Need an IBM ID?
Forgot your IBM ID?


Forgot your password?
Change your password

By clicking Submit, you agree to the developerWorks terms of use.

 


The first time you sign into developerWorks, a profile is created for you. Information in your profile (your name, country/region, and company name) is displayed to the public and will accompany any content you post, unless you opt to hide your company name. You may update your IBM account at any time.

All information submitted is secure.

Choose your display name



The first time you sign in to developerWorks, a profile is created for you, so you need to choose a display name. Your display name accompanies the content you post on developerWorks.

Please choose a display name between 3-31 characters. Your display name must be unique in the developerWorks community and should not be your email address for privacy reasons.

Required fields are indicated with an asterisk (*).

(Must be between 3 – 31 characters.)

By clicking Submit, you agree to the developerWorks terms of use.

 


All information submitted is secure.

Dig deeper into Information management on developerWorks


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=1
Zone=Information Management
ArticleID=342847
ArticleTitle=Use IBM Entity Analytic Solutions to analyze watch lists
publish-date=10022008