curam.pdc.impl

Interface PDCEvidence

@AccessLevel(value=EXTERNAL)
public interface PDCEvidence

PDC evidence interface

This interface defines the contract that must be fulfilled for evidence that is configured on the Person Case (a.k.a Person Data Case or PDC) to be successfully shared to and from the Person Case.

In order to ensure evidence can be shared to a Person case the evidence must support automated processing. That is, the evidence must either get to an active state on the Person case or be ignored without manual intervention. Unlike Integrated Cases the evidence on a Person Case can not be held in an incoming or in-edit state awaiting manual processing.

The automated processing is achieved by implementing the methods of this interface to return the information the infrastructure needs to handle the evidence. Each evidence type will have its own specific implementation that encodes the business logic that should be applied to the sharing process.

In brief the processing will either

• Ignore the shared evidence because the same information already exists on the target case.
• Insert the shared evidence as a new record on the target case.
• Modify an existing record on the target case to reflect the shared evidence.

Note: When this process is invoked, the validations that are normally run on the activation of evidence on a case are suppressed. The expectation is that the implementation provided by this class will supplant the normal validations.

Configuring a PDCEvidence implementation.

A PDCEvidence implementation can be bound to its evidence type using Guice bindings.

E.g.

final MapBinder<String,PDCEvidence> pdcEvidenceMapBinder = MapBinder.new MapBinder(binder(), String.class, MyPDCEvidenceImpl.class); pdcEvidenceMapBinder.addBinding("DET0000123").to(MyPDCEvidenceImpl.class);

The evidence type definition identifier, "DET00001234" in the example above, can be retrieved from the EvidenceTypeDef table.

To override an existing implementation you can bind the new implementation to the existing.

E.g.

bind(ExistingPDCImpl.class).to(MyNewPDCEvidenceImpl.class);

Method Summary

Modifier and Type	Method and Description
void	assignEvidenceDetails(curam.dynamicevidence.impl.DynamicEvidenceDataDetails sharedEvidenceDetails, curam.dynamicevidence.impl.DynamicEvidenceDataDetails originalEvidenceDetails) Update the fields of the evidence on the target case that are affected by sharing.
curam.core.sl.infrastructure.impl.EIEvidenceReadDtls	getNonIdenticalEvidenceModifyDetails(curam.dynamicevidence.impl.DynamicEvidenceDataDetails shareEvidenceDetails, java.util.Set<curam.core.sl.infrastructure.impl.EIEvidenceReadDtls> evidenceDetailsList) Resolve which evidence on the target case will be updated on sharing.
boolean	isMultipleTimeLinePerType(curam.dynamicevidence.impl.DynamicEvidenceDataDetails sharedEvidenceDetails) Identifies if an evidence record is a 'multiple timeline per sub type' evidence type.
boolean	matchAllEvidenceDetails(curam.dynamicevidence.impl.DynamicEvidenceDataDetails sharedEvidenceDetails, curam.util.type.Date sharedEffectiveDate, curam.dynamicevidence.impl.DynamicEvidenceDataDetails originalEvidenceDetails, curam.util.type.Date originalEffectiveDate) Determine if sharing should be attempted.
boolean	matchEvidenceDetails(curam.dynamicevidence.impl.DynamicEvidenceDataDetails sharedEvidenceDetails, curam.util.type.Date sharedEffectiveDate, curam.dynamicevidence.impl.DynamicEvidenceDataDetails originalEvidenceDetails, curam.util.type.Date originalEffectiveDate) Find evidence on the target case to update.

Method Detail

isMultipleTimeLinePerType

@AccessLevel(value=EXTERNAL)
boolean isMultipleTimeLinePerType(curam.dynamicevidence.impl.DynamicEvidenceDataDetails sharedEvidenceDetails)
                                                        throws curam.util.exception.AppException,
                                                               curam.util.exception.InformationalException

Identifies if an evidence record is a 'multiple timeline per sub type' evidence type.

An evidence type that is multi-timeline per sub type will allow more than one record to be created as long as it is not the same sub type as an existing record. Typically the sub type is defined by a single attribute which is a codetable value, but it could be based on any number of attributes of the evidence type and the attributes could be of any type.

E.g. An AlternateID evidence has a 'sub type' attribute which indicates the type of ID that is being record for the client. Only 1 record can be recorded for a Social Security Number because a person can only have 1 Social Security Number. Therefore an AlternateID record with a type of Social Security Number is not multiple time line per type and should return false.

Parameters:

sharedEvidenceDetails - Details of the evidence being shared.

Returns:

true if evidence is multi-timeline per sub type.

Throws:

curam.util.exception.InformationalException

curam.util.exception.AppException

matchEvidenceDetails

@AccessLevel(value=EXTERNAL)
boolean matchEvidenceDetails(curam.dynamicevidence.impl.DynamicEvidenceDataDetails sharedEvidenceDetails,
                                                          curam.util.type.Date sharedEffectiveDate,
                                                          curam.dynamicevidence.impl.DynamicEvidenceDataDetails originalEvidenceDetails,
                                                          curam.util.type.Date originalEffectiveDate)
                                                   throws curam.util.exception.AppException,
                                                          curam.util.exception.InformationalException

Find evidence on the target case to update.

This function is used to find evidence on the target case that is a match for the shared evidence. If true is returned, i.e. a match is found, the infrastructure will try to share to the matched evidence by checking ...

1. Shared and target evidence have the same effective date.
2. Shared evidence is a more recent update than the target evidence.

• If true is returned and 1) is false, the evidence will be inserted as a new record.
• If true is returned and 2) is false, the shared evidence will be ignored.
• If false is returned a further attempt to share to an existing evidence record is made if the evidence is not multi-timeline per type (See getNonIdenticalEvidenceModifyDetails(DynamicEvidenceDataDetails, Set))
• Otherwise the target evidence will be modified using assignEvidenceDetails(DynamicEvidenceDataDetails, DynamicEvidenceDataDetails).

Parameters:

sharedEvidenceDetails - Shared PDC evidence details

sharedEffectiveDate - Effective date of shared PDC evidence

originalEvidenceDetails - Existing PDC evidence details

originalEffectiveDate - Effective date of existing PDC evidence

Returns:

true if the shared evidence is as a match to the target case evidence.

Throws:

curam.util.exception.InformationalException

curam.util.exception.AppException

matchAllEvidenceDetails

@AccessLevel(value=EXTERNAL)
boolean matchAllEvidenceDetails(curam.dynamicevidence.impl.DynamicEvidenceDataDetails sharedEvidenceDetails,
                                                             curam.util.type.Date sharedEffectiveDate,
                                                             curam.dynamicevidence.impl.DynamicEvidenceDataDetails originalEvidenceDetails,
                                                             curam.util.type.Date originalEffectiveDate)
                                                      throws curam.util.exception.AppException,
                                                             curam.util.exception.InformationalException

Determine if sharing should be attempted.

This method will be called to compare the shared evidence to all existing evidence of the same type on the target case. If this method returns true for any target evidence, then the sharing is terminated because it is deemed unnecessary.

For example, if the shared evidence is an exact match to an existing target evidence after comparing all fields, then the sharing is unnecessary as the information is already recorded and sharing can terminate at this point.

Parameters:

sharedEvidenceDetails - Shared evidence details

sharedEffectiveDate - Effective date of shared evidence

originalEvidenceDetails - Existing target details

originalEffectiveDate - Effective date of target evidence

Returns:

true if shared evidence should be ignored.

Throws:

curam.util.exception.InformationalException

curam.util.exception.AppException

assignEvidenceDetails

@AccessLevel(value=EXTERNAL)
void assignEvidenceDetails(curam.dynamicevidence.impl.DynamicEvidenceDataDetails sharedEvidenceDetails,
                                                        curam.dynamicevidence.impl.DynamicEvidenceDataDetails originalEvidenceDetails)
                                                 throws curam.util.exception.AppException,
                                                        curam.util.exception.InformationalException

Update the fields of the evidence on the target case that are affected by sharing.

When sharing results in an existing record on the target case being updated, this method will be invoked to copy the details from the shared evidence to the target evidence. Implementing this method gives control over what information is shared. For example, you may want to retain field values on the target evidence when the shared evidence has no value for the same field.

Parameters:

sharedEvidenceDetails - Shared evidence details

originalEvidenceDetails - Target evidence details

Throws:

curam.util.exception.InformationalException

curam.util.exception.AppException

getNonIdenticalEvidenceModifyDetails

@AccessLevel(value=EXTERNAL)
curam.core.sl.infrastructure.impl.EIEvidenceReadDtls getNonIdenticalEvidenceModifyDetails(curam.dynamicevidence.impl.DynamicEvidenceDataDetails shareEvidenceDetails,
                                                                                                                       java.util.Set<curam.core.sl.infrastructure.impl.EIEvidenceReadDtls> evidenceDetailsList)
                                                                                                                throws curam.util.exception.AppException,
                                                                                                                       curam.util.exception.InformationalException

Resolve which evidence on the target case will be updated on sharing.

Given a list of evidence records that are a potential candidate for update, select only one record to be updated. This method is only invoked for evidence that is not multi-timeline per sub type (See isMultipleTimeLinePerType(DynamicEvidenceDataDetails)). If invoked it will only result in an update if the shared evidence is considered to be an update. An update is decided by comparing the received dates. If the shared evidence has a later received date, the shared evidence is accepted. If the shared evidence has an earlier received date it is ignored. If the shared evidence has the same received date, the creation dates will be compared and if the shared evidence was created later it will be accepted.

Note: Validations are disabled during this process, and returning null will result in the shared evidence being created as a new record, so returning null can result in duplicate records being created by bypassing validations if the implementation allows this.

Parameters:

shareEvidenceDetails - Shared evidence details

evidenceDetailsList - Target evidence details list

Returns:

EIEvidenceReadDtls a single record from the list provided that is to be updated. Returning null will result in the shared evidence being created as a new record on the target case.

Throws:

curam.util.exception.InformationalException

curam.util.exception.AppException