public AuthController(IBusinessUser authService, ITokenHelper tokenHelper, IBusinessCustomer customerService, IBusinessAccount accountService, IBusinessTransaction transactionService)
{
_authService = authService;
_tokenHelper = tokenHelper;
_customerService = customerService;
_accountService = accountService;
_transactionService = transactionService;
}
public void ApplyTransaction(IBusinessTransaction transaction)
{
MustNotBePosted();
foreach (var x in transaction.GetAdditionalChanges())
{
Apply(x);
}
}
/// <summary>
/// Rollback all the inserts.
/// </summary>
/// <returns>A task.</returns>
public async Task RollbackAsync()
{
if (this.bulkSubscriptionPersistenceTransaction != null)
{
await this.bulkSubscriptionPersistenceTransaction.RollbackAsync();
this.bulkSubscriptionPersistenceTransaction = null;
}
}
/// <summary>
/// Rollback all the inserts.
/// </summary>
/// <returns>A task.</returns>
public async Task RollbackAsync()
{
if (bulkSubscriptionPersistenceTransaction != null)
{
await bulkSubscriptionPersistenceTransaction.RollbackAsync().ConfigureAwait(false);
bulkSubscriptionPersistenceTransaction = null;
}
}
private const string GenericDataType_Deductible_Service = "GenericDataType.Deductible.Service"; // SVC
#region ITransactionPlugin Members
/// <summary>
/// Processes the transaction - validates policy data items on PostValidate
/// </summary>
/// <param name="businessTransaction">The business transaction.</param>
/// <param name="point">The point.</param>
/// <param name="PluginId">The plugin identifier.</param>
/// <param name="parameters">The parameters.</param>
/// <returns>Process Results Collection or null</returns>
public ProcessResultsCollection ProcessTransaction(IBusinessTransaction businessTransaction, TransactionInvocationPoint point, int PluginId, params object[] parameters)
{
if (point == TransactionInvocationPoint.PostValidate)
{
return this.ValidatePolicyDataItems((Header)businessTransaction.Component);
}
return null;
}
/// <summary>
/// Adds error details to the transaction if the payment cannot be cancelled because unauthorised reserves,
/// payments, or recovery receipts still exist on it.
/// invoked when CancelPayment transaction is selected.
/// </summary>
/// <param name="businessTransaction">TransactionType CancelPayment</param>
/// <param name="point">Pre Create</param>
/// <param name="PluginId">Plug ID</param>
/// <param name="parameters">Process Transaction Parameters</param>
/// <returns>return Result Collection</returns>
public ProcessResultsCollection ProcessTransaction(IBusinessTransaction businessTransaction, TransactionInvocationPoint point, int PluginId, params object[] parameters)
{
if (point == TransactionInvocationPoint.PreCreate)
{
PreValidate(businessTransaction);
}
return businessTransaction.Results;
}
/// <summary>
/// Transaction process started on Pre complete invocation point.
/// </summary>
/// <param name="businessTransaction">transaction of Business Type</param>
/// <param name="point">Process Invocation Point</param>
/// <param name="PluginId">unique plugin id</param>
/// <param name="parameters">Process parameters</param>
/// <returns>collection of process results</returns>
public ProcessResultsCollection ProcessTransaction(IBusinessTransaction businessTransaction, TransactionInvocationPoint point, int PluginId, params object[] parameters)
{
if (point == TransactionInvocationPoint.PreComplete)
{
ClaimHeader claimHeader = (ClaimHeader)businessTransaction.Component;
// If ClaimHeaderStatusCode is "Report Only-No Estimates" or "Report Only-Estimates Made"
// then raise errors if there are any payments or recovery receipts in progress
if (claimHeader.ClaimHeaderStatusCode == "CRO" || claimHeader.ClaimHeaderStatusCode == "CRE")
{
if (this.InProgressPaymentExists(claimHeader))
{
Xiap.Claims.BusinessLogic.ClaimsBusinessLogicHelper.AddError(businessTransaction.Results, "ENTRY_NOT_ALLOWED_FOR_REPORT_ONLY_CLAIMS", point, claimHeader, StaticValues.ClaimTransactionSource.Payment);
}
else if (this.InProgressRecoveryReceiptExists(claimHeader))
{
Xiap.Claims.BusinessLogic.ClaimsBusinessLogicHelper.AddError(businessTransaction.Results, "ENTRY_NOT_ALLOWED_FOR_REPORT_ONLY_CLAIMS", point, claimHeader, StaticValues.ClaimTransactionSource.RecoveryReceipt);
}
}
// If ClaimHeaderStatusCode is "Open - Payment Made" or "Open - Estimate Made" or "Open - No Estimate" or "Report Only - No Estimate"
// then update the header status code based on payments or reserves.
if (claimHeader.ClaimHeaderStatusCode == "CPY" || claimHeader.ClaimHeaderStatusCode == "CES" || claimHeader.ClaimHeaderStatusCode == "COU" || claimHeader.ClaimHeaderStatusCode == "CRO")
{
// Check for any payments found on the claim.
if (this.IsPaymentFoundOnClaimTransactionHeaders(claimHeader))
{
claimHeader.ClaimHeaderStatusCode = "CPY";// Change to "Open - Payment Made"
claimHeader.PropertiesChanged.Remove(ClaimHeader.ClaimHeaderStatusCodeFieldName);////fix to remove status validation error from ces to cpy
}
else if (this.IsReserveFoundOnClaimTransactionHeaders(claimHeader))
{
// Reserve Made and header status is "Report Only - No Estimate"
if (claimHeader.ClaimHeaderStatusCode == "CRO")
{
claimHeader.ClaimHeaderStatusCode = "CRE"; // change to "Report Only-Estimates Made"
}
else
{
claimHeader.ClaimHeaderStatusCode = "CES"; // else change to "Open - Estimate Made"
}
}
else
{
// "Report Only - No Estimate"
if (claimHeader.ClaimHeaderStatusCode != "CRO")
{
// change to "Open - No Estimate"
claimHeader.ClaimHeaderStatusCode = "COU";
}
}
}
}
return businessTransaction.Results;
}
/// <summary>
/// Call on ClaimHandlerEventDefaulter.
/// Generate an event if this is a PreComplete invocation point.
/// </summary>
/// <param name="businessTransaction">Claim Header</param>
/// <param name="point">Point PreComplete</param>
/// <param name="PlunginId">PlugIn ID</param>
/// <param name="Paramaters">Processing Transaction Parameters</param>
/// <returns>return ProcessResultCollection which have Error msg If any validation failed.</returns>
public ProcessResultsCollection ProcessTransaction(IBusinessTransaction businessTransaction, TransactionInvocationPoint point, int PlunginId, params object[] Paramaters)
{
ClaimHeader claimHeader = (ClaimHeader)businessTransaction.Component;
if (point == TransactionInvocationPoint.PreComplete)
{
this.GenerateEvent(claimHeader);
}
return businessTransaction.Results;
}
/// <summary>
/// Add Claim wake up Validation
/// </summary>
/// <param name="businessTransaction">Bussiness Transaction Reopen Claim</param>
/// <param name="point">Pre Creat</param>
/// <param name="PluginId">Plugin Id</param>
/// <param name="parameters">Extra Parameters</param>
/// <returns>Process Results Collection</returns>
public ProcessResultsCollection ProcessTransaction(IBusinessTransaction businessTransaction, TransactionInvocationPoint point, int PluginId, params object[] parameters)
{
switch (point)
{
case TransactionInvocationPoint.PreCreate:
this.ValidateMigrationStatus(businessTransaction, point);
break;
}
return businessTransaction.Results;
}
/// <summary>
/// Process on Pre-Create of a Genius controlled name usage type.
/// </summary>
/// <param name="businessTransaction">The business transaction.</param>
/// <param name="point">The point.</param>
/// <param name="PluginId">The plugin identifier.</param>
/// <param name="parameters">The parameters.</param>
/// <returns>Process Results Collection</returns>
public ProcessResultsCollection ProcessTransaction(IBusinessTransaction businessTransaction, TransactionInvocationPoint point, int PluginId, params object[] parameters)
{
if (point == TransactionInvocationPoint.PreCreate)
{
Name sourceName = businessTransaction.Component as Name;
if (sourceName.NameUsages.Any(nu=>nu.GetDefinitionComponent().CustomCode01 != IDConstants.NAME_CONTROLLED_IN_GENIUSX))
{
// This will throw an exception of the user isn't allowed to maintain Genius-controlled names.
InsuranceDirectoryBusinessLogicHelper.VerifyPermissionForCurrentUser(IDConstants.GENIUS_SOURCED_NAME_MAINTENANCE_PERMISSION_TOKEN);
}
}
return businessTransaction.Results;
}
/// <summary>
/// Call on ClaimEventTransaction
/// </summary>
/// <param name="businessTransaction">Event Container</param>
/// <param name="point">Point such as PostComplete,PreComplete </param>
/// <param name="PluginId">PlugIN ID</param>
/// <param name="parameters">Processing Trasnaction Parameters</param>
/// <returns>return ProcessResultCollection which have Error msg If any validation failed.</returns>
public ProcessResultsCollection ProcessTransaction(IBusinessTransaction businessTransaction, TransactionInvocationPoint point, int PluginId, params object[] parameters)
{
try
{
// If Transaction Invocation Point is 'PostComplete' or 'PreComplete', then check if the ClaimHeaderStatusCode has changed and trigger the
// corresponding virtual 'Process-handler' plug-ins
if (point == TransactionInvocationPoint.PostComplete || point == TransactionInvocationPoint.PreComplete)
{
IEventContainer eventContainer;
// Get the event container, either from the component or its parent.
if (businessTransaction.Component is IEventContainer)
{
eventContainer = (IEventContainer)businessTransaction.Component;
}
else
{
eventContainer = (IEventContainer)businessTransaction.Component.Parent;
}
if (point == TransactionInvocationPoint.PreComplete)
{
// Create event(s) based on the sources (Payment, Reserve, Recoveries) on the Claim Transaction Header
this.CreateEventOnTransaction(eventContainer);
}
// Check Newly added event and invoke the process handler if attached with the event.
foreach (IEvent ev in eventContainer.Events)
{
if (ev.IsNew)
{
this.InvokeVirtualProcess(ev, eventContainer, point);
}
}
// Check Deleted event and invoke the process handler if attached with the event.
foreach (IEvent ev in businessTransaction.Context.DeletedEvents)
{
this.InvokeVirtualProcess(ev, eventContainer, point);
}
}
}
catch (Exception e)
{
_Logger.Error(e);
throw;
}
return businessTransaction.Results;
}
/// <summary>
/// Create a Payment Cancellation Event against the claim detail for this Claim Transaction, if applicable.
/// </summary>
/// <param name="businessTransaction">Claim Header</param>
private void CreateEventOnTransaction(IBusinessTransaction businessTransaction)
{
ClaimHeader clmHeader = null;
clmHeader = businessTransaction.Component.Parent as ClaimHeader;
if (clmHeader == null)
{
// If there's no Claim Header associated with this transaction do no further processing.
return;
}
// Check if there are Claim Transaction Headers in progress for this claim header that we can process against.
if (clmHeader.InProgressClaimTransactionHeaders != null)
{
// Find a Product Event for this Product Version for a Payment Cancellation
var productEvent = ProductService.GetProductEventQuery().GetProductEvents(clmHeader.ProductVersionID.GetValueOrDefault())
.Where(x => x.EventTypeCode == ClaimConstants.EVENT_TYPECODE_PAYMENTCANCELLATION).FirstOrDefault();
if (productEvent != null)
{
// We have a Product Event that can be raised so cycle through all the In Progress CTHs
foreach (ClaimTransactionHeader clmTransHeader in clmHeader.InProgressClaimTransactionHeaders)
{
if (clmTransHeader.ClaimTransactionGroups != null)
{
// We need at least one claim transaction group on the CT header, although we only use the first.
ClaimTransactionGroup clmTransGroup = clmTransHeader.ClaimTransactionGroups.First();
// Only work with Payment Cancellation Claim Transaction Header types.
switch (clmTransHeader.ClaimTransactionSource)
{
case (short)StaticValues.ClaimTransactionSource.PaymentCancellation:
// Find out if we have a Payment amount against any Claim Transaction Details on the current CT Group for this CT Header
bool result = clmTransGroup.ClaimTransactionDetails.AsEnumerable<ClaimTransactionDetail>().Any(x => x.AmountType == (short)StaticValues.AmountType.Payment);
if (result)
{
// If so, raise the Payment Cancellation event against the claim detail for this group.
this.CreateEvent(clmTransGroup.ClaimDetail, clmTransHeader, productEvent.ProductEventID);
}
break;
}
}
}
}
}
}
public void Initialise()
{
this.plugin = new ExcessAndDeductibleDataSetValidationPlugin();
this.componentMetadata = MockRepository.GenerateStub<IComponentMetadata>();
// var headerVersionBuilder = new BusinessComponentBuilder<HeaderVersion>().Build();
// var sdvBuilder = new BusinessComponentBuilder<SectionDetailVersion>().Build();
// var coverageBuilder = new BusinessComponentBuilder<CoverageVersion>().Build();
var hdr = new BusinessComponentBuilder<Header>()
.Add(new BusinessComponentBuilder<HeaderVersion>()
.SetProperty(a => a.IsLatestVersion = true))
.Add(new BusinessComponentBuilder<Section>()
.Add(new BusinessComponentBuilder<SectionVersion>()
.SetProperty(a => a.IsLatestVersion = true))
.Add(new BusinessComponentBuilder<SectionDetail>()
.Add(new BusinessComponentBuilder<SectionDetailVersion>()
.SetProperty(a => a.IsLatestVersion = true))
.Add(new BusinessComponentBuilder<Coverage>()
.Add(new BusinessComponentBuilder<CoverageVersion>()
.SetProperty(a => a.IsLatestVersion = true))))).Build();
this.componentMetadata = MockRepository.GenerateStub<IComponentMetadata>();
var genericDataTypeVersion = new ProductBuilder<GenericDataTypeVersion>(this.componentMetadata).Build();
genericDataTypeVersion.GenericDataTypeComponent = new GenericDataType { Code = "AND2" };
this.header = hdr;
this.headerVersion = this.header.HeaderVersions[0];
this.headerVersion.CreateGenericDataSet();
this.sectionDetailVersion = this.header.Sections[0].SectionDetails[0].SectionDetailVersions[0];
this.sectionDetailVersion.CreateGenericDataSet();
this.coverageVersion = this.header.Sections[0].SectionDetails[0].Coverages[0].CoverageVersions[0];
this.coverageVersion.CreateGenericDataSet();
this.businessTransaction = MockRepository.GenerateStub<IBusinessTransaction>();
this.businessTransaction.Component = hdr;
var metadata = MockRepository.GenerateStub<IMetadataQuery>();
metadata.Stub(a => a.GetGenericDataTypeVersion(0, DateTime.Now)).IgnoreArguments().Return(new GenericDataTypeVersion { GenericDataTypeVersionID = 0 });
var container = new UnityContainer();
container.RegisterInstance<IMetadataQuery>(metadata);
container.RegisterInstance<IComponentMetadata>(this.componentMetadata);
container.RegisterInstance<IMessageService>(new MockMessagingService());
ObjectFactory.Instance = new ObjectFactory(container);
}
/// <summary>
/// Records all the resulting subscriptions as well as their initial purchase history into persistence.
/// </summary>
/// <returns>A task.</returns>
public async Task ExecuteAsync()
{
var inputs = this.AcquireInput.Invoke();
Order partnerCenterPurchaseOrder = inputs.Item1;
IEnumerable <PurchaseLineItemWithOffer> purchaseLineItems = inputs.Item2;
ICollection <TransactionResultLineItem> transactionResultLineItems = new List <TransactionResultLineItem>();
ICollection <IBusinessTransaction> persistenceTransactions = new List <IBusinessTransaction>();
DateTime rightNow = DateTime.UtcNow;
foreach (var orderLineItem in partnerCenterPurchaseOrder.LineItems)
{
var matchingPartnerOffer = purchaseLineItems.ElementAt(orderLineItem.LineItemNumber).PartnerOffer;
// add a record new customer subscription transaction for the current line item
persistenceTransactions.Add(new RecordNewCustomerSubscription(
this.CustomerSubscriptionsRepository,
new CustomerSubscriptionEntity(this.CustomerId, orderLineItem.SubscriptionId, matchingPartnerOffer.Id, rightNow.AddYears(1))));
// add a record purchase history for the current line item
persistenceTransactions.Add(new RecordPurchase(
this.CustomerPurchasesRepository,
new CustomerPurchaseEntity(CommerceOperationType.NewPurchase, Guid.NewGuid().ToString(), this.CustomerId, orderLineItem.SubscriptionId, orderLineItem.Quantity, matchingPartnerOffer.Price, rightNow)));
// build the transaction result line item
transactionResultLineItems.Add(new TransactionResultLineItem(
orderLineItem.SubscriptionId,
matchingPartnerOffer.Id,
orderLineItem.Quantity,
matchingPartnerOffer.Price,
matchingPartnerOffer.Price * orderLineItem.Quantity));
}
// bundle up all the transactions together
this.bulkSubscriptionPersistenceTransaction = new SequentialAggregateTransaction(persistenceTransactions);
// execute it!
await this.bulkSubscriptionPersistenceTransaction.ExecuteAsync();
// store the reuslting transaction line items
this.Result = transactionResultLineItems;
}
/// <summary>
/// Check whether migration processing has been completed or not.
/// </summary>
/// <param name="businessTransaction">IBusiness Transaction</param>
/// <param name="point">Transaction Invocation Point</param>
private void ValidateMigrationStatus(IBusinessTransaction businessTransaction, TransactionInvocationPoint point)
{
ClaimHeader claimHeader = (ClaimHeader)businessTransaction.Component;
// UI Label = Data Source
if (claimHeader.CustomCode19 == ClaimConstants.CLAIMS_MIGRATION_STATUS)
{
// ClaimWakeUp Validations
// CustomCode18=CMS Migration Status
// UI Label = CMS Migration Status
// if REOPENING OF UNPROCESSED CLAIM NOT ALLOWED
// else if MIGRATED CLOSED CLAIM BEING PROCESSED
// send message REOPENING OF A CLAIM ALREADY BEING PROCESSED NOT ALLOWED
// else if = FAILED DUE TO INTERNAL SERVICE CONNECTION ISSUES
// send message REOPENING OF A CLAIM THAT FAILED PROCESSING NOT ALLOWED
// else if FAILED POLICY DOES NOT EXIST IN GENIUSX
// send message REOPENING OF A CLAIM NOT ALLOWED WITHOUT POLICY
// else if FAILED POLICY EXISTS BUT COULD NOT ATTACH TO CLAIM
// send message REOPENING OF CLAIM NOT ALLOWED POLICY FAILURE
if (string.IsNullOrWhiteSpace(claimHeader.CustomCode18))
{
ClaimsBusinessLogicHelper.AddFatalError(businessTransaction.Results, ClaimConstants.REOPENING_OF_UNPROCESSED_CLAIM_NOT_ALLOWED,point, businessTransaction.Component);
}
else if (claimHeader.CustomCode18 == ClaimConstants.MIGRATED_CLOSED_CLAIM_BEING_PROCESSED)
{
ClaimsBusinessLogicHelper.AddFatalError(businessTransaction.Results, ClaimConstants.REOPENING_OF_A_CLAIM_ALREADY_BEING_PROCESSED_NOT_ALLOWED, point, businessTransaction.Component);
}
else if (claimHeader.CustomCode18 == ClaimConstants.FAILED_DUE_TO_INTERNAL_SERVICE_CONNECTION_ISSUES)
{
ClaimsBusinessLogicHelper.AddFatalError(businessTransaction.Results, ClaimConstants.REOPENING_OF_A_CLAIM_THAT_FAILED_PROCESSING_NOT_ALLOWED, point, businessTransaction.Component);
}
else if (claimHeader.CustomCode18 == ClaimConstants.FAILED_POLICY_DOES_NOT_EXIST_IN_GENIUSX)
{
ClaimsBusinessLogicHelper.AddFatalError(businessTransaction.Results, ClaimConstants.REOPENING_OF_CLAIM_NOT_ALLOWED_WITHOUT_POLICY, point, businessTransaction.Component);
}
else if (claimHeader.CustomCode18 == ClaimConstants.FAILED_POLICY_EXISTS_BUT_COULD_NOT_ATTACH_TO_CLAIM)
{
ClaimsBusinessLogicHelper.AddFatalError(businessTransaction.Results, ClaimConstants.REOPENING_OF_CLAIM_NOT_ALLOWED_POLICY_FAILURE, point, businessTransaction.Component);
}
}
}
public TransactionController(IBusinessTransaction transactionService)
{
_transactionService = transactionService;
}
/// <summary>
/// Process on the PostComplete point.
/// If Create Claim,CloseClaim,ReopenClaim,AmendClaim,Copy,Delete ,CancelPayment,ReserveAuthorisation,PaymentAuthorisation,RecoveryReceiptAuthorisation
/// </summary>
/// <param name="businessTransaction">Processing ClaimTransactionHeader</param>
/// <param name="point">it is invocation(PostComplete)</param>
/// <param name="PluginId">Plugin ID</param>
/// <param name="parameters">Process transaction Parameters if any </param>
/// <returns>return Result Collection</returns>
public ProcessResultsCollection ProcessTransaction(IBusinessTransaction businessTransaction, TransactionInvocationPoint point, int PluginId, params object[] parameters)
{
ClaimHeader claimHeader = null;
using (PerfLogger _LG = new PerfLogger(typeof(AXAClaimTransferPlugin), "AXAClaimTransferPlugin"))
{
if (point == TransactionInvocationPoint.PostComplete)
{
if (businessTransaction.Component != null)
{
if (businessTransaction.Component is ClaimTransactionHeader)
{
claimHeader = businessTransaction.Component.Parent as ClaimHeader;
}
else
{
claimHeader = businessTransaction.Component as ClaimHeader;
}
}
// Get invalid Header Status codes from the application configuration
// No claims of this header status code will be transferred.
string invalidClaimHeaderStatusCodes = ClaimsBusinessLogicHelper.ResolveMandatoryConfig<string>(ClaimConstants.APP_SETTING_KEY_HEADERSTATUSESFORINVALIDCLAIMTRANSFER);
if (claimHeader != null && ClaimsBusinessLogicHelper.CheckValidHeaderStatus(claimHeader, invalidClaimHeaderStatusCodes))
{
if (_Logger.IsDebugEnabled)
{
_Logger.Debug(claimHeader.ClaimReference + " : has valid claim header status code.");
}
// If header status of claim has been changed to Abandoned then if previous header status was valid then insert entry in claim transfer control log table.
if (claimHeader.ClaimHeaderStatusCode == ClaimConstants.CLAIM_HEADER_STATUS_ABANDONED)
{
if (claimHeader.OriginalTransitionStatus == ClaimConstants.CLAIM_HEADER_STATUS_NO_ESTIMATE
|| claimHeader.OriginalTransitionStatus == ClaimConstants.CLAIM_HEADER_STATUS_ESTIMATE_MADE
|| claimHeader.OriginalTransitionStatus == ClaimConstants.CLAIM_HEADER_STATUS_PAYMENT_MADE)
{
this.AddClaimTransferControlLogEntry(businessTransaction);
}
// No further processing of an abandoned claim
return null;
}
// Check if status is moved from invalid to valid then write out all ClaimTransactions to Transfer log which were added when claim status was invalid.
List<string> invalidClaimHeaderStatusesList = invalidClaimHeaderStatusCodes.Split(',').ToList<string>();
if (!string.IsNullOrEmpty(invalidClaimHeaderStatusCodes)
&& claimHeader.OriginalTransitionStatus != claimHeader.ClaimHeaderStatusCode
&& invalidClaimHeaderStatusesList.Contains(claimHeader.OriginalTransitionStatus.ToString())
&& !invalidClaimHeaderStatusesList.Contains(claimHeader.ClaimHeaderStatusCode.ToString()))
{
// If there is status transition from invalid to valid then this won't insert records for financial transactions instead
// Stored Procedure will insert all the finanical transactions.
this.AddClaimTransferControlLogEntry(businessTransaction, false);
if (_Logger.IsDebugEnabled)
{
_Logger.Debug(claimHeader.ClaimReference + " : Using SP to to Inserting financial records that were made when claim was having invalid header status code into ClaimTransferControlLog table.");
}
// Use Stored Procedure to retroactively insert the necessary financial recors.
IAXAClaimsQuery query = ObjectFactory.Resolve<IAXAClaimsQuery>();
query.ExecuteClaimTransferControlLogSP(claimHeader.ClaimReference.ToString());
}
else
{
if (_Logger.IsDebugEnabled)
{
_Logger.Debug(claimHeader.ClaimReference + " : Inserting financial records of claim having valid header status code, into ClaimTransferControlLog table.");
}
// This will insert records for create/update claim and financial transaction if exist.
this.AddClaimTransferControlLogEntry(businessTransaction, true);
}
}
}
}
return null;
}
/// <summary>
/// Entry of claims having invalid ClaimHeaderStatusCode will not be inserted into ClaimTransferControlLog table
/// </summary>
/// <param name="businessTransaction">IBusinessTransaction businessTransaction</param>
/// <param name="insertFinancialTransactions">Insert Financial Transactions</param>
/// <returns>ProcessResultsCollection businessTransaction.Results</returns>
private ProcessResultsCollection AddClaimTransferControlLogEntry(IBusinessTransaction businessTransaction, bool insertFinancialTransactions = true)
{
ClaimHeader claimHeader = null;
bool? isRootComponentClaimHeader = null;
if (businessTransaction.Component != null)
{
ComponentStateChange claimHeaderComponentStateChange = null;
// Determine if the root component is a Claim Header or a Claim Transaction Header and set boolean appropriately
if (businessTransaction.Component is ClaimTransactionHeader)
{
claimHeader = businessTransaction.Component.Parent as ClaimHeader;
isRootComponentClaimHeader = false;
}
else
{
claimHeader = businessTransaction.Component as ClaimHeader;
isRootComponentClaimHeader = true;
}
if (claimHeader != null)
{
// Get a list of changes to the component.
List<ComponentStateChange> componentStateChanges = (businessTransaction as AbstractEFBusinessTransaction).ComponentStateChanges;
if (claimHeader.PolicyHeaderID.GetValueOrDefault(0) == 0 || string.IsNullOrEmpty(claimHeader.PolicyExternalDataSource))
{
// If there's no external data source attached to the product data, we aren't going to transfer anything so leave
return businessTransaction.Results;
}
if (componentStateChanges.Count > 0)
{
ClaimDetail claimDetail = null;
// Add a single entry to ClaimTransferRequestLog of type claim if Claim Header,ClaimDetail and ClaimNameInvolvement exist in list.
List<ComponentStateChange> componentList = componentStateChanges.Where(x => x.Component is ClaimHeader || x.Component is ClaimDetail || x.Component is ClaimNameInvolvement).ToList();
if (!componentList.IsNullOrEmpty())
{
claimHeaderComponentStateChange = componentList.Where(x => x.Component is ClaimHeader).FirstOrDefault();
// Claim Header changes
if (claimHeaderComponentStateChange != null)
{
// Single entry should be added if ComponentChangeType is deleted.
if (claimHeaderComponentStateChange.ComponentChangeType == ChangeType.Deleted)
{
ClaimTransfer.AddControlLogRequest((short)StaticValues.ClaimTransferType.Delete, claimHeader.ClaimReference, claimHeader.ClaimHeaderStatusCode, null);
return businessTransaction.Results;
}
else if (claimHeader.Context.TransactionType == ClaimsProcessConstants.REOPENCLAIM)
{
// Otherwise add a reopen if we are doing a reopen on the claim.
ClaimTransfer.AddControlLogRequest((short)StaticValues.ClaimTransferType.Reopen, claimHeader.ClaimReference, claimHeader.ClaimHeaderStatusCode, null);
}
}
List<ComponentStateChange> claimDetailComponentList = componentList.Where(x => (x.Component is ClaimDetail)).ToList();
// Claim Detail changes
if (!claimDetailComponentList.IsNullOrEmpty())
{
// Find the first claim detail on the list that is attached to a policy
ComponentStateChange stateChange = claimDetailComponentList.Where(x => (x.Component as ClaimDetail).PolicyLinkLevel != null).FirstOrDefault();
if (stateChange != null)
{
claimDetail = stateChange.Component as ClaimDetail;
}
}
if (claimDetail == null)
{
// We don't have a valid claim detail (it's attached to a policy)
// now go back to our list and find the first name involvement change, if any
ComponentStateChange componentStateChange = componentList.Where(x => x.Component is ClaimNameInvolvement).FirstOrDefault();
if (componentStateChange != null)
{
ClaimNameInvolvement claimNameInvolvement = componentStateChange.Component as ClaimNameInvolvement;
ClaimTransfer.AddControlLogRequest((short)StaticValues.ClaimTransferType.Claim, claimHeader.ClaimReference, claimHeader.ClaimHeaderStatusCode, null);
}
else
{
ClaimTransfer.AddControlLogRequest((short)StaticValues.ClaimTransferType.Claim, claimHeader.ClaimReference, claimHeader.ClaimHeaderStatusCode, null);
}
}
else
{
// Change to claim detail so send through a claim change request.
ClaimTransfer.AddControlLogRequest((short)StaticValues.ClaimTransferType.Claim, claimHeader.ClaimReference, claimHeader.ClaimHeaderStatusCode, null);
}
}
if (insertFinancialTransactions)
{
// For each authorised entry in the list for a ClaimTransactionheader in ClaimTransferRequestLog
List<ComponentStateChange> claimTransactionheaderlist = componentStateChanges.Where(x => x.Component is ClaimTransactionHeader).ToList();
if (!claimTransactionheaderlist.IsNullOrEmpty())
{
if (claimTransactionheaderlist.Any(x => (x.Component as ClaimTransactionHeader).IsClaimPaymentCancelled == true))
{
// Remove cancelled payments from the list
claimTransactionheaderlist.RemoveAll(x => (x.Component as ClaimTransactionHeader).ClaimTransactionSource != (short)StaticValues.ClaimTransactionSource.PaymentCancellation);
}
foreach (ComponentStateChange componentStateChange in claimTransactionheaderlist)
{
ClaimTransactionHeader claimTransactionHeader = componentStateChange.Component as ClaimTransactionHeader;
if (this.IsAmountAuthorized(isRootComponentClaimHeader, claimTransactionHeader))
{
// Add a transfer for any authorised payment
ClaimTransfer.AddControlLogRequest((short)StaticValues.ClaimTransferType.FinancialTransaction, claimHeader.ClaimReference, claimHeader.ClaimHeaderStatusCode, claimTransactionHeader.ClaimTransactionHeaderID);
}
}
}
}
if (!componentList.IsNullOrEmpty())
{
// If we have any entry on the component list for a claim header
claimHeaderComponentStateChange = componentList.Where(x => x.Component is ClaimHeader).FirstOrDefault();
if (claimHeaderComponentStateChange != null)
{
claimHeader = claimHeaderComponentStateChange.Component as ClaimHeader;
// if we moved this claim to finalised or Closed/Opened in error, then send through a Close request to Genius.
if ((claimHeader.ClaimHeaderInternalStatus.GetValueOrDefault() == (short)StaticValues.ClaimHeaderInternalStatus.Finalized || claimHeader.ClaimHeaderInternalStatus.GetValueOrDefault() == (short)StaticValues.ClaimHeaderInternalStatus.ClosedOpenedInError) && claimHeader.ClaimHeaderStatusCode != claimHeader.OriginalTransitionStatus)
{
ClaimTransfer.AddControlLogRequest((short)StaticValues.ClaimTransferType.Close, claimHeader.ClaimReference, claimHeader.ClaimHeaderStatusCode, null);
}
}
}
}
}
}
return businessTransaction.Results;
}
