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; }