/// <summary>
/// Validates the policy data items.
/// </summary>
/// <param name="header">The header.</param>
/// <returns>Process Results Collection</returns>
private ProcessResultsCollection ValidatePolicyDataItems(Header header)
{
var processResultsCollection = new ProcessResultsCollection();
// Get the latest version of the UW Header
var headerVersion = (HeaderVersion)header.GetLatestVersion();
// Validate the Generic Data Items
this.ValidateGenericDataItems(processResultsCollection, headerVersion, this.ExtractGenericDataItems(headerVersion), headerVersion);
var sectionDetails = from s in header.Sections
from sd in s.SectionDetails
select sd;
// Cycle through all Section Details on the Header
foreach (var sectionDetail in sectionDetails)
{
// Get the latest version
var sectionDetailVersion = (SectionDetailVersion)sectionDetail.GetLatestVersion();
// Validate all the generic data items are correct on this Section detail.
this.ValidateGenericDataItems(processResultsCollection, sectionDetailVersion, this.ExtractGenericDataItems(sectionDetailVersion), headerVersion);
// Cycle through all the coverages on this Section Detail
foreach (var coverage in sectionDetail.Coverages)
{
// Get latest version and validate the Generic data items
var coverageVersion = (CoverageVersion)coverage.GetLatestVersion();
this.ValidateGenericDataItems(processResultsCollection, coverageVersion, this.ExtractGenericDataItems(coverageVersion), headerVersion);
}
}
return processResultsCollection;
}
/// <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;
}
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;
}
public void AreVehicleTypeAndGeniusVehicleCategory_Mismatch_True()
{
string[] list = new string[5] { "T1", StaticValues.PolicyLinkLevel.Coverage.ToString(), "DummyCode", "InvalidCode", "ExternalCovRef" };
this.claimHeader.ClaimHeaderAnalysisCode09 = "ValidCode";
this.target = new PolicyAttachmentAndVehicleTypeValidationPlugin();
this.processResultsCollection = this.target.ProcessComponent(this.claimHeader, Xiap.Framework.ProcessInvocationPoint.Virtual, 0, new ProcessParameters { Parameters = list });
Assert.AreEqual(this.processResultsCollection.Count, 1);
AssertEx.ContainsMessage(this.processResultsCollection, ClaimConstants.VEHICLE_TYPE_AND_GENIUS_VEHICLE_TYPE_MISMATCH);
}
/// <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;
}
public void ValidateMigrationStatus_MigrationStatusIsNull_ClaimReopenNotAllowed()
{
string[] parameters = { this.claimHeader.ClaimHeaderID.ToString() };
Xiap.Testing.Utils.Mocks.MockBusinessTransaction mockBT = new Xiap.Testing.Utils.Mocks.MockBusinessTransaction("ReopenClaim", parameters, "Claims", new ClaimsTransactionContext(Guid.NewGuid().ToString(), "Claims", "ReopenClaim"));
this.claimHeader.ClaimHeaderID = 1;
this.claimHeader.CustomCode18 = null;
this.claimHeader.CustomCode19 = "C";
mockBT.Component = this.claimHeader;
ReopenClaimTransactionPlugin transaction = new ReopenClaimTransactionPlugin();
this.results = transaction.ProcessTransaction(mockBT, TransactionInvocationPoint.PreCreate, 1, parameters);
Assert.AreEqual(1, this.results.Count);
Assert.AreEqual("REOPENING_OF_UNPROCESSED_CLAIM_NOT_ALLOWED", this.results.Results.First().MessageId);
}
public void ClaimReopenNotAllowedErrorTest()
{
string[] parameters = { this.claimHeader.ClaimHeaderID.ToString() };
Xiap.Testing.Utils.Mocks.MockBusinessTransaction mockBT = new Xiap.Testing.Utils.Mocks.MockBusinessTransaction("ReopenClaim", parameters, "Claims", new ClaimsTransactionContext(Guid.NewGuid().ToString(), "Claims", "ReopenClaim"));
this.claimHeader.ClaimHeaderID = 1;
this.claimHeader.CustomCode18 = "F01"; // ClaimWakeUp Validation error check
this.claimHeader.CustomCode19 = "C";
mockBT.Component = this.claimHeader;
ReopenClaimTransactionPlugin transaction = new ReopenClaimTransactionPlugin();
this.results = transaction.ProcessTransaction(mockBT, TransactionInvocationPoint.PreCreate, 1, parameters);
Assert.AreEqual(1, this.results.Count);
Assert.AreEqual(ClaimConstants.REOPENING_OF_CLAIM_NOT_ALLOWED_WITHOUT_POLICY, this.results.Results.First().MessageId);
}
/// <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)
{
// 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;
}
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>
/// Updates the header from genius.
/// </summary>
/// <param name="xiapHeader">The xiap header.</param>
/// <param name="results">The results.</param>
/// <exception cref="System.ServiceModel.FaultException">new FaultCode(Sender)</exception>
/// <exception cref="FaultReason"></exception>
/// <exception cref="FaultCode">Sender</exception>
private void UpdateFromGenius(Header xiapHeader, ProcessResultsCollection results)
{
try
{
IUWHeader externalHeader = null;
IPolicyService riskService = null;
// Create an external policy service to the external service linked on the Header product.
// This external service will be Genius.
riskService = new PolicyService(xiapHeader.GetProduct().Product.ExternalDataSource);
externalHeader = riskService.GetPolicy(xiapHeader.HeaderReference);
if (this.ValidateExternalHeader(xiapHeader, externalHeader, results).Count == 0)
{
// Count is 0, i.e. no errors added to the ProcessResultsCollection 'results' in the Validation of External Header
this.UpdateHeader(xiapHeader, externalHeader);
// Apply the external policy terms to the GeniusX policy.
foreach (IUWTerms externalTerm in externalHeader.ITerms)
{
this.ProcessTerms(xiapHeader, externalTerm);
}
// Order the external policy sections by the External Reference, which will be a Genius Reference,
// thus the sections will be ordered as they are in the Genius policy.
// Then apply each to the GeniusX policy in turn.
var sections = externalHeader.ISections.OrderBy(x => x.ExternalReference);
foreach (IUWSection externalSection in sections)
{
this.ProcessSection(xiapHeader, externalSection);
}
// Finally, update NameInvolvements from the external Genius policy
this.UpdateNameInvolvement(xiapHeader, externalHeader);
}
}
catch (Exception e)
{
if (_logger.IsErrorEnabled)
{
_logger.Error(e);
}
throw new FaultException(new FaultReason(e.Message), new FaultCode("Sender"));
}
}
public void TestInitialize()
{
this.container = new UnityContainer();
this.container.RegisterType<IMessageService, MessageService>();
this.componentMetadata = MockRepository.GenerateStub<IComponentMetadata>();
this.container.RegisterInstance<IXiapCache>(MockRepository.GenerateStub<IXiapCache>());
this.container.RegisterInstance<IComponentMetadata>(this.componentMetadata);
var metadataMock = MockRepository.GenerateStub<IMetadataQuery>();
container.RegisterInstance<IMetadataQuery>(metadataMock);
List<ValueSetCacheName> codes = new List<ValueSetCacheName>();
codes.Add(new ValueSetCacheName() { Code = "DummyCode", LanguageID = 1, LongDescription = "Description", ShortDescription = "Description" });
IQueryable<ValueSetCacheName> codeNames = codes.AsQueryable<ValueSetCacheName>();
metadataMock.Stub(md => md.QueryValueSetNames(Arg<SystemValueSetCodeEnum>.Is.Anything, Arg<int>.Is.Equal(1))).Return(codeNames);
BusinessComponentKey key = new BusinessComponentKey("TEST");
key.Add(new BusinessComponentKeyMember("TEST", "1"));
this.componentMetadata.Stub(a => a.FieldExists("ClaimHeaderAnalysisCode02")).Return(true);
this.componentMetadata.Stub(a => a.GetField("ClaimHeaderAnalysisCode02")).Return(new Field() { Title = "ClaimHeaderAnalysisCode02", LookupDefinitionKey = key, LookupParameters = new LookupParameters { Code = "TEST" } });
this.decisionTableHelper = MockRepository.GenerateStub<IDecisionTableHelper>();
this.container.RegisterInstance<IDecisionTableHelper>(this.decisionTableHelper);
this.decisionTableComponent = new DecisionTableComponent { Context = new TransactionContext(string.Empty, string.Empty, string.Empty) };
this.decisionTableHelper.Stub(s => s.Call(Arg<string>.Is.Anything, Arg<DateTime>.Is.Anything, Arg<object[]>.Is.Anything)).Return(this.decisionTableComponent);
this.claimHeader = new ClaimHeader();
ILookupDefinitionCache lookupDefinitionCache = MockRepository.GenerateStub<ILookupDefinitionCache>();
ILookupDefinition lookupDefinition = MockRepository.GenerateStub<ILookupDefinition>();
lookupDefinitionCache.Stub(a => a.GetLookupDefinition(string.Empty, 0)).IgnoreArguments().Return(lookupDefinition);
this.container.RegisterInstance<ILookupDefinitionCache>(lookupDefinitionCache);
lookupDefinition.Stub(a => a.RetrieveValues(Arg<LookupParameters>.Is.Anything,
Arg<short>.Is.Equal((short)1),
Arg<int>.Is.Anything,
Arg<int?>.Is.Anything,
Arg<LookupOptions>.Is.Equal(LookupOptions.None),
out Arg<int>.Out(new int()).Dummy)).Return((new CodeRow[] { new CodeRow() { Code = "ClaimHeaderAnalysisCode02", Description = "ClaimHeaderAnalysisCode02", LanguageId = 1 } }));
this.container.RegisterInstance<ILookupDefinition>(lookupDefinition);
this.mockIUnderwritingService = MockRepository.GenerateStub<IUnderwritingService>();
container.RegisterInstance<IUnderwritingService>(this.mockIUnderwritingService);
ObjectFactory.Instance = new ObjectFactory(this.container);
this.processResultsCollection = new ProcessResultsCollection();
}
/// <summary>
/// Defaults the name refrence.
/// </summary>
/// <param name="results">The results.</param>
/// <param name="component">The component.</param>
/// <param name="point">The point.</param>
/// <param name="name">The name.</param>
private void DefaultNameRefrence(ProcessResultsCollection results, IBusinessComponent component, ProcessInvocationPoint point, Name name)
{
if (name != null)
{
// We have a valid name
if (String.IsNullOrEmpty(name.NameReference))
{
// The NameReference is not yet set so first get a Name Code defaulted
// this should default the name reference.
this.DefaultNameCode(name);
// Check the namereference is now set. If not, raise an error to say we couldn't lock the Name Reference and this is why it wasn't updated.
if (!String.IsNullOrEmpty(name.NameReference))
{
if (!LockManager.UpdateReferenceLocks(component.Context.TransactionId, name.NameReference, LockLevel.NameReference, LockType.Update, LockDurationType.Transaction, LockOrigin.InsuranceDirectory, string.Empty))
{
InsuranceDirectoryHelper.SetProcessResult(results, component, ProcessInvocationPoint.Instantiation, "CREATE_LOCK_FAILED");
}
}
}
}
}
/// <summary>
/// Validates the person has a title and then uses this in the list name creation.
/// Otherwise, list name is just a concatenation of forename and surname.
/// </summary>
/// <param name="results">The results.</param>
/// <param name="personDetailVersion">The person detail version.</param>
/// <param name="point">The point.</param>
public void PersonValidation(ProcessResultsCollection results, PersonDetailVersion personDetailVersion, ProcessInvocationPoint point)
{
string title = string.Empty;
if (!string.IsNullOrEmpty(personDetailVersion.TitleCode))
{
// Default the title as a string from the selected Title code on the Person detail
title = FieldsHelper.GetCodeDescription(personDetailVersion.TitleCodeField, personDetailVersion.TitleCode);
}
if (!string.IsNullOrWhiteSpace(title))
{
// We have a title, so format the list name to include the title at the start.
string listName = String.Format("{0} {1}", title, personDetailVersion.Forename).Trim();
personDetailVersion.ListName = String.Format("{0} {1}", listName, personDetailVersion.Surname).Trim();
}
else
{
// Otherwise, the list name is just forename surname.
personDetailVersion.ListName = String.Format("{0} {1}", personDetailVersion.Forename, personDetailVersion.Surname).Trim();
}
}
public override ProcessResultsCollection ProcessComponent(IBusinessComponent component, ProcessInvocationPoint point, int pluginId)
{
ProcessResultsCollection processResults = new ProcessResultsCollection();
if (point == ProcessInvocationPoint.Created)
{
bool isClaimDetailDefaulted = false;
ClaimDetail claimDetail = (ClaimDetail)component;
bool isUniqueClaimDetail = false;
// default the Claim Detail Reference with AllocateClaimDetailReference
claimDetail.ClaimDetailReference = this.AllocateClaimDetailReference(claimDetail, claimDetail.GetProduct(), ref isClaimDetailDefaulted);
// Validate that the ClaimDetailRef is unique for this ClaimDetailID
isUniqueClaimDetail = ClaimDetailReferenceDefaulterPlugin.IsUniqueClaimDetailReference(claimDetail, point, isClaimDetailDefaulted);
if (!isUniqueClaimDetail)
{
processResults = ClaimsBusinessLogicHelper.AddError(processResults, MessageConstants.ClaimDetailRefNotUnique, point, component);
}
}
return processResults;
}
public void IsExternalPolicyChild_ComponentExists_False()
{
this.mockIUnderwritingService.Stub(a => a.GetCoverageIDByExternalReference(Arg<string>.Is.Anything)).Return(0);
this.decisionTableComponent.IsValid = true;
this.target = new PolicyAttachmentAndTypeOfLossValidationPlugin();
this.processResultsCollection = this.target.ProcessComponent(this.claimHeader, Xiap.Framework.ProcessInvocationPoint.Virtual, 0, new ProcessParameters { Parameters = this.list });
Assert.AreEqual(this.processResultsCollection.Count, 1);
AssertEx.ContainsMessage(this.processResultsCollection, ClaimConstants.POLICY_ATTACHMENT_NOT_ALLOWED);
}
public void ValidateTypeOfLossAndCoverageTypeCombination_Mismatch_True()
{
this.mockIUnderwritingService.Stub(a => a.GetCoverageIDByExternalReference(Arg<string>.Is.Anything)).Return(1);
this.claimHeader.ClaimHeaderAnalysisCode02 = "ClaimHeaderAnalysisCode02";
this.decisionTableComponent.IsValid = false;
this.target = new PolicyAttachmentAndTypeOfLossValidationPlugin();
this.processResultsCollection = this.target.ProcessComponent(this.claimHeader, Xiap.Framework.ProcessInvocationPoint.Virtual, 0, new ProcessParameters { Parameters = this.list });
Assert.AreEqual(this.processResultsCollection.Count, 1);
AssertEx.ContainsMessage(this.processResultsCollection, ClaimConstants.TYPE_OF_LOSS_AND_COVERAGE_TYPE_MISMATCH);
}
/// <summary>
/// Validates GeniusX policy can be updated from Genius.
/// </summary>
/// <param name="header">The header.</param>
/// <param name="results">The results.</param>
/// <returns>Process Results Collection</returns>
private ProcessResultsCollection ValidateXiapHeader(Header header, ProcessResultsCollection results)
{
// If status is verified, creation of components from Genius not allowed
if (header.HeaderStatusThreshold >= 30)
{
UWBusinessLogicHelper.AddError(results, UwMessageConstants.HEADERSTATUS_VERIFIED_GENIUSUPDATE_NOTALLOWED, ProcessInvocationPoint.Virtual, header);
}
// We can't collect from Genius if we haven't defined the product as actually using an external source (which should be Genius).
if (header.GetProduct().Product.ExternalDataSource == null)
{
UWBusinessLogicHelper.AddError(results, UwMessageConstants.EXTERNALDATASOURCE_REQUIRED, ProcessInvocationPoint.Virtual, header);
}
// Note that core validation already checks duplicate XIAP header references, so shouldn't have to re-check
return results;
}
public void ValidateTypeOfLossAndCoverageTypeCombination_Mismatch_False()
{
this.mockIUnderwritingService.Stub(a => a.GetCoverageIDByExternalReference(Arg<string>.Is.Anything)).Return(1);
this.decisionTableComponent.IsValid = true;
this.target = new PolicyAttachmentAndTypeOfLossValidationPlugin();
this.processResultsCollection = this.target.ProcessComponent(this.claimHeader, Xiap.Framework.ProcessInvocationPoint.Virtual, 0, new ProcessParameters { Parameters = this.list });
Assert.AreEqual(this.processResultsCollection.Count, 0);
}
/// <summary>
/// Setting values when component create, copy and when component changes.
/// </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)
{
ProcessResultsCollection processResults = new ProcessResultsCollection();
if (point == ProcessInvocationPoint.Created || point == ProcessInvocationPoint.Copy || point == ProcessInvocationPoint.ComponentChange)
{
try
{
bool IsClaimHeaderDefaulted = false;
ClaimHeader claimHeader = (ClaimHeader)component;
// if Claim Reference field property gets changes.
if (point == ProcessInvocationPoint.ComponentChange && !claimHeader.PropertiesChanged.ContainsKey(ClaimHeader.ClaimReferenceFieldName))
{
return processResults;
}
Product product = claimHeader.GetProduct().GetProduct();
string createdBy = claimHeader.CustomReference05; // UI Label = Created By
if (point == ProcessInvocationPoint.Copy)
{
claimHeader = component.Context.CopyDictionary[component.DataId] as ClaimHeader;
claimHeader.CustomReference05 = createdBy; // claimHeader.CustomReference05 = Created By
product = claimHeader.GetProduct().GetProduct();
}
if (claimHeader != null)
{
if (!claimHeader.ClaimStage.HasValue)
{
claimHeader.ClaimStage = product.ClaimStage;
}
if (claimHeader.ClaimStage.GetValueOrDefault((short)StaticValues.ClaimStage.Claim) != (short)StaticValues.ClaimStage.Claim)
{
return processResults;
}
bool isUniqueClaimRef = false;
bool isLockSuccess = false;
for (int loopCounter = 0; loopCounter < 5; loopCounter++)
{
isUniqueClaimRef = false;
isLockSuccess = false;
if (string.IsNullOrEmpty(claimHeader.ClaimReference))
{
claimHeader.ClaimReference = this.AllocateClaimReference(claimHeader, product, ref IsClaimHeaderDefaulted);
}
isUniqueClaimRef = this.IsUniqueClaimReference(claimHeader, point, IsClaimHeaderDefaulted);
isLockSuccess = IsCreateLockStatus(claimHeader);
if (isUniqueClaimRef && isLockSuccess)
{
break;
}
if (!IsClaimHeaderDefaulted || isLockSuccess)
{
break;
}
claimHeader.ClaimReference = string.Empty;
}
// if Claim reference is not unique then add error.
if (!isUniqueClaimRef)
{
ClaimsBusinessLogicHelper.AddError(processResults, MessageConstants.CLAIM_REFERENCE_EXIST, point, component);
}
if (isUniqueClaimRef && !isLockSuccess)
{
ClaimsBusinessLogicHelper.AddError(processResults, MessageConstants.ERROR_IN_LOCKING, point, claimHeader);
}
}
}
catch (Exception e)
{
this._Logger.Error(e);
this._Logger.Info(e.StackTrace);
}
}
return processResults;
}
/// <summary>
/// Validates the external Genius Policy can be used to refresh the GeniusX policy.
/// </summary>
/// <param name="xiapheader">The xiapheader.</param>
/// <param name="externalheader">The externalheader.</param>
/// <param name="results">The results.</param>
/// <returns>Process Results Collection</returns>
private ProcessResultsCollection ValidateExternalHeader(Header xiapheader, IUWHeader externalheader, ProcessResultsCollection results)
{
// Genius policy not found
if (externalheader == null)
{
UWBusinessLogicHelper.AddError(results, MessageConstants.INVALID_POLICY_REFERENCE, ProcessInvocationPoint.Virtual, xiapheader);
}
else
{
// Genius policy product must match XIAP product
if (externalheader.ProductCode != xiapheader.GetProduct().Product.Code)
{
UWBusinessLogicHelper.AddError(results, UwMessageConstants.GENIUS_PRODUCT_DOES_NOT_MATCH, ProcessInvocationPoint.Virtual, xiapheader);
}
}
return results;
}
/// <summary>
/// Validate the Deductible Sequence
/// </summary>
/// <param name="processResults">The process results.</param>
/// <param name="sourceComponent">The source component.</param>
/// <param name="genericDataItems">The generic data items.</param>
/// <param name="headerVersion">The header version.</param>
private void DeductibleSequenceValidation(ProcessResultsCollection processResults, IBusinessComponent sourceComponent, IEnumerable<IGenericDataItem> genericDataItems, HeaderVersion headerVersion)
{
// Group by CustomNumeric01 - the Deductible sequence
var grouping = genericDataItems.ToLookup(a => a.CustomNumeric01);
// Deductible sequence must be different if subtypes match
foreach (var group in grouping)
{
IGenericDataItem prevGroup = null;
// Cycle through each entry in the group (of deductibles at a given sequence)
foreach (IGenericDataItem entry in group)
{
// If we've viewed a group previously, compare the subtypes and throw an error if they match
if (prevGroup != null)
{
// CustomCode01 = Division SubSection, CustomCode02 = Vehicle SubSection, CustomCode03 = DeductibleReasonSubSection
if (entry.CustomCode01 == prevGroup.CustomCode01
&& entry.CustomCode02 == prevGroup.CustomCode02
&& entry.CustomCode03 == prevGroup.CustomCode03)
{
UWBusinessLogicHelper.AddError(processResults, "DeductibleSequenceMustBeDistinct", ProcessInvocationPoint.Validation, sourceComponent);
break;
}
}
// Assign this current Item to the 'previousGroup' (previous entry in the group) field.
prevGroup = entry;
}
}
// Cycle through all Generic Data Items
foreach (IGenericDataItem genericData in genericDataItems)
{
decimal customNumeric03 = genericData.CustomNumeric03.GetValueOrDefault(0); // CustomNumeric03 is Deductible Policy Sequence number
// Check if this is Funded (CustomBoolean03) AND
// - the Deductible Type matches the Deductible Service Generic Data Type in the config
// OR
// - the Deductible Type matches the Deductible Captive Generic Data Type in the config
// AND Deductible Policy Sequence number is 0
if (genericData.CustomBoolean03.GetValueOrDefault(false) == true && (genericData.CustomCode04 == ResolveMandatoryConfig(GenericDataType_Deductible_Service) || genericData.CustomCode04 == ResolveMandatoryConfig(GenericDataType_Deductible_Captive)) && customNumeric03 == 0)
{
// Raise error that the Deductible Policy Sequence must be > 0.
string shortDescription = this.GetUWValueSetShortDescription(genericData);
UWBusinessLogicHelper.AddError(processResults, UwMessageConstants.DEDUCTIBLE_SEQUENCE_MUST_BE_GREATER_THAN_ZERO, ProcessInvocationPoint.Validation, sourceComponent, shortDescription);
}
else if (genericData.CustomCode04 == ResolveMandatoryConfig(GenericDataType_Deductible_Client) && customNumeric03 > 0)
{
// Otherwise, if this is a Client type deductible, and the DEDUCIBLE POLICY sequence is > 0, it should be zero - raise an error.
string shortDescription = this.GetUWValueSetShortDescription(genericData);
UWBusinessLogicHelper.AddError(processResults, UwMessageConstants.DEDUCTIBLE_POLICY_SEQUENCE_SHOULD_BE_ZERO, ProcessInvocationPoint.Validation, sourceComponent, shortDescription);
}
// If we have a HeaderVersion
if (headerVersion != null)
{
// Raise error if Deductible Policy Sequence == 1 and no Deductible Policy Reference on the UW Header in Custom Reference 01
// likewise for Deductible Policy Sequence a value of 2 to 5, with no custom reference02 to 05 set.
if (customNumeric03 == 1 && string.IsNullOrWhiteSpace(headerVersion.CustomReference01))
{
UWBusinessLogicHelper.AddError(processResults, UwMessageConstants.DEDUCTIBLE_POLICY_REFERENCE_SHOULD_NOT_BE_NULL, ProcessInvocationPoint.Validation, sourceComponent, headerVersion.CustomReference01Field.Title);
}
else if (customNumeric03 == 2 && string.IsNullOrWhiteSpace(headerVersion.CustomReference02))
{
UWBusinessLogicHelper.AddError(processResults, UwMessageConstants.DEDUCTIBLE_POLICY_REFERENCE_SHOULD_NOT_BE_NULL, ProcessInvocationPoint.Validation, sourceComponent, headerVersion.CustomReference02Field.Title);
}
else if (customNumeric03 == 3 && string.IsNullOrWhiteSpace(headerVersion.CustomReference03))
{
UWBusinessLogicHelper.AddError(processResults, UwMessageConstants.DEDUCTIBLE_POLICY_REFERENCE_SHOULD_NOT_BE_NULL, ProcessInvocationPoint.Validation, sourceComponent, headerVersion.CustomReference03Field.Title);
}
else if (customNumeric03 == 4 && string.IsNullOrWhiteSpace(headerVersion.CustomReference04))
{
UWBusinessLogicHelper.AddError(processResults, UwMessageConstants.DEDUCTIBLE_POLICY_REFERENCE_SHOULD_NOT_BE_NULL, ProcessInvocationPoint.Validation, sourceComponent, headerVersion.CustomReference04Field.Title);
}
else if (customNumeric03 == 5 && string.IsNullOrWhiteSpace(headerVersion.CustomReference05))
{
UWBusinessLogicHelper.AddError(processResults, UwMessageConstants.DEDUCTIBLE_POLICY_REFERENCE_SHOULD_NOT_BE_NULL, ProcessInvocationPoint.Validation, sourceComponent, headerVersion.CustomReference05Field.Title);
}
}
}
}
/// <summary>
/// Validates the collection of generic data items that is passed in.
/// </summary>
/// <param name="processResults">The process results.</param>
/// <param name="sourceComponent">The source component.</param>
/// <param name="genericDataItems">The generic data items.</param>
private void CommonGenericDataItemsValidation(ProcessResultsCollection processResults, IBusinessComponent sourceComponent, IEnumerable<IGenericDataItem> genericDataItems)
{
var genericDataItemCount = genericDataItems.Count();
// Return if there are no items in the collection
if (genericDataItemCount == 0)
{
return;
}
// CustomCode01 = Division SubSection, CustomCode02 = Vehicle SubSection, CustomCode03 = DeductibleReasonSubSection
bool isNotSubSection = genericDataItems.Any(a => a.CustomCode01 == null && a.CustomCode02 == null && a.CustomCode03 == null);
bool isDivisionSubSection = genericDataItems.Any(a => a.CustomCode01 != null);
bool isVehicleSubSection = genericDataItems.Any(a => a.CustomCode02 != null);
bool isDeductibleReasonSubSection = genericDataItems.Any(a => a.CustomCode03 != null);
var currentlyActiveSubSections = new[] { isDivisionSubSection, isVehicleSubSection, isDeductibleReasonSubSection }.Count(a => a);
// should only have one or fewer active sub sections AND not mix sub section and top level
if (genericDataItemCount > 1 && (currentlyActiveSubSections > 1 || (currentlyActiveSubSections > 0 && isNotSubSection)))
{
UWBusinessLogicHelper.AddError(processResults, "DataItemsRepresentMultipleSubSections", ProcessInvocationPoint.Validation, sourceComponent);
}
}
/// <summary>
/// Validates the generic data items and puts data into the ProcessResultsCollection.
/// All objects are passed by reference so the ProcessResults collection will return the results
/// </summary>
/// <param name="processResults">The process results.</param>
/// <param name="sourceComponent">The source component.</param>
/// <param name="genericDataItems">The generic data items.</param>
/// <param name="header">The header.</param>
private void ValidateGenericDataItems(ProcessResultsCollection processResults, IBusinessComponent sourceComponent, IEnumerable<IGenericDataItem> genericDataItems, HeaderVersion header)
{
// Get excess type Data Items then validate
var excessDataItems = genericDataItems.Where(a => a.GenericDataTypeCode == ResolveMandatoryConfig("GenericDataType.Excess"));
this.CommonGenericDataItemsValidation(processResults, sourceComponent, excessDataItems);
// Get deductible data items, then validate
var deductibleDataItems = genericDataItems.Where(a => a.GenericDataTypeCode == ResolveMandatoryConfig("GenericDataType.Deductible"));
this.CommonGenericDataItemsValidation(processResults, sourceComponent, deductibleDataItems);
// Validate deductible sequence
this.DeductibleSequenceValidation(processResults, sourceComponent, deductibleDataItems, header);
}