public override ProcessResultsCollection FieldRetrieval(IBusinessComponent component, ProcessInvocationPoint point, ref Xiap.Framework.Metadata.Field field, int pluginId)
{
UwGenericDataItem item = (UwGenericDataItem)component;
// Check if this is an aggregate, deductible or AD excess Generic Data Type
if (item.GenericDataTypeCode == "AND1" || item.GenericDataTypeCode == "AND2" || item.GenericDataTypeCode == "AND3")
{
// If we're retrieving is 'Division', because this is the name on the GenericDataItem's CustomCode01 field.
if (field.PropertyName.Equals(UwGenericDataItem.CustomCode01FieldName))
{
field.LookupParameters.GroupCode = EmptyGroup;
// Get the header from the Generic Data Item
Header header = item.GenericDataSet.GetUwHeader();
if (header != null)
{
// Get the inception date from the latest Header Version (or today's date if it's not set), and the Major Insured from the Header.
DateTime effectiveDate = ((HeaderVersion)header.GetLatestVersion()).InceptionDate.GetValueOrDefault(DateTime.Today);
UwNameInvolvement insured = header.NameInvolvements.Where(a => a.NameID != null && a.NameInvolvementType == (short)StaticValues.NameInvolvementType.MajorInsured).FirstOrDefault() as UwNameInvolvement;
if (insured != null)
{
// Assuming we have the insured name involvement, find the name usage for the inception date from the header.
IInsuranceDirectoryService ids = ObjectFactory.Resolve<IInsuranceDirectoryService>();
INameUsage assdNameUsage = ids.GetNameUsage(insured.NameID.Value, insured.NameUsageTypeCode, effectiveDate);
if (assdNameUsage != null && assdNameUsage.CustomReference01 != null)
{
// Use the CustomReference01 value from the Insured Name Usage as the Group Code for the drop down in our Division lookup.
field.LookupParameters.GroupCode = assdNameUsage.CustomReference01;
}
}
}
}
}
return null;
}
public override ProcessResultsCollection ProcessComponent(IBusinessComponent component, ProcessInvocationPoint point, int pluginId, ProcessParameters processParameters)
{
ProcessResultsCollection processResults = new ProcessResultsCollection();
Header header = (Header)component;
// Get the header status code that matches Policy Verified from the Application Configuration
string verifiedHeaderStatus = UWBusinessLogicHelper.ResolveMandatoryConfig<string>("PolicyVerifiedHeaderStatus");
// If the header status code has been changed and now matches the verified header status code retried, process
if (header.HeaderStatusCode == verifiedHeaderStatus && header.HeaderStatusCode != header.OriginalTransitionStatus)
{
// Retrieve the Policy Verify Permission Token and the Submitted for verification Event codes from the Application Configuration
string policyVerifyPermissionToken = UWBusinessLogicHelper.ResolveMandatoryConfig<string>("PolicyVerificationPermissionToken");
string submittedForVerificationEventTypeCode = UWBusinessLogicHelper.ResolveMandatoryConfig<string>("SubmittedForVerificationEventTypeCode");
// Check if this user has Policy Verify in their permission tokens. This method throws a SecurityException if this fails
XiapSecurity.Assert(policyVerifyPermissionToken);
// Check in tasks for a 'submitted for verification' task and make sure it wasn't entered by the user who is now trying to
// verify the policy. Throw an error if so.
var eventType = header.UwEvents.Where(e => e.EventTypeCode == submittedForVerificationEventTypeCode).OrderByDescending(e => e.EventDate).FirstOrDefault();
if (eventType != null && eventType.CreatedByUserID == XiapSecurity.GetUser().UserID)
{
UWBusinessLogicHelper.AddError(processResults, UwMessageConstants.POLICY_CANNOT_BE_VERIFIED_BY_PERSON_SUBMITTED, ProcessInvocationPoint.Virtual, component);
}
}
return processResults;
}
/// <summary>
/// This will validate correct combination of TypeOfLoss and CoverageType through decision table.
/// </summary>
/// <param name="component">Claim Header Component</param>
/// <param name="point">Process Invocation Point Virtual</param>
/// <param name="pluginId">plugin Id</param>
/// <param name="processParameters">List of processParameters</param>
/// <returns>Process Results Collection</returns>
public override ProcessResultsCollection ProcessComponent(IBusinessComponent component, ProcessInvocationPoint point, int pluginId, ProcessParameters processParameters)
{
StaticValues.PolicyLinkLevel policyLinkLevel;
PluginHelper<ClaimHeader> pluginHelper = new PluginHelper<ClaimHeader>(point, component as ClaimHeader, new ProcessResultsCollection());
switch (point)
{
case ProcessInvocationPoint.Virtual:
this.ValidateTypeOfLossAndCoverageTypeCombination(pluginHelper, (string)processParameters.Parameters[2]);
if (Enum.TryParse(processParameters.Parameters[1].ToString(), out policyLinkLevel))
{
this.IsExternalPolicyChildComponentExists(pluginHelper, (string)processParameters.Parameters[0], policyLinkLevel);
}
else
{
string messageTitle = string.Empty;
string messageBody = string.Empty;
MessageServiceFactory.GetMessageService().GetMessage(MessageConstants.InvalidValue, out messageTitle, out messageBody, ClaimConstants.POLICY_LINK_LEVEL);
throw new ArgumentException(messageBody);
}
break;
}
return pluginHelper.ProcessResults;
}
/// <summary>
/// Process runs on Create or Copy of a name.
/// </summary>
/// <param name="component">The component.</param>
/// <param name="point">The point.</param>
/// <param name="pluginId">The plugin identifier.</param>
/// <returns>Process Results Collection</returns>
public override ProcessResultsCollection ProcessComponent(IBusinessComponent component, ProcessInvocationPoint point, int pluginId)
{
ProcessResultsCollection results = new ProcessResultsCollection();
TransactionContext transactionContext = component.Context;
switch (point)
{
case ProcessInvocationPoint.Created:
{
// Run for create or copy of any name usage that is defined as controlled in GeniusX
if ((transactionContext.TransactionType == TransactionProcessConstants.CreateName || transactionContext.TransactionType == TransactionProcessConstants.CopyName)
&& (component as NameUsage).GetDefinitionComponent().CustomCode01 == IDConstants.NAME_CONTROLLED_IN_GENIUSX)
{
Name name = component.Parent as Name;
this.DefaultNameRefrence(results, component, point, name);
}
break;
}
case ProcessInvocationPoint.Copy:
{
// Run for copy of any name usage that is defined as controlled in GeniusX
if ((transactionContext.TransactionType == TransactionProcessConstants.CopyName)
&& (component as NameUsage).GetDefinitionComponent().CustomCode01 == IDConstants.NAME_CONTROLLED_IN_GENIUSX)
{
Name name = component.Context.CopyDictionary[component.Parent.DataId] as Name;
this.DefaultNameRefrence(results, component, point, name);
}
break;
}
}
return results;
}
/// <summary>
/// Set the Task Initial User and Due Date on the event as appliccable.
/// </summary>
/// <param name="component">Claim Event</param>
/// <param name="point">Process Invocation Point</param>
/// <param name="pluginId">unique plugin id</param>
/// <param name="processParameters">Process parameters</param>
/// <returns>collection of process results</returns>
public override ProcessResultsCollection ProcessComponent(IBusinessComponent component, ProcessInvocationPoint point, int pluginId, ProcessParameters processParameters)
{
PluginHelper<IBusinessComponent> pluginHelper = new PluginHelper<IBusinessComponent>(point, (ClaimEvent)component, new ProcessResultsCollection());
switch (pluginHelper.InvocationPoint)
{
case ProcessInvocationPoint.Created:
case ProcessInvocationPoint.Virtual:
{
this.UpdateTaskInitialUser(pluginHelper);
break;
}
case ProcessInvocationPoint.PreValidationDefaulting:
{
// if a new event is added.
ClaimEvent clmEvent = (ClaimEvent)pluginHelper.Component;
if (clmEvent.IsNew)
{
this.SetTaskInitialUserForEvents(pluginHelper, clmEvent);
}
break;
}
}
return pluginHelper.ProcessResults;
}
public override ProcessResultsCollection FieldRetrieval(IBusinessComponent component, ProcessInvocationPoint point, ref Field field, int pluginId)
{
Address address = component as Address;
Name name = null;
if (address.NameToAddress != null && address.NameToAddress.Count > 0)
{
name = address.NameToAddress.First().Name as Name;
}
if (field.IsInUse == true && field.Visible && name != null)
{
if (field.PropertyName == Address.CustomReference04FieldName && name.NameUsages.Count > 0)
{
if (name.NameUsages.OrderBy(n => n.NameUsageID).First().GetDefinitionComponent().CustomCode01 == IDConstants.NAME_CONTROLLED_OUTSIDE_GENIUSX
&& component.IsEditable)
{
field.Readonly = false;
}
else
{
field.Readonly = true;
}
}
}
return null;
}
/// <summary>
/// Call on ClaimDetail Component
/// </summary>
/// <param name="component">Claim Detail</param>
/// <param name="point">Points Create,Virtual,ComponentChange,PreCreateValidation</param>
/// <param name="pluginId">PlugIn ID</param>
/// <returns>return ProcessResultCollection which have Error msg If any validation failed.</returns>
public override ProcessResultsCollection ProcessComponent(IBusinessComponent component, ProcessInvocationPoint point, int pluginId)
{
PluginHelper<ClaimDetail> pluginHelper = new PluginHelper<ClaimDetail>(point, component as ClaimDetail, new ProcessResultsCollection());
switch (point)
{
// Set the claim title and check whether we default the isFunded? and Excess values from the Claim Header
case ProcessInvocationPoint.Created:
this.SetClaimDetailTitle(pluginHelper.Component as ClaimDetail, point);
this.InitializeExcess(pluginHelper.Component);
break;
// Raise a claim inactivity event on the deatail if it's been closed; if this CD is attached at coverage level
// attach all other unattached coverages to the same Policy Coverage
case ProcessInvocationPoint.ComponentChange:
this.ClaimDetailStatusChangeEvent(pluginHelper);
this.AttacheAllClaimDetailsToCoverage(pluginHelper);
break;
// Add estimate reviewed event, if applicable.
case ProcessInvocationPoint.Virtual:
ClaimDetail cd = pluginHelper.Component as ClaimDetail;
this.CreateReviewEvent(cd);
break;
}
return pluginHelper.ProcessResults;
}
/// <summary>
/// Virtual plugin called by coverage verification to validate the external policy. Used by UK motor policies to check there is an existing Xuber policy for the
/// Genius policy and that the policy is verified
/// </summary>
/// <param name="component">Claim Header</param>
/// <param name="point">Points Create,ComponentChange</param>
/// <param name="pluginId">PlugIN ID</param>
/// <param name="processParameters">The parameters for the virtual process. This should contain a UwHeaderData for the external policy</param>
/// <returns>return ProcessResultCollection which have Error msg If any validation failed.</returns>
public override ProcessResultsCollection ProcessComponent(IBusinessComponent component, ProcessInvocationPoint point, int pluginId, ProcessParameters processParameters)
{
PluginHelper<IBusinessComponent> pluginHelper = new PluginHelper<IBusinessComponent>(point, (ClaimHeader)component, new ProcessResultsCollection());
if (pluginHelper.InvocationPoint == ProcessInvocationPoint.Virtual)
{
UWHeaderData policyHeaderData = processParameters.Parameters != null && processParameters.Parameters.Any() ? processParameters.Parameters[0] as UWHeaderData : null;
if (policyHeaderData == null || string.IsNullOrEmpty(policyHeaderData.HeaderReference))
{
ClaimsBusinessLogicHelper.AddError(pluginHelper.ProcessResults, ClaimConstants.ATTACHMENT_NOT_ALLOWED, ProcessInvocationPoint.Virtual, pluginHelper.Component);
}
else
{
// Get the verified policy header status from the application configuration
var verifiedHeaderStatus = ClaimsBusinessLogicHelper.ResolveMandatoryConfig<string>(ConfigSetting_PolicyVerifiedHeaderStatus);
// check the header status matches the verified status
if (policyHeaderData.HeaderStatusCode != verifiedHeaderStatus)
{
ClaimsBusinessLogicHelper.AddError(pluginHelper.ProcessResults, ClaimConstants.POLICYNOTVERIFIED_COVERAGEVERIFICATION_NOTALLOWED, ProcessInvocationPoint.Virtual, pluginHelper.Component, policyHeaderData.HeaderReference);
}
}
}
return pluginHelper.ProcessResults;
}
/// <summary>
/// Create client specific GenericDataSet
/// </summary>
/// <param name="component">Claim Generic DataSet Container</param>
/// <param name="clientCode">Client Code</param>
internal static void CreateClientSpecificGenericDataSet(IBusinessComponent component, string clientCode)
{
// Retrieve ProductGD definition header
IClaimGenericDataSetContainer genericDataSetContainer = (IClaimGenericDataSetContainer)component;
ProductGDDefinitionHeader genericDataDefHeader = genericDataSetContainer.GetProductGDDefinitionHeader();
if (genericDataDefHeader != null)
{
ProductGDDefinitionDetail genericDataDefDetail = null;
genericDataDefDetail = genericDataDefHeader.ProductGDDefinitionDetails.FirstOrDefault((gd) =>
{
var gdtVersion = ObjectFactory.Resolve<IMetadataQuery>().GetGenericDataTypeVersion(gd.ProductGDDefinitionDetailID, genericDataSetContainer.GDSParentStartDate);
// CustomCode01 ClientCode01
if (gdtVersion != null && gdtVersion.GenericDataTypeComponent.CustomCode01 == clientCode) // UI Label = Client Code 1; ClientCodes
{
return true;
}
return false;
});
// Create Generic Data Set and add Generic Data Item
if (genericDataDefDetail != null)
{
IGenericDataSet genericDataSet = genericDataSetContainer.GetGenericDataSet();
if (genericDataSet == null)
{
genericDataSet = genericDataSetContainer.CreateGenericDataSet();
}
genericDataSet.AddGenericDataItem(genericDataDefDetail.ProductGDDefinitionDetailID, genericDataSetContainer.GDSParentStartDate);
}
}
}
/// <summary>
/// Called on ClaimDetail Change Attachment. If we are creating a Claim Detail and one already exists, copy the details from there
/// to prevent another call to Coverage Verification. If we are updating
/// </summary>
/// <param name="component">Claim Detail</param>
/// <param name="point">ComponentChange, Create, Validation</param>
/// <param name="pluginId">PlugIN ID</param>
/// <returns>return Result Collection </returns>
public override ProcessResultsCollection ProcessComponent(IBusinessComponent component, ProcessInvocationPoint point, int pluginId)
{
PluginHelper<ClaimDetail> pluginHelper = new PluginHelper<ClaimDetail>(point, component as ClaimDetail, new ProcessResultsCollection());
ClaimDetail clmDetail = component as ClaimDetail;
switch (point)
{
// If another claim detail already exists, use the same Coverage Verification settings to avoid checking policy on Genius again.
case ProcessInvocationPoint.Created:
this.LinkPolicytoClaimDetails(pluginHelper);
ClaimsBusinessLogicHelper.ValidateStartAndEndDate(pluginHelper);
break;
// If we change a claim detail, enforce it is still attached to the same policy component.
case ProcessInvocationPoint.ComponentChange:
if (pluginHelper.Component.PropertiesChanged.ContainsKey(ClaimConstants.POLICY_LINK_LEVEL))
{
ClaimsBusinessLogicHelper.ValidateAgainstExistingClaimDetails(pluginHelper);
ClaimsBusinessLogicHelper.ValidateStartAndEndDate(pluginHelper);
}
break;
// Validates that the Claim Detail is always attached to the same Policy Component.
case ProcessInvocationPoint.Validation:
ClaimsBusinessLogicHelper.ValidateAgainstExistingClaimDetails(pluginHelper);
break;
}
return pluginHelper.ProcessResults;
}
/// <summary>
/// Field Retrival for diffrent type of Name type set field visibilty
/// </summary>
/// <param name="component">Claim Name Involvement</param>
/// <param name="point">Field Retrieval</param>
/// <param name="field">CustomReference02, CustomReference03,CustomReference04-Field Description Change according to Name Type </param>
/// <param name="pluginId">Plugin Id </param>
/// <returns>Process Results Collection</returns>
public override ProcessResultsCollection FieldRetrieval(IBusinessComponent component, ProcessInvocationPoint point, ref Xiap.Framework.Metadata.Field field, int pluginId)
{
ClaimNameInvolvement claimNameInvolvement = component as ClaimNameInvolvement;
if (claimNameInvolvement.NameID != null)
{
ClaimsTransactionContext transactionContext = component.Context as ClaimsTransactionContext;
IName name = transactionContext.GetName(claimNameInvolvement.NameID.Value);
if (name.NameType == (short)StaticValues.NameType.Company)
{
// UI Label = Contact; Not used in all the NI's
// else if UI Label = Contact; Not used in all the NI's
if (field.PropertyName == ClaimNameInvolvement.CustomReference02FieldName || field.PropertyName == ClaimNameInvolvement.CustomReference03FieldName || field.PropertyName == ClaimNameInvolvement.CustomReference04FieldName)
{
field.Visible = true;
}
}
else if (name.NameType == (short)StaticValues.NameType.Person)
{
if (field.PropertyName == ClaimNameInvolvement.CustomReference02FieldName || field.PropertyName == ClaimNameInvolvement.CustomReference03FieldName || field.PropertyName == ClaimNameInvolvement.CustomReference04FieldName)
{
field.Visible = false;
}
}
}
return null;
}
/// <summary>
/// Property change plugin if Propert get change
/// </summary>
/// <param name="component">Claim Name Involvement</param>
/// <param name="point">Property Change</param>
/// <param name="propertyName"> Name ID </param>
/// <param name="oldValue">OLd Value </param>
/// <param name="newValue">New Value </param>
/// <param name="pluginId">Plugin ID </param>
/// <returns>Process Results Collection</returns>
public override ProcessResultsCollection PropertyChange(IBusinessComponent component, ProcessInvocationPoint point, string propertyName, object oldValue, object newValue, int pluginId)
{
PluginHelper<ClaimNameInvolvement> pluginHelper = new PluginHelper<ClaimNameInvolvement>(point, (ClaimNameInvolvement)component);
ClaimsTransactionContext transactionContext = component.Context as ClaimsTransactionContext;
ClaimNameInvolvement claimNameInvolvement = component as ClaimNameInvolvement;
if (propertyName == ClaimNameInvolvement.NameIDFieldName)
{
if (newValue != null && (long)newValue != 0 && claimNameInvolvement != null && claimNameInvolvement.NameInvolvementType == (short)StaticValues.NameInvolvementType.MajorInsured && claimNameInvolvement.NameInvolvementMaintenanceStatus == (short)StaticValues.ClaimNameInvolvementMaintenanceStatus.Latest)
{
INameUsage assdNameUsage = null;
ClaimHeader claimHeader = claimNameInvolvement.ClaimInvolvement.ClaimHeader;
DateTime date = DateTime.Today;
if (claimHeader.DateOfLossFrom != null)
{
date = claimHeader.DateOfLossFrom.Value;
}
assdNameUsage = transactionContext.GetNameUsage((long)newValue, claimNameInvolvement.NameUsageTypeCode, date);
// UI Label = Client-Specific Claim Data Set; For Insured
if (assdNameUsage == null || string.IsNullOrEmpty(assdNameUsage.CustomCode01))
{
return null;
}
AddandRemoveClientSpecficCodes(assdNameUsage, claimHeader);
}
}
this.UpdateNameInvolvementField(pluginHelper, propertyName, oldValue, newValue, transactionContext);
return pluginHelper.ProcessResults;
}
public override ProcessResultsCollection PropertyChange(IBusinessComponent component, ProcessInvocationPoint point, string propertyName, object oldValue, object newValue, int pluginId)
{
if (propertyName == ClaimDetail.PolicyCoverageIDFieldName && newValue != null)
{
this.UpdateEDData(component as ClaimDetail, (long)newValue);
}
return null;
}
/// <summary>
/// Processes the component on the Virtual invocation point.
/// </summary>
/// <param name="component">The component.</param>
/// <param name="point">The point.</param>
/// <param name="pluginId">The plugin identifier.</param>
/// <returns>Process Results Collection</returns>
public override ProcessResultsCollection ProcessComponent(IBusinessComponent component, ProcessInvocationPoint point, int pluginId)
{
PluginHelper<ClaimHeader> pluginHelper = new PluginHelper<ClaimHeader>(point, (ClaimHeader)component, new ProcessResultsCollection());
if (point == ProcessInvocationPoint.Virtual)
{
this.LoadReasonCodes(pluginHelper);
}
return pluginHelper.ProcessResults;
}
/// <summary>
/// Retrive field for ClaimHeader Component
/// </summary>
/// <param name="component">Claim Header </param>
/// <param name="point"> Invocation point -FieldRetrieval</param>
/// <param name="field">Field Name </param>
/// <param name="pluginId">Plug In ID</param>
/// <returns>Result Collection</returns>
public override ProcessResultsCollection FieldRetrieval(IBusinessComponent component, ProcessInvocationPoint point, ref Xiap.Framework.Metadata.Field field, int pluginId)
{
ClaimHeader claimHeader = component as ClaimHeader;
if ((field.PropertyName == ClaimHeader.DateOfLossTypeCodeFieldName || field.PropertyName == ClaimHeader.DateOfLossFromFieldName) && claimHeader.Context.TransactionType == ClaimConstants.TRANSACTION_TYPE_AMEND_CLAIM && claimHeader.PolicyHeaderID != null && claimHeader.PropertiesChanged.ContainsKey(ClaimConstants.POLICY_HEADER_ID) == false)
{
field.Readonly = true;
}
return null;
}
/// <summary>
/// Perform Validation for Coverage verifaction process for Motor Product
/// </summary>
/// <param name="component"> Claim Header</param>
/// <param name="point">Process Invocation Point Virtual </param>
/// <param name="pluginId">plugin Id</param>
/// <returns>Process Results Collection</returns>
public override ProcessResultsCollection ProcessComponent(IBusinessComponent component, ProcessInvocationPoint point, int pluginId)
{
PluginHelper<ClaimHeader> pluginHelper = new PluginHelper<ClaimHeader>(point, (ClaimHeader)component, new ProcessResultsCollection());
if (point == ProcessInvocationPoint.Virtual)
{
this.PerformPreCoverageVerificationVehicleTypeValidations(pluginHelper);
}
return pluginHelper.ProcessResults;
}
/// <summary>
/// This method assigns next transaction reference to Claim Transaction Reference (ClaimTransactionHeaderReference of ClaimTransactionHeader)
/// </summary>
/// <param name="component">Claim Transaction Header</param>
/// <param name="point">Process Invocation Point</param>
/// <param name="pluginId">plugin Id</param>
/// <returns>Process Results Collection</returns>
public override ProcessResultsCollection ProcessComponent(IBusinessComponent component, ProcessInvocationPoint point, int pluginId)
{
PluginHelper<ClaimTransactionHeader> pluginHelper = new PluginHelper<ClaimTransactionHeader>(point, (ClaimTransactionHeader)component, new ProcessResultsCollection());
ProcessResultsCollection processResults = new ProcessResultsCollection();
if (point == ProcessInvocationPoint.Virtual)
{
ClaimTransactionHeaderReferenceDefaulting(pluginHelper);
}
return processResults;
}
/// <summary>
/// Call in ClaimDetailToClaimInvolvementLinkPlugin basically it set ClaimDetail title.
/// </summary>
/// <param name="component">ClaimDetail To ClaimInvolvementLink</param>
/// <param name="point">Point Create,Deletes</param>
/// <param name="pluginId">PlugIN ID</param>
/// <returns>return ProcessResultCollection which have Error msg If any validation failed.</returns>
public override ProcessResultsCollection ProcessComponent(IBusinessComponent component, ProcessInvocationPoint point, int pluginId)
{
PluginHelper<ClaimDetailToClaimInvolvementLink> pluginHelper = new PluginHelper<ClaimDetailToClaimInvolvementLink>(point, component as ClaimDetailToClaimInvolvementLink, new ProcessResultsCollection());
switch (point)
{
case ProcessInvocationPoint.Created:
case ProcessInvocationPoint.Delete:
ClaimsBusinessLogicHelper.SetClaimDetailTitle(pluginHelper.Component as ClaimDetailToClaimInvolvementLink, point);
break;
}
return pluginHelper.ProcessResults;
}
/// <summary>
/// Cal on ClaimLitigation
/// </summary>
/// <param name="component">Claim Litigation</param>
/// <param name="point">Pre Create Validation</param>
/// <param name="pluginId">Plug In ID</param>
/// <returns>return ProcessResultCollection which have Error msg If any validation failed.</returns>
public override ProcessResultsCollection ProcessComponent(IBusinessComponent component, ProcessInvocationPoint point, int pluginId)
{
ClaimLitigation claimLitigation = (ClaimLitigation)component;
PluginHelper<ClaimLitigation> pluginHelper = new PluginHelper<ClaimLitigation>(point, claimLitigation, new ProcessResultsCollection());
switch (point)
{
case ProcessInvocationPoint.PreCreateValidation:
this.ValidateClaimHeaderStatus(pluginHelper);
break;
}
return pluginHelper.ProcessResults;
}
/// <summary>
/// Call on claimheaderstatus change
/// </summary>
/// <param name="component">Claim Header</param>
/// <param name="point">Point Validation</param>
/// <param name="pluginId">PlugIN ID</param>
/// <returns>return ProcessResultCollection which have Error msg If any validation failed.</returns>
public override ProcessResultsCollection ProcessComponent(IBusinessComponent component, ProcessInvocationPoint point, int pluginId)
{
PluginHelper<ClaimHeader> pluginHelper = new PluginHelper<ClaimHeader>(point, (ClaimHeader)component, new ProcessResultsCollection());
switch (point)
{
case ProcessInvocationPoint.Validation:
this.ValidateClaimHeaderStatus(pluginHelper);
this.NotifierValidation(pluginHelper);
break;
}
return pluginHelper.ProcessResults;
}
private void UpdateCustomProperties(IBusinessComponent component, BusinessData dataClass)
{
ArgumentCheck.ArgumentNullCheck(component, "component");
ArgumentCheck.ArgumentNullCheck(dataClass, "dataClass");
ClaimDetail claimDetail = component as ClaimDetail;
ClaimHeader claimHeader = claimDetail.ClaimHeader as ClaimHeader;
if (claimHeader.GetProduct().Product.Code == ClaimConstants.PRODUCT_MOTORCLAIM)
{
//// Registration number is only available in MOTOR Claim product.
this.AssignClaimantRegistrationNumber(claimHeader, claimDetail, dataClass);
}
this.AssignClaimantDetails(claimHeader, claimDetail, dataClass);
}
/// <summary>
/// Invocation point of plugin
/// </summary>
/// <param name="component">Claim Detail component</param>
/// <param name="point"> Invocation point Virtual</param>
/// <param name="pluginId">Plugin Id </param>
/// <returns>Result collection</returns>
public override ProcessResultsCollection ProcessComponent(IBusinessComponent component, ProcessInvocationPoint point, int pluginId)
{
PluginHelper<ClaimDetail> pluginHelper = new PluginHelper<ClaimDetail>(point, component as ClaimDetail, new ProcessResultsCollection());
switch (point)
{
case ProcessInvocationPoint.Virtual:
ClaimDetail cd = pluginHelper.Component as ClaimDetail;
this.CreateReviewEvent(cd);
break;
}
return pluginHelper.ProcessResults;
}
/// <summary>
/// This will validate whether VehicleType and Class3Code of section detail of selected coverage are equal.
/// </summary>
/// <param name="component">Claim Header</param>
/// <param name="point">Process Invocation Point</param>
/// <param name="pluginId">plugin Id</param>
/// <param name="processParameters">Process Parameters</param>
/// <returns>ProcessResults Collection</returns>
public override ProcessResultsCollection ProcessComponent(IBusinessComponent component, ProcessInvocationPoint point, int pluginId, ProcessParameters processParameters)
{
PluginHelper<ClaimHeader> pluginHelper = new PluginHelper<ClaimHeader>(point, component as ClaimHeader, new ProcessResultsCollection());
switch (point)
{
case ProcessInvocationPoint.Virtual:
this.AreVehicleTypeAndGeniusVehicleCategoryEqual(pluginHelper, processParameters.Parameters[3].ToString(), processParameters.Parameters[4].ToString());
break;
}
return pluginHelper.ProcessResults;
}
public override ProcessResultsCollection ProcessComponent(IBusinessComponent component, ProcessInvocationPoint point, int pluginId)
{
PluginHelper<ClaimDocument> pluginHelper = new PluginHelper<ClaimDocument>(point, component as ClaimDocument, new ProcessResultsCollection());
switch (point)
{
case ProcessInvocationPoint.PreValidationDefaulting:
this.UpdateDocumentData(component);
this.SetDefaultValues(component);
break;
}
return pluginHelper.ProcessResults;
}
/// <summary>
/// Call on ClaimDetail Component
/// </summary>
/// <param name="component">Claim Detail</param>
/// <param name="point">PreCreate Validation</param>
/// <param name="pluginId">PlugIn ID</param>
/// <returns>return ProcessResultCollection which have Error msg If any validation failed.</returns>
public override ProcessResultsCollection ProcessComponent(IBusinessComponent component, ProcessInvocationPoint point, int pluginId)
{
PluginHelper<ClaimDetail> pluginHelper = new PluginHelper<ClaimDetail>(point, component as ClaimDetail, new ProcessResultsCollection());
switch (point)
{
// Make sure we only bother to get E&D from the policy once, by checking for existing, similar claim details.
case ProcessInvocationPoint.PreCreateValidation:
this.PreCreateValidate(pluginHelper);
break;
}
return pluginHelper.ProcessResults;
}
/// <summary>
/// Sets the Claim Transaction Description field on the Claim Transaction Header
/// based on whether a payment or reserve is being created.
/// </summary>
/// <param name="component">Component of Business Type</param>
/// <param name="point">Process Invocation Point</param>
/// <param name="pluginId">unique plugin id</param>
/// <returns>collection of process results</returns>
public override ProcessResultsCollection ProcessComponent(IBusinessComponent component, ProcessInvocationPoint point, int pluginId)
{
PluginHelper<ClaimTransactionHeader> pluginHelper = new PluginHelper<ClaimTransactionHeader>(point, (ClaimTransactionHeader)component, new ProcessResultsCollection());
switch (pluginHelper.InvocationPoint)
{
case ProcessInvocationPoint.Created:
{
this.OnCreate(pluginHelper);
break;
}
}
return pluginHelper.ProcessResults;
}
/// <summary>
/// Processes the component in the Virtual Invocation Point
/// </summary>
/// <param name="component">The component.</param>
/// <param name="point">The point.</param>
/// <param name="pluginId">The plugin identifier.</param>
/// <returns>Process Results Collection</returns>
public override ProcessResultsCollection ProcessComponent(IBusinessComponent component, ProcessInvocationPoint point, int pluginId)
{
ProcessResultsCollection results = new ProcessResultsCollection();
Header header = (Header)component;
if (point == ProcessInvocationPoint.Virtual)
{
if (this.ValidateXiapHeader(header, results).Count == 0)
{
// Count is 0, i.e. no errors added to the ProcessResultsCollection 'results' in the Validation the GeniusX policy, so update
this.UpdateFromGenius(header, results);
}
}
return results;
}
public override ProcessResultsCollection ProcessComponent(IBusinessComponent component, ProcessInvocationPoint point, int pluginId)
{
// Update header to verified when automatically creating a policy from coverage verification
ProcessResultsCollection results = new ProcessResultsCollection();
if (point == ProcessInvocationPoint.Virtual)
{
Header header = (Header)component;
if (header.GetProduct().Product.ExternalDataSource != null)
{
var verifiedHeaderStatus = UWBusinessLogicHelper.ResolveMandatoryConfig<string>("PolicyVerifiedHeaderStatus");
header.HeaderStatusCode = verifiedHeaderStatus;
}
}
return results;
}
/// <summary>
/// Call on ClaimHeader
/// </summary>
/// <param name="component">Claim Header</param>
/// <param name="point">Points Create,ComponentChange</param>
/// <param name="pluginId">PlugIN ID</param>
/// <returns>return ProcessResultCollection which have Error msg If any validation failed.</returns>
public override ProcessResultsCollection ProcessComponent(IBusinessComponent component, ProcessInvocationPoint point, int pluginId)
{
PluginHelper<IBusinessComponent> pluginHelper = new PluginHelper<IBusinessComponent>(point, (ClaimHeader)component, new ProcessResultsCollection());
switch (pluginHelper.InvocationPoint)
{
case ProcessInvocationPoint.Created:
this.SetCreatedBy(pluginHelper.Component as ClaimHeader);
break;
case ProcessInvocationPoint.ComponentChange:
this.AddDeductibleExcessEvent(pluginHelper.Component as ClaimHeader);
break;
}
return pluginHelper.ProcessResults;
}
public override ProcessResultsCollection ProcessComponent(IBusinessComponent component, ProcessInvocationPoint point, int pluginId)
{
// Plugin is configured to run after core HeaderReferenceDefaulter
ProcessResultsCollection results = new ProcessResultsCollection();
Header header = (Header)component;
if (point == ProcessInvocationPoint.Created)
{
if (!string.IsNullOrEmpty(header.GetProduct().Product.ExternalDataSource))
{
// Reset to blank, header ref will be entered manually
header.HeaderReference = string.Empty;
}
}
return results;
}
/// <summary>
///
/// </summary>
/// <param name="businessComponent"></param>
public ProductsController(IBusinessComponent <Product> businessComponent)
{
this.businessComponent = businessComponent;
}
public CreditServiceController(BusinessComponent businessComponent)
{
_businessComponent = businessComponent;
}
