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