/// <summary>
/// Add new event on ClaimHeader if there are ClaimInvolvements on an Amend Claim or Change Claim Handler
/// where the claim handler has been modified.
/// </summary>
/// <param name="claimHeader">Claim Header</param>
private void GenerateEvent(ClaimHeader claimHeader)
{
if (claimHeader.ClaimInvolvements == null)
{
return;
}
string transactionType = claimHeader.Context.TransactionType;
if (transactionType != ClaimConstants.TRANSACTION_TYPE_AMEND_CLAIM && transactionType != ClaimConstants.TRANSACTION_TYPE_CHANGE_CLAIM_HANDLER)
{
return;
}
// Has the Claim Handler been changed.
if (claimHeader.ClaimInvolvements.Any(a => this.IsMainClaimHandlerModified(a)))
{
var productEvents = ProductService.GetProductEventQuery().GetProductEvents(claimHeader.ProductVersionID.GetValueOrDefault());
// If this product has an event of the system update type defined, raise it against the claim handler, to show it's been updated.
if (productEvents.Any(x => x.EventTypeCode == ClaimConstants.SYSUPD_Event_Type))
{
var productEvent = productEvents.Where(x => x.EventTypeCode == ClaimConstants.SYSUPD_Event_Type).First();
ClaimEvent claimEvent = claimHeader.AddNewClaimEvent(productEvent.ProductEventID, true);
claimEvent.EventDescription = ClaimConstants.CLAIM_HANDLER_CHANGED;
}
}
}
/// <summary>
/// Returns the value of 'Your Reference', that will contain the concatenated references from each recipient..
/// </summary>
/// <param name="document">The document.</param>
/// <param name="claimHeader">The claim header.</param>
/// <returns>Your Reference. Note, returns NULL if there are no recipients for this document.</returns>
private string GetYourReference(ClaimDocument document, ClaimHeader claimHeader)
{
// Set your Reference
string yourReference = null;
if (document.DocumentRecipients != null)
{
List<IDocumentRecipient> docuemntRecipients = document.DocumentRecipients.Where(r => r.RecipientType == (short)StaticValues.RecipientType.To || r.RecipientType == (short)StaticValues.RecipientType.Cc).ToList<IDocumentRecipient>();
// If we have one recipient then 'Your Reference' is only Custom Reference 01 from the Document Recipient Name Involvement.
// Otherwise, we cycle through each recipient and prefix their reference with their name, putting a new line before each.
if (docuemntRecipients.Count > 1)
{
foreach (ClaimDocumentRecipient dr in docuemntRecipients)
{
ClaimNameInvolvement ni = (ClaimNameInvolvement)claimHeader.NameInvolvements.Where(a => a.DataId == dr.DocumentRecipientNameInvolvementID).FirstOrDefault();
if (ni != null)
{
yourReference = yourReference + System.Environment.NewLine + dr.RecipientName + " " + "Reference: " + ni.CustomReference01; // UI Label = Reference; Reference common to all named involvements
}
}
}
else if (docuemntRecipients.Count == 1)
{
ClaimDocumentRecipient dr = docuemntRecipients.First() as ClaimDocumentRecipient;
ClaimNameInvolvement ni = (ClaimNameInvolvement)claimHeader.NameInvolvements.Where(a => a.DataId == dr.DocumentRecipientNameInvolvementID).FirstOrDefault();
if (ni != null)
{
yourReference = ni.CustomReference01; // UI Label = Reference; Reference common to all named involvements
}
}
}
return yourReference;
}
private static void CreateNameTransferRequests(ClaimHeader claimHeader)
{
var idService = GlobalClaimWakeUp.Container.Resolve<IInsuranceDirectoryService>();
foreach (var nameInvolvement in GetTransientNames(claimHeader))
{
try
{
// NameInvolvement can only be CLAIMANT, DRIVER, WITNESS otherwise it should have been setup in Genius already
var nameData = idService.GetName(nameInvolvement.NameID.GetValueOrDefault(-1));
if (GlobalClaimWakeUp.NameReferences.Contains(nameData.NameReference))
{
Logger.DebugFormat("NAME already set to transfer\r\n{0}\r\n", JObject.FromObject(new { claimHeader.ClaimReference, nameData.NameReference }));
continue;
}
GlobalClaimWakeUp.NameReferences.Add(nameData.NameReference);
NameTransfer.AddControlLogRequest(nameData.NameReference, GlobalClaimWakeUp.ActingUserId.Value);
Logger.InfoFormat("NAME transfer created for\r\n{0}\r\n", JObject.FromObject(new { claimHeader.ClaimReference, nameData.NameReference }));
}
catch (Exception ex)
{
Logger.ErrorFormat(
"Exception thrown while transfering NAME\r\n{0}\r\n",
JObject.FromObject(new { claimHeader.ClaimReference, nameInvolvement.Name.NameReference, ex.Message, ex.StackTrace }));
}
}
}
// ClaimInfo: ClaimFiles/ClaimInfo
public ActionResult ClaimInfo(int FileID, int recordsequence, string FileVersion, ClaimLayoutType ClaimLayout, string DCN)
{
try
{
ParsedViewModel pvm = new ParsedViewModel();
ClaimFile claimFile = db.ClaimFiles.Find(FileID);
if (claimFile == null)
{
return(HttpNotFound());
}
int iFileID = FileID;
pvm.cf = claimFile;
pvm.cf.fh = new FileHeader(iFileID);
pvm.cf.fh.lsdch = new List <ClaimHeader>();
pvm.lsCHTVM = new List <ClaimHeaderTableViewModel>();
ClaimHeader ch = new ClaimHeader(FileID, recordsequence, FileVersion, DCN);
PaperHeader ph = new PaperHeader(FileID, recordsequence + 1, FileVersion, ClaimLayout);
ch.ph = ph;
ch.lscd = new List <ClaimDetail>();
for (int x = 0; x < ch.NumberofDetails; x++)
{
int iCDRecordSeq = recordsequence + 2 + (x * 2);
ClaimDetail cd = new ClaimDetail(FileID, iCDRecordSeq, FileVersion, ClaimLayout);
ch.lscd.Add(cd);
}
pvm.cf.fh.lsdch.Add(ch);
return(View(pvm));
}
catch (Exception ex)
{
return(View("Error", new HandleErrorInfo(ex, "ClaimFiles", "Index")));
}
}
private void AssignClaimantDetails(ClaimHeader claimHeader, ClaimDetail claimDetail, BusinessData dataClass)
{
var claimants = claimDetail.ClaimDetailToClaimInvolvementLinks.Where(lnk => lnk.ClaimInvolvement.ClaimInvolvementType == (short)StaticValues.LinkableComponentType.NameInvolvement).SelectMany(link => link.ClaimInvolvement.ClaimNameInvolvements.Where(a=> a.NameUsageTypeCode == "UCL" || a.NameUsageTypeCode == "DRV"));
if (claimants.Count() > 0)
{
ClaimNameInvolvement claimant = claimants.FirstOrDefault();
if (claimant.NameID.HasValue)
{
dataClass.CustomProperties["ClaimantNameID"] = claimant.NameID.GetValueOrDefault();
}
CodeRow code = claimant.CustomCode01Field.AllowedValues().Where(c => c.Code == claimant.CustomCode01).FirstOrDefault();
if (code != null)
{
dataClass.CustomProperties["ClaimantCustomCode01Desc"] = code.Description;
}
else
{
dataClass.CustomProperties["ClaimantCustomCode01Desc"] = string.Empty;
}
}
else
{
dataClass.CustomProperties["ClaimantCustomCode01Desc"] = string.Empty;
}
}
public void Initialise()
{
this.container = new UnityContainer();
ObjectFactory.Instance = new ObjectFactory(this.container);
this.container.RegisterType<IMessageService, MessageService>();
IConfigurationManager icm = MockRepository.GenerateStub<IConfigurationManager>();
icm.Stub(m => m.AppSettings).Return(new System.Collections.Specialized.NameValueCollection());
this.container.RegisterInstance<IConfigurationManager>(icm);
var metadataEntities = MockRepository.GenerateStub<IMetadataQuery>();
this.container.RegisterInstance(metadataEntities);
this.container.RegisterType<ObjectContext, MetadataEntities>("MetadataEntities", new InjectionConstructor[] { new InjectionConstructor(new object[] { }) });
this.container.RegisterType<MetadataEntities>("MetadataEntities", new InjectionConstructor[] { new InjectionConstructor(new object[] { }) });
string[] parameters = { "1" };
this.mockBT = GetMockClaimsBusinessTransaction("CreateClaim", parameters);
this.claimHeader = new BusinessComponentBuilder<ClaimHeader>()
.Add(new BusinessComponentBuilder<ClaimDetail>()
.As(out claimDetailRefFirst))
.Add(new BusinessComponentBuilder<ClaimDetail>()
.As(out claimDetailRefLast))
.Add(new BusinessComponentBuilder<ClaimTransactionHeader>()
.SetProperty(a => a.IsInProgress = true)
.SetProperty(a => a.ClaimTransactionSource = 1)
.Add(new BusinessComponentBuilder<ClaimTransactionGroup>()
.AddRef(claimDetailRefFirst))
.Add(new BusinessComponentBuilder<ClaimTransactionGroup>()
.AddRef(claimDetailRefLast)))
.Build();
this.mockBT.Component = this.claimHeader;
}
private void AssignClaimantRegistrationNumber(ClaimHeader claimHeader, ClaimDetail claimDetail, BusinessData dataClass)
{
string registrationNumber = string.Empty;
var insuredObjects = claimDetail.ClaimDetailToClaimInvolvementLinks.Where(lnk => lnk.ClaimInvolvement.ClaimInvolvementType == (short)StaticValues.LinkableComponentType.InsuredObject).SelectMany(link => link.ClaimInvolvement.InternalClaimInsuredObjects);
int number = insuredObjects.Count(io => io.InternalIOType == (short)StaticValues.InternalIOType.Vehicle);
if (number == 0)
{
var nameInvolvements = claimHeader.ClaimInvolvements.SelectMany<ClaimInvolvement, ClaimNameInvolvement>(ci => ci.ClaimNameInvolvements);
registrationNumber = this.GetRegistationNumber(claimHeader, this.GetNameInvolmentDataID(claimDetail, (short)StaticValues.NameInvolvementType_ClaimNameInvolvement.AdditionalClaimant));
if (string.IsNullOrEmpty(registrationNumber))
{
registrationNumber = this.GetRegistationNumber(claimHeader, this.GetNameInvolmentDataID(claimDetail, (short)StaticValues.NameInvolvementType_ClaimNameInvolvement.Driver));
}
}
else if (number > 1)
{
registrationNumber = ClaimConstants.CONST_VARIOUS;
}
else
{
var claimIOVehicle = insuredObjects.First(io => io.InternalIOType == (short)StaticValues.InternalIOType.Vehicle).ClaimIOVehicles.FirstOrDefault();
registrationNumber = claimIOVehicle.RegistrationNumber;
}
dataClass.CustomProperties["RegistrationNumber"] = registrationNumber;
}
private void InitiateClaimMigrationProcessing(ClaimHeader header)
{
using (var client = new WebClient())
{
System.Xml.XmlDocument xmlDoc = new System.Xml.XmlDocument();
if (_Logger.IsInfoEnabled)
{
_Logger.Info(string.Format("ClaimReviewTaskProcessHandler: Calling out to Wake Up service for claim {0}.", header.ClaimReference));
}
string soapRequest = string.Format(@"<s:Envelope xmlns:s=""http://schemas.xmlsoap.org/soap/envelope/"">
<s:Body>
<ProcessClaim xmlns=""http://tempuri.org/"">
<ClaimReference>{0}</ClaimReference>
</ProcessClaim>
</s:Body>
</s:Envelope>", header.ClaimReference);
XmlReader reader = System.Xml.XmlReader.Create(new System.IO.StringReader(soapRequest));
xmlDoc.Load(reader);
string data = xmlDoc.InnerXml;
Uri uri = new Uri(ClaimsBusinessLogicHelper.ResolveMandatoryConfig<string>(ClaimProcessorUri));
client.Headers.Add("Content-Type", "text/xml;charset=utf-8");
client.Headers.Add("SOAPAction", string.Format("\"{0}\"", ClaimsBusinessLogicHelper.ResolveMandatoryConfig<string>(ClaimProcessorSoapHeaderUri)));
client.UploadString(uri, data);
}
}
private static IEnumerable<ClaimNameInvolvement> GetTransientNames(ClaimHeader claimHeader)
{
return claimHeader
.NameInvolvements
.Cast<ClaimNameInvolvement>()
.Where(ni => GlobalClaimWakeUp.NameUsageTypeCodes.Contains(ni.NameUsageTypeCode));
}
private static void AddandRemoveClientSpecficCodes(INameUsage assdNameUsage, ClaimHeader claimHeader)
{
string clientCode = assdNameUsage.CustomCode01; // UI Label = Client-Specific Claim Data Set; For Insured
// Delete existing client specific generic data item on header
ClaimComponentsHelper.DeleteExistingClientSpecificCode(claimHeader);
// Add client specific generic data item on header
ClaimComponentsHelper.CreateClientSpecificGenericDataSet(claimHeader, clientCode);
}
public void Initialise()
{
this.inactivityThresholdPeriod = int.Parse(ConfigurationManager.AppSettings["InactivityThresholdPeriod"]);
this.reviewEventyTypeCode = ConfigurationManager.AppSettings["ReviewEventyTypeCode"];
this.inactivityDetectionProcess = ConfigurationManager.AppSettings["InactivityDetectionProcess"];
var container = new UnityContainer();
ObjectFactory.Instance = new ObjectFactory(container);
this.inactivityTask = new InactivityDetectionTask();
this.processes = new List<ITaskProcess>();
this.processEvents = new List<IProcessEvent>();
var taskService = MockRepository.GenerateStub<ITaskService>();
container.RegisterInstance(taskService);
taskService.Stub(a => a.FindActiveProcesses(null)).IgnoreArguments().Return(this.processes);
taskService.Stub(a => a.FindProcessEvents(null, 0, 0)).IgnoreArguments().Return(this.processEvents);
this.claimHeader = new BusinessComponentBuilder<ClaimHeader>()
.SetProperty(a => a.ClaimReference = "CH Reference")
.SetProperty(a => a.CustomCode20 = MaxClaimDetails.ToString())
.Add(new BusinessComponentBuilder<ClaimDetail>()
.SetProperty(a => a.ClaimDetailReference = "CD1 Reference"))
.Add(new BusinessComponentBuilder<ClaimDetail>()
.SetProperty(a => a.ClaimDetailReference = "CD2 Reference"))
.Add(new BusinessComponentBuilder<ClaimInvolvement>()
.SetProperty(a => a.ClaimInvolvementType = (short)StaticValues.LinkableComponentType.NameInvolvement)
.Add(new BusinessComponentBuilder<ClaimNameInvolvement>()
.SetProperty(a => a.NameInvolvementType = (short)StaticValues.NameInvolvementType_ClaimNameInvolvement.MainClaimHandler)
.SetProperty(a => a.NameInvolvementMaintenanceStatus = (short)StaticValues.ClaimNameInvolvementMaintenanceStatus.Latest)
.SetProperty(a => a.NameID = 2)))
.Build();
var claimEntities = MockRepository.GenerateStub<IClaimsQuery>();
this.targetClaimEvent = new ClaimEvent();
this.targetUser = new User { UserID = 999};
Func<DateTime, IEnumerable<long>, ILookup<ClaimHeader, ClaimDetail>> returnLookup = (x, y) => this.claimHeader.InternalClaimDetails.ToLookup(a => a.ClaimHeader);
claimEntities.Stub(a => a.GetInactiveClaims(DateTime.Now, null)).IgnoreArguments().Do((Func<DateTime, IEnumerable<long>, ILookup<ClaimHeader, ClaimDetail>>)returnLookup);
container.RegisterInstance<IClaimsQuery>(claimEntities);
MockRepository repository = new MockRepository();
container.RegisterInstance(MockRepository.GenerateStub<ICopyValidation>());
this.claimEventTransaction = new MockBusinessTransaction(new TransactionContext(string.Empty, string.Empty, string.Empty));
this.claimEventTransaction.Context.SetUsage(BusinessProcessUsage.Updateable);
this.claimEventTransaction.Component = this.targetClaimEvent;
container.RegisterInstance<IBusinessTransaction>("Claims.CreateEvent", this.claimEventTransaction);
var metadataEntities = MockRepository.GenerateStub<IMetadataQuery>();
metadataEntities.Stub(a => a.GetEventTypeVersion(null)).IgnoreArguments().Return(new EventTypeVersion[] { }.AsQueryable());
metadataEntities.Stub(a => a.GetUserByNameId(2)).Return(this.targetUser);
container.RegisterInstance(metadataEntities);
container.RegisterInstance<IMessageService>(new MockMessagingService());
this.inactivityTask.GetInactiveClaimDetails = this.GetInactiveTestClaims;
}
public void TestInitialize()
{
this.claimHeader = new ClaimHeader() { ClaimStage = (short)StaticValues.ClaimStage.Claim };
UnityContainer container = new UnityContainer();
ObjectFactory.Instance = new ObjectFactory(container);
container.RegisterType<IMessageService, MessageService>();
IConfigurationManager icm = MockRepository.GenerateStub<IConfigurationManager>();
icm.Stub(m => m.AppSettings).Return(new System.Collections.Specialized.NameValueCollection());
container.RegisterInstance<IConfigurationManager>(icm);
var metadataEntities = MockRepository.GenerateStub<IMetadataQuery>();
container.RegisterInstance(metadataEntities);
container.RegisterType<ObjectContext, MetadataEntities>("MetadataEntities", new InjectionConstructor[] { new InjectionConstructor(new object[] { }) });
container.RegisterType<MetadataEntities>("MetadataEntities", new InjectionConstructor[] { new InjectionConstructor(new object[] { }) });
}
public void Initialize()
{
string qualityControlEventTypeCode = ClaimsBusinessLogicHelper.ResolveMandatoryConfig<string>(QualityControlEventTypeCode);
string processName = ClaimsBusinessLogicHelper.ResolveMandatoryConfig<string>(QualityControlProcess);
string claimUserRoleCode = ClaimsBusinessLogicHelper.ResolveMandatoryConfig<string>(ClaimUserRoleCode);
var container = new UnityContainer();
ObjectFactory.Instance = new ObjectFactory(container);
this.qualityCheckTask = new QualityCheckTask();
this.processes = new List<ITaskProcess>();
List<string> processNames = new List<string>();
object[] parameters = new object[] { XiapConstants.XIAP_DATASOURCE };
this.taskService = MockRepository.GenerateStub<ITaskService>();
container.RegisterInstance(this.taskService);
this.taskService.Stub(a => a.GetFinishedTasksForUserByDateRange(null, null, DateTime.Now, DateTime.Now)).IgnoreArguments().Return(this.processes);
this.claimEntities = MockRepository.GenerateStub<IClaimsQuery>();
container.RegisterInstance<IClaimsQuery>(this.claimEntities);
this.claimHeader = new BusinessComponentBuilder<ClaimHeader>()
.SetProperty(a => a.ClaimReference = "CH Reference")
.Add(new BusinessComponentBuilder<ClaimDetail>()
.SetProperty(a => a.ClaimDetailReference = "CD1 Reference"))
.Add(new BusinessComponentBuilder<ClaimInvolvement>()
.SetProperty(a => a.ClaimInvolvementType = (short)StaticValues.LinkableComponentType.NameInvolvement)
.Add(new BusinessComponentBuilder<ClaimNameInvolvement>()
.SetProperty(a => a.NameInvolvementType = (short)StaticValues.NameInvolvementType_ClaimNameInvolvement.MainClaimHandler)
.SetProperty(a => a.NameInvolvementMaintenanceStatus = (short)StaticValues.ClaimNameInvolvementMaintenanceStatus.Latest)
.SetProperty(a => a.NameID = 2)))
.Build();
this.targetUser = new User { UserID = 999, UserIdentity = "TestUser" };
var metadataEntities = MockRepository.GenerateStub<IMetadataQuery>();
container.RegisterInstance(metadataEntities);
metadataEntities.Stub(a => a.GetUserByNameId(2)).Return(this.targetUser);
metadataEntities.Stub(a => a.GetUsersByRole("Developer")).IgnoreArguments().Return(new List<User>() { this.targetUser });
MockRepository repository = new MockRepository();
container.RegisterInstance(MockRepository.GenerateStub<ICopyValidation>());
this.claimEventTransaction = new MockBusinessTransaction(new TransactionContext(String.Empty, String.Empty,String.Empty));
this.claimEventTransaction.Context.SetUsage(BusinessProcessUsage.Updateable);
this.targetClaimEvent = new ClaimEvent();
this.claimEventTransaction.Component = this.targetClaimEvent;
container.RegisterInstance<IBusinessTransaction>("Claims.CreateEvent", this.claimEventTransaction);
}
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();
}
private static ClaimEvent CreateReviewEvent(ClaimHeader claimHeader, long claimHandlerId, long productEventID)
{
try
{
var reviewEvent = claimHeader.AddNewClaimEvent(productEventID);
reviewEvent.CreatedByUserID = claimHandlerId;
reviewEvent.TaskInitialUserID = claimHandlerId;
reviewEvent.CreatedDate = DateTime.Now;
reviewEvent.TaskInitialDueDate = DateTime.Now;
reviewEvent.EventDescription = "Migrated Claim Review";
reviewEvent.TaskInitialDetails = "Migrated Claim Review";
return reviewEvent;
}
catch (Exception ex)
{
Logger.ErrorFormat("Exception thrown while creating review task for Claim\r\n{0}\r\n",
JObject.FromObject(new { claimHeader.ClaimReference, ex.Message, ex.StackTrace }));
return null;
}
}
public void Init()
{
UnityContainer container = new UnityContainer();
container.RegisterInstance<IXiapCache>(MockRepository.GenerateStub<IXiapCache>());
container.RegisterInstance<MetadataEntities>("MetadataEntities", new MetadataEntities());
IProductClaimDetailQuery claimDetailQuery = MockRepository.GenerateStub<IProductClaimDetailQuery>();
container.RegisterInstance<IProductClaimDetailQuery>(claimDetailQuery);
IMetadataQuery metadataMock = MockRepository.GenerateStub<IMetadataQuery>();
container.RegisterInstance<IMetadataQuery>(metadataMock);
ObjectFactory.Instance = new ObjectFactory(container);
this.mockBT = GetMockClaimsBusinessTransaction("AmendClaim", null);
this.claimHeader = new BusinessComponentBuilder<ClaimHeader>()
.SetProperty(c => c.ClaimProductVersionID = 1)
.Add(new BusinessComponentBuilder<ClaimDetail>()
.As(out claimDetailRef)
.SetProperty(a => a.ClaimDetailStatusCode = "TST"))
.Add(new BusinessComponentBuilder<ClaimTransactionHeader>()
.SetProperty(a => a.IsInProgress = true)
.SetProperty(a => a.ClaimTransactionSource = 1)
.Add(new BusinessComponentBuilder<ClaimTransactionGroup>()
.AddRef(claimDetailRef)))
.Build();
ClaimDetail claimDetail = this.claimHeader.ClaimDetails.First();
string status = claimDetail.OriginalTransitionStatus;
claimDetail.ClaimDetailStatusCode = "TST1";
claimDetail.ClaimDetailInternalStatus = (short)StaticValues.ClaimDetailInternalStatus.Finalized;
this.mockBT.Component = this.claimHeader as IBusinessComponent;
ProductXML.ProductClaimDetail productClaimDetail = new ProductXML.ProductClaimDetail() { ProductClaimDetailID = 1, IsFinalizationWithNonZeroOSAllowed = true, ClaimDetailTypeCode = "TEST" };
productClaimDetail.ProductClaimDetailToComponentLinks = new ProductXML.ProductClaimDetailToComponentLink[1]
{
new ProductXML.ProductClaimDetailToComponentLink()
};
claimDetailQuery.Stub(x => x.GetProductClaimDetail(Arg<long>.Is.Anything)).Return(productClaimDetail);
metadataMock.Stub(c => c.GetClaimDetailStatusCodeStatusLevel(Arg<long>.Is.Anything, Arg<string>.Is.Anything)).Return(10);
}
/// <summary>
/// If this claim is Migrated (ClaimHeader.CustomCode19 == 'C') and it's not yet been processed, or it was processed and that
/// resulted in an F01 or F02 error (ClaimHeader.CustomCode18 is NULL, whitespace, F01 or F02), and this is a closed claim
/// we should go ahead and reopen it.
/// </summary>
/// <param name="header">ClaimHeader Object</param>
/// <param name="pluginHelper">PluginHelper Object</param>
private void ProcessClaimForReopen(ClaimHeader header, PluginHelper<IBusinessComponent> pluginHelper)
{
if (ClaimsBusinessLogicHelper.CheckMigratedCloseClaim(header))
{
try
{
if (_Logger.IsInfoEnabled)
{
_Logger.Info(string.Format("Initiating migrated claim processing for claim {0}.", header.ClaimReference));
}
this.InitiateClaimMigrationProcessing(header);
}
catch (Exception err)
{
_Logger.Error("Failed on Claim WakeUp Processing");
_Logger.Error(err);
pluginHelper.AddError(ClaimConstants.FAILED_TO_INITIATE_MIGRATION_PROCESSING, header.ClaimReference);
}
}
}
public void Initialize()
{
/*
var container = new UnityContainer();
var componentMetadata = MockRepository.GenerateStub<IComponentMetadata>();
container.RegisterInstance<IComponentMetadata>(componentMetadata);
var product = new ProductBuilder<ProductVersion>(componentMetadata)
.Add(new ProductBuilder<ProductClaimDefinition>(componentMetadata))
.Build();
this.productClaimDefinition = product.ProductClaimDefinition;
ObjectFactory.Instance = new ObjectFactory(container);
*/
var clmHeader = new BusinessComponentBuilder<ClaimHeader>()
.SetProperty(a => a.ClaimProductVersionID = 1)
.SetProperty(a => a.ClaimReference = "AXATEST")
.Build();
this.claimHeader = clmHeader; // new ClaimHeader() { ClaimProductVersionID = 0, ClaimReference = "AXATEST" };
}
private static void CreateClaimTransferRequests(ClaimHeader claimHeader, Claim claim)
{
// Change to claim header and detail will automatically result in the claim transferring, need to transfer the latest reserve
// and names that aren't already in Genius
try
{
// Claim Transfer Type: 1(Reopen), 2(Claim), 3(Financial FlattenedTransaction), 4(Close), 5(Delete)
//long? lastReserveHeader = null;
ClaimTransfer.AddControlLogRequest((short)StaticValues.ClaimTransferType.Claim,
claimHeader.ClaimReference, claimHeader.ClaimHeaderStatusCode, null);
Logger.InfoFormat("Claim transfer request created\r\n{0}\r\n", JObject.FromObject(new { claim.ClaimReference, claim.PolicyNumber }));
var transactions = claimHeader.GetFlattenedTransactionData().ToArray();
var latestReservesHeaders = (
from t in transactions
//from ctg in cth.TransactionGroups
//from ctd in ctg.TransactionDetails
where
(t.AmountType == (short)StaticValues.AmountType.Reserve || t.AmountType == (short)StaticValues.AmountType.RecoveryReserve) &&
(
t.ClaimTransactionSource != (short)StaticValues.ClaimTransactionSource.Payment &&
t.ClaimTransactionSource != (short)StaticValues.ClaimTransactionSource.PaymentCancellation &&
t.ClaimTransactionSource != (short)StaticValues.ClaimTransactionSource.RecoveryReceipt
)
group t by new
{
t.ClaimDetailID,
t.MovementType
} into grp
select new
{
grp.Key.ClaimDetailID,
ClaimTransactionHeaderID =
grp.OrderByDescending(x => x.TransactionDate)
.ThenByDescending(x => x.ReserveDate)
.ThenByDescending(x => x.ReserveDaySequence)
.Select(x => x.ClaimTransactionHeaderID)
.First()
}
).ToArray();
var latestReservesHeaderIds = latestReservesHeaders.Select(g => g.ClaimTransactionHeaderID).Distinct().ToArray();
Logger.InfoFormat("Latest reserves for Claim defined as\r\n{0}\r\n",
JObject.FromObject(new { claim.ClaimReference, ReserveTransactionHeaders = latestReservesHeaders }));
var claimTransactionHeaders = claimHeader
.HistoricalClaimTransactionHeaders
.Where(cth => latestReservesHeaderIds.Contains(cth.ClaimTransactionHeaderID))
.OrderBy(cth => cth.TransactionDate)
.ToArray();
foreach (var claimTransactionHeader in claimTransactionHeaders)
{
try
{
if (claimTransactionHeader != null)
{
ClaimTransfer.AddControlLogRequest((short)StaticValues.ClaimTransferType.FinancialTransaction,
claimHeader.ClaimReference, claimHeader.ClaimHeaderStatusCode,
claimTransactionHeader.ClaimTransactionHeaderID);
Logger.InfoFormat(
"Attempting to create FINANCIALTRANSACTION transfer request\r\n{0}\r\n",
JObject.FromObject(
new { claim.ClaimReference, claimTransactionHeader.ClaimTransactionHeaderID }));
}
}
catch (Exception ex)
{
Logger.ErrorFormat(
"Exception thrown while creating transfer request for Claim\r\n{0}\r\n",
JObject.FromObject(new { claimHeader.ClaimReference, claimTransactionHeader.ClaimTransactionHeaderReference, ex.Message, ex.StackTrace }));
}
}
// Submit a close Claim request too. Then the normal Genius.X processing can reopen it.
if (GlobalClaimWakeUp.Container.Resolve<ClaimProcessorConfiguration>().ReopeningClaims)
{
ClaimTransfer.AddControlLogRequest((short)StaticValues.ClaimTransferType.Close,
claimHeader.ClaimReference, claimHeader.ClaimHeaderStatusCode, null);
Logger.InfoFormat("Attempting to create CLOSECLAIM trasfer requests\r\n{0}", JObject.FromObject(new { claim.ClaimReference}));
}
}
catch (Exception ex)
{
Logger.ErrorFormat(
"Exception thrown while creating transfer request for Claim\r\n{0}\r\n",
JObject.FromObject(new { claimHeader.ClaimReference, ex.Message, ex.StackTrace }));
}
}
/// <summary>
/// Update Claim AD Excess Data from Genius
/// </summary>
/// <param name="claimHeader">Claim Header</param>
/// <param name="genericDataItems">Generic Data Items</param>
private void UpdateClaimADExcessData(ClaimHeader claimHeader, IEnumerable<IGenericDataItem> genericDataItems)
{
foreach (IGenericDataItem genericData in genericDataItems)
{
if (claimHeader.PolicyAmountCurrencyCodeField.IsInUse.GetValueOrDefault(false))
{
claimHeader.PolicyAmountCurrencyCode = genericData.CurrencyCode;
}
// If AD Excess is in use
// UI Label = Excess
if (claimHeader.CustomNumeric10Field.IsInUse.GetValueOrDefault(false))
{
if (claimHeader.ClaimHeaderAnalysisCode02 == "31")
{
claimHeader.CustomNumeric10 = genericData.CustomNumeric01; // Accident
}
else if (claimHeader.ClaimHeaderAnalysisCode02 == "32")
{
claimHeader.CustomNumeric10 = genericData.CustomNumeric02; // Fire
}
else if (claimHeader.ClaimHeaderAnalysisCode02 == "33")
{
claimHeader.CustomNumeric10 = genericData.CustomNumeric04; // Storm (Natural Event)
}
else if (claimHeader.ClaimHeaderAnalysisCode02 == "34")
{
claimHeader.CustomNumeric10 = genericData.CustomNumeric03; // Theft
}
else if (claimHeader.ClaimHeaderAnalysisCode02 == "35")
{
claimHeader.CustomNumeric10 = genericData.CustomNumeric05; // Vandalism
}
else if (claimHeader.ClaimHeaderAnalysisCode02 == "36")
{
claimHeader.CustomNumeric10 = genericData.CustomNumeric06; // Windscreen
}
else if (!string.IsNullOrEmpty(claimHeader.ClaimHeaderAnalysisCode02))
{
claimHeader.CustomNumeric10 = genericData.CustomNumeric07; // Other
}
claimHeader.CustomBoolean15 = genericData.CustomBoolean03; // Funded
}
}
}
/// <summary>
/// Update Term Data Claim Currency Code From Genius
/// </summary>
/// <param name="claimHeader">Claim Header</param>
private void UpdateTermsData(ClaimHeader claimHeader)
{
IAXAClaimsQuery query = new AXAClaimsQueries();
IUWTerms term = query.GetlatestTerm(claimHeader.PolicyHeaderID.Value);
if (term != null && !string.IsNullOrEmpty(term.MainOriginalCurrencyCode))
{
claimHeader.ClaimCurrencyCode = term.MainOriginalCurrencyCode;
}
}
/// <summary>
/// Update Claim DeDucatble Data from Genius
/// </summary>
/// <param name="claimHeader">Claim Header</param>
/// <param name="genericDataItems">Generic Data Items</param>
/// <param name="policyRefData">Policy Ref Data</param>
/// <param name="policyRefs">Policy Refs</param>
private void UpdateClaimDeductibleData(ClaimHeader claimHeader, IEnumerable<IGenericDataItem> genericDataItems, ClaimGenericDataItem policyRefData, string[] policyRefs)
{
foreach (IGenericDataItem genericData in genericDataItems)
{
if (claimHeader.PolicyAmountCurrencyCodeField.IsInUse.GetValueOrDefault(false))
{
claimHeader.PolicyAmountCurrencyCode = genericData.CurrencyCode;
}
if (genericData.CustomNumeric01 == 1 && claimHeader.PolicyDeductible01Field.IsInUse.GetValueOrDefault(false))
{
claimHeader.PolicyDeductible01 = genericData.CustomNumeric02; // Deductible amount
claimHeader.IsDeductible01PaidByInsurer = genericData.CustomBoolean03; // Funded
claimHeader.CustomBoolean12 = genericData.CustomBoolean02; // Adjustable
}
else if (genericData.CustomNumeric01 == 2 && claimHeader.PolicyDeductible02Field.IsInUse.GetValueOrDefault(false))
{
claimHeader.PolicyDeductible02 = genericData.CustomNumeric02; // Deductible amount
claimHeader.IsDeductible02PaidByInsurer = genericData.CustomBoolean03; // Funded
claimHeader.CustomBoolean12 = genericData.CustomBoolean02; // Adjustable
}
else if (genericData.CustomNumeric01 == 3 && claimHeader.PolicyDeductible03Field.IsInUse.GetValueOrDefault(false))
{
claimHeader.PolicyDeductible03 = genericData.CustomNumeric02; // Deductible amount
claimHeader.IsDeductible03PaidByInsurer = genericData.CustomBoolean03; // Funded
claimHeader.CustomBoolean12 = genericData.CustomBoolean02; // Adjustable
}
else if (genericData.CustomNumeric01 == 4 && claimHeader.PolicyDeductible04Field.IsInUse.GetValueOrDefault(false))
{
claimHeader.PolicyDeductible04 = genericData.CustomNumeric02; // Deductible amount
claimHeader.IsDeductible04PaidByInsurer = genericData.CustomBoolean03; // Funded
claimHeader.CustomBoolean12 = genericData.CustomBoolean02; // Adjustable
}
else if (genericData.CustomNumeric01 == 5 && claimHeader.PolicyDeductible05Field.IsInUse.GetValueOrDefault(false))
{
claimHeader.PolicyDeductible05 = genericData.CustomNumeric02; // Deductible amount
claimHeader.IsDeductible05PaidByInsurer = genericData.CustomBoolean03;
claimHeader.CustomBoolean12 = genericData.CustomBoolean02; // Adjustable
}
// copy Policy refs
if (policyRefData != null)
{
if (genericData.CustomNumeric01 == 1)
{
policyRefData.CustomCode01 = genericData.CustomCode04; // UI Label = Deductiple Type 1; GDT - AND4
if (genericData.CustomBoolean03.GetValueOrDefault(false) && genericData.CustomNumeric03 != null)
{
policyRefData.CustomReference01 = policyRefs[(int)genericData.CustomNumeric03 - 1]; // UI Label = Deductiple Pol Ref 1; GDT - AND4
}
}
else if (genericData.CustomNumeric01 == 2)
{
policyRefData.CustomCode02 = genericData.CustomCode04; // UI Label = Deductiple Type 2; GDT - AND4
if (genericData.CustomBoolean03.GetValueOrDefault(false) && genericData.CustomNumeric03 != null)
{
policyRefData.CustomReference02 = policyRefs[(int)genericData.CustomNumeric03 - 1]; // UI Label = Deductiple Pol Ref 2; GDT - AND4
}
}
else if (genericData.CustomNumeric01 == 3)
{
policyRefData.CustomCode03 = genericData.CustomCode04; // UI Label = Deductiple Type 3; GDT - AND4
if (genericData.CustomBoolean03.GetValueOrDefault(false) && genericData.CustomNumeric03 != null)
{
policyRefData.CustomReference03 = policyRefs[(int)genericData.CustomNumeric03 - 1]; // UI Label = Deductiple Pol Ref 3; GDT - AND4
}
}
else if (genericData.CustomNumeric01 == 4)
{
policyRefData.CustomCode04 = genericData.CustomCode04; // UI Label = Deductiple Type 4; GDT - AND4
if (genericData.CustomBoolean03.GetValueOrDefault(false) && genericData.CustomNumeric03 != null)
{
policyRefData.CustomReference04 = policyRefs[(int)genericData.CustomNumeric03 - 1]; // UI Label = Deductiple Pol Ref 4; GDT - AND4
}
}
else if (genericData.CustomNumeric01 == 5)
{
policyRefData.CustomCode05 = genericData.CustomCode04; // UI Label = Deductiple Type 5; GDT - AND4
if (genericData.CustomBoolean03.GetValueOrDefault(false) && genericData.CustomNumeric03 != null)
{
policyRefData.CustomReference05 = policyRefs[(int)genericData.CustomNumeric03 - 1]; // UI Label = Deductiple Pol Ref 5; GDT - AND4
}
}
}
}
}
private static bool GetPolicyAndAttachClaim(Claim claim, ClaimHeader claimHeader)
{
var headerStatusMap = new Dictionary<string, StaticValues.ClaimHeaderInternalStatus>
{
{"CAB", StaticValues.ClaimHeaderInternalStatus.Finalized},
{"CCL", StaticValues.ClaimHeaderInternalStatus.Finalized},
{"CES", StaticValues.ClaimHeaderInternalStatus.InProgress},
{"CON", StaticValues.ClaimHeaderInternalStatus.InProgress},
{"COU", StaticValues.ClaimHeaderInternalStatus.InProgress},
{"CPY", StaticValues.ClaimHeaderInternalStatus.InProgress},
{"CRE", StaticValues.ClaimHeaderInternalStatus.InProgress},
{"CRL", StaticValues.ClaimHeaderInternalStatus.Finalized},
{"CRO", StaticValues.ClaimHeaderInternalStatus.InProgress},
};
if (!GetPolicyAndAttachToClaim(claimHeader, claim))
{
claim.ClaimProcessingFailed = true;
claim.FailureReason = "Policy does not exist or could not attach";
claim.CustomCode18 = "F02";
return false;
}
claimHeader.ClaimHeaderInternalStatus = (short)headerStatusMap[claimHeader.ClaimHeaderStatusCode];
claim.ClaimIsAttachedToPolicy = true;
claim.ClaimIsClosed = claimHeader.ClaimHeaderInternalStatus >= 4;
var updateEdDataPlugin = new UpdateExcessAndDeductibles();
var claimHeaderInteralStatus = new Dictionary<long, StaticValues.ClaimDetailInternalStatus>();
foreach (var claimDetail in claimHeader.ClaimDetails)
{
claimHeaderInteralStatus.Add(claimDetail.ClaimDetailID, (StaticValues.ClaimDetailInternalStatus)claimDetail.ClaimDetailInternalStatus.GetValueOrDefault(0));
claimDetail.ClaimDetailInternalStatus = (short)StaticValues.ClaimDetailInternalStatus.Finalized;
}
foreach (var claimDetail in claimHeader.ClaimDetails)
{
if (updateEdDataPlugin.UpdateEDData(claimDetail, claimDetail.PolicyCoverageID))
{
Logger.InfoFormat("Executed \"UpdateExcessAndDeductibles\" successfully\r\n{0}\r\n",
JObject.FromObject(new { claimHeader.ClaimReference, claimDetail.ClaimDetailReference }));
}
else
{
Logger.InfoFormat("Executed \"UpdateExcessAndDeductibles\" but there was a problem\r\n{0}\r\n",
JObject.FromObject(new { claimHeader.ClaimReference, claimDetail.ClaimDetailReference }));
}
}
foreach (var kvp in claimHeaderInteralStatus)
{
var claimDetail = claimHeader.ClaimDetails.FirstOrDefault(cd => cd.ClaimDetailID == kvp.Key);
if (claimDetail == null) continue;
claimDetail.ClaimDetailInternalStatus = (short)kvp.Value;
}
return true;
}
private static bool GetPolicyAndAttachToClaim(ClaimHeader claimHeader, Claim claim)
{
var policyAttachmentHandler = GlobalClaimWakeUp.Container.Resolve<AttachClaimToPolicyHandler>();
var result = policyAttachmentHandler.Execute(claimHeader, claim);
GlobalClaimWakeUp.GeniusXPolicyState.TryAdd(claim.PolicyNumber, result);
return result;
}
public FinancialTransactionContext(ClaimHeader claimHeader, ClaimDetail claimDetail, ClaimTransactionHeader claimTransactionHeader, ClaimTransactionGroup claimTransactionGroup, User user)
{
this.ClaimHeader = claimHeader;
this.ClaimDetail = claimDetail;
this.ClaimTransactionHeader = claimTransactionHeader;
this.ClaimTransactionGroup = claimTransactionGroup;
this.CurrentUser = user;
this.TransactionSource = (StaticValues.ClaimTransactionSource)this.ClaimTransactionHeader.ClaimTransactionSource;
this.Product = claimHeader.GetProduct();
this.ProductClaimDefinition = this.Product.ProductClaimDefinition;
this.ProductClaimDetails = this.Product.ClaimDetails;
}
public bool Execute(ClaimHeader claimHeader, Claim claim)
{
if (claimHeader == null) throw new ArgumentNullException("claimHeader");
if (claim == null) throw new ArgumentNullException("claim");
IUWHeader uwHeader = null;
if (!FindPolicy(claimHeader, claim, out uwHeader)) return false;
claim.PolicyHeaderStatusCode = uwHeader.HeaderStatusCode;
var geniusGateway = GlobalClaimWakeUp.Container.Resolve<IGeniusGateway>();
var queryProductSectionDetails = ObjectFactory.Resolve<ISystemValueSetQuery<ISectionDetailTypeData>>();
try
{
//SetDateOfLossTypeCode(claimHeader, uwHeader);
claimHeader.PolicyHeaderID = uwHeader.HeaderID;
claimHeader.ProposedPolicyReference = uwHeader.HeaderReference;
foreach (var claimDetail in claim.ClaimDetails)
{
//var components = new SortedList<string, ComponentRequest>();
var geniusXClaimDetail = claimHeader.ClaimDetails.SingleOrDefault(cd => cd.ClaimDetailID == claimDetail.GeniusXDetailID);
if (geniusXClaimDetail == null)
{
Logger.ErrorFormat(
"Could not find ClaimDetail\r\n{0}\r\n",
JObject.FromObject(
new{
claim.ClaimReference,
uwHeader.HeaderReference,
claimDetail.GeniusXDetailID,
claimDetail.ClaimDetailType}));
return false;
}
geniusXClaimDetail.PolicyLinkLevel = (short)StaticValues.PolicyLinkLevel.Coverage;
var section = uwHeader.ISections.SingleOrDefault(s => s.SectionTypeCode == claimDetail.PolicySectionCode);
if (section == null)
{
Logger.ErrorFormat("Could not find Section\r\n{0}\r\n",
JObject.FromObject(new{claim.ClaimReference, uwHeader.HeaderReference, claimDetail.PolicySectionCode}));
return false;
}
IUWSectionDetail sectionDetail = section.ISectionDetails
.FirstOrDefault(
sd => string.Equals(sd.SectionDetailTitle, claimDetail.SectionDetailIdentifier, StringComparison.OrdinalIgnoreCase) &&
sd.ICoverages.Any(
c => c.CoverageTypeCode == claimDetail.CoverageCode &&
geniusGateway.CheckDates(c.ExternalReference, claimHeader.DateOfLossFrom.GetValueOrDefault(DateTime.MinValue)) ||
geniusGateway.CheckDates(c.ExternalReference, claimHeader.DateOfLossTo.GetValueOrDefault(DateTime.MinValue))));
if (sectionDetail == null)
{
Logger.WarnFormat("Could not find a matching SectionDetail, trying 'WW'\r\n{0}",
JObject.FromObject(
new
{
claim.ClaimReference,
uwHeader.HeaderReference,
claimDetail.PolicySectionCode,
claimDetail.SectionDetailIdentifier
}
));
sectionDetail = section.ISectionDetails
.FirstOrDefault(sd => string.Equals(sd.SectionDetailTitle, "WW", StringComparison.OrdinalIgnoreCase) &&
sd.ICoverages.Any(
c => c.CoverageTypeCode == claimDetail.CoverageCode &&
geniusGateway.CheckDates(c.ExternalReference, claimHeader.DateOfLossFrom.GetValueOrDefault(DateTime.MinValue)) ||
geniusGateway.CheckDates(c.ExternalReference, claimHeader.DateOfLossTo.GetValueOrDefault(DateTime.MinValue))));
}
if (sectionDetail == null)
{
Logger.WarnFormat("Could not find a matching SectionDetail, trying 'EL UK'\r\n{0}",
JObject.FromObject(
new
{
claim.ClaimReference,
uwHeader.HeaderReference,
claimDetail.PolicySectionCode,
claimDetail.SectionDetailIdentifier
}
));
sectionDetail = section.ISectionDetails
.FirstOrDefault(sd => string.Equals(sd.SectionDetailTitle, "EL UK", StringComparison.OrdinalIgnoreCase) &&
sd.ICoverages.Any(
c => c.CoverageTypeCode == claimDetail.CoverageCode &&
geniusGateway.CheckDates(c.ExternalReference, claimHeader.DateOfLossFrom.GetValueOrDefault(DateTime.MinValue)) ||
geniusGateway.CheckDates(c.ExternalReference, claimHeader.DateOfLossTo.GetValueOrDefault(DateTime.MinValue))));
}
if (sectionDetail == null)
{
Logger.WarnFormat("Could not find a matching SectionDetail, trying 'Europe'\r\n{0}",
JObject.FromObject(
new
{
claim.ClaimReference,
uwHeader.HeaderReference,
claimDetail.PolicySectionCode,
claimDetail.SectionDetailIdentifier
}
));
sectionDetail = section.ISectionDetails
.FirstOrDefault(sd => string.Equals(sd.SectionDetailTitle, "Europe", StringComparison.OrdinalIgnoreCase) &&
sd.ICoverages.Any(
c => c.CoverageTypeCode == claimDetail.CoverageCode &&
geniusGateway.CheckDates(c.ExternalReference, claimHeader.DateOfLossFrom.GetValueOrDefault(DateTime.MinValue)) ||
geniusGateway.CheckDates(c.ExternalReference, claimHeader.DateOfLossTo.GetValueOrDefault(DateTime.MinValue))));
}
if (sectionDetail == null)
{
Logger.WarnFormat("Could not find a matching SectionDetail using *any* method, picking first SectionDetail\r\n{0}",
JObject.FromObject(
new
{
claim.ClaimReference,
uwHeader.HeaderReference,
claimDetail.PolicySectionCode,
}
));
sectionDetail = section.ISectionDetails
.FirstOrDefault(sd => queryProductSectionDetails.GetValue(sd.SectionDetailTypeCode).IsSummarySectionDetailType == false);
}
if (sectionDetail == null)
{
Logger.ErrorFormat("Could not find SectionDetail\r\n{0}\r\n",
JObject.FromObject(
new {
/*\tVehicleType={3}\r\n\tAreaCode={4}\r\n]", */
claim.ClaimReference,
uwHeader.HeaderReference,
claimDetail.PolicySectionCode
//,claimDetail.VehicleType
//,claimDetail.AreaCode
}));
return false;
}
if (!string.Equals(sectionDetail.SectionDetailTitle, claimDetail.SectionDetailIdentifier, StringComparison.OrdinalIgnoreCase))
{
Logger.WarnFormat(
"Fuzzy matched SectionDetail\r\n{0}\r\n",
JObject.FromObject(
new{
/*\tVehicleType={3}\r\n\tAreaCode={4}\r\n]", */
claim.ClaimReference,
uwHeader.HeaderReference,
claimDetail.CmsPolicySectionCode,
claimDetail.PolicySectionCode,
claimDetail.SectionDetailIdentifier,
sectionDetail.SectionDetailTitle
//,claimDetail.VehicleType
//,claimDetail.AreaCode
}));
}
var coverage = sectionDetail.ICoverages.FirstOrDefault(
c => c.CoverageTypeCode == claimDetail.CoverageCode &&
geniusGateway.CheckDates(c.ExternalReference, claimHeader.DateOfLossFrom.GetValueOrDefault(DateTime.MinValue)) ||
geniusGateway.CheckDates(c.ExternalReference, claimHeader.DateOfLossTo.GetValueOrDefault(DateTime.MinValue))) ??
sectionDetail.ICoverages.FirstOrDefault();
if (coverage == null)
{
Logger.ErrorFormat(
"Could not find Coverage\r\n{0}\r\n",
JObject.FromObject(
new{
claim.ClaimReference,
uwHeader.HeaderReference,
claimDetail.PolicySectionCode,
claimDetail.CoverageCode
}));
return false;
}
if (!string.Equals(sectionDetail.SectionDetailTitle, claimDetail.SectionDetailIdentifier, StringComparison.OrdinalIgnoreCase) || !string.Equals(coverage.CoverageTypeCode, claimDetail.CoverageCode, StringComparison.OrdinalIgnoreCase))
{
Logger.WarnFormat(
"Fuzzy matched CoverageType\r\n{0}\r\n",
JObject.FromObject(
new {
/*\tVehicleType={3}\r\n\tAreaCode={4}\r\n]", */
claim.ClaimReference,
uwHeader.HeaderReference,
claimDetail.CmsPolicySectionCode,
claimDetail.PolicySectionCode,
claimDetail.SectionDetailIdentifier,
sectionDetail.SectionDetailTitle,
claimDetail.CoverageCode,
coverage.CoverageTypeCode
//,claimDetail.VehicleType
//,claimDetail.AreaCode
}));
}
geniusXClaimDetail.PolicyCoverageID = coverage.CoverageID;
geniusXClaimDetail.PolicySectionDetailID = sectionDetail.SectionDetailID;
geniusXClaimDetail.PolicySectionID = section.SectionID;
}
foreach (var sectionDetail in uwHeader.ISections.SelectMany(s => s.ISectionDetails.Where(sd => queryProductSectionDetails.GetValue(sd.SectionDetailTypeCode).IsSummarySectionDetailType == false)))
{
var dateOfLossTypeCode = "O";
var sectionDetailCustomCode03 = GlobalClaimWakeUp.Container.Resolve<IGeniusGateway>().GetSectionDetailDateOfLossTypeCode(sectionDetail.ExternalReference);
if (!string.IsNullOrEmpty(sectionDetailCustomCode03) && (sectionDetailCustomCode03 == "M" || sectionDetailCustomCode03 == "O"))
{
dateOfLossTypeCode = sectionDetailCustomCode03;
}
if (dateOfLossTypeCode != claimHeader.DateOfLossTypeCode)
{
claimHeader.DateOfLossTypeCode = dateOfLossTypeCode;
Logger.InfoFormat("Setting Claim DATEOFLOSSTYPECODE \r\n{0}",
JObject.FromObject(new { ClaimReference = claimHeader.ClaimReference, DateOfLossTypeCode = dateOfLossTypeCode }));
break;
}
}
}
catch (Exception ex)
{
claim.ClaimIsAttachedToPolicy = false;
claim.CustomCode18 = "F02";
claim.ClaimProcessingFailed = true;
claim.FailureReason = "Could not attach Claim to Policy";
Logger.WarnFormat("Claim to Policy attachment failed:\r\n{0}\r\n", JObject.FromObject(new{claim.ClaimReference, claim.PolicyNumber, @Exception=ex}));
return false;
}
// Create the lossBroker name involvement
try
{
var transaction = UWBusinessTransactionFactory.DisplayPolicy(uwHeader.HeaderReference, false, VersionSelectionParameters.SelectLatestVersion);
var lossBroker = transaction.Header.NameInvolvements.FirstOrDefault(ni => ni.NameInvolvementType == (short)StaticValues.NameInvolvementType_UWNameInvolvement.MajorBroker);
if (lossBroker != null && !claimHeader.NameInvolvementExists((short)StaticValues.NameInvolvementType_ClaimNameInvolvement.LossBroker, lossBroker.NameID))
{
if (lossBroker.NameID != null)
{
var claimInvolvement = claimHeader.AddNewClaimInvolvement(StaticValues.LinkableComponentType.NameInvolvement);
var claimProduct = claimHeader.GetProduct();
// TGB: New changes to XIAP mean you now must supply the NameUsageTypeCode here. For Loss Broke it is 'Broker', which is UBK
claimInvolvement.AddClaimNameInvolvement(claimProduct.ProductVersionID, (short)StaticValues.NameInvolvementType_ClaimNameInvolvement.LossBroker, lossBroker.NameID, "UBK");
Logger.InfoFormat("LOSSBROKER setup on Claim\r\n{0}\r\n", JObject.FromObject(new { claim.ClaimReference, lossBroker.NameID }));
}
else
{
Logger.WarnFormat("Could not setup LOSSBROKER on Claim\r\n{{ClaimReference: {0}\r\n}}", claim.ClaimReference);
}
}
transaction.Cancel();
}
catch (Exception ex)
{
Logger.WarnFormat("Error creating LOSSBROKER for '{0}'\r\n[\r\n\tException={1}\r\n]", claim.ClaimReference, ex);
return false;
}
Logger.InfoFormat("Claim to Policy attachment success:\r\n{0}\r\n",
JObject.FromObject(
new {claim.ClaimReference, claim.PolicyNumber}
));
return true;
}
public void GenrateFolioTest()
{
ClaimHeader header = new ClaimHeader();
header.ClaimReference = "TestReference";
string expected = "TestReference";
string actual;
actual = ClaimsProcessHelper.GenerateFolio(header, ClaimsBusinessLogicHelper.GetInsuredFromHeader(header));
Assert.AreEqual(expected, actual);
}
public void CheckValidHeaderStatusFalseTest()
{
ClaimHeader header = new ClaimHeader();
header.ClaimHeaderStatusCode = "CON";
Assert.IsFalse(ClaimsBusinessLogicHelper.CheckValidHeaderStatus(header, ClaimsBusinessLogicHelper.ResolveMandatoryConfig<string>(ClaimConstants.APP_SETTING_KEY_HEADERSTATUSESFORINVALIDCLAIMTRANSFER)));
}
private static bool IsCalculatingDeductibles(ProductClaimDetail productClaimDetail, ProductClaimDefinition productClaimDefinition, ClaimHeader claimHeader)
{
return productClaimDetail.ClaimDetailAutomaticDeductibleProcessingMethod == (short)StaticValues.ClaimDetailAutomaticDeductibleProcessingMethod.FromClaimHeader
&& productClaimDefinition.ClaimHeaderAutomaticDeductibleProcessingMethod == (short)StaticValues.ClaimHeaderAutomaticDeductibleProcessingMethod.StandardClaimHeaderDeductible
&& claimHeader.IsAutomaticDeductibleProcessingApplied == true;
}
private static bool FindPolicy(ClaimHeader claimHeader, Claim claim, out IUWHeader uwHeader)
{
lock (SyncLock)
{
var claimService = ObjectFactory.Resolve<ClaimService>();
try
{
Logger.InfoFormat("Looking for Policy based on Claim\r\n{0}\r\n",
JObject.FromObject(
new {claim.ClaimReference, claim.PolicyNumber}));
uwHeader = claimService.GetPolicyDataForCoverageVerification(claim.PolicyNumber, XiapConstants.XIAP_DATASOURCE, null);
claim.PolicyShellWasCreated = false;
return true;
}
catch (Exception ex)
{
//try
//{
// Logger.InfoFormat("Could not find Policy in Genius.X, going to Genius\r\n{0}\r\n",
// JObject.FromObject(new {claim.ClaimReference, claim.PolicyNumber}));
// var claimProduct = claimHeader.GetProduct();
// var linkedUwProduct = claimProduct.Links.First(l => l.ProductLinkType == (short)StaticValues.ProductLinkType.ClaimtoPolicy);
// var tran = UWBusinessTransactionFactory.CreatePolicy(linkedUwProduct.ProductCode, DateTime.UtcNow, false);
// var header = tran.Header;
// header.HeaderReference = claim.PolicyNumber;
// var updater = ObjectFactory.Resolve<UpdateFromGeniusPlugin>();
// updater.ProcessComponent(header, ProcessInvocationPoint.Virtual, 0);
// //_updater.Handle(header);
// tran.Complete(false);
// claim.PolicyShellWasCreated = true;
// uwHeader = claimService.GetPolicyDataForCoverageVerification(claim.PolicyNumber, XiapConstants.XIAP_DATASOURCE, null);
// return true;
//}
//catch (Exception ex)
//{
claim.PolicyShellWasCreated = false;
claim.ClaimIsAttachedToPolicy = false;
claim.CustomCode18 = "F01";
claim.ClaimProcessingFailed = true;
claim.FailureReason = "Policy does not exist";
Logger.ErrorFormat("Exception creating policy from Genius policy \r\n{0}\r\n",
JObject.FromObject(new{ex.Message, ex.StackTrace}));
uwHeader = null;
return false;
//}
}
}
}
/// <summary>
/// Load historical reserves/payments/recovery reserves/recovery receipts for the specified claim
/// </summary>
/// <param name="transactionSource">transaction source</param>
/// <param name="productClaimDefinition">claim product</param>
/// <param name="claimDetailProductMap">claim details used for filtering</param>
/// <param name="claimHeader">claim header</param>
/// <param name="reserves">resulting reserves</param>
/// <param name="payments">resulting payments and recovery receipts</param>
/// <param name="recoveryReserves">resulting recovery reserves</param>
private static void LoadFinancialAmounts(StaticValues.ClaimTransactionSource transactionSource, ProductClaimDefinition productClaimDefinition, IDictionary<string, ProductClaimDetail> claimDetailProductMap, ClaimHeader claimHeader, ClaimTransactionHeader claimtransactionheader, out IEnumerable<ClaimFinancialAmount> reserves, out IEnumerable<ClaimFinancialAmount> payments, out IEnumerable<ClaimFinancialAmount> recoveryReserves)
{
var inProgressData = ObjectFactory.Resolve<IInProgressFinancialAmountData>();
var historicalData = ObjectFactory.Resolve<IHistoricalFinancialAmountData>();
var claimHeaderArg = new ClaimHeaderArgument(AmountDataSource.Both, claimHeader, claimtransactionheader);
var validClaimDetails = claimDetailProductMap
.Where(a => a.Value.ClaimDetailAutomaticDeductibleProcessingMethod == (short)StaticValues.ClaimDetailAutomaticDeductibleProcessingMethod.FromClaimHeader)
.Select(a => a.Key);
var reserveCalculation = new TotalClaimReserveFinancialCalculation(inProgressData, historicalData);
var paymentCalcuation = new TotalClaimPaymentFinancialCalculation(inProgressData, historicalData);
var recoveryReceiptCalculation = new TotalClaimReceiptFinancialCalculation(inProgressData, historicalData);
var recoveryRerserveCalculation = new TotalClaimRecoveryReserveFinancialCalculation(inProgressData, historicalData);
bool includeEstimated = productClaimDefinition.IncurredAmountDerivationMethod == (short)StaticValues.IncurredAmountDerivationMethod.PaymentsReservesincludingEstimated;
bool includeRecoveryEstimated = productClaimDefinition.RecoveryIncurredAmountDerivationMethod == (short)StaticValues.RecoveryIncurredAmountDerivationMethod.ReceiptsRecoveryReservesincludingEstimated;
reserves = reserveCalculation.ReadLatestClaimReserves(claimHeaderArg, includeEstimated).Where(a => validClaimDetails.Contains(a.ClaimDetailReference));
payments = paymentCalcuation.ReadClaimPayments(claimHeaderArg).Where(a => validClaimDetails.Contains(a.ClaimDetailReference));
payments = payments.Concat(recoveryReceiptCalculation.ReadClaimReceipts(claimHeaderArg).Where(a => validClaimDetails.Contains(a.ClaimDetailReference)));
recoveryReserves = recoveryRerserveCalculation.ReadLatestClaimRecoveryReserves(claimHeaderArg, includeRecoveryEstimated).Where(a => validClaimDetails.Contains(a.ClaimDetailReference));
var excludedMovementTypes = ClaimsBusinessLogicHelper.GetExcludedMovementTypesFromAutomaticDeductibleCalculations();
reserves = FilterExcludedMovementTypes(reserves, excludedMovementTypes);
recoveryReserves = FilterExcludedMovementTypes(recoveryReserves, excludedMovementTypes);
payments = FilterExcludedMovementTypes(payments, excludedMovementTypes);
reserves = CreateAmountsForCalculation(reserves);
recoveryReserves = CreateAmountsForCalculation(recoveryReserves);
payments = CreateAmountsForCalculation(payments);
}
