/* Minification failed. Returning unminified contents.
(489,60-61): run-time error JS1195: Expected expression: >
(489,77-78): run-time error JS1004: Expected ';': )
(490,9-10): run-time error JS1002: Syntax error: }
(493,12-13): run-time error JS1195: Expected expression: )
(493,14-15): run-time error JS1004: Expected ';': {
(546,2-3): run-time error JS1195: Expected expression: )
(547,12-13): run-time error JS1195: Expected expression: )
(547,14-15): run-time error JS1004: Expected ';': {
(575,2-3): run-time error JS1195: Expected expression: )
(576,12-13): run-time error JS1195: Expected expression: )
(576,14-15): run-time error JS1004: Expected ';': {
(672,2-3): run-time error JS1195: Expected expression: )
(673,12-13): run-time error JS1195: Expected expression: )
(673,14-15): run-time error JS1004: Expected ';': {
(845,71-72): run-time error JS1100: Expected ',': =
(845,74-75): run-time error JS1002: Syntax error: ,
(845,97-98): run-time error JS1100: Expected ',': =
(2519,2-3): run-time error JS1195: Expected expression: )
(2520,12-13): run-time error JS1195: Expected expression: )
(2520,14-15): run-time error JS1004: Expected ';': {
(2572,2-3): run-time error JS1195: Expected expression: )
(2573,12-13): run-time error JS1195: Expected expression: )
(2573,14-15): run-time error JS1004: Expected ';': {
(2667,56-57): run-time error JS1195: Expected expression: >
(2669,17-18): run-time error JS1195: Expected expression: )
(2669,26-27): run-time error JS1197: Too many errors. The file might not be a JavaScript file: )
(2665,9-39): run-time error JS1301: End of file encountered before function is properly closed: function b64DecodeUnicode(str)
(2669,27-28): run-time error JS1195: Expected expression: )
(2669,28-29): run-time error JS1197: Too many errors. The file might not be a JavaScript file: ;
(2579,5-68): run-time error JS1301: End of file encountered before function is properly closed: function utilityService($filter, apiUrlConstService, $resource)
(2737,5-6): run-time error JS1002: Syntax error: }
(2738,1-2): run-time error JS1197: Too many errors. The file might not be a JavaScript file: }
 */
//making this module global
var app = angular.module('appUI', ['ngResource', 'ui.grid', 'ui.grid.pagination', 'angular-loading-bar', 'ngAnimate', 'ngCookies', 'ngMessages', 'ngDatePicker', 'ngMaterial', 'angularMoment', 'ngMessages', 'ui.mask', 'ngFileSaver', 'ngSanitize', 'angularjs-crypto', 'angular-carousel']);
;
(function () {
    'use strict';
    angular.module('appUI').factory('BearerAuthInterceptor', ['$window', '$cookieStore', '$q', BearerAuthInterceptor]);

    function BearerAuthInterceptor($window, $cookieStore, $q) {
        return {
            request: function (config) {
                config.headers = config.headers || {};
                return config || $q.when(config);
            },
            response: function (response) {
                if (response.status === 307) {
                    $window.location.href = "/Application/Index";
                }
                else if (response.data.error !== undefined && response.data.error !== "") {
                    if (response.data.error.number === "307") {
                        $cookieStore.put("systemDownTimeMsg", response.data.data);
                        $window.location.href = "/Application/Index";
                    }
                    else if (response.data.error.number === 401)
                        $window.location.href = "/";
                    else
                        return response || $q.when(response);
                }
                else if (response.data.errors !== undefined && response.data.errors.length > 0) {
                    if (response.data.errors[0].Number === "307") {
                        $cookieStore.put("systemDownTimeMsg", response.data.data);
                        $window.location.href = "/Application/Index";
                    }
                    else if (response.data.errors.number === 401)
                        $window.location.href = "/";
                    else
                        return response || $q.when(response);
                }
                else {
                    return response || $q.when(response);
                }
            }
        };
    }
})();;
(function () {
    'use strict';
    angular.module('appUI').factory('OverlayInterceptor', ['$rootScope', '$q', OverlayInterceptor]);

    function OverlayInterceptor($rootScope, $q) {
        var numLoadings = 0;

        return {
            request: function (config) {
                numLoadings++;
                if (!config.skipInterceptor) {
                    $rootScope.$broadcast("loader_show");
                }

                return config || $q.when(config)
            },
            response: function (response) {
                if ((--numLoadings) === 0) {
                    $rootScope.$broadcast("loader_hide");
                }

                return response || $q.when(response);
            },
            responseError: function (response) {
                if (!(--numLoadings)) {
                    $rootScope.$broadcast("loader_hide");
                }

                return $q.reject(response);
            }
        };
    }

})();;
(function () {
    'use strict'
    app.config(['$httpProvider', '$provide', 'cfpLoadingBarProvider', '$sceDelegateProvider', appConfig]);

    function appConfig($httpProvider, $provide, cfpLoadingBarProvider) {
        cfpLoadingBarProvider.includeBar = true;
        cfpLoadingBarProvider.includeSpinner = false;
        $httpProvider.interceptors.push('BearerAuthInterceptor');
        $httpProvider.interceptors.push('OverlayInterceptor');
    }
})();;
(function () {
    'use strict'
    app.run(['$rootScope', '$http', '$mdDialog', appRun]);

    function appRun($rootScope, $httpProvider) {
        // Set request headers
        $httpProvider.defaults.headers.common['X-Requested-With'] = 'XMLHttpRequest';
        //$httpProvider.defaults.headers.common['Origin'] = 'clientbase';
        $httpProvider.defaults.headers.common['X-App-Origin'] = 'clientbase'; 
    }
})();;
(function () {
    'use strict';

    angular.module('appUI')
        .constant('routeConstService', {
            routeName: "selectedRoute"
        });

})();;
(function () {
    'use strict';

    angular.module('appUI')
        .constant('apiUrlConstService', {
            clientURL: '/Proxy/Client/',
            addClientAsyncURL: '/Proxy/Client/AddClientAsync',
            getByCodeURL: '/Proxy/Client/GetByClientCode?clientCode=:clientCode',
            getByNameURL: '/Proxy/Client/GetByName?name=:name',
            getByNameAndCodeURL: '/Proxy/Client/GetByNameAndCodeAsync',
            getAllClientsByClientCodeURL: '/Proxy/Client/GetAllClientsByClientCode',
            getClients: '/Proxy/Client/GetClients?',
            deleteClientURL: '/Proxy/Client/Delete?clientCode=:clientCode',
            updateClientURL: '/Proxy/Client/Put?client=:client',
            disclaimerDataSave: '/Proxy/broker/SaveAllBrokerTermsAndCondition',
            quoteDocumentURL: '/Proxy/QuoteCase/QuoteDocumentsAsync',
            policyDocumentURL: '/Proxy/Bind/PolicyDocumentsAsync',
            policyScheduleDocumentURL: '/Proxy/Bind/PolicyScheduleDocumentAsync',
            clientFirstNameURL: '/Proxy/Client/GetClientAllSearch',
            productURL: '/Proxy/Product/',
            quoteURL: '/Proxy/Quote/',
            quoteDetailURL: '/Proxy/Quote/GetQuote',
            nvicMotorURL: '/Proxy/NVICMotor/',
            lookupURL: '/Proxy/Lookup/',
            bindURL:  '/Proxy/Bind/',
            addressURL: '/Proxy/AddressService/',
            quotesUrl: '/Proxy/broker/GetAllQuotesAsync?',
            policiesUrl: '/Proxy/broker/GetAllPoliciesAsync?',
            getPoliciesQuotes: '/Proxy/broker/GetAllQuotesPoliciesAsync?',
            monthUrl : '/Proxy/broker/GetAllQuotesPoliciesBasedOnQueryAsync?month=:month&product=:product&status=:status',
            quoteUrl : '/Proxy/broker/:brokerId/quote/:quoteId',
            saveQuoteUrl : '/Proxy/Quote/SaveRequestAsync',
            generateQuoteUrl : '/Proxy/Quote/QuoteRequestAsync',
            ExistingCaseUrl : '/Proxy/NewBusiness/Get?caseId=:caseId',
            getInsuredNameUrl : '/Proxy/Client/GetInsuredNameListAsync?caseId=:caseId',
            intechCordellApiUrl : '/Proxy/AddressService/IntechAddressCordellApiAsync',
            sumInsuredEstimateApiUrl: '/Proxy/AddressService/SumInsuredEstimate',
            quotesearchUrl: '/Proxy/Quote/Get',
            getQuoteCaseUrl:'/Proxy/Quotecase?transactionId=:transactionId',
            policySearchUrl: '/Proxy/Policy/Get',
            partialPolicySearchUrl: '/Proxy/Policy/GetPartialPolicySearch?',
            partialPackageSearchUrl: '/Proxy/Policy/GetPartialPackageSearch?',
            getPackageSearchUrl: '/Proxy/Quote/GetPackageSearch?',
            getClientPackages: '/Proxy/package?clientNameandCode=:clientNameandCode',
            getbrokerFeeGSTURL: '/Proxy/Quote/GetBrokerFeeGST',
            getbrokerCommissionRequestURL: '/Proxy/Lookup/GetbrokerCommissionRequest',
            getbrokerCommissionRequestOnEditURL: '/Proxy/Quote/GetbrokerCommissionRequestOnEdit',
            getOccupation: '/Proxy/Lookup/GetOccupation',
            dropCancellationQuote: '/Proxy/Cancellation/DropCancellationQuoteAsync?qid=',
            generateCancellationQuoteUrl: '/Proxy/Quote/CancellationQuoteRequestAsync',
            getGSTAmount: '/Proxy/RatingSummary/GetGSTAmountAsync',
            endorsementNonComissionQuoteUrl: '/Proxy/Quote/EndorsementNonComissionQuoteRequest',
            endorsementComissionQuoteUrl: '/Proxy/Quote/EndorsementComissionQuoteRequest',
            userUrl: '/Proxy/user/',
            userSentResetPasswordEmailUrl: '/Proxy/user/SentResetPasswordEmail',
            userResetPasswordUrl: '/Proxy/user/ResetPassword',
            userChangePasswordUrl: '/Proxy/user/ChangePassword',
            quoteReferralSavingApiUrl: '/Proxy/Quote/BackDatingBindReferralAsync?qid=:qid',
            attachementUploadUrl: '/Proxy/Quote/UploadRequestAsync',
            quoteDiscardRequestApiUrl: '/Proxy/Quote/QuoteDiscardRequestAsync?qid=:qid',
            paymentCollectionMode: '/Proxy/Bind/PaymentCollection',
            packageSearchUrl: '/Proxy/PackageManager/GetPackageList?',
            saveMonthlyPackagePaymentDay: '/Proxy/PackageManager/SaveMonthlyPackagePaymentDay?',
            saveAnnualPackagePaymentDate: '/Proxy/PackageManager/SaveAnnualPackagePaymentDate?',
            discardQuote: '/Proxy/PackageManager/discardQuote?',
            getPackageDetails: '/Proxy/PackageManager/GetPackageDetails?',
            getMotorVehicleManuYears: '/Proxy/NVICMotor/GetYearOfManufacture',
            getDDlVehicleColours: '/Proxy/NVICMotor/GetDropDownVehicleColour?',
            getMotorVehiclemake: '/Proxy/NVICMotor/GetMotorMake?',
            getMotorVehiclemodel: '/Proxy/NVICMotor/GetMotorModel?',
            getMotorVehicledesList: '/Proxy/NVICMotor/GetMotorDetails?',
            getMotorDetailsForId: '/Proxy/NVICMotor/GetMotorDetailsForId?',
            getSecondaryInsured: '/Proxy/Client/GetInsuredNameListAsync?caseId=:caseId',
            getMotorVehicleStyle: '/Proxy/NVICMotor/GetMotorDetails?',
            getMotorVehicleTransmission: '/Proxy/NVICMotor/GetMotorTransmission?',
            getMotorVehicleSize: '/Proxy/NVICMotor/GetMotorSize?',
            policyQuestionSetUrl: '/Proxy/Quote/GetQuestionSetForExistingPolicy',
            packageSearchQueryUrl: 'Proxy/PackageManager/GetPartialPackageSearch',
            updateExpirationInstallmentDate: 'Proxy/PackageManager/UpdateExpirationInstallmentDate?',
            documentLibraryList: '/Proxy/DocumentLibrary/GetDocumentLibraryList',
            getDocument: '/mediaProxy/DocumentLibrary/GetDocumentLibrary',
            claimTabList: '/Proxy/claimTab/GetclaimTabList',
            getclaimTab: '/mediaProxy/claimTab/GetclaimTab',
            illionURL: '/Proxy/Illion/',
            quoteDiscard: '/Proxy/PackageManager/DiscardQuote?',
            getQuoteStatus: '/Proxy/PackageManager/GetQuoteStatus?',
            renewalReportGenerationL: '/mediaProxy/Renewal/GenerateRenewalsReport',
            cancellationReportGeneration: '/mediaProxy/Cancellation/GenerateCancellationReport',                               
            getRenewalData: '/Proxy/Renewal/GetRenewalData?',
            getCancellationReportData: '/Proxy/Cancellation/GetCancellationReportData?',
            quoteIndexUrl: '/QuoteCase/Index?',
            bindIndexUrl: '/Bind/Index?',
            getUpcomingDuePoliciesData: '/mediaProxy/Report/GetDueAnnualPolicy?',
            getQuoteTransaction: '/Proxy/Quote/GetQuoteTransaction?transactionId=:transactionId',
            getClaimHistoryData: '/mediaProxy/Report/GetClaimHistory?',
            refreshToken: '/Application/RefreshToken',
            getLookUpValueFromShortDescription: '/Proxy/Lookup/GetLookUpValueFromShortDescription',
            getExcessListForDefaultExcess: '/Proxy/NVICMotor/GetExcessListForDefaultExcess?',
            getV2Token: '/PortalV2/GetV2Token',
            getUiVersionUrl: '/Proxy/Quote/GetUIVersion',
            generateCancellationQuoteV2Url: '/Proxy/Quote/CancellationQuoteRequestV2Async',
            getAddressEnquiryUrl: '/Proxy/Quote/GetAddressEnquiryJson'
        });

})();;
(function () {
    'use strict';

    angular.module('appUI')
        .constant('messageConstService', {
            errServiceUnavailable: 'Service is currently not available. Please try again or contact system administrator.',
            errService3rdAPIUnavailable: 'System is currently not working. Please try after sometime.',
            errLoginInvalid: 'User Name or Password Incorrect. Please try Again.',
            errUserNameNotEmail: 'Please enter a valid username.',
            errUserNameNotAlphanumeric: 'Please enter a valid username.',
            errPasswordMiniCharacter: 'Please enter atleast 8 characters.',
            errPasswordMaxCharacter: 'Password cannot be more than 20 characters.',
            errInputRequired: 'Please fill the required field.',
            succAdded: "Added Successfully.",
            succUpdated: "Updated Successfully.",
            succDeleted: "Deleted Successfully.",
            errDateInvalid: "Invalid Date!",
            errFutureDateNotAllowed: "Future date not allowed!",
            errDateNotAllowed: "Date not allowed!",
            errDateOutOfRange: "Minimum policy Date is greater than maximum date.",
            errDateBelowRange: "Date Below Range.",
            errDateAboveRange: "Date Above Range.",
            errPolicyMinimumPeriod: "Policy period less than ##0 days is not allowed.",
            errPolicyMaximumPeriod: "Policy period has exceeded the maximum limit of ##0 days.",
            errRegoStateNotFound: "State/Plate not found!",
            succdetailUpdated: "Quote successfully referred to the underwriter.",
            errRecordUpdated: "The record has been updated by another user.",
            errRatingService: "Rating Service is currently not available.Please try again or contact system administrator.",
            errDecisionService: "Decision Service is currently not available. Please try again or contact system administrator.",
            errSumInsuredCalculation: "API Service Not Available.Building Sum Insured Not Calculated",
            errCompleteAddress: "Please enter complete address",
            errDuplicatePolicyHolder: "Duplicate additional policyholder not allowed.",
            errEffectiveDateNotAllowed: "Effective Date not allowed!",
            errMinExpirationDate: "Expiration Date cannot be less than Effective Date.",
            succPaymentInfoSaved: "Payment infomation saved successfully.",
            succPaymentInfoExist: "Payment Detail already exist for the package and will be applicable on this policy.",
            errCancellationSubmit: "Something went wrong in cancellation process.",
            errSelectAgain: "Please Select Again!",
            errCordellWarning: "API Service Not Available. Building sum insured not returned. Please enter it manually and proceed.",
            errCordellPropertyType: "Unfortunately we won’t be able to fill property data as sum insured calculator is not suitable for your property. Please enter the details manually and proceed.",
            errMessageDecline: "We are unable to offer cover for this risk on the terms requested.",
            errMessagePolicyBound: "The quote cannot be viewed or editied as the policy for this quote has already been bound.",
            errInvalidDLYear: "Please enter a valid year of driving license or check driver date of birth to proceed further.",
            errNVICNotFound: "Unable to return a quote as no vehicle data can be found corresponding to this rego.",
            errNonRegoDetails: "Please enter the vehicle details again as effective date has been changed.",
            errPaymentDate: "Date is outside the valid range.",
            errDeclineOnPropertryRewire: "Note this will be a decline as it is not within appetite.",
            quoteExpired: "This quote is now expired, to reactivate it please edit the quote and proceed to get quote again. Note as the original quote has expired the original premium is no longer valid and may change.",
            errDashboardRangeDate: "Please enter a valid range.",
            errPropertyUsed: "Note this will be a decline as it is not within underwriting appetite",
            errScheduleDocumentsUnavailable: "Endorsement/Cancellation Schedule documents are not avaialble for landlords",
            errFutureDatedForAddHolder: "Future date DOB for Additional Policy Holders not allowed!",
            errQuoteAlreadyBound: "Quote is already bound.",
            errMinExpirationDateInstallment: "Not enough time left before expiry date for installments to be taken. Please requote as annual",
            errSelectedYeargrtEffDte: "Selected year should be less than or equal to Policy effective Date",
            errSelectedInsured: "Please select a Business Client",
            errSelectedInsuredNotIndividual: "Please select an Individual Client",
            errManuallyDeclinedForQuotedToBeReleased: "Declined by UnderWriter",
            errAddressIsNotValid: "Address of primary client is not valid",
            errMessageWhenDuplicateEntryIssue: "There is a technical issue. Please try again after some time.",
            updatePaymentInfo: "Payment info updated successfully.",
            productDeactivatedInfo: "Selected product has been deactived from the branch.",
            effectiveDateNotAllowed: "Effective date not allowed.",
            errDateInvalidDueToProduct: "Effective date not allowed since the product selected is not available for the selected date.",
            manualAddressList: "If address shown above is not accurate for you, please click here to enter the address manually",
            OptionalCoverChangeOnAddress: "Please note that if the address is changed, optional cover details may also change"
        });
})();;
(function () {
    'use strict';

    angular.module('appUI')
        .constant('keyConstService', {
            bindData: 'bindData',
            brokerData: 'brokerData',
            caseId: 'caseId',
            caseNumber: 'caseNumber',
            newBusinessCaseData: 'newBusinessCaseData',
            package: 'package',
            quoteDetail: 'quoteDetail',
            quoteState: 'quoteState',
            quoteTransactionId: 'quoteTransactionId',
            transactionNumber: 'transactionNumber',
            IsFromNewBusinessPage: 'IsFromNewBusinessPage',
            clientFullNameandCode: 'clientFullNameandCode',
            searchState: 'searchState',
            backSearch: 'backSearch',
            declineQuoteStatus: 'declined',
            moreInfoQuoteStatus: 'moreinfo',
            toBeReferredQuoteStatus: 'tobereferred',
            referredQuoteStatus: 'referred',
            rowVersion: 'rowVersion',
            IsNewBusinessReadOnly: 'IsNewBusinessReadOnly',
            IsNewEditTransaction: 'IsNewEditTransaction',
            AmountMax999999999: 999999999,
            WeeklyRentalMinAmount: 150,
            WeeklyRentalMaxAmount: 5000,
            DefaultLandlordProtectionSI: 50000,
            DefaultLandlordStandardSI: 50000,
            MinLandlordProtectionSI: 10000,
            MinLandlordStandardSI: 10000,
            endorsementRequestVM: 'endorsementRequestVM',
            IsEndorsementEdit: 'IsEndorsementEdit',
            IsNewBusinessEdit: 'IsNewBusinessEdit',
            IsValidQuestionsBack: 'IsValidQuestionsBack',
            getQuestionSetWithoutSaving: 'getQuestionSetWithoutSaving',
            getTransactionIdWithoutSaving: 'getTransactionIdWithoutSaving',
            pdf: '.pdf',
            rtf: '.rtf',
            Home: 'Home',
            Motor: 'Motor',
            LandlordADLE: 'Landlord – AD and LE',
            LandlordEssentials: 'Landlord – Essentials',
            NonRego: 'NonRego',
            isManualRegoEnabled: 'isManualRegoEnabled',
            resetNonRegoData: 'resetNonRegoData',
            newBusinessData: 'newBusinessData',
            sessionStorageState: 'sessionStorageState',
            stampDutyExemption: 'stampDutyExemption',
            referredReturnQuoteStatus: 'ReferralReturned',
            setDriverDL: 'setDriverDL',
            IsPackageEditable: 'IsPackageEditable',
            LPExcess1: " 500",
            LPExcess2: "750",
            LPExcess3: "1000",
            NVIcNotFound: "NVIcNotFound",
            IsUnspecifiedPortableItems: "IsUnspecifiedPortableItems",
            findRegoData: "findRegoData",
            specialContentvalidity: "specialContentvalidity",
            effectiveDateInEdit: "effectiveDateInEdit",
            AddressValue: "AddressValue",
            annualizedConst: 365,
            LLContentSumInsuredLimit: 150000,
            HomeLiveDate: '11/05/2018',
            MotorLiveDate: '27/06/2018',
            LandlordsLiveDate: '15/11/2018',
            SMELiveDate: '15/05/2019',
            PaLiveDate: '29/08/2019',
            StartRenewal: '2019-03-01',
            PrimaryInsuredId: 'PrimaryInsuredId',
            PrimaryClientId: 'PrimaryClientId',
            SMEUrlPrefix: '/sme/',
            SMEPolicyPound: 'policy/policy-bound',
            SMEQuotePremiumSummary: 'quote/premium-summary',
            SMEPolicyCancel: 'cancel-policy',
            SMEProductCode: 'BSME',
            SMEBoundPageURL: '/sme/policy/policy-bound',
            SMEProductId: 5,
            ActionButtonEnable: 'ActionButtonEnable',
            isCancelledPolicy: 'isCancelledPolicy',
            searchCancelledPolicyDate: '2018-01-01',
            PaProductDescription: 'Personal Accident',
            PersonalAccidentProductId: 6,
            personalAccidentCover: 'PersonalAccident',
            paAccidentOnlyCoverageKey: 'PaAccidentOnly',
            paAccidnetAndSicknessCoverageKey: 'PaAccidentAndSickness',
            AccidentOnlyCoverageDescription: 'Accident Only',
            AccidentSicknessCoverageDescription: 'Accident & Sickness',
            sameExcessValueMessage: 'Excess value cannot be same.',
            WeeklyBenefitThreshold: 0,            
            MinCapitalCoverThreshold: 0,
            MaxCapitalCoverThreshold: 500000,
            SMEProductType: 'SME - Commercial Package',
            SMEViewQuoteLink: 'view-quote',
            paCoverName: 'Personal Accident',
            help_text_for_Endorsement: 'Please note once a policy is bound, you are unable to change the expiry date.The only option to get different periods on risk at this stage is to cancel and rekey a new policy for the new term you require.',
            CommercialMotorLiveDate: '15/12/2019',
            CommercialMotorProductDescription: 'Commercial Motor',
            CommercialMotorProductId: 50,
            CommercialMotorUrlPrefix: '/v2/#/',
            CommercialMotorPolicyBound: 'policysummary/',
            CommercialMotorViewQuote: 'view-quote/',
            CommercialMotorEditQuote: 'edit-quote/',
            CommercialMotorQuoteSummary: 'quotesummary/',
            CommercialMotorProductCode:'BCM',
            IsCopyQuote: 'IsCopyQuote',
            IsRenewalPolicy: 'IsRenewalPolicy',
            MotorComprehensiveCoverageKey: "Comprehensive",
            MotorComprehensivePlusCoverageKey: "ComprehensivePlus",
            MotorThirdPartyCoverageKey: "TPPD",
            ////Version For Phase 2 QuestionSet
            Version: 2.0,
            CyberLiveDate: '12/05/2020',
            CyberProductDescription: 'Cyber',
            CyberProductId: 51,
            CyberUrlPrefix: '/v2/#/',
            CyberPolicyBound: 'policysummary/',
            CyberNewQuote: 'new-quote/',
            CyberViewQuote: 'view-quote/',
            CyberEditQuote: 'edit-quote/',
            CyberQuoteSummary: 'quotesummary/',
            Colour: 'Colour',
            SemiDetachedHome: 'SemiDetachedHome',
            Apartments: 'Apartments',
            OtherDwellingType: 'OtherDwellingType',
            MultipleUnits: 'MultipleUnits',
            DefautExcess1OtherStates: "600",
            DefautExcess2OtherStates: "800",
            DefautExcess3OtherStates: "1000",
            DefautExcess1Sa: "500",
            DefautExcess2Sa: "750",
            DefautExcess3Sa: "1000",
            CyberMaxQuoteForwardDate: 'CyberMaxQuoteForwardDate',
            CancellationPremiumSummaryLink: 'quote/steps/premium-summary',
            OldEffectiveDate: 'OldEffectiveDate',
            //// for Personal accident agreed value
            AgreedValueThreshold: 1000,
            CopyQuoteOldTransactionId: "CopyQuoteOldTransactionId",
            V2Auth: 'V2Auth',
            PaPaymentFrequencyError: 'Payment type should be \'Annual\' for PA product.',
            PaBrokerManageTypeError: 'Broker Collection should be selected as \'Yes\' for selected product',
            MonthlyPaymentType: 'Monthly',
            AnnualPaymentType: 'Annual',
            PortalV2DebuggingHost: 'http://localhost:4200',
            IllionAddressEnquiry: 'IllionAddressEnquiry'
        });

})();;
(function () {
    'use strict';

    angular.module('appUI')
        .constant('cancellationConstService', {
            InsuredRequest: 'InsuredRequest',
            ProcessingError: 'ProcessingError',
            NotPaid: 'NotPaid',
            TotalLoss:'TotalLoss'
        });
})();;
(function () {
    'use strict';

    angular.module('appUI')
        .service('occupationService', ['$rootScope', '$resource', '$q', '$http', '$log', 'apiUrlConstService', occupationService]);

    function occupationService($rootScope, $resource, $q, $http, $log, apiUrlConstService) {
        return {
            get: get
        };

        function get(occupationANZSIC) {
            var api = $resource(apiUrlConstService.getOccupation, {
                occupationANZSIC: occupationANZSIC
            }, { get: { method: 'GET', isArray: false } });

            return api.get().$promise;
        }

    }

})();;
(function () {
    'use strict';
    angular.module('appUI')
        .service('stringService', ['$rootScope', '$window', stringService]);

    function stringService($rootScope, $window) {
        return {
            stringFormat: stringFormat,
            titleCase: titleCase
        };

        function stringFormat(stringFormat) {
            if (stringFormat && arguments.length > 0) {
                for (var i = 1; i < arguments.length; i++) {
                    var stringToReplace = "##" + (i - 1);
                    stringFormat = stringFormat.replace(stringToReplace, arguments[i]);
                }
                return stringFormat;
            }
            else { return stringFormat;}
        }

        function titleCase(str) {
            return str.toLowerCase().replace(/\b(\w)/g, s => s.toUpperCase());
        }
    }
})();;
(function () {
    'use strict';

    angular.module('appUI')
        .constant('webUrlConstService', {
            loginURL: '/brokerlogin',
            clientAdd: '/Client/Add',
            clientIndex: '/Client/Index',
            newBusinessIndex: '/NewBusiness/Index?',
            quoteCaseIndex: '/QuoteCase/Index',
            paymentInfo: '/PaymentInfo/Index?',
            bindIndex: '/Bind/Index?',
            homeIndex: '/Home/Index',
            newBuinessnessHome: '/Home/Home',
            newBuinessnessLandlord: '/Home/Landlord',
            newBuinessnessMotor: '/Home/Motor',
            policyDocument: '/mediaProxy/DocumentGenerator/GenerateDocument/?policyTransactionId=',
            cancellationInitaiation: '/Cancellation?',
            cancellationQuote: '/Cancellation/Quote?',
            CancellationViewQuote: '/Cancellation/VieworEditQuote?',
            cancellationFinalIndex: '/CancellationFinal/Index',
            quoteCasePremiumURL: '/QuoteCase/Index?',
            HomeView: '/Home/ViewHome',
            MotorView: '/Home/ViewMotor',
            LandlordProtection: '/Home/LandlordProtection',
            LandlordStandard: '/Home/LandlordStandard',
            LandlordStandardView: '/Home/ViewLandlordStandard',            
            LandlordProtectionView: '/Home/ViewLandlordProtection',
            HomeUpdate: '/Home/UpdateHome',
            MotorUpdate: '/Home/UpdateMotor',
            LandlordStandardUpdate: '/Home/UpdateLandlordStandard',
            LandlordProtectionUpdate: '/Home/UpdateLandlordProtection',
            documentDownloadUrl: '/mediaProxy/DocumentGenerator/GenerateDocument/?policyTransactionId=',
            documentSelectedDownloadUrl: '/mediaProxy/DocumentGenerator/GenerateSelectedDocument/?policyTransactionId=',
            paymentInfoUrl: './PaymentInfo/Index?',
            endorsementRequest: '/Endorsement/Index?',
            viewPolicyHome: '/Home/ViewHome?',
            viewPolicyMotor: '/Home/ViewMotor?',
            viewLandlordStandard: '/Home/ViewLandlordStandard?',
            viewLandlordProtection: '/Home/ViewLandlordProtection?',
            getPackageInfo: '/PackageManager/GetPackageInfo?',
            changePasswordUrl: '/ResetPassword',
            documentDownloadSetUrl: 'documentlibrary/Document',
            seachPackage: '/PackageManager',
            bindQuote: '/QuoteCase/Index?',
            switchBrokerBranch: '/application/RefreshToken',
            PersonalAccident: 'Home/PersonalAccident?',
            PersonalAccidentView: 'Home/ViewPersonalAccident?',
            PersonalAccidentUpdate: 'Home/UpdatePersonalAccident',
            passwordPolicyCheck: '/ResetPassword/CheckPasswordPolicy',
            copyQuote: '/Home/CopyQuote'
        });

})();;
(function () {
    'use strict';

    angular.module('appUI')
        .service('quoteCaseService', ['$rootScope', '$resource', '$q', '$http', '$log', 'apiUrlConstService', quoteCaseService]);

    function quoteCaseService($rootScope, $resource, $q, $http, $log, apiUrlConstService) {
        return {
            get: get,
            bindDocumentGrid: bindDocumentGrid
        };

        function get(quoteTransactionId, IsCopyQuote) {
            var api = $resource(apiUrlConstService.getQuoteCaseUrl, {
                transactionId: quoteTransactionId,
                hasCopyQuote: IsCopyQuote
            }, { get: { method: 'GET', isArray: false } });

            return api.get().$promise;
        }

        function bindDocumentGrid(CoverType) {
            var documentGridApi = $resource(apiUrlConstService.quoteDocumentURL, {},
                { request: { method: 'POST', isArray: false } });
            return documentGridApi.save(CoverType).$promise;
        }
    }

})();;
(function () {
    'use strict';

    angular.module('appUI').factory('cancellationService', ['$resource', 'sessionStorageService', 'apiUrlConstService', '$http', 'keyConstService', 'FileSaver', 'Blob','utilityService', cancellationService]);

    function cancellationService($resource, sessionStorageService, apiUrlConstService, $http, keyConstService, FileSaver, Blob, utilityService) {
        return {
            dropCancellationQuote: dropCancellationQuote,
            GetQuoteDownloadSelected: GetQuoteDownloadSelected,
            GetQuoteEmailSelected: GetQuoteEmailSelected,
            getCancellationReport: getCancellationReport
        };

        function dropCancellationQuote(qid) {
            var dropCancellationApi = $resource(apiUrlConstService.dropCancellationQuote, {},
                { request: { method: 'POST', isArray: false } });
            return dropCancellationApi.save({ "qid": qid }).$promise;
        }
        
     
        function GetQuoteDownloadSelected(quoteTransactionId, referenceNumber, docDetail, quoteNumber) {
            var flag = 0;
            docDetail.forEach(function (trans) {
                if (trans.isChecked === true) {
                    flag++;
                    return $http
                        ({
                            url: "/mediaProxy/Bind/DownloadQuoteRequest/?QuoteTransactionId=" + quoteTransactionId + "&QuoteReferenceNumber=" + referenceNumber + "&quoteDocumentId=" + trans.id,
                            method: "GET",
                            responseType: 'blob'
                        })
                        .then(function (result) {
                            var blob = new Blob([result.data], { type: [result.data.type] });
                            var ext = result.data.type === 'application/pdf' ? keyConstService.pdf : keyConstService.rtf;
                            trans.isDynamic === true ? FileSaver.saveAs(blob, utilityService.RemoveFilePostFix(trans.templateName) + '_' + quoteNumber + ext) : FileSaver.saveAs(blob, trans.templateName + '_' + quoteNumber + ext);
                            return result.data.data;
                        },
                            function (data) {
                                toastr.error("System is currently not working. Please try after sometime.");
                                return;
                            });
                };
            });
            if (flag === 0) {
                toastr.error("Please select atleast one document");
                return;
            }
        }

        function GetQuoteEmailSelected(quoteTransactionId, referenceNumber, docDetail, quoteNumber) {
            var idChecked = [];
            var flag = 0;
            docDetail.forEach(function (trans) {
                if (trans.isChecked === true) {
                    idChecked.push(trans.id);
                    flag++;
                }
            });
            if (flag === 0) {
                toastr.error("Please select atleast one document");
                return;
            } else {
                return $http
                    ({
                        url: "/mediaProxy/Bind/DownloadSelectedQuoteRequest/?QuoteTransactionId=" + quoteTransactionId + "&QuoteReferenceNumber=" + referenceNumber + "&documentDetail=" + JSON.stringify(idChecked),
                        method: "GET"
                    })
                    .then(function (result) {
                        var email = sessionStorageService.get('userEmail');
                        if (result && result.data && result.data.data) {
                            toastr.success("E-mail sent successfully to " + result.data.data);
                        }
                        else {
                            toastr.success("E-mail sent successfully to " + email.split('"')[1]);
                        }
                        return result.data.data;
                    },
                        function (data) {
                            toastr.error("System is currently not working. Please try after sometime.");
                            return;
                        });
            }      
        }

        function getCancellationReport(FromDate, ToDate, Branchlevel) {
            var cancellationApi = $resource(apiUrlConstService.getCancellationReportData, {
                dateFrom: FromDate,
                dateTo: ToDate,
                branchLevel: Branchlevel
            },
                { get: { method: 'GET', isArray: false } });

            return cancellationApi.get().$promise;
        }

    }
})();;
(function () {
    'use strict';

    angular.module('appUI')
        .service('quotesService', ['$rootScope', '$resource', '$q', '$http', '$log', 'apiUrlConstService', 'dateService', 'sessionStorageService', 'keyConstService', quotesService]);

    function quotesService($rootScope, $resource, $q, $http, $log, apiUrlConstService, dateService, sessionStorageService, keyConstService) {
        return {
            getQuotes: getQuotes,
            getQuote: getQuote,
            loadQuoteData: loadQuoteData,
            generateRequest: generateRequest,
            updateClaimYears: updateClaimYears,
            handleResponse: handleResponse,
            saveQuote: saveQuote,
            generateQuote: generateQuote,
            getCaseData: getCaseData,
            getQuotesPoliciesBasedOnQuery: getQuotesPoliciesBasedOnQuery,
            sumInsuredEstimateApi: sumInsuredEstimateApi,
            getInsuredNameList: getInsuredNameList,
            getSecondaryInsured: getSecondaryInsured,
            intechCrordellApi: intechCrordellApi,
            getSearchQuotes: getSearchQuotes,
            generateCancellationQuote: generateCancellationQuote,
            getClientDetail: getClientDetail,
            getQuoteData: getQuoteData,
            getPackageDetail: getPackageDetail,
            getBrokerFeeGST: getBrokerFeeGST,
            getGstAmount: getGstAmount,
            quoteReferralRequest: quoteReferralRequest,
            quoteReferralAttachement: quoteReferralAttachement,
            quoteDiscardRequest: quoteDiscardRequest,
            getBrokerCommission: getBrokerCommission,
            getBrokerCommissiononEdit: getBrokerCommissiononEdit,
            getQuestionSetForPolicy: getQuestionSetForPolicy,
            updateClaimsInfo: updateClaimsInfo,
            updateMotorClaimsInfo: updateMotorClaimsInfo,
            getUiVersion: getUiVersion,
            generateCancellationQuoteV2: generateCancellationQuoteV2
        };

        function getUiVersion(quoteTransactionId) {
            var uiVersionApi = $resource(apiUrlConstService.getUiVersionUrl, {
                quotetransactionId: quoteTransactionId
            }, { get: { method: 'GET', isArray: false } });

            return uiVersionApi.get().$promise;
        }

        function getQuestionSetForPolicy(policyTransactionId) {
            var questionsApi = $resource(apiUrlConstService.policyQuestionSetUrl, { policyTransactionId: policyTransactionId }, { get: { method: 'GET', isArray: false } });

            return questionsApi.get().$promise;
        }

        function quoteDiscardRequest(qid) {
            var quoteReferralApi = $resource(apiUrlConstService.quoteDiscardRequestApiUrl, { qid: qid }, { get: { method: 'GET', isArray: false } });
            return quoteReferralApi.get().$promise;
        }

        function getCaseData(caseId) {
            var caseApi = $resource(apiUrlConstService.ExistingCaseUrl, {
                caseId: caseId
            }, { get: { method: 'GET', isArray: false } });

            return caseApi.get().$promise;
        }

        function getQuoteData(query) {
            var quoteApi = $resource(apiUrlConstService.quoteDetailURL, {
                QuoteNumber: query
            }, { get: { method: 'GET', isArray: false } });

            return quoteApi.get().$promise;
        }

        function quoteReferralRequest(qid) {
            var quoteReferralApi = $resource(apiUrlConstService.quoteReferralSavingApiUrl, { qid: qid }, { get: { method: 'GET', isArray: false } });
            return quoteReferralApi.get().$promise;
        }

        function quoteReferralAttachement(detailsForReferral, attachementDataList) {
            var fd = new FormData();
            fd.append('ReferralDetails', JSON.stringify(detailsForReferral));

            attachementDataList.reduce(function (prevVal, elem) {
                if (elem.file) {
                    fd.append('file', elem.file, elem.file.name + "|" + elem.attachementText);
                }
            }, 0);
            //for (var i = 0; i < attachementDataList.length; i++) {
            //    if (attachementDataList[i].file) {
            //        fd.append('file', attachementDataList[i].file, attachementDataList[i].file.name + "|" + attachementDataList[i].attachementText);
            //    }
            //}

            return $http.post(apiUrlConstService.attachementUploadUrl, fd, {
                transformRequest: angular.identity,
                headers: { 'Content-Type': undefined }
            });
        }


        function getClientDetail(query) {
            var clientApi = $resource(apiUrlConstService.clientFirstNameURL, {
                searchClient: query
            }, { get: { method: 'GET', isArray: false } });

            return clientApi.get().$promise;
        }

        function getSearchQuotes(quoteSearchData) {
            var quotesApi = $resource(apiUrlConstService.quotesearchUrl, {
            }, { get: { method: 'POST', isArray: false } });

            return quotesApi.get(quoteSearchData).$promise;
        }

        function getInsuredNameList(caseId) {
            var insuredApi = $resource(apiUrlConstService.getInsuredNameUrl, {
                caseId: caseId
            }, { get: { method: 'GET', isArray: false } });

            return insuredApi.get().$promise;
        }


        function getQuotes(dateFrom,dateTo,pageNumber,pageSize,product,processType) {
            var quotesApi = $resource(apiUrlConstService.quotesUrl,
                {
                    dateFrom: dateFrom,
                    dateTo: dateTo,
                    pageNumber: pageNumber,
                    pageSize: pageSize,
                    product: product,
                    processType: processType
                },
                { get: { method: 'GET', isArray: false } });

            return quotesApi.get().$promise;
        }

        function getQuotesPoliciesBasedOnQuery(month, product, status, pageNumber, pageSize) {
            var getQuotesPoliciesBasedOnQueryApi = $resource(apiUrlConstService.monthUrl,
                {
                    month: month,
                    product: product,
                    status: status,
                    pageNumber: pageNumber,
                    pageSize: pageSize
                }, { get: { method: 'GET', isArray: false } });
            return getQuotesPoliciesBasedOnQueryApi.get().$promise;
        }

        function getQuote(quoteId, brokerId) {
            var quoteApi = $resource(apiUrlConstService.quoteUrl, {
                quoteId: quoteId,
                brokerId: brokerId
            }, { get: { method: 'GET', isArray: false } });

            return quoteApi.get().$promise;
        }

        function intechCrordellApi(addressLogVM) {
            var gnafApi = $resource(apiUrlConstService.intechCordellApiUrl, {}
                , { request: { method: 'POST', isArray: false } });

            return gnafApi.save(addressLogVM).$promise;
        }



        function loadQuoteData(data, productId, dropDowndata, version = 1, IsRentDefaultChanges = false) {
            if (productId === 1) {
                //checking for home
                if (version >= 2.0) {
                    var rootQuestionsModel = getHomeQuestions(dropDowndata);
                    return getHomeQuestionsV2(rootQuestionsModel, dropDowndata);
                }
                else {
                    return getHomeQuestions(dropDowndata);
                }
            }
            else if (productId === 2) {
                //checking for motor
                return getMotorQuestions(dropDowndata);
            }
            else if (productId === 3) {
                //checking for landLordProtection
                return getLandlordProtectionQuestions(dropDowndata);
            }

            else if (productId === 4) {
                //checking for landLordStandard
                if (version >= 2.0) {
                    var rootQuestionsModel = getLandlordStandardQuestions(dropDowndata);
                    if (IsRentDefaultChanges != null && IsRentDefaultChanges==true) {
                        var rootQuestionsModelv2 = getLandlordStandardQuestionsV2(rootQuestionsModel, dropDowndata);
                        return getLandlordStandardQuestionsRd(rootQuestionsModelv2);
                    }
                    else {
                        return getLandlordStandardQuestionsV2(rootQuestionsModel, dropDowndata);
                   }
                }
                else {
                    return getLandlordStandardQuestions(dropDowndata);
                }
            }

            else if (productId === keyConstService.PersonalAccidentProductId) {
                return getPersonalAccidentQuestions(dropDowndata, productId);
            }

        }

        function loadSecondaryInsuredData() {

            return getSecondaryInsured();


        }


        function generateRequest(state, product) {
            return state;
        }

        function handleResponse(state, product) {
            return state;
        }

        function getSecondaryInsured() {
            var rootClientModel = {};

            rootClientModel.secondaryInsured = {

                addInsured: []
            };
            return rootClientModel;
        }

        function sumInsuredEstimateApi(cordellData) {
            $log.log(cordellData);
            var sumInsuredApi = $resource(apiUrlConstService.sumInsuredEstimateApiUrl,
                {}, { request: { method: 'POST', isArray: false } });
            return sumInsuredApi.save(cordellData).$promise;
        }

        function getHomeQuestions(dropDowndata) {
            var rootQuestionsModel = {};

            rootQuestionsModel.YesNoList = [
                { Value: false, Text: "No" },
                { Value: true, Text: "Yes" }
            ];

            //PolicyHolder
            rootQuestionsModel.PolicyHolder = {
                DateOfBirth: null,
                DateOfBirthApp: null,
                InsuredName: null,
                InsuredClientId: null,
                OtherInsuredName: null,
                InsuredNameList: [],
                IsAdditionalPolicyHolder: false,
                AdditionalPolicyHolderList: [{ AdditionalPolicyHolder: null, AdditionalDateOfBirth: null, AdditionalPolicyHolderType: null, OtherPolicyHolderName: null, OtherDateOfBirth: null }],
                SecondaryInsuredsList: [],
                HomeOccupancyType: null,
                BuildingCover: true,
                ContentCover: true
            };


            //UnderwritingCriteria
            rootQuestionsModel.UnderwritingCriteria = {
                HasInsuredInLast3Years: null, //manadatory
                InsuredInLast3YearsData: {
                    IsEverInsuranceDeclined: null,  //manadatory
                    ReasonEverInsuranceDeclined: null,
                    IsCriminalConvictionFraudTheftBurglaryArson: null,  //manadatory
                    IsClaimDeclinedIn3Years: null,  //manadatory
                    ReasonClaimDeclinedIn3Years: null
                },
                IsAnswerYesToFollowing: null,//manadatory y/n
                AnswerYesToFollowingData: {
                    IsUnoccupiedProperty100days: null,
                    UnoccupiedProperty100days: null,
                    IsHomeUnderConstructionRenovation: null,
                    HomeUnderConstructionRenovationData: {
                        IsCostofRenovation: null,
                        IsOpeningExternalRoofWalls: null,
                        IsBuildingSecured: null,
                        IsBuildingRainWaterProtected: null
                    },
                    IsPoorlyMaintainedProperty: null,
                    IsPropertyHeriatgeListed: null,
                    PropertyHeritgeListingDetail: null,
                }
            };

            //Property Detail
            rootQuestionsModel.PropertyDetail = {
                AddressText: null,
                AddressLine1: null,
                AddressState: null,
                Postcode: null,
                AddressValue: null,
                Gnaf: null,
                IsManualAddress: null
            };

            //BuildingSumInsured
            rootQuestionsModel.BuildingSumInsuredDetail = {
                BuildingSumInsured: 0,
                BuildingSumInsuredEstimate: 0
            };


            //Security Detail
            rootQuestionsModel.SecurityDetails = {
                WindowSecurities: null,
                WindowSecuritiesList: dropDowndata.WindowSecuritiesList,
                DoorSecurities: [],
                DoorSecuritiesList: dropDowndata.DoorSecuritiesList,
                IsAlarmSecurity: null,
                AlarmType: null,
                AlarmTypeList: dropDowndata.AlarmTypeList

            };

            //ContentsSumInsured
            rootQuestionsModel.ContentsSumInsured = {
                GeneralContentSumInsured: null,
                IsValuableContent: false,
                ValuableContents: [
                    { Category: null, Description: null, Value: null, AwayFromHome: false }
                ],
                ValuableContentCategoryList: dropDowndata.SpecifiedItemsList,
                IsPortableValueCover: false,
                IsUnspecifiedPortableItems: null,
                UnspecifiedPortableItem: null,
                UnspecifiedPortablesCoverList: dropDowndata.PortableValuesCoverList,
                IsSpecifiedPortableItems: null,
                SpecifiedPortableItems: [
                    { Category: null, Description: null, Value: null }
                ],
                SpecifiedPortableItemsCategoryList: dropDowndata.SpecifiedPortableItemsList,
            };


            var years = getClaimYears();

            //Claims
            rootQuestionsModel.Claims = {
                IsClaimsInLast3Years: null,
                ClaimsInLast3YearsList: dropDowndata.ExcessList,

                ClaimTypeList: dropDowndata.ClaimTypeList,
                ClaimYears: years,
                ClaimsList: [{ ClaimYear: null, ClaimType: null, CostOfClaim: 0 }]
            };

            //OtherInfo
            rootQuestionsModel.OtherInfo = {
                IsDomesticWorkerCompensation: null,
                IsBusinessConductedHome: null,
                IsBuyBusinessExtensionOption: null,
                BusinessName: null,
                OccupationName: null,
                OccupationANZSIC: null,
                IsStampDutyExemption: null,
                OccupationNameList: dropDowndata.Occupation,
                AnnualRevenue: 0,
                PreviousInsurer: null,
                OtherPreviousInsurer: null,
                PreviousInsurerList: dropDowndata.PreviousInsurerList,
                OtherInterestParty: null,
                OtherInterestPartyText: null,
                OtherInterestPartyList: dropDowndata.InterestedParty,
                IsAddMorePolicyToPackage: false
            };

            //Excess
            rootQuestionsModel.Excess = {
                ExcessList: dropDowndata.ExcessList,
                BuildingExcess1: "600",
                BuildingExcess2: "800",
                BuildingExcess3: "1000",
                ContentExcess1: "600",
                ContentExcess2: "800",
                ContentExcess3: "1000"
            };

            var instalmentDayOfMonthList = [];
            var instalmentDayOfMonth = new Date().getDate();
            if (instalmentDayOfMonth > 28) {
                instalmentDayOfMonth = 28;
            }

            for (var i = 1; i <= 28; i++) {
                instalmentDayOfMonthList.push({ Value: i.toString(), Text: i });
            }

            //Payments 
            rootQuestionsModel.PaymentFrequency = {
                ModeOfPayment: "Annual",
                DayofInstallment: instalmentDayOfMonth.toString(),
                DayofInstallmentList: angular.copy(instalmentDayOfMonthList),
                BrokerFee: 0,
                BrokerFeeGST: 0,
                BrokerManagedPayment: null
            };

            //Boker Commision
            rootQuestionsModel.BrokerCommission = {
                BrokerCommissionPercentage: null
            };

            //Cupping Capping Factors
            rootQuestionsModel.CuppingCappingFactor = {
                AdjustmentFactor: null,
                ExpirationPremium: null,
                ExpirationBuildingExcess: null,
                ExpirationContentExcess: null,
                ExpirationCoverageType: null
            };

            //For mga automated referral
            rootQuestionsModel.IsAutomatedReferral = false;
            rootQuestionsModel.AutomatedReferralStatus = null;

            //Notes
            rootQuestionsModel.Notes = [{
                NoteText: null,
                IsPrintable: false
            }];



            //cordell response data
            rootQuestionsModel.CordellResponse = {
                Propertydata: {
                    periodName: null,
                    yearBuilt: null,
                    bushland: null,
                    slope: null,
                    externalWallMaterial: null,
                    roof: null,
                    floorArea: null,
                    quality: null,
                    levels: 0,
                    propertyRewired: null,
                    knowTheArea: null,
                    roomBed: 0,
                    roomBedSizeList: null,
                    roomBed1Size: null,
                    roomBed2Size: null,
                    roomBed3Size: null,
                    roomBed4Size: null,
                    roomBed5Size: null,
                    roomBed6Size: null,
                    roomBed7Size: null,
                    roomBed8Size: null,
                    roomBed9Size: null,
                    roomBath: 0,
                    roomBathSizeList: null,
                    roomBath1Size: null,
                    roomBath2Size: null,
                    roomBath3Size: null,
                    roomBath4Size: null,
                    roomBath5Size: null,
                    roomBath6Size: null,
                    roomToilet: 0,
                    garage: 0,
                    roomLaundry: 0,
                    roomLaundrySizeList: null,
                    roomLaundry1Size: null,
                    roomLaundry2Size: null,
                    roomEntryFoyerSize: null,
                    roomLivingSize: null,
                    roomDiningSize: null,
                    roomFamilySize: null,
                    roomRumpusSize: null,
                    roomSunSize: null,
                    roomBilliardSize: null,
                    roomHomeTheatreSize: null,
                    roomOther: null,
                    roomOtherList: null,
                    roomOther1Size: null,
                    roomOther2Size: null,
                    roomWardrobeBuiltin: null,
                    roomLinenCloset: null,
                    roomWardrobeWalkin: null,
                    carport: 0,
                    balconyDeck: 0,
                    porchVerandah: 0,
                    retainingWalls: null,
                    cabin: 0,
                    cabinSizeList: null,
                    cabin1Size: null,
                    cabin2Size: null,
                    cabin3Size: null,
                    heatingCooling_Included: null,
                    heatingCooling_airConDuctedType: null,
                    heatingCooling_airConStandalone: null,
                    heatingCooling_fireplace: null,
                    solar_Included: null,
                    solar_HotWater: null,
                    solar_Electricity: null,
                    shed_Included: null,
                    shed_Small: 0,
                    shed_Large: 0,
                    poolSpa_Included: null,
                    poolSpa_ConcretePoolSize: null,
                    poolSpa_FibreglassPoolSize: null,
                    poolSpa_VinylPoolSize: null,
                    tennisCourt_Included: null,
                    tennisCourt_Number: 0,
                    tennisCourt_SurfaceType: null,
                    tennisCourt_Lighting: null,
                    propertyId: null,
                    postcode: null,
                    roomKitchen: 0,
                    roomKitchen1Size: null,
                    roomKitchen2Size: null
                },


            };


            //cordell dropdown values
            rootQuestionsModel.CordellDropDownValues = {
                BedRoomSize: dropDowndata.BedRoomSize,
                BathRoomLaundarySize: dropDowndata.BathRoomLaundarySize,
                ConstructionStyleList: dropDowndata.ConstructionStyleList,
                BushLandList: dropDowndata.BushLandList,
                SlopeList: dropDowndata.SlopeList,
                ExternalWallList: dropDowndata.ExternalWallList,
                RoofMaterialList: dropDowndata.RoofMaterialList,
                QualityList: dropDowndata.QualityList,
                EntryFoyerList: dropDowndata.EntryFoyerList,
                SizeList: dropDowndata.SizeList,
                BilliardHomeSizeList: dropDowndata.BilliardHomeSizeList,
                OtherRoomList: dropDowndata.OtherRoomList,
                RetainingWallList: dropDowndata.RetainingWallList,
                CabinSizeList: dropDowndata.CabinSizeList,
                DuctedTypeList: dropDowndata.DuctedTypeList,
                SpaList: dropDowndata.SpaList,
                PoolType: dropDowndata.PoolType,
                SurfaceMaterialList: dropDowndata.SurfaceMaterialList,
                LevelList: dropDowndata.LevelList,
                ZeroToNine: dropDowndata.ZeroToNine,
                ZeroToSix: dropDowndata.ZeroToSix,
                ZeroToFour: dropDowndata.ZeroToFour,
                ZeroToTwo: dropDowndata.ZeroToTwo,
                ZeroToThree: dropDowndata.ZeroToThree,
            };

            rootQuestionsModel.Other = {
                IsAddMorePolicyToPackage: false,
                InterestedParty: null,
                InterestedPartyList: dropDowndata.InterestedParty
            };

            rootQuestionsModel.IllionClaimResponse = [{
                ClaimNumber: null,
                ClaimStatus: null,
                DateOfLoss: null,
                InsuranceClaimLines: [{
                    CauseOfLoss: null,
                    EstimatedClaimAmount: 0,
                    GrossSettlementClaimAmount: 0,
                    IsClaimRecoveredFromThirdParty: false,
                    IsExcessPaid: false,
                    NetSettlementClaimAmount: 0,
                    Relationships: []
                }],
                InsuranceType: null,
                MemberName: null,
                PolicyHolders: [],
                PolicyNumber: null,
                Relationships: []
            }];

            rootQuestionsModel.IllionClaimResponseId = null;

                return rootQuestionsModel;
        }

        //new added questions for verion 2 binding

        function getHomeQuestionsV2(rootQuestionsModel, dropDowndata) {
           
            rootQuestionsModel.OtherInfo = {
                IsDomesticWorkerCompensation: null,
                PolicyHolderHoldInsurance: null, //new properties added for version 2
                PeriodOfInsuranceHoldByPolicyholder: null, ////new properties added for version 2
                IsBusinessConductedHome: null,
                IsBuyBusinessExtensionOption: null,
                BusinessName: null,
                OccupationName: null,
                OccupationANZSIC: null,
                IsStampDutyExemption: null,
                OccupationNameList: dropDowndata.Occupation,
                AnnualRevenue: 0,
                PreviousInsurer: null,
                OtherPreviousInsurer: null,
                PreviousInsurerList: dropDowndata.PreviousInsurerList,
                OtherInterestParty: null,
                OtherInterestPartyText: null,
                OtherInterestPartyList: dropDowndata.InterestedParty,
                IsAddMorePolicyToPackage: false
            };
            //UnderwritingCriteria
            rootQuestionsModel.UnderwritingCriteria = {
                HasInsuredInLast3Years: null, //manadatory
                InsuredInLast3YearsData: {
                    IsEverInsuranceDeclined: null,  //manadatory
                    ReasonEverInsuranceDeclined: null,
                    IsCriminalConvictionFraudTheftBurglaryArson: null,  //manadatory
                    IsClaimDeclinedIn3Years: null,  //manadatory
                    ReasonClaimDeclinedIn3Years: null,
                    AnyInsurancePolicyCancelledOrDeclinedInPreviousYears: null,       ////new properties added for version 2
                    CancellationReason: null,                               ////new properties added for version 2
                    NoOfCancellationOrDeclinationOccurredInPreviousYearsForInsured: null ////new properties added for version 2
                },
                IsAnswerYesToFollowing: null,//manadatory y/n
                AnswerYesToFollowingData: {
                    IsUnoccupiedProperty100days: null,
                    UnoccupiedProperty100days: null,
                    IsHomeUnderConstructionRenovation: null,
                    HomeUnderConstructionRenovationData: {
                        IsCostofRenovation: null,
                        IsOpeningExternalRoofWalls: null,
                        IsBuildingSecured: null,
                        IsBuildingRainWaterProtected: null,
                        ValueOfRenovation: null,    ////new properties added for version 2
                        RenovationStartDate: null,  ////new properties added for version 2
                        RenovationEndDate: null,    ////new properties added for version 2
                        WorkUndertaken: null,       ////new properties added for version 2
                        IsContractWorksPolicy: null ////new properties added for version 2
                    },
                    IsPoorlyMaintainedProperty: null,
                    IsPropertyHeriatgeListed: null,
                    PropertyHeritgeListingDetail: null,
                    IsPropertyBeingChecked: null ////new properties added for version 2
                }
            };

            rootQuestionsModel.PropertyDetail = {
                AddressText: null,
                AddressLine1: null,
                AddressState: null,
                Postcode: null,
                AddressValue: null,
                Gnaf: null,
                IsManualAddress: null,
                BuildingType: null,////new properties added for version 2
                BuiltOn: null, ////new properties added for version 2
                ApartmentType: null,////new properties added for version 2
                SemiDetachedHomeType: null,////new properties added for version 2
                OtherDwellingTypeHome: null,    ////new properties added for version 2
                IsStrataManagement: null   ////new properties added for version 2
            };

            return rootQuestionsModel;

        }

        function getLandlordProtectionQuestions(dropDowndata) {
            var rootQuestionsModel = {};

            rootQuestionsModel.YesNoList = [
                { Value: false, Text: "No" },
                { Value: true, Text: "Yes" }
            ];

            //PolicyHolder
            rootQuestionsModel.PolicyHolder = {
                DateOfBirth: null,
                DateOfBirthApp: null,
                InsuredName: null,
                OtherInsuredName: null,
                InsuredClientId: null,
                InsuredNameList: [],
                IsAdditionalPolicyHolder: false,
                AdditionalPolicyHolderList: [{ AdditionalPolicyHolder: null, AdditionalDateOfBirth: null, AdditionalPolicyHolderType: null, OtherPolicyHolderName: null, OtherDateOfBirth: null }],
                SecondaryInsuredsList: [],
                HomeOccupancyType: null,
                ContentCover: true,
                WeeklyRentalAmount: null
            };

            //excess
            rootQuestionsModel.Excess = {
                ExcessList: dropDowndata.ExcessList,
                ContentExcess1: "500",
                ContentExcess2: "750",
                ContentExcess3: "1000"
            };

            //UnderwritingCriteria
            rootQuestionsModel.UnderwritingCriteria = {
                HasInsuredInLast3Years: null, //manadatory
                InsuredInLast3YearsData: {
                    IsEverInsuranceDeclined: null,  //manadatory
                    ReasonEverInsuranceDeclined: null,
                    IsCriminalConvictionFraudTheftBurglaryArson: null,  //manadatory
                    IsClaimDeclinedIn3Years: null,  //manadatory
                    ReasonClaimDeclinedIn3Years: null
                },
                IsAnswerYesToFollowing: null,//manadatory y/n
                AnswerYesToFollowingData: {
                    IsUnoccupiedProperty100days: null,
                    UnoccupiedProperty100days: null,
                    IsHomeUnderConstructionRenovation: null,
                    HomeUnderConstructionRenovationData: {
                        IsCostofRenovation: null,
                        IsOpeningExternalRoofWalls: null,
                        IsBuildingSecured: null,
                        IsBuildingRainWaterProtected: null
                    },
                    IsPoorlyMaintainedProperty: null,
                    IsPropertyHeriatgeListed: null,
                    PropertyHeritgeListingDetail: null,
                },
                IsPropertyUsedForFollowing:null,
                PropertyUsedData: {
                    IsBedBreakfast: null,
                    IsBoardingHouse: null,
                    IsHostel: null
                }
            };

            //Property Detail
            rootQuestionsModel.PropertyDetail = {
                AddressText: null,
                AddressLine1: null,
                AddressState: null,
                Postcode: null,
                AddressValue: null,
                Gnaf: null,
                poolSpa_Included: null,
                IsManualAddress: false

            };

            //Security Detail
            rootQuestionsModel.SecurityDetails = {
                WindowSecurities: null,
                WindowSecuritiesList: dropDowndata.WindowSecuritiesList,
                DoorSecurities: [],
                DoorSecuritiesList: dropDowndata.DoorSecuritiesList,
                IsAlarmSecurity: null,
                AlarmType: null,
                AlarmTypeList: dropDowndata.AlarmTypeList

            };

            //ContentsSumInsured
            rootQuestionsModel.ContentsSumInsured = {
                GeneralContentSumInsured: null,
                IsValuableContent: false,
                ValuableContents: [
                    { Category: null, Description: null, Value: null, AwayFromHome: false }
                ],
                ValuableContentCategoryList: dropDowndata.SpecifiedItemsList,
                IsPortableValueCover: false,
                IsUnspecifiedPortableItems: null,
                UnspecifiedPortableItem: null,
                UnspecifiedPortablesCoverList: dropDowndata.PortableValuesCoverList,
                IsSpecifiedPortableItems: null,
                SpecifiedPortableItems: [
                    { Category: null, Description: null, Value: null }
                ],
                SpecifiedPortableItemsCategoryList: dropDowndata.SpecifiedPortableItemsList,
            };


            var years = getClaimYears();

            //Claims
            rootQuestionsModel.Claims = {
                IsClaimsInLast3Years: null,
                ClaimsInLast3YearsList: dropDowndata.ExcessList,

                ClaimTypeList: dropDowndata.ClaimTypeList,
                ClaimYears: years,
                ClaimsList: [{ ClaimYear: null, ClaimType: null, CostOfClaim: 0 }]
            };

            //OtherInfo
            rootQuestionsModel.OtherInfo = {
                IsBusinessConductedHome: null,
                IsBuyBusinessExtensionOption: null,
                BusinessName: null,
                OccupationName: null,
                OccupationANZSIC: null,
                IsStampDutyExemption: null,
                OccupationNameList: dropDowndata.Occupation,
                AnnualRevenue: 0,
                PreviousInsurer: null,
                OtherPreviousInsurer: null,
                PreviousInsurerList: dropDowndata.PreviousInsurerList,
                OtherInterestParty: null,
                OtherInterestPartyText: null,
                OtherInterestPartyList: dropDowndata.InterestedParty,
                IsAddMorePolicyToPackage: false
            };

            var instalmentDayOfMonthList = [];
            var instalmentDayOfMonth = new Date().getDate();
            if (instalmentDayOfMonth > 28) {
                instalmentDayOfMonth = 28;
            }

            for (var i = 1; i <= 28; i++) {
                instalmentDayOfMonthList.push({ Value: i.toString(), Text: i });
            }

            //Payments 
            rootQuestionsModel.PaymentFrequency = {
                ModeOfPayment: "Annual",
                DayofInstallment: instalmentDayOfMonth.toString(),
                DayofInstallmentList: angular.copy(instalmentDayOfMonthList),
                BrokerFee: 0,
                BrokerFeeGST: 0,
                BrokerManagedPayment: null
            };

            //Boker Commision
            rootQuestionsModel.BrokerCommission = {
                BrokerCommissionPercentage: null
            };

            //Cupping Capping Factors
            rootQuestionsModel.CuppingCappingFactor = {
                AdjustmentFactor: null,
                ExpirationPremium: null,                
                ExpirationContentExcess: null,
                ExpirationCoverageType: null
            };

            rootQuestionsModel.OptionalCover = {
                IsDomesticWorkerCompensation: null,
            };

            //For mga automated referral
            rootQuestionsModel.IsAutomatedReferral = false;         
            rootQuestionsModel.AutomatedReferralStatus = null;

            //Notes
            rootQuestionsModel.Notes = [{
                NoteText: null,
                IsPrintable: false
            }];

            rootQuestionsModel.IllionClaimResponse = [{
                ClaimNumber: null,
                ClaimStatus: null,
                DateOfLoss: null,
                InsuranceClaimLines: [{
                    CauseOfLoss: null,
                    EstimatedClaimAmount: 0,
                    GrossSettlementClaimAmount: 0,
                    IsClaimRecoveredFromThirdParty: false,
                    IsExcessPaid: false,
                    NetSettlementClaimAmount: 0,
                    Relationships: []
                }],
                InsuranceType: null,
                MemberName: null,
                PolicyHolders: [],
                PolicyNumber: null,
                Relationships: []
            }];

            rootQuestionsModel.IllionClaimResponseId = null;

            return rootQuestionsModel;

        }
        function getLandlordStandardQuestions(dropDowndata) {
          
            var rootQuestionsModel = {};

            rootQuestionsModel.YesNoList = [
                { Value: false, Text: "No" },
                { Value: true, Text: "Yes" }
            ];

            //PolicyHolder
            rootQuestionsModel.PolicyHolder = {
                DateOfBirth: null,
                DateOfBirthApp: null,
                InsuredName: null,
                OtherInsuredName: null,
                InsuredClientId: null,
                InsuredNameList: [],
                IsAdditionalPolicyHolder: false,
                AdditionalPolicyHolderList: [{ AdditionalPolicyHolder: null, AdditionalDateOfBirth: null, AdditionalPolicyHolderType: null, OtherPolicyHolderName: null, OtherDateOfBirth: null }],
                SecondaryInsuredsList: [],
                HomeOccupancyType: null,
                BuildingCover: true,
                ContentCover: true,
                LandlordOccupancyType: null,
                LandlordManageType: null
            };
            
            //UnderwritingCriteria
            rootQuestionsModel.UnderwritingCriteria = {
                HasInsuredInLast3Years: null, //manadatory
                InsuredInLast3YearsData: {
                    IsEverInsuranceDeclined: null,  //manadatory
                    ReasonEverInsuranceDeclined: null,
                    IsCriminalConvictionFraudTheftBurglaryArson: null,  //manadatory
                    IsClaimDeclinedIn3Years: null,  //manadatory
                    ReasonClaimDeclinedIn3Years: null
                },
                IsPropertyUsed: null,//manadartory

                IsAnswerYesToFollowing: null,//manadatory y/n
                AnswerYesToFollowingData: {
                    IsUnoccupiedProperty100days: null,
                    UnoccupiedProperty100days: null,
                    IsHomeUnderConstructionRenovation: null,
                    HomeUnderConstructionRenovationData: {
                        IsCostofRenovation: null,
                        IsOpeningExternalRoofWalls: null,
                        IsBuildingSecured: null,
                        IsBuildingRainWaterProtected: null
                    },
                    IsPoorlyMaintainedProperty: null,
                    IsPropertyHeriatgeListed: null,
                    PropertyHeritgeListingDetail: null,
                }
            };

            //Property Detail
            rootQuestionsModel.PropertyDetail = {
                AddressText: null,
                AddressState: null,
                Postcode: null,
                AddressValue: null,
                Gnaf: null
            };

            //BuildingSumInsured
            rootQuestionsModel.BuildingSumInsuredDetail = {
                BuildingSumInsured: 0,
                BuildingSumInsuredEstimate: 0
            };
           
            ////Security Detail
            rootQuestionsModel.SecurityDetails = {
                WindowSecurities: null,
                WindowSecuritiesList: dropDowndata.WindowSecuritiesList,
                DoorSecurities: [],
                DoorSecuritiesList: dropDowndata.DoorSecuritiesList,
                IsAlarmSecurity: null,
                AlarmType: null,
                AlarmTypeList: dropDowndata.AlarmTypeList
                
            };
         
            //ContentsSumInsured
            rootQuestionsModel.ContentsSumInsured = {
                GeneralContentSumInsured: null,
                IsValuableContent: false,
                ValuableContents: [
                    { Description: null, Value: null, AwayFromHome: false }
                ],
                
            };
         

            var years = getClaimYears();

            //Optional Cover 
            rootQuestionsModel.OptionalCover = {
                IsTheftByTenant: true,
                IsLossOfRent: true,
                IsRentDefault: false,
                WeeklyRentalAmount: null,
                IsRentMoreThan14Days: null,
                IsDomesticWorkerCompensation: null,
            };

            

            //Claims
            rootQuestionsModel.Claims = {
                IsClaimsInLast3Years: null,
                ClaimsInLast3YearsList: dropDowndata.ExcessList,

                ClaimTypeList: dropDowndata.ClaimTypeList,
                ClaimYears: years,
                ClaimsList: [{ ClaimYear: null, ClaimType: null, CostOfClaim: 0 }]
            };
           
            //OtherInfo
            rootQuestionsModel.OtherInfo = {
                IsBusinessConductedHome: null,
                IsBuyBusinessExtensionOption: null,
                BusinessName: null,
                OccupationName: null,
                OccupationANZSIC: null,
                IsStampDutyExemption: null,
                OccupationNameList: dropDowndata.Occupation,
                AnnualRevenue: 0,
                PreviousInsurer: null,
                OtherPreviousInsurer: null,
                PreviousInsurerList: dropDowndata.PreviousInsurerList,
                OtherInterestParty: null,
                OtherInterestPartyText: null,
                OtherInterestPartyList: dropDowndata.InterestedParty,
                IsAddMorePolicyToPackage: false
            };

            //Excess
            rootQuestionsModel.Excess = {
                ExcessList: dropDowndata.ExcessList,
                BuildingExcess1: "600",
                BuildingExcess2: "800",
                BuildingExcess3: "1000",
                ContentExcess1: "600",
                ContentExcess2: "800",
                ContentExcess3: "1000"
            };
           
            var instalmentDayOfMonthList = [];
            var instalmentDayOfMonth = new Date().getDate();
            if (instalmentDayOfMonth > 28) {
                instalmentDayOfMonth = 28;
            }

            for (var i = 1; i <= 28; i++) {
                instalmentDayOfMonthList.push({ Value: i.toString(), Text: i });
            }

            //Payments 
            rootQuestionsModel.PaymentFrequency = {
                ModeOfPayment: "Annual",
                DayofInstallment: instalmentDayOfMonth.toString(),
                DayofInstallmentList: angular.copy(instalmentDayOfMonthList),
                BrokerFee: 0,
                BrokerFeeGST: 0,
                BrokerManagedPayment: null
            };

            //Boker Commision
            rootQuestionsModel.BrokerCommission = {
                BrokerCommissionPercentage: null
            };
         
            //Cupping Capping Factors
            rootQuestionsModel.CuppingCappingFactor = {
                AdjustmentFactor: null,
                ExpirationPremium: null,
                ExpirationBuildingExcess: null,
                ExpirationContentExcess: null,
                ExpirationCoverageType: null
            };
         
            //Automated referral for Mga
            rootQuestionsModel.IsAutomatedReferral = false;
            rootQuestionsModel.AutomatedReferralStatus = null;

            //Notes
            rootQuestionsModel.Notes = [{
                NoteText: null,
                IsPrintable: false
            }];

            //cordell response data
            rootQuestionsModel.CordellResponse = {
                Propertydata: {
                    periodName: null,
                    yearBuilt: null,
                    bushland: null,
                    slope: null,
                    externalWallMaterial: null,
                    roof: null,
                    floorArea: null,
                    quality: null,
                    levels: 0,
                    propertyRewired: null,
                    knowTheArea: null,
                    roomBed: 0,
                    roomBedSizeList: null,
                    roomBed1Size: null,
                    roomBed2Size: null,
                    roomBed3Size: null,
                    roomBed4Size: null,
                    roomBed5Size: null,
                    roomBed6Size: null,
                    roomBed7Size: null,
                    roomBed8Size: null,
                    roomBed9Size: null,
                    roomBath: 0,
                    roomBathSizeList: null,
                    roomBath1Size: null,
                    roomBath2Size: null,
                    roomBath3Size: null,
                    roomBath4Size: null,
                    roomBath5Size: null,
                    roomBath6Size: null,
                    roomToilet: 0,
                    garage: 0,
                    roomLaundry: 0,
                    roomLaundrySizeList: null,
                    roomLaundry1Size: null,
                    roomLaundry2Size: null,
                    roomEntryFoyerSize: null,
                    roomLivingSize: null,
                    roomDiningSize: null,
                    roomFamilySize: null,
                    roomRumpusSize: null,
                    roomSunSize: null,
                    roomBilliardSize: null,
                    roomHomeTheatreSize: null,
                    roomOther: null,
                    roomOtherList: null,
                    roomOther1Size: null,
                    roomOther2Size: null,
                    roomWardrobeBuiltin: null,
                    roomLinenCloset: null,
                    roomWardrobeWalkin: null,
                    carport: 0,
                    balconyDeck: 0,
                    porchVerandah: 0,
                    retainingWalls: null,
                    cabin: 0,
                    cabinSizeList: null,
                    cabin1Size: null,
                    cabin2Size: null,
                    cabin3Size: null,
                    heatingCooling_Included: null,
                    heatingCooling_airConDuctedType: null,
                    heatingCooling_airConStandalone: null,
                    heatingCooling_fireplace: null,
                    solar_Included: null,
                    solar_HotWater: null,
                    solar_Electricity: null,
                    shed_Included: null,
                    shed_Small: 0,
                    shed_Large: 0,
                    poolSpa_Included: null,
                    poolSpa_ConcretePoolSize: null,
                    poolSpa_FibreglassPoolSize: null,
                    poolSpa_VinylPoolSize: null,
                    tennisCourt_Included: null,
                    tennisCourt_Number: 0,
                    tennisCourt_SurfaceType: null,
                    tennisCourt_Lighting: null,
                    propertyId: null,
                    postcode: null,
                    roomKitchen: 0,
                    roomKitchen1Size: null,
                    roomKitchen2Size: null
                },


            };
            
            //cordell dropdown values
            rootQuestionsModel.CordellDropDownValues = {
                BedRoomSize: dropDowndata.BedRoomSize,
                BathRoomLaundarySize: dropDowndata.BathRoomLaundarySize,
                ConstructionStyleList: dropDowndata.ConstructionStyleList,
                BushLandList: dropDowndata.BushLandList,
                SlopeList: dropDowndata.SlopeList,
                ExternalWallList: dropDowndata.ExternalWallList,
                RoofMaterialList: dropDowndata.RoofMaterialList,
                QualityList: dropDowndata.QualityList,
                EntryFoyerList: dropDowndata.EntryFoyerList,
                SizeList: dropDowndata.SizeList,
                BilliardHomeSizeList: dropDowndata.BilliardHomeSizeList,
                OtherRoomList: dropDowndata.OtherRoomList,
                RetainingWallList: dropDowndata.RetainingWallList,
                CabinSizeList: dropDowndata.CabinSizeList,
                DuctedTypeList: dropDowndata.DuctedTypeList,
                SpaList: dropDowndata.SpaList,
                PoolType: dropDowndata.PoolType,
                SurfaceMaterialList: dropDowndata.SurfaceMaterialList,
                LevelList: dropDowndata.LevelList,
                ZeroToNine: dropDowndata.ZeroToNine,
                ZeroToSix: dropDowndata.ZeroToSix,
                ZeroToFour: dropDowndata.ZeroToFour,
                ZeroToTwo: dropDowndata.ZeroToTwo,
                ZeroToThree: dropDowndata.ZeroToThree,
            };

            rootQuestionsModel.Other = {
                IsAddMorePolicyToPackage: false,
                InterestedParty: null,
                InterestedPartyList: dropDowndata.InterestedParty
            }

            rootQuestionsModel.IllionClaimResponse = [{
                ClaimNumber: null,
                ClaimStatus: null,
                DateOfLoss: null,
                InsuranceClaimLines: [{
                    CauseOfLoss: null,
                    EstimatedClaimAmount: 0,
                    GrossSettlementClaimAmount: 0,
                    IsClaimRecoveredFromThirdParty: false,
                    IsExcessPaid: false,
                    NetSettlementClaimAmount: 0,
                    Relationships: []
                }],
                InsuranceType: null,
                MemberName: null,
                PolicyHolders: [],
                PolicyNumber: null,
                Relationships: []
            }];

            rootQuestionsModel.IllionClaimResponseId = null;

            return rootQuestionsModel;
        }

        //function for verion 2.0
        function getLandlordStandardQuestionsV2(rootQuestionsModel, dropDowndata) {
            //UnderwritingCriteria
            rootQuestionsModel.UnderwritingCriteria = {
                HasInsuredInLast3Years: null, //manadatory
                InsuredInLast3YearsData: {
                    IsEverInsuranceDeclined: null,  //manadatory
                    ReasonEverInsuranceDeclined: null,
                    IsCriminalConvictionFraudTheftBurglaryArson: null,  //manadatory
                    IsClaimDeclinedIn3Years: null,  //manadatory
                    ReasonClaimDeclinedIn3Years: null,
                    AnyInsurancePolicyCancelledOrDeclinedInPreviousYears: null,       ////new properties added for version 2
                    CancellationReason: null,                               ////new properties added for version 2
                    NoOfCancellationOrDeclinationOccurredInPreviousYearsForInsured: null ////new properties added for version 2
                },
                IsPropertyUsed: null,//manadartory

                IsAnswerYesToFollowing: null,//manadatory y/n
                AnswerYesToFollowingData: {
                    IsUnoccupiedProperty100days: null,
                    UnoccupiedProperty100days: null,
                    IsHomeUnderConstructionRenovation: null,
                    HomeUnderConstructionRenovationData: {
                        IsCostofRenovation: null,
                        IsOpeningExternalRoofWalls: null,
                        IsBuildingSecured: null,
                        IsBuildingRainWaterProtected: null,
                        ValueOfRenovation: null,    ////new properties added for version 2
                        RenovationStartDate: null,  ////new properties added for version 2
                        RenovationEndDate: null,    ////new properties added for version 2
                        WorkUndertaken: null,       ////new properties added for version 2
                        IsContractWorksPolicy: null ////new properties added for version 2
                    },
                    IsPoorlyMaintainedProperty: null,
                    IsPropertyHeriatgeListed: null,
                    PropertyHeritgeListingDetail: null,
                    IsPropertyBeingChecked: null ////new properties added for version 2
                }
            };

            //Property Detail
            rootQuestionsModel.PropertyDetail = {
                AddressText: null,
                AddressState: null,
                Postcode: null,
                AddressValue: null,
                Gnaf: null,
                AllOwnedByInsured: null,                    ////new properties added for version 2
                NumberOfUnitsOrResidencesToBeInsured: null, ////new properties added for version 2
                BuildingType: null,                         ////new properties added for version 2
                BuiltOn: null,                              ////new properties added for version 2
                ApartmentType: null,                        ////new properties added for version 2
                SemiDetachedHomeType: null,                 ////new properties added for version 2
                OtherDwellingTypeHome: null,                     ////new properties added for version 2
                IsStrataManagement: null,              ////new properties added for version 2
                ListOfUnitsOrResidencesRequiringCoverage:null ////new properties added for version 2
            };

            //OtherInfo
            rootQuestionsModel.OtherInfo = {
                PolicyHolderHoldInsurance: null, //new properties added for version 2
                PeriodOfInsuranceHoldByPolicyholder: null, ////new properties added for version 2
                IsBusinessConductedHome: null,
                IsBuyBusinessExtensionOption: null,
                BusinessName: null,
                OccupationName: null,
                OccupationANZSIC: null,
                IsStampDutyExemption: null,
                OccupationNameList: dropDowndata.Occupation,
                AnnualRevenue: 0,
                PreviousInsurer: null,
                OtherPreviousInsurer: null,
                PreviousInsurerList: dropDowndata.PreviousInsurerList,
                OtherInterestParty: null,
                OtherInterestPartyText: null,
                OtherInterestPartyList: dropDowndata.InterestedParty,
                IsAddMorePolicyToPackage: false
            };

            return rootQuestionsModel;
        }

        function getLandlordStandardQuestionsRd(rootQuestionModel) {
            rootQuestionModel.OptionalCover = {
              IsTheftByTenant: true,
                IsLossOfRent: true,
               IsRentDefault: null,
              WeeklyRentalAmount: null,
                IsStatementForRentDefault: null,
                IsPropertyStatementForRentDefault: null,
                IsRentMoreThan14Days: null,
                IsDomesticWorkerCompensation: null
            };
            return rootQuestionModel;
        }
        function getPersonalAccidentQuestions(dropDowndata, productId) {
            var rootQuestionsModel = {};
            // QuotePolicyDetail (contains basic info about the quote)
            rootQuestionsModel.QuotePolicyInfo = {
                ProductId: productId,
                PackageId: null,
                StartDate: null,
                ExpirationDate: null,
                EffectiveDate: null,
                PackageNumber: null,
                ProductCode: null,
                LineOfBusinessId: null,
                Version: null,
                PackageRenewalCounter: null
            };

            //PolicyHolder(Details to get started section)
            rootQuestionsModel.PolicyHolder = {
                DateOfBirth: null,
                DateOfBirthApp: null,
                InsuredName: null,
                InsuredClientId: null,
                InsuredNameList: []
               
            };

            // Risk information
            rootQuestionsModel.RiskInformation = {
                OccupationList: [{
                    OccupationName: null,
                    OccupationClass: null,
                    OccupationKey: null,
                    AnzicCode: null
                    //SearchText: null,
                    //SelectedOccupation: {
                    //    OccupationName: null,
                    //    OccupationKey: null,
                    //    OccupationClass: null,
                    //    AnzicCode: null
                    //}
                }],
                AddressDetails: {
                    AddressText: null,
                    AddressState: null,
                    AddressLine1: null,
                    Postcode: null,
                    AddressValue: null,
                    IsManualAddress: false
                }
            };

            // Coverage Info
            rootQuestionsModel.CoverageInfo = {
                //BenifitPeriodList: dropDowndata.BenefitPeriodList,
                BenefitPeriod: null,
                WeeklyBenefit: null,
                IsAgreedValue: null,
                CapitalCover: 0,
                IncludeSpecificCondition: false,
                ExcludeSpecificCondition: false,
                CoverageonEndorsement: null
            };

            //excess
            rootQuestionsModel.Excess = {
                //ExcessList: dropDowndata.ExcessList,
                AccidentOnlyExcess1: "7",
                AccidentOnlyExcess2: "14",
                AccidentOnlyExcess3: "21",
                AccidentSicknessExcess1: "7",
                AccidentSicknessExcess2:"14",
                AccidentSicknessExcess3:"21"
            };

            //UnderwritingCriteria
            rootQuestionsModel.UnderwritingCriteria = {
                HasInsuredInLast3Years: false, //manadatory
                InsuredInLast3YearsData: {
                    IsEverInsuranceDeclined: null,  //manadatory
                    ReasonEverInsuranceDeclined: null,
                    IsBankrupt: null,  //manadatory
                    ReasonBankrupt: null,  //manadatory
                    IsIncarcerated: null
                },
                IsMotorCycleCover: null,
                IsSmoker:null
            };

            //OtherInfo
            rootQuestionsModel.OtherInfo = {
                PreviousInsurer: null,
                OtherPreviousInsurer: null,
                //PreviousInsurerList: dropDowndata.PreviousInsuredList,
                IsAddMorePolicyToPackage: false
            };

            //Payments 
            rootQuestionsModel.PaymentFrequency = {
                ModeOfPayment: "Annual",
                DayofInstallment: 0
            };

            //Boker Commision
            rootQuestionsModel.BrokerRemuneration = {
                BrokerCommissionPercentage: null,
                BrokerFee: 0,
                BrokerFeeGST: 0
            };

            //Cupping Capping Factors
            rootQuestionsModel.CuppingCappingFactor = {
                AdjustmentFactor: null,
                ExpirationPremium: null,
                ExpirationContentExcess: null,
                ExpirationCoverageType: null
            };

            //For mga automated referral
            rootQuestionsModel.IsAutomatedReferral = false;
            rootQuestionsModel.AutomatedReferralStatus = null;

            //Notes
            rootQuestionsModel.Notes = [{
                NoteText: null,
                IsPrintable: false
            }];

            return rootQuestionsModel;

        }

        function getList(dataList, key) {
            for (var i = 0; i < dataList.length; i++) {
                if (dataList[i].Type === key) {
                    return dataList[i].DropDownListOptions;
                }
            }

        }



        ///////////////////////////////////////////////////////////////////////////////////////
        //  Motor Questions 
        /////////////////////////////////////////////////////////////////////////////////////////
        function getMotorQuestions(dataList) {
            if (dataList) { 
            $log.log('getting the getMotorQuestions', dataList);
            var rootQuestionsModel = {};


            rootQuestionsModel.YesNoList = [
                { Value: false, Text: "No" },
                { Value: true, Text: "Yes" }
            ];

            rootQuestionsModel.GenderList = dataList.GenderList;

            //broker info
            rootQuestionsModel.Broker = {
                BrokerFirstName: null,
                BrokerLastName: null,
                BrokerEmail: null,
                BrokerPhoneNumber: null,
                BrokerFax: null
            };

            //Insured
            rootQuestionsModel.Insured = {
                InsuredName: null,
                DateOfBirth: null,
                DateOfBirthApp: null,
                InsuredClientId: null,
                IsAdditionalPolicyHolder: false,
                AdditionalPolicyHolderList: [{ AdditionalPolicyHolder: null, AdditionalDateOfBirth: null, AdditionalPolicyHolderType: null, OtherPolicyHolderName: null, OtherDateOfBirth: null }],

            };

            //UnderwritingCriteria
            rootQuestionsModel.UnderwritingCriteria = {
                HasInsuredInLast3Years: null, //manadatory
                InsuredInLast3YearsData: {
                    IsEverInsuranceDeclined: null,  //manadatory
                    ReasonEverInsuranceDeclined: null,
                    IsCriminalConvictionFraudTheftBurglaryArson: null,  //manadatory
                    IsClaimDeclinedIn3Years: null,  //manadatory
                    ReasonClaimDeclinedIn3Years: null,
                    //// New Version 2.0 -- Add for new questionset version
                    IsExistingDamageToVehicle: null, //Mandatory
                    HailDamage: null,
                    OtherDamage: null,
                    AnyInsurancePolicyCancelledInLast3Years: null, //Madatory
                    CancellationReason: null,
                    NoOfCancellationOccurredInLast3YearsForInsured: null

                },
                IsAnswerYesToFollowing: null//manadatory y/n

            };


            //address
            rootQuestionsModel.OvernightParkedAddress = {
                AddressText: null,
                AddressState: null,
                Postcode: null,
                AddressValue: null,
                Gnaf: null,
                IsManualAddress: false
            };



            //Vehicle Overview
            rootQuestionsModel.Vehicle = {
                MotorGlassDetailId: null,
                State: null,
                StateList: dataList.StateVehicleList,
                RegistrationNumer: null,
                Colour:null,//add color code here
                ManufactureYear: null,
                Make: null,
                Model: null,
                Variant: null,
                Series: null,
                Style: null,
                Engine: null,
                Size: null,
                Transmission: null,
                Cylinders: null,
                VehicleDescription: null,
                NVICValue: null,
                IsNonRegoManual:null
            };



            //Coverage
            rootQuestionsModel.Coverages = {
                Coverage: 'Comprehensive',
                CoverageList: dataList.CoverageList,
                AddtionalCoverages: [],
                AddtionalCoveragesList: dataList.AddtionalCoverageList,
                ComprehensiveRoadSide: false,
                ComprehensiveWindscreeenExcess: false,
                ComprehensiveHireCar: false,
                ComprehensiveRepairChoice: false,
                IsNonManufactureModification: false,
                NonManufactureModifications: [{ ModificationCategory: null, Description: null, Value: null }], //store the multiple modifications
                ModificationCategoryList: dataList.ModificationCategoryList,
                InsureVehicleFor: "Market",
                InsureVehicleForList: dataList.InsureVehicleForList,
                InsureVehicleForValue: null,
                InsureVehicleForGlassMarketValueAV: null,
                InsureVehicleForGlassMarketValueAAV: null,
                InsureVehicleForGlassMarketValueBAV: null,
            };

            //Driver details
                rootQuestionsModel.Drivers = {
                MainDriver: {
                    Name: null,
                    DOB: null,
                    Gender: null,
                    YearDL: "",
                    ClaimNumber: "0",
                    Claims: [],
                    LicenceSuspensionsOrCancellationsInLast3Years: "0",
                    LicenceSuspensionsOrCancellationsInLast3YearsReasonArray: [],
                    Employment: null, //Mandatory //// New Version 2.0 -- Add for new questionset version
                    PolicyHolderDemeritPointsIncurredIn3Years: null //Mandatory //// New Version 2.0 -- Add for new questionset version
                    },
                IsAdditionalDriver: false,
                AdditionalDrivers: [{
                    Name: null,
                    DOB: null,
                    Gender: null,
                    YearDL: null,
                    ClaimNumber: "0",
                    Claims: [],
                    LicenceSuspensionsOrCancellationsInLast3Years: "0",
                    LicenceSuspensionsOrCancellationsInLast3YearsReasonArray: [],
                    Employment: null, //Mandatory //// New Version 2.0 -- Add for new questionset version
                    PolicyHolderDemeritPointsIncurredIn3Years: null //Mandatory //// New Version 2.0 -- Add for new questionset version

                }],
                MainDriverExperience: "",
                ClaimNumberList: dataList.NumberPriorClaimsList,
                ClaimTypes: dataList.ClaimTypeList,
                YearList: [],
                DriverDLYearList: [],
                LicenceSuspensionsOrCancellationsInLast3YearsList: dataList.LicenceSuspensionsOrCancellationsInLast3YearsList,
                LicenceSuspensionsOrCancellationsInLast3YearsReasonList: dataList.LicenceSuspensionsOrCancellationsInLast3YearsReasonList
            };

            var instalmentDayOfMonth = new Date().getDate();
            if (instalmentDayOfMonth > 28) {
                instalmentDayOfMonth = 28;
            }

            //other information
            rootQuestionsModel.OtherInformation = {
                PreviousInsurer: null,
                OtherPreviousInsuredText: null,
                PreviousInsurerList: dataList.PreviousInsuredList,
                OtherInterestedParty: null,
                OtherInterestPartyText: null,
                OtherInterestedPartyList: dataList.OtherInterestedPartyList,
                VehicleUsedFor: null,
                VehicleUsedForList: dataList.VehicleUsedForList,
                IsEligibleForNSWSmallBusinessSDExemption: false,
                IsAddMorePolicyToPackage: false,
                //// New Version 2.0 -- Add for new questionset version
                PolicyHolderHoldInsurance: null, //Mandatory //Default value changed for the question from false to null for version 2
                PeriodOfInsuranceHoldByPolicyholder: null,
                CarDrivenPerYear:null //Mandatory
            }

            //excess Option
            rootQuestionsModel.ExcessOption = {
                ExcessList: dataList.ExcessOptionList,
                Excess1: null,
                Excess2: null,
                Excess3: null,
                DefaultExcessValues: [
                    { State: "NSW", Excess1: 600, Excess2: 800, Excess3: 1000 },
                    { State: "VIC", Excess1: 600, Excess2: 800, Excess3: 1000 },
                    { State: "QLD", Excess1: 600, Excess2: 800, Excess3: 1000 },
                    { State: "ACT", Excess1: 600, Excess2: 800, Excess3: 1000 },
                    { State: "SA", Excess1: 600, Excess2: 800, Excess3: 1000 },
                    { State: "NT", Excess1: 600, Excess2: 800, Excess3: 1000 },
                    { State: "WA", Excess1: 600, Excess2: 800, Excess3: 1000 },
                    { State: "TAS", Excess1: 600, Excess2: 800, Excess3: 1000 }
                ]
            }

            // Payment/installments
            rootQuestionsModel.Payment = {
                Frequency: "Annual",
                FrequencyList: dataList.FrequencyList,
                DayofInstallment: instalmentDayOfMonth.toString(),
                BrokerFeeExcludingGST: 0,
                BrokerFeeGST: 0,
                InstalmentDayOfMonthList: dataList.PreferredDayofMonthList,
                BrokerManagedPayment: null
            };


            //Boker Commission
            rootQuestionsModel.BrokerCommission = {
                BrokerCommissionPercentage: null
            }

            //Cupping Capping Factors
            rootQuestionsModel.CuppingCappingFactor = {
                AdjustmentFactor: null,
                ExpirationPremium: null,                
                ExpirationMotorExcess: null,
                ExpirationCoverageType: null
            };

             //Automated referral for Mga
            rootQuestionsModel.IsAutomatedReferral = false;
            rootQuestionsModel.AutomatedReferralStatus = null;

            //Notes
            rootQuestionsModel.Notes = [{
                NoteText: null,
                IsPrintable: false
            }]

                rootQuestionsModel.IllionClaimResponse = [{
                    ClaimNumber: null,
                    ClaimStatus: null,
                    DateOfLoss: null,
                    InsuranceClaimLines: [{
                        CauseOfLoss: null,
                        EstimatedClaimAmount: 0,
                        GrossSettlementClaimAmount: 0,
                        IsClaimRecoveredFromThirdParty: false,
                        IsExcessPaid: false,
                        NetSettlementClaimAmount: 0,
                        Relationships: []
                    }],
                    InsuranceType: null,
                    MemberName: null,
                    PolicyHolders: [],
                    PolicyNumber: null,
                    Relationships: []
                }];

                rootQuestionsModel.IllionClaimResponseId = null;

            return rootQuestionsModel;
        }
    }

        function saveQuote(quoteRequest, product) {
            var saveQuoteApi = $resource(apiUrlConstService.saveQuoteUrl, {},
                { request: { method: 'POST', isArray: false } });
            return saveQuoteApi.request(quoteRequest).$promise;
        }

        function generateQuote(quoteRequest, product) {
            var generateQuoteApi = $resource(apiUrlConstService.generateQuoteUrl, {},
                { request: { method: 'POST', isArray: false } });
            return generateQuoteApi.save(quoteRequest).$promise;
        }

        function getPackageDetail(query) {
            var packageApi = $resource(apiUrlConstService.getPackageSearchUrl, {
                searchPackage: query
            }, { get: { method: 'GET', isArray: false } });

            return packageApi.get().$promise;
        }

        function generateCancellationQuote(quoteRequest) {
            var generateQuoteApi = $resource(apiUrlConstService.generateCancellationQuoteUrl, {},
                { request: { method: 'POST', isArray: false } });
            return generateQuoteApi.save(quoteRequest).$promise;
        }

        function getBrokerFeeGST(brokerGSTRequest) {
            var brokerFeeGSTApi = $resource(apiUrlConstService.getbrokerFeeGSTURL, {},
                { request: { method: 'POST', isArray: false } });
            return brokerFeeGSTApi.save(brokerGSTRequest).$promise;
        }
        function getBrokerCommission(brokerCommissionRequest) {
            var brokerCommissionApi = $resource(apiUrlConstService.getbrokerCommissionRequestURL, {},
            { request: { method: 'POST', isArray: false } });
            return brokerCommissionApi.save(brokerCommissionRequest).$promise;
        }
        function getBrokerCommissiononEdit(brokerCommissionRequestOnEdit) {
            var brokerCommissionOnEditApi = $resource(apiUrlConstService.getbrokerCommissionRequestOnEditURL, {},
                { request: { method: 'POST', isArray: false } });
            return brokerCommissionOnEditApi.save(brokerCommissionRequestOnEdit).$promise;
        }
        

        function getGstAmount(request) {
            var generateQuoteApi = $resource(apiUrlConstService.getGSTAmount, {},
                { request: { method: 'POST', isArray: false } });
            return generateQuoteApi.save(request).$promise;
        }

        function getYearFromEffectiveDate() {
            var year = null;
            console.log('getting year from effective date');
            // Getting bussiness data from storage and if data is null then get year from effective date
            var newBusinessCaseDataString = sessionStorageService.get(keyConstService.newBusinessCaseData);
            if (newBusinessCaseDataString) {
                var newBusinessCaseData = JSON.parse(newBusinessCaseDataString);
                if (newBusinessCaseData && newBusinessCaseData.data && newBusinessCaseData.data.EffectiveDate)
                    year = dateService.getYear(newBusinessCaseData.data.EffectiveDate);
            }
            return year;
        }

        function getClaimYears()
        {
            // Getting year of effective date 
            var year = getYearFromEffectiveDate();
            //  If Year is null then set it with current year
            if (!year) {
                year = new Date().getFullYear();
            }
            var years = [{ Value: "", Text: null }];
            // Adding last three previous years from year and includes year itself also. year is either effective date or current year
            for (var i = 1; i < 5; i++) {
                years.push({ Value: year.toString(), Text: year });
                year--;
            }

            return years;
        }

        function updateClaimYears(effectiveDate) {
            var year = (new Date(effectiveDate)).getFullYear();
            var years = [{ Value: "", Text: null }];
            for (var i = 1; i < 5; i++) {
                years.push({ Value: year.toString(), Text: year });
                year--;
            }
            return years;
        }

        function updateClaimsInfo(claims) {
            var effectiveYear = getYearFromEffectiveDate();
            if (effectiveYear && claims && claims.ClaimYears) {
                var years = getClaimYears();
                claims.ClaimYears = years;
              // Setting year to null which is not in claim years after changing effective date. from 2019 to 2018
                if (claims.ClaimsList && claims.ClaimsList.length >= 1 && claims.IsClaimsInLast3Years) {
                    claims.ClaimsList = claims.ClaimsList.filter(function (item) {
                        var year = years.filter(function (obj) {
                            return obj.Value === item.ClaimYear;
                        });
                      // if year is not in years as per effective date then set claim year for that particular year in claim list to null.
                        if (!year || year.length === 0)
                          item.ClaimYear = null;
                      return item;
                    });
              }
            }
        }
        function updateMotorClaimsInfo(claims,years) {
                // Setting year to null which is not in claim years after changing effective date. from 2019 to 2018
                if (claims && claims.length > 0) {
                    claims = claims.filter(function (item) {
                        var year = years.filter(function (obj) {
                            return obj === item.ClaimYear;
                        });
                        // if year is not in years as per effective date then set claim year for that particular year in claim list to null.
                        if (!year || year.length === 0)
                            item.ClaimYear = null;
                        return item;
                    });
                }
        }
        function generateCancellationQuoteV2(quoteRequest) {
            var generateQuoteApi = $resource(apiUrlConstService.generateCancellationQuoteV2Url, {},
                { request: { method: 'POST', isArray: false } });
            return generateQuoteApi.save(quoteRequest).$promise;
        }
    }
})();;
(function () {
    'use strict';

    angular.module('appUI')
        .service('userService', ['$rootScope', '$resource', 'apiUrlConstService', '$q', 'webUrlConstService', userService]);

    function userService($rootScope, $resource, apiUrlConstService, $q, webUrlConstService) {
        return {
            userSentResetPasswordEmail: userSentResetPasswordEmail,
            userResetPassword: userResetPassword,
            userChangePassword: userChangePassword,
            switchBranch: switchBranch,
            passwordPolicyCheck: passwordPolicyCheck,
            refreshToken: refreshToken
        };

        function refreshToken() {
            var api = $resource(apiUrlConstService.refreshToken, {},
                { request: { params: { "hasTokenRefresh": true }, method: 'POST', isArray: false } });
            return api.request().$promise;
        }

        function passwordPolicyCheck(password) {
            var api = $resource(webUrlConstService.passwordPolicyCheck, {},
                { request: { params: { "password": password }, method: 'POST', isArray: false } });
            return api.request({ password: password }).$promise;
        }

        function switchBranch(brokerBranchId, brokerId) {
            var api = $resource(webUrlConstService.switchBrokerBranch, {},
                { request: { params: { "brokerBranchId": brokerBranchId, "brokerId": brokerId, "hasTokenRefresh": false }, method: 'POST', isArray: false } });
            return api.request({ brokerBranchId: brokerBranchId, brokerId: brokerId}).$promise;
        }

        function userSentResetPasswordEmail(email) {
            var api = $resource(apiUrlConstService.userSentResetPasswordEmailUrl , {},
                { request: { params: { "email": "@email" }, method: 'POST', isArray: false } });
            return api.request({ email: email }).$promise;
        }

        function userResetPassword(data) {
            var api = $resource(apiUrlConstService.userResetPasswordUrl, {},
                { request: { method: 'POST', isArray: false } });
            return api.request(data).$promise;
        }

        function userChangePassword(data) {
            var api = $resource(apiUrlConstService.userChangePasswordUrl, {},
                { request: { method: 'POST', isArray: false } });
            return api.request(data).$promise;
        }
    }
})();;
(function () {
    'use strict';

    var appUI = angular.module('appUI');
    appUI.service('utilityService', ['$filter', 'apiUrlConstService', '$resource',utilityService]);

    function utilityService($filter, apiUrlConstService, $resource) {
        return {
            toCamel: toCamel,
            toPascal: toPascal,
            getQueryString: getQueryString,
            parseJwt: parseJwt,
            RemoveFilePostFix: RemoveFilePostFix,
            valueExistsInArray: valueExistsInArray,
            valueExistsInDropDown: valueExistsInDropDown,
            ConvertDateTimeForUi: ConvertDateTimeForUi,
            getRandomIdentity: getRandomIdentity,
            getAddressEnquiry: getAddressEnquiry
        };

        function getQueryString() {
            var key = false, res = {}, itm = null;
            // get the query string without the ?
            var qs = location.search.substring(1);
            // check for the key as an argument
            if (arguments.length > 0 && arguments[0].length > 1)
                key = arguments[0];
            // make a regex pattern to grab key/value
            var pattern = /([^&=]+)=([^&]*)/g;
            // loop the items in the query string, either
            // find a match to the argument, or build an object
            // with key/value pairs
            while (itm = pattern.exec(qs)) {
                if (key !== false && decodeURIComponent(itm[1]) === key)
                    return decodeURIComponent(itm[2]);
                else if (key === false)
                    res[decodeURIComponent(itm[1])] = decodeURIComponent(itm[2]);
            }

            return key === false ? res : null;
        }

        function toCamel(o) {
            var newO, origKey, newKey, value
            if (o instanceof Array) {
                return o.map(function (value) {
                    if (typeof value === "object") {
                        value = toCamel(value)
                    }
                    return value
                })
            } else {
                newO = {}
                for (origKey in o) {
                    if (o.hasOwnProperty(origKey)) {
                        newKey = (origKey.charAt(0).toLowerCase() + origKey.slice(1) || origKey).toString()
                        value = o[origKey]
                        if (value instanceof Array || (value !== null && value.constructor === Object)) {
                            value = toCamel(value)
                        }
                        newO[newKey] = value
                    }
                }
            }
            return newO
        }

        function toPascal(o) {
            var newO, origKey, newKey, value;
            if (o instanceof Array) {
                return o.map(function (value) {
                    if (typeof value === "object") {
                        value = toPascal(value);
                    }
                    return value;
                });
            } else {
                newO = {};
                for (origKey in o) {
                    if (o.hasOwnProperty(origKey)) {
                        newKey = (origKey.charAt(0).toUpperCase() + origKey.slice(1) || origKey).toString();
                        value = o[origKey];
                        if (value instanceof Array || (value !== null && value.constructor === Object)) {
                            value = toPascal(value);
                        }
                        newO[newKey] = value;
                    }
                }
            }
            return newO
        }

        function b64DecodeUnicode(str) {
            return decodeURIComponent(
                Array.prototype.map.call(atob(str), c =>
                    '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2)
                ).join(''));
        }

        
        function parseJwt(token) {
            return JSON.parse(
                b64DecodeUnicode(
                    token.split('.')[1].replace('-', '+').replace('_', '/')
                )
            );
        }

        function RemoveFilePostFix(fileName) {
            var removeexte = ['(PDF)', '(RTF)'];
            for (var i = 0; i <= removeexte.length; i++) {
                if (fileName.indexOf(removeexte) === - 1) {
                    fileName = fileName.replace(removeexte[i], '').replace(/\s+$/, '');
                }
            }

            return fileName;
        }

        function valueExistsInArray(value, array) {
            if (array && value && array.length > 0) {
             var item =   array.filter(function (item) {
                 return item.value === value;
                })[0];
                if (item) {
                    // value is NOT in array
                    return true;
                }
                return false;
            }
            return true;
        }

        function valueExistsInDropDown(value, array) {
            if (array && value && array.length > 0) {
                var item = array.filter(function (item) {
                    return item.Value === value;
                })[0];
                if (item) {
                    // value is NOT in array
                    return true;
                }
                return false;
            }
            return true;
        }

        function ConvertDateTimeForUi(inputDateTime) {
            var dateFilter = $filter("date");
            var newDate = dateFilter(inputDateTime, "dd/MM/yyyy");
            return moment(newDate, "DD/MM/YYYY");
        }

        function getRandomIdentity() {
            var currentIdentity = new Date().getTime();
            currentIdentity = Math.sin(currentIdentity) * 10000;
            return currentIdentity - Math.floor(currentIdentity);
        }

        function getAddressEnquiry(illionAddressEnquiryRequestVM) {
            var quoteTransaction = $resource(apiUrlConstService.getAddressEnquiryUrl, { },
                { request: { method: 'Post', isArray: false } });
            return quoteTransaction.save(illionAddressEnquiryRequestVM).$promise;
        }        
    }
})();;
(function () {
    'use strict';

    angular.module('appUI')
        .service('bindService', ['$rootScope', '$resource', '$q', 'apiUrlConstService', bindService]);

    var bindRequestUrl = '/Proxy/Bind/BindRequest';

    function bindService($rootScope, $resource, $q,apiUrlConstService) {
        return {
            bind: bind,
            bindPolicyDocumentGrid: bindPolicyDocumentGrid,
            downloadScheduleDocument: downloadScheduleDocument,
            getBoundTransaction: getBoundTransaction
        };

        function bind(transactionId, referenceNumber, paymentCollectedByBroker, confirmBind, noclaimsinbind) {
            var bindApi = $resource(bindRequestUrl, {},
                { request: { method: 'POST', isArray: false } });
            return bindApi.save({ "quoteTransactionId": transactionId, "referenceNumber": referenceNumber, "paymentCollectedByBroker": paymentCollectedByBroker, "confirmBind": confirmBind, "noclaimsinbind": noclaimsinbind }).$promise;
        }

        function bindPolicyDocumentGrid(CoverType) {
            var documentGridApi = $resource(apiUrlConstService.policyDocumentURL, {},
                { request: { method: 'POST', isArray: false } });
            return documentGridApi.save(CoverType).$promise;
        }

        function downloadScheduleDocument(CoverType) {
            var documentScheduleApi = $resource(apiUrlConstService.policyScheduleDocumentURL, {},
                { request: { method: 'POST', isArray: false } });
            return documentScheduleApi.save(CoverType).$promise;
        }

        function getBoundTransaction(policyTransactionId, isAlreadyCancelled) {
            var quoteTransaction = $resource(apiUrlConstService.getQuoteTransaction, { transactionId: policyTransactionId, hasAlreadyCancelled: isAlreadyCancelled }, { get: { method: 'GET', isArray: false } });
            return quoteTransaction.get().$promise;
        }
    }
})();;
(function () {
    'use strict';

    angular.module('appUI')
        .service('policyService', ['$rootScope', '$resource', '$q', '$http', '$log', 'apiUrlConstService', policyService]);

    function policyService($rootScope, $resource, $q, $http, $log, apiUrlConstService) {
        return {
            getPolicies: getPolicies,
            getPolicy: getPolicy,
            getSearchPolicy: getSearchPolicy,
            getClientDetail: getClientDetail,
            getPolicyDetail: getPolicyDetail,
            getPackageDetail: getPackageDetail,
            getPoliciesQuotes: getPoliciesQuotes
        };

        function getCaseData(caseId) {
            var caseApi = $resource(apiUrlConstService.ExistingCaseUrl, {
                caseId: caseId
            }, { get: { method: 'GET', isArray: true } });

            return caseApi.get().$promise;
        }

        function getSearchPolicy(policySearchData) {
            console.log(policySearchData);
            var PoliciesApi = $resource(apiUrlConstService.policySearchUrl, {
            }, { get: { method: 'POST', isArray: false } });

            return PoliciesApi.get(policySearchData).$promise;
        }

        function getClientDetail(query) {
            var clientApi = $resource(apiUrlConstService.clientFirstNameURL, {
                searchClient: query
            }, { get: { method: 'GET', isArray: false } });

            return clientApi.get().$promise;
        }

        function getPolicyDetail(query) {
            var policyApi = $resource(apiUrlConstService.partialPolicySearchUrl, {
                searchPolicy: query
            }, { get: { method: 'GET', isArray: false } });

            return policyApi.get().$promise;
        }

        function getPackageDetail(query) {
            var packageApi = $resource(apiUrlConstService.partialPackageSearchUrl, {
                searchPackage: query
            }, { get: { method: 'GET', isArray: false } });

            return packageApi.get().$promise;
        }

        function getPolicies(dateFrom, dateTo, pageNumber, pageSize, product, status) {
            var policiesApi = $resource(apiUrlConstService.policiesUrl,
                {
                    dateFrom: dateFrom,
                    dateTo: dateTo,                    
                    pageNumber: pageNumber,
                    pageSize: pageSize,
                    product: product,
                    status: status
                },
                { get: { method: 'GET', isArray: false } });

            return policiesApi.get().$promise;
        }


        function getPolicy(policyId, brokerId) {
            var policyApi = $resource(apiUrlConstService.policyUrl, {
                policyId: policyId,
                brokerId: brokerId
            }, { get: { method: 'GET', isArray: false } });

            return policyApi.get().$promise;
        }

        function getPoliciesQuotes(effectiveFrom, effectiveTo, pageNumber, pageSize, product, status , processType) {
            var quotePoliciesApi = $resource(apiUrlConstService.getPoliciesQuotes,
                {
                    dateFrom: effectiveFrom,
                    dateTo: effectiveTo,
                    pageNumber: pageNumber,
                    pageSize: pageSize,
                    product: product,
                    status: status,
                    processType: processType
                },
                { get: { method: 'GET', isArray: false } });

            return quotePoliciesApi.get().$promise;
        }
    }

})();;
(function () {
    'use strict';

    angular.module('appUI')
        .service('disclaimerService', ['$rootScope', '$resource', '$q', '$http', '$log', 'apiUrlConstService', disclaimerService]);

    var getBrokerUrl = '/Proxy/broker/GetExistingBrokerDetail';
    function disclaimerService($rootScope, $resource, $q, $http, $log, apiUrlConstService) {
        return {
            saveDisclaimerDetail: saveDisclaimerDetail,
            getExistingBrokerDetails: getExistingBrokerDetails
        };
        function saveDisclaimerDetail(disclaimerDataId, tokenResponse) {
            if (disclaimerDataId && tokenResponse) {
                var disclaimerDataDetail = $resource(apiUrlConstService.disclaimerDataSave,
                    {}, {
                        update: {
                            method: 'POST',
                            headers: {
                                    'Authorization': 'Bearer ' + tokenResponse.access_token
                            },
                            isArray: false
                        }
                    });

                return disclaimerDataDetail.update( disclaimerDataId ).$promise;
            }

        }

        function getExistingBrokerDetails() {
            var getVerificationIdApi = $resource(getBrokerUrl, { get: { method: 'GET', isArray: false } });
            return getVerificationIdApi.get().$promise;
        }
    }

})();;
(function () {
    'use strict';

    angular.module('appUI')
        .factory('loginService', ['$rootScope', '$resource', '$q','webUrlConstService', loginService]);


    function loginService($rootScope, $resource, $q, webUrlConstService) {

        return $resource(webUrlConstService.loginURL, {}, {
            post: {
                method: 'POST'
            }
        });

    }
})();;
(function () {
    "use strict";
    angular
        .module("appUI")
        .service("nvicMotorService", [
            "$rootScope",
            "$resource",
            "$q",
            "apiUrlConstService",
            nvicMotorService
        ]);

    function nvicMotorService($rootScope, $resource, $q, apiUrlConstService) {
        return {
            getMotorDetailsForVIN: getMotorDetailsForVIN,
            getMotorDetailsForPlate: getMotorDetailsForPlate,
            getExcessListAccordingtoDefaultExcess: getExcessListAccordingtoDefaultExcess
        };
        function getMotorDetailsForVIN(vin) {
            var nvicMotorApi = $resource(
                apiUrlConstService.nvicMotorURL,
                {
                    vin: vin
                },
                { get: { method: "GET", isArray: false } }
            );

            return nvicMotorApi.get().$promise;
        }
        function getMotorDetailsForPlate(plate, jurisdiction, policyEffectiveDttm, caseNumberForPlate) {
            var nvicMotorApi = $resource(
                apiUrlConstService.nvicMotorURL,
                {
                    plate: plate,
                    jurisdiction: jurisdiction,
                    policyEffectiveDttm: policyEffectiveDttm,
                    caseNumberForPlate: caseNumberForPlate
                },
                { get: { method: "GET", isArray: false } }
            );

            return nvicMotorApi.get().$promise;
        }

        function getExcessListAccordingtoDefaultExcess(defaultExcess, defaultExcessFlag, policyNumber) {
            var getExcessList = $resource(
                apiUrlConstService.getExcessListForDefaultExcess,
                {
                    defaultExcess: defaultExcess,
                    defaultExcessFlag: defaultExcessFlag,
                    policyNumber: policyNumber
                },
                { get: { method: "GET", isArray: false } }
            );

            return getExcessList.get().$promise;
        }
    }
})();
;
(function () {
    'use strict';

    app.service('sessionStorageService', ['$rootScope', '$resource', '$http', '$q', '$window', sessionStorageService]);


    function sessionStorageService($rootScope, $resource, $http, $q, $window) {
        //declarations
        this.get = get;
        this.set = set;
        this.remove = remove;
        this.clearAll = clearAll;
        this.getEncryption = getEncryption;
        this.encodeToHex = encodeToHex;
        this.encryptionKey = "bzinsurance";
        this.Key = CryptoJS.enc.Utf8.parse("8080808080808080");
        this.iv = CryptoJS.enc.Utf8.parse("8080808080808080");

        function get(sessionName) {
            var data = $window.sessionStorage.getItem(sessionName);
            if (data !== null) {
                var decryptedData = CryptoJS.AES.decrypt(data, this.encryptionKey);
                data = decryptedData.toString(CryptoJS.enc.Utf8);
                if (sessionName === "tokenData")
                    data = JSON.parse(data);
            }
            return data;
        }

        function set(sessionName, data) {
            if (data !== null) {
                data = JSON.stringify(data);
                var enryptedData = CryptoJS.AES.encrypt(data, this.encryptionKey);
            }
            $window.sessionStorage.setItem(sessionName, enryptedData);
        }

        function remove(sessionName) {
            $window.sessionStorage.removeItem(sessionName);
        }
        function clearAll() {
            $window.sessionStorage.clear();
        }

        function getEncryption(data) {
            return this.encodeToHex(CryptoJS.AES.encrypt(CryptoJS.enc.Utf8.parse(data), this.Key,
                {
                    keySize: 128 / 8,
                    iv: this.iv,
                    mode: CryptoJS.mode.CBC
                }).toString());
        }

        function encodeToHex(cipherText) {
            var hexEquivalent = '';
            for (var i = 0; i < cipherText.length; i++) {
                hexEquivalent += '' + cipherText.charCodeAt(i).toString(16);
            }
            return hexEquivalent;
        }
    }
})();;
(function () {
    "use strict";
    app.service("dateService", ["$rootScope", "$log", "$window", "messageConstService", dateService]);

    function dateService($rootScope, $log, $window, messageConstService) {
        this.getDateDDMMtoMMDD = getDateDDMMtoMMDD;
        this.getDateMMDDtoDDMM = getDateMMDDtoDDMM;
        this.validateDate = validateDate;
        this.validateDateRange = validateDateRange;
        this.validateBirthDDMMYYYY = validateBirthDDMMYYYY;
        this.validateRange = validateRange;
        this.add = add;
        this.subtract = subtract;
        this.getMomentDateforDDMM = getMomentDateforDDMM;
        this.convertDatetoMMDDYYYFormat = convertDatetoMMDDYYYFormat;
        this.convertDatetoDDMMYYYFormat = convertDatetoDDMMYYYFormat;
        this.getExpiryDateMoment = getExpiryDateMoment;
        this.checkValidExpiratonDate = checkValidExpiratonDate;
        this.getYear = getYear;
        this.getSeperatedDate = getSeperatedDate;
        this.validateRangeForEndorsement = validateRangeForEndorsement;

        var response = { isValid: false, errorMsg: "" };
        var dateFormatDDMMYYYY = "DD/MM/YYYY";
        var dateFormatMMDDYYYY = "MM/DD/YYYY";

        function getExpiryDateMoment(inputDate){
            var mDate = moment(inputDate).format('DD/MM/YYYY');
            return mDate;
        }

        function getMomentDateforDDMM(inputDate) {
            var mDate = moment(inputDate, dateFormatDDMMYYYY);
            return mDate;
        }

        function convertDatetoMMDDYYYFormat(inputDate) {
            var mDate = moment(inputDate).format(dateFormatMMDDYYYY);
            return mDate;
        }

        function convertDatetoDDMMYYYFormat(inputDate) {
            var mDate = moment(inputDate).format(dateFormatDDMMYYYY);
            return mDate;
        }

        function add(inputDate, value, unit) {
            var mDate = moment(inputDate, dateFormatDDMMYYYY);
            if (!mDate._isValid) {
                return;
            }
            var returnDate = mDate.add('years', 1).format(dateFormatDDMMYYYY);
            return returnDate;
        }

        function subtract(inputDate, value, unit) {
            var mDate = moment(inputDate, dateFormatDDMMYYYY);
            if (!mDate._isValid) {
                return;
            }
            var returnDate = mDate.subtract('years', 1).format(dateFormatDDMMYYYY);
            return returnDate;
        }

        //convert date string from DD/MM/YYYY to MM/DD/YYYY
        function getDateDDMMtoMMDD(inputDate) {
            var momentDate = moment(inputDate, dateFormatDDMMYYYY);
            if (momentDate._isValid) {
                var newDate = moment(momentDate).format(dateFormatMMDDYYYY);
                return newDate;
            }
            response.errorMessage = messageConstService.errDateInvalid;
            return response;
        }

        //convert date string from MM/DD/YYYY to DD/MM/YYYY
        function getDateMMDDtoDDMM(inputDate) {
            var momentDate = moment(inputDate, dateFormatMMDDYYYY);
            if (momentDate._isValid) {
                var newDate = moment(momentDate).format(dateFormatDDMMYYYY);
                return newDate;
            }
            response.errorMessage = messageConstService.errDateInvalid;
            return response;
        }

        //validates the date for the proper format in DD/MM/YYYY
        function validateDate(inputDate) {
            var mDate = moment(inputDate, dateFormatDDMMYYYY);
            if (!mDate._isValid) {
                response.errorMsg = messageConstService.errDateInvalid;
                response.isValid = false;

                return response;
            }
            var newDate = getDateDDMMtoMMDD(mDate);
            response.date = newDate;
            response.isValid = true;
            return response;
        }

        //validates the date of birth and for not allowing the future dates and dates  below allowed years
        function validateBirthDDMMYYYY(inputDate, allowedYears) {
            if (allowedYears) {
                allowedYears = 115;
            }
            var validDateResponse = validateDate(inputDate);
            if (!validDateResponse.isValid) {
                response.errorMsg = messageConstService.errDateInvalid;
                response.isValid = false;

                return response;
            }
            var mDate = moment(inputDate, dateFormatDDMMYYYY);

            var currentDate = moment();
            //date should not be future date
            if (mDate >= currentDate) {
                response.errorMsg = messageConstService.errFutureDateNotAllowed;
                response.isValid = false;

                return response;
            }

            var minDate = currentDate.subtract(allowedYears, "years");
            if (mDate <= minDate) {
                response.errorMsg = messageConstService.errDateNotAllowed;
                response.isValid = false;

                return response;
            }

            var newDate = getDateDDMMtoMMDD(inputDate);
            response.date = newDate;
            response.isValid = true;
            return response;
        }

        //validates the given date that it is within the range of subtract startRange number of days from cuurrent date and add endRange number of days from cuurrent date
        function validateRange(inputDate, startRange, endRange, unit) {
            //convert and validates the given dates
            var inputDateResponse = validateDate(inputDate);
            if (!inputDateResponse.isValid) {
                response.isValid = false;
                response.errorMsg = messageConstService.errDateInvalid;
                return response;
            }
            var mDate = moment(inputDate, dateFormatDDMMYYYY);
            var minDate = moment().subtract(startRange, unit);
            var maxDate = moment().add(endRange, unit);

            //compare
            if (!mDate.isBetween(minDate, maxDate, "days", true)) {
                response.errorMsg = messageConstService.errDateOutOfRange;
                response.isValid = false;
                return response;
            }
            response.isValid = true;
            return response;
        }

        function validateRange(unit, minUnits, maxUnits, inputDate, baseDate, endorsementExpirationDate, isEndorsement) {
            //convert and validates the given dates
            var inputDateResponse = validateDate(inputDate);
            if (!inputDateResponse.isValid) {
                response.isValid = false;
                response.errorMsg = messageConstService.errDateInvalid;
                return response;
            }
            var minDate = "";
            var maxDate = "";

            var inputDateMoment = moment(inputDate, dateFormatDDMMYYYY);
            var expirationDateMoment = moment(endorsementExpirationDate, dateFormatDDMMYYYY);
            if (!baseDate) {
                //baseDate not present then calculate the min ,max date base on the current  date
                if (minUnits < 0) {
                    minDate = moment().subtract(Math.abs(minUnits), unit);
                }
                else {
                    minDate = moment().add(Math.abs(minUnits), unit);
                }

                if (maxUnits < 0) {
                    maxDate = moment().subtract(Math.abs(maxUnits), unit);
                }
                else {
                    maxDate = moment().add(Math.abs(maxUnits), unit);
                }
                if (isEndorsement)
                {
                    if (maxDate > expirationDateMoment) {
                        maxDate = expirationDateMoment;
                    }
                }
            }
            else {                
                if (minUnits < 0) {
                    minDate = moment(baseDate, dateFormatDDMMYYYY).subtract(Math.abs(minUnits), unit);
                }
                else {
                    minDate = moment(baseDate, dateFormatDDMMYYYY).add(Math.abs(minUnits), unit);
                }

                if (maxUnits < 0) {
                    maxDate = moment(baseDate, dateFormatDDMMYYYY).subtract(Math.abs(maxUnits), unit);
                }
                else {
                    maxDate = moment(baseDate, dateFormatDDMMYYYY).add(Math.abs(maxUnits), unit);
                }
                if (isEndorsement) {
                    if (maxDate > expirationDateMoment) {
                        maxDate = expirationDateMoment;
                    }
                }
            }

            if (minDate > maxDate) {
                response.errorMsg = messageConstService.errDateOutOfRange;
                response.isValid = false;
                return response;
            }

            //compare
            if (!inputDateMoment.isBetween(minDate, maxDate, "days", true)) {
                if (inputDateMoment < minDate) {
                    response.errorMsg = messageConstService.errDateBelowRange;
                }
                if (inputDateMoment > maxDate) {
                    response.errorMsg = messageConstService.errDateAboveRange;
                }
                response.isValid = false;
                return response;
            }

            response.isValid = true;
            return response;
        }

        function validateDateRange(inputDate, startRange, endRange) {
            //convert and validates the given dates
            var inputDateResponse = validateDate(inputDate);
            if (!inputDateResponse.isValid) {
                response.isValid = false;
                response.errorMsg = messageConstService.errDateInvalid;
                return response;
            }
            var startRangeString = moment(startRange).format(dateFormatDDMMYYYY);
            var endRangeString = moment(endRange).format(dateFormatDDMMYYYY);
            var mDate = moment(inputDate, dateFormatDDMMYYYY);
            var minDate = moment(startRangeString, dateFormatDDMMYYYY);
            var maxDate = moment(endRangeString, dateFormatDDMMYYYY);

            //compare
            if (!mDate.isBetween(minDate, maxDate, "days", true)) {
                response.errorMsg = messageConstService.errEffectiveDateNotAllowed;
                response.isValid = false;
                return response;
            }
            response.isValid = true;
            return response;
        }

        function checkValidExpiratonDate(inputDate,minDaystoExpirationFromCurrentDate) {
            var currentDate = moment();
            var inputDateMoment = moment(inputDate, dateFormatDDMMYYYY);
            if (inputDateMoment < currentDate) {
                var minExpirationDate = currentDate.add(minDaystoExpirationFromCurrentDate, "days");
                response.minExpirationDate = minExpirationDate;
                return response;
            }
            else {
                return null;
            }
        }

        // Get year of given date
        function getYear(inputDate) {
            var mDate = moment(inputDate, dateFormatMMDDYYYY).year();
            return mDate;
        }

        // get Day,Month and Year from a date in DD/MM/YYYY fromat
        function getSeperatedDate(inputDate) {
            var Date = inputDate.split('/');
            if (Date) {
                response.isValid = true;
                response.Day = Date[0];
                response.Month = Date[1];
                response.Year = Date[2];                
            }
            else {
                response.isValid = false;
            }
            return response;
        }

        function validateRangeForEndorsement(unit, maxUnits, inputDate, endorsementeffectiveDate, endorsementExpirationDate) {
            //convert and validates the given dates
            var inputDateResponse = validateDate(inputDate);
            if (!inputDateResponse.isValid) {
                response.isValid = false;
                response.errorMsg = messageConstService.errDateInvalid;
                return response;
            }

            var maxDate = "";

            var inputDateMoment = moment(inputDate, dateFormatDDMMYYYY);
            var expirationDateMoment = moment(endorsementExpirationDate, dateFormatDDMMYYYY);            
                
            if (maxUnits < 0) {
                maxDate = moment().subtract(Math.abs(maxUnits), unit);
            }
            else {
                maxDate = moment().add(Math.abs(maxUnits), unit);
            }
                
            if (maxDate > expirationDateMoment) {
                maxDate = expirationDateMoment;
            }

            if (endorsementeffectiveDate > maxDate) {
                response.errorMsg = messageConstService.errDateOutOfRange;
                response.isValid = false;
                return response;
            }

            //compare
            if (!inputDateMoment.isBetween(endorsementeffectiveDate, maxDate, "days", true)) {
                if (inputDateMoment < endorsementeffectiveDate) {
                    response.errorMsg = messageConstService.errDateBelowRange;
                }
                else if (inputDateMoment > maxDate) {
                    response.errorMsg = messageConstService.errDateAboveRange;
                }
                response.isValid = false;
                return response;
            }

            response.isValid = true;
            return response;
        }
    }
})();
;
(function () {
    'use strict';

    /**
     * @ngdoc service
     * @name responsiveService
     *
     * # responsiveService
     *
     * @description
     * provides some helper methods to programmatically detect screen-size and accordingly make decisions
     * primarily used in top-navigation drop-down menu's collapse-related-function currently
     */

    angular.module('appUI')
        .service('responsiveService', ['$rootScope', '$window', responsiveService]);

    function responsiveService($rootScope, $window) {
        return {
            runningOnExtraSmallDevice: function () {
                return $('.device-xs').is(':visible');
            },

            runningOnSmallDevice: function () {
                return $('.device-sm').is(':visible');
            },

            runningOnMediumDevice: function () {
                return $('.device-md').is(':visible');
            },

            runningOnLargeDevice: function () {
                return $('.device-lg').is(':visible');
            }
        };
    }
})();;
(function () {
    'use strict';

    angular.module('appUI')
        .service('brokerQuestionService', ['$rootScope', '$resource', '$q', brokerQuestionService]);

    var brokerQuestionsUrl = '/Proxy/QuoteQuestionEngine/GetQuestion?brokerId=:brokerId&productId=:productId&InceptionDate=:InceptionDate&ExceptionDate=:ExceptionDate&ProductType=:ProductType';
 
    function brokerQuestionService($rootScope, $resource, $q) {
        return {
            getBrokerQuestions: getBrokerQuestions
        };

        function getBrokerQuestions(brokerId,productId,InceptionDate,ExceptionDate,ProductType)
        {
            var brokerQuestionApi = $resource(brokerQuestionsUrl, {
                brokerId: brokerId,
                productId: productId,
                InceptionDate: InceptionDate,
                ExceptionDate:ExceptionDate,
                ProductType:ProductType
            }, { get: { method: 'GET', isArray: true } });

            return brokerQuestionApi.get().$promise;
        }
    }
})();;
(function () {
    'use strict';

    angular.module('appUI').factory('clientService', ['$resource', 'apiUrlConstService','$http', clientService]);

    function clientService($resource, apiUrlConstService,$http) {
        return {
            getByName: getByName,
            updateClientData: updateClientData,
            saveClientData: saveClientData,
            deleteClientData: deleteClientData,
            getByClientCode: getByClientCode,
            getByNameAndCode: getByNameAndCode,
            getClients: getClients,
            getSecondaryInmsured: getSecondaryInmsured,
            AutoSearchResult: AutoSearchResult,
            getAllClientsByClientCode: getAllClientsByClientCode,
            getABNDetail: getABNDetail
        };

        function getByName(name) {
            var clientData = $resource(apiUrlConstService.getByNameURL, {
                name: name
            }, { get: { method: 'GET', isArray: false } });

            return clientData.get().$promise;
        }
        function getByClientCode(clientCode) {
            var clientData = $resource(apiUrlConstService.getByCodeURL, {
                clientCode: clientCode
            }, { get: { method: 'GET', isArray: false } });

            return clientData.get().$promise;
        }

        function getByNameAndCode(clientRequest) {
            var clientData = $resource(apiUrlConstService.getByNameAndCodeURL, {},
                { request: { method: 'POST', isArray: false } });
            return clientData.save(clientRequest).$promise;
        }

        function getClients(clientRequest) {
            var clientData = $resource(apiUrlConstService.getClients, {
                clientSearchRequest: clientRequest
            },
            { request: { method: 'POST', isArray: false } });
            return clientData.get().$promise;
        }

        function updateClientData(client) {
            var clientData = $resource(apiUrlConstService.updateClientURL, {
                client: client.client}
                , { 'upate': { method: 'PUT', isArray: false } });

            return clientData.upate(client.client).$promise;
        }

        function saveClientData(client) {
            var clientData = $resource(apiUrlConstService.addClientAsyncURL, {}
                , { request: { method: 'POST', isArray: false } });

            return clientData.save(client.client).$promise;
        }

        function deleteClientData(clientCode) {
            var clientCode = clientCode.clientCode;
            var clientData = $resource(apiUrlConstService.deleteClientURL, {
                clientCode: clientCode,
            } , { 'delete': { method: 'DELETE', isArray: false } });

            return clientData.delete().$promise;
        }


        function getSecondaryInmsured(caseId) {
            var clientData = $resource(apiUrlConstService.getSecondaryInsured, {
                caseId: caseId
            }, { get: { method: 'GET', isArray: false } });

            return clientData.get().$promise;
        }       
        function AutoSearchResult(query) {
            return $http.get(apiUrlConstService.clientURL + 'GetClientAllSearch?searchClient=' + query, { skipInterceptor: true })
                .then(function (result) {
                    var data = result.data.data;
                    var client1 = [];
                    if (data) {
                        var arr = data;
                        client1 = arr.map(function (val, i, arr) {                            
                            return val.fullName;
                        });
                    }
                    return client1;
                });
        }

        function getAllClientsByClientCode(clientNameandCode) {
            return $http.post(apiUrlConstService.getAllClientsByClientCodeURL + '?clientNameandCode=' + clientNameandCode, { skipInterceptor: true })
                .then(function (result) {
                    if (result.data.status) {
                        //console.log('idata', result.data.data);
                        var data = result.data.data;
                        var clients = [];
                        if (data) {
                            clients = data.map(function (val, i, arr) {
                                return val;
                            });
                        }
                    }
                    return clients;

                }, function (error) {
                    console.log('error', error);
                });
        }

        function getABNDetail(abnNumber) {
            return $http.get(apiUrlConstService.illionURL + 'GetABNDetail?abnNumber=' + abnNumber)
                .then(function (result) {
                    return result;
                });                   
        }
    }

})();;
(function () {
    'use strict';

    angular.module('appUI').factory('packageService', ['$resource', 'apiUrlConstService', packageService]);

    function packageService($resource, apiUrlConstService) {

        return {
            getClientPackages: getClientPackages
        };

        function getClientPackages(selectedClientCode) {
            var packagesApi = $resource(apiUrlConstService.getClientPackages, {
                clientNameandCode: selectedClientCode
            }, { get: { method: 'GET', isArray: false } });

            return packagesApi.get().$promise;
        }
    }

})();;
(function () {
    'use strict';

    angular.module('appUI')
        .service('endorsementService', ['apiUrlConstService','$resource', endorsementService]);


    function endorsementService(apiUrlConstService, $resource) {
        return {
            endorsementComisionQuoteRequest: endorsementComisionQuoteRequest,
            endorsementNonComisionQuoteRequest: endorsementNonComisionQuoteRequest
        };


        function endorsementComisionQuoteRequest(endorsementVM) {
            var endorsementComisionQuoteRequestApi = $resource(apiUrlConstService.endorsementComissionQuoteUrl, {}
                , { request: { method: 'POST', isArray: false } });
            return endorsementComisionQuoteRequestApi.save(endorsementVM).$promise;
        }

        function endorsementNonComisionQuoteRequest(endorsementVM) {
            var endorsementNonComisionQuoteRequestApi = $resource(apiUrlConstService.endorsementNonComissionQuoteUrl, {}
                , { request: { method: 'POST', isArray: false } });
            return endorsementNonComisionQuoteRequestApi.save(endorsementVM).$promise;
        }

    }
   
})();;
(function () {
    'use strict';

    var appUI = angular.module('appUI');
    appUI.filter('convertDateTime', function ($filter) {

        return function (input) {
            console.log("input in filter convert date");
            var timeFormat = 'dd MMM yyyy HH:mm'; //date format

            if (input == null) { return ""; }

            return $filter('date')(parseInt(input.substr(6)), timeFormat);

        };

    });
})();;
(function () {
    'use strict';

    var appUI = angular.module('appUI');

    appUI.controller('rootCtrl', ['$rootScope', '$scope', '$window', 'sessionStorageService', '$cookieStore', '$q', 'userService', 'webUrlConstService', '$cookies', '$mdDialog', 'utilityService', rootCtrl]);

    function rootCtrl($rootScope, $scope, $window, sessionStorageService, $cookieStore, $q, userService, webUrlConstService, $cookies, $mdDialog, utilityService) {
        var rootModel = this;
        rootModel.ready = true;
        rootModel.init = init;
        rootModel.isLoggedIn = isLoggedIn;
        rootModel.isReady = isReady;
        rootModel.getAgent = getAgent;
        // rootModel.getBrokerBranchList = getBrokerBranchList;
        rootModel.switchBranch = switchBranch;
        rootModel.brokerBranchCount = 0;
        rootModel.selectedBranch;
        rootModel.brokerId;
        rootModel.checkRandomChange = checkRandomChange;
        var tokenTimeOut = JSON.parse(sessionStorageService.get('tokenTimeOut'));
        var tokenLifeStart = JSON.parse(sessionStorageService.get('tokenLifeStart'));
        var triggerPopUp = tokenTimeOut * 60000;
        var popUp, timerController;
        var isPopUpTrigerred = false;
        var remainingTime = null;

        $window.setInterval(checkRandomChange, 10000);

        //timerController = setInterval(setTimer, 1000);

        //function setTimer() {
        //    remainingTime = ((new Date()).getTime() - JSON.parse(sessionStorageService.get('tokenLifeStart'))) / 60;
        //}
        // refresh multiple tabs and windows of same browser
        function checkRandomChange() {
            var cookieRandomId = JSON.parse($cookies.get('randomLoginId'));
            var sessionRndomId = JSON.parse(sessionStorageService.get('randomLoginId'));
            
            if (cookieRandomId !== sessionRndomId) {
                sessionStorageService.set('randomLoginId', cookieRandomId);
                $window.location.href = "Home/Index";
            }
        }

        popUp = setInterval(RunTokenExpiryTimer, 5000);

        function RunTokenExpiryTimer() {
            //console.log(sessionStorageService.get("IsTokenRefreshDeclined"));
            var currentTime = (new Date()).getTime();
            var elapsedTime = currentTime - tokenLifeStart;
            var comparisonWindow = 0.7 * tokenTimeOut * 60000;
            //console.log(elapsedTime);
            //console.log(comparisonWindow);
            //console.log(elapsedTime >= comparisonWindow);
            triggerPopUp = elapsedTime >= comparisonWindow ? 1 : tokenTimeOut * 60000;
            if (triggerPopUp === 1 && isPopUpTrigerred === false) {
                isPopUpTrigerred = true;
                //console.log(remainingTime);
                TokenRefreshPrompt();
                //triggerPopUp = tokenTimeOut * 60000;
                //clearInterval(popUp);
                //tokenLifeStart = (new Date()).getTime();
                //currentTime = (new Date()).getTime();
            }
            //console.log(triggerPopUp);
        }

        //Prompt for Token Refresh after lapse of 90% of the token expiry time.
        //$window.setInterval(TriggerPopUpTimer, 100);
        function TriggerPopUpTimer() {
            if (triggerPopUp === 1 && isPopUpTrigerred === false) {
                console.log('PopUp Trigger Initiated');
                $window.setInterval(TokenRefreshPrompt, triggerPopUp);
                triggerPopUp = tokenTimeOut * 60000;
                isPopUpTrigerred = true;
            }
        }

        function TokenRefreshPrompt() {
            var tokenRefreshDeclined = JSON.parse(sessionStorageService.get('IsTokenRefreshDeclined'));
            if (tokenRefreshDeclined === false) {
                $mdDialog.show({
                    controller: TokenRefreshController,
                    templateUrl: 'app/pages/shared/session-modal-form.html',
                    parent: angular.element(document.body),
                    locals: { modalTitle: 'Your session is going to expire. Click on Accept to refresh your session time.' },
                    escapeToClose: false,
                    clickOutsideToClose: false
                }).then(function (answer) {
                    if (answer === 'Accept') {
                        userService.refreshToken().then(function (result) {
                            if (result.status === true) {
                                toastr.success("Session has been refreshed successfully!");
                                sessionStorageService.set("IsTokenRefreshDeclined", false);
                                sessionStorageService.set("tokenLifeStart", (new Date()).getTime());
                                tokenLifeStart = (new Date()).getTime();
                                isPopUpTrigerred = false;
                            }
                            else {
                                toastr.failure("Service not responding.");
                            }
                        });
                    }
                    else {
                        sessionStorageService.set("IsTokenRefreshDeclined", true);
                    }
                }, function () {
                    toastr.error("Service not responding.");
                });
            }
        }

        function TokenRefreshController($scope, $mdDialog, modalTitle) {
            $scope.modalTitle = modalTitle;
            $scope.hide = function () {
                $mdDialog.hide();
            };
            $scope.cancel = function () {
                $mdDialog.cancel();
            };
            $scope.answer = function (answer) {
                $mdDialog.hide(answer);
            };
        }

        function init(data, email, IsPackageManagerOn, branchViewOnly, brokerBranchList) {
            if (data !== null) {
                //store the name in the session storage.
                sessionStorageService.set('userName', data);
            }
            if (email !== null)
                sessionStorageService.set('userEmail', email);
            if (IsPackageManagerOn) {
                sessionStorageService.set('IsPackageManagerOn', IsPackageManagerOn);
            }

            if (sessionStorageService.get('IsBranchViewOnly') == null) {
                sessionStorageService.set('IsBranchViewOnly', branchViewOnly);
            }

            if (brokerBranchList !== null) {
                sessionStorageService.set('brokerBranchList', brokerBranchList);
                rootModel.brokerBranchCount = Object.keys(brokerBranchList).length;
            }
            else if (brokerBranchList === null) {
                brokerBranchList = sessionStorageService.get('brokerBranchList');
                rootModel.brokerBranchCount = JSON.parse(brokerBranchList).length;
            }

            rootModel.ready = true;
            getBrokerBranchList();

            var isChangedBrokerBranch = sessionStorageService.get('isChangedBrokerBranch');
            if (isChangedBrokerBranch == "true") {
                toastr.success("Broker branch has been switched successfully!");
                sessionStorageService.remove('isChangedBrokerBranch');
                var randomLoginId = utilityService.getRandomIdentity();
                $cookies.put("randomLoginId", randomLoginId);
                sessionStorageService.set("randomLoginId", randomLoginId);
            }
        }

        function isReady() {
            return (rootModel.ready && rootModel.isLoggedIn());
        }

        function isLoggedIn() {
            return true;
        }

        function getAgent() {
            //get the name from the session storage.
            var name = sessionStorageService.get('userName');
            name = JSON.parse(name);
            return name;
        }

        function getBrokerBranchList() {
            var currentBranchRowCount = 0
            var brokerBranchList = sessionStorageService.get('brokerBranchList');
            rootModel.brokerBranchList = JSON.parse(brokerBranchList);
            angular.forEach(rootModel.brokerBranchList, function (val, key) {
                if (val.LatestBranchSwitchedTo === true) {
                    //rootModel.selectedBranch = val.BrokerBranchId.toString();
                    rootModel.selectedBranch = val.BrokerBranchName;
                  //rootModel.selectedBranch = rootModel.selectedBranch + " _Testx Private Limited Limited1";
                    rootModel.brokerId = val.BrokerId.toString();
                    currentBranchRowCount = key;
                }
            });
            rootModel.brokerBranchList.splice(currentBranchRowCount, 1)
        }

        function switchBranch(brokerBranchId) {
            var currentBranchRowCount = 0
            //var brokerBranchId = parseInt(rootModel.selectedBranch);
            userService.switchBranch(brokerBranchId, rootModel.brokerId).then(function (result) {
                if (result.status === true) {
                    location.href = webUrlConstService.homeIndex;
                    sessionStorageService.set('isChangedBrokerBranch', true);
                    // toastr.success("Broker branch has been switched successfully!");
                }
                else {
                    toastr.error(result.error.message);
                    angular.forEach(rootModel.brokerBranchList, function (val) {
                        if (val.LatestBranchSwitchedTo === true) {
                            //ootModel.selectedBranch = val.BrokerBranchId.toString();
                            rootModel.selectedBranch = val.BrokerBranchName;
                            currentBranchRowCount = key;
                        }
                    });
                    rootModel.brokerBranchList.splice(currentBranchRowCount, 1)
                }
            });
        }

        history.pushState(null, null, location.href);
        window.onpopstate = function () {
            history.go(1);
        };

    }

})();;
(function () {
    'use strict';

    var appUI = angular.module('appUI');

    appUI.controller('quotesCtrl', ['$rootScope', '$q', '$log', '$window', '$scope', 'uiGridConstants', 'quotesService', 'apiUrlConstService', 'keyConstService', 'sessionStorageService', '$http', 'messageConstService', 'webUrlConstService', 'portalV2Service', quotesCtrl]);

    function quotesCtrl($rootScope, $q, $log, $window, $scope, uiGridConstants, quotesService, apiUrlConstService, keyConstService, sessionStorageService, $http, messageConstService, webUrlConstService, portalV2Service) {
        var rootModel = this;
        rootModel.selectionBasis = null;
        var isShown = false;
        rootModel.scope = $rootScope;
        rootModel.message = false;
        rootModel.getLink = getLink;
        rootModel.selectedProduct = "All";
        rootModel.quoteSearch;
        $scope.quote = {};
        rootModel.IsReset = false;
        $scope.getParamEncrytion = getParamEncrytion;
        rootModel.BrokerPortalV2Debugging = false;

        angular.element(document).ready(function () {            
            angular.element(window).keydown(function () {                
                if (event.keyCode == 13) {
                    event.preventDefault();
                    return false;
                }
            });
        });
        rootModel.querySearch = function (query) {
            // var res = /^[a-zA-Z0-9'\s]+$/.test(query);
            var rgxPtrn = new RegExp("\d|[a-z]|\s|\&|\.|\-");
            var res = rgxPtrn.test(query)
            if (!res) {
                query = "";
                rootModel.searchName = "";
            }
            return quotesService.getClientDetail(query)
                .then(function (result) {
                    rootModel.data = result.data;
                    rootModel.clientSearchResult = [];
                    if (rootModel.data) {
                        var clientData = rootModel.data;
                        rootModel.clientSearchResult = clientData.map(function (val, i, clientData) {
                            return rootModel.data[i].fullName + "(" + rootModel.data[i].clientCode + ")";
                        });
                    }
                    return rootModel.clientSearchResult;
                });
        };

        rootModel.init = function (quotesearch) {
            initPaginationSettings();
            rootModel.ready = true;
            var brokerId = "1";
            rootModel.getProduct = quotesearch.Products;
            sessionStorageService.remove(keyConstService.Colour);
            sessionStorageService.remove(keyConstService.IsNewEditTransaction);
            sessionStorageService.remove(keyConstService.getTransactionIdWithoutSaving);
            sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
            sessionStorageService.remove(keyConstService.resetNonRegoData);
            sessionStorageService.remove(keyConstService.newBusinessCaseData);
            sessionStorageService.remove(keyConstService.endorsementRequestVM);
            sessionStorageService.remove(keyConstService.IsCopyQuote);
            sessionStorageService.remove(keyConstService.CopyQuoteOldTransactionId);
            sessionStorageService.remove(keyConstService.IsRenewalPolicy);
            rootModel.SMESearchQuoteURL = quotesearch.SMESearchQuoteURL;
            rootModel.CommercialMotorSearchQuoteURL = quotesearch.CommercialMotorSearchQuoteURL;
            rootModel.CommercialMotorEditQuoteURL = quotesearch.CommercialMotorEditQuoteURL;
            rootModel.BrokerPortalV2Debugging = quotesearch.BrokerPortalV2Debugging;

            sessionStorageService.remove(keyConstService.ActionButtonEnable);
            rootModel.selectionList = [
                { text: 'Client Name', value: 'clientName' },
                { text: 'Quote Number/Case Number', value: 'quoteNumber' },
                { text: 'Product', value: 'product' },
                { text: 'Package Number', value: 'packageId' }
            ];

            rootModel.quoteOptions = {
                totalItems: $scope.quote.totalItems,
                paginationPageSize: $scope.quote.paginationOptions.pageSize,
                enablePagination: true,
                paginationPageSizes: [$scope.quote.pageSize, $scope.quote.pageSize * 2, $scope.quote.pageSize * 3],
                enableHorizontalScrollbar: 2,
                enableRowHeaderSelection: false,
                enableColumnMenus: false,
                gridMenuShowHideColumns: false,
                enableHiding: false,
                useExternalPagination: true,
                rowHeight: 50,
                headerRowHeight: 40,
                data: null,
                columnDefs: [
                    { name: 'Quote/Case Number', field: 'quoteNumberCaseID', cellTemplate: getLink(), width: "250" },
                    { name: 'PackageNumber', field: 'packageNumber', width: "220" },
                    { name: 'ClientName', field: 'insuredName', width: "220" },
                    { name: 'Product', field: 'product', width: "200" },
                    { name: 'QuoteTerm', field:'renewalTerm',width: "180"},
                    { name: 'Date Created', field: 'creationDate', type: 'date', cellFilter: 'date:\'dd-MM-yyyy\'', width: "200" },
                    { name: 'Start Date', field: 'startDate', type: 'date', cellFilter: 'date:\'dd-MM-yyyy\'', width: "150" },
                    { name: 'Expiration Date', field: 'expirationDate', type: 'date', cellFilter: 'date:\'dd-MM-yyyy\'', width: "200" },
                    { name: 'Status', field: 'status', visible: false }
                ],
                onRegisterApi: function (gridApi) {
                    $scope.quote.gridApi = gridApi;
                    gridApi.pagination.on.paginationChanged($scope, function (newPage, pageSize) {
                        $scope.quote.paginationOptions.pageNumber = newPage;
                        $scope.quote.paginationOptions.pageSize = pageSize;
                        $scope.quote.pageSize = pageSize;
                        $scope.quote.currentPage = newPage;
                        $scope.quote.totalPage = Math.ceil($scope.quote.totalItems / $scope.quote.pageSize);
                        rootModel.searchItem(0);
                    });
                }
            };

            var isBackSearch = sessionStorageService.get('backSearch');
            if (isBackSearch === 1) {
                rootModel.quoteOptions.data = JSON.parse(sessionStorageService.get('searchState'));
                sessionStorageService.set('backSearch', 0);
            }
            else {
                sessionStorageService.remove("searchState");
                sessionStorageService.remove("backSearch");
            }
        };

        function initPaginationSettings() {
            $scope.quote.paginationOptions = {
                pageNumber: 1,
                pageSize: 10
            };
            $scope.quote.currentPage = 1;
            $scope.quote.pageSize = $scope.quote.paginationOptions.pageSize;
        }

        rootModel.ResetOnSelection = function () {
            rootModel.IsReset = true;
            rootModel.searchName = null;
            rootModel.searchQuote = null;
            rootModel.packageNumber = null;
            rootModel.selectedItem = null;
            rootModel.searchQuoteNumber = null;
            rootModel.selectedProduct = "All";
            rootModel.quoteOptions.paginationCurrentPage = 1;
            rootModel.quoteOptions.paginationPageSize = $scope.quote.paginationOptions.pageSize;
        };


        rootModel.pageRedirect = function () {
            $window.location.href = webUrlConstService.newBusinessIndex;
        };

        rootModel.gridShow = function () {

            if (rootModel.quoteOptions.data !== null) {
                if (rootModel.quoteOptions.data.length > 0) {
                    return true;
                }
                else {
                    return false;
                }
            }
        };

        function getLink(item) {
            return '<div class="ui-grid-cell-contents"><a ng-if=\'row.entity.processType === "CANCELLATION" && row.entity.product !== "SME - Commercial Package" && row.entity.product !== "Commercial Motor" && row.entity.product !== "Cyber" && row.entity.quoteNumber !== null\' ng-click="grid.appScope.getParamEncrytion(1,row.entity.quoteTransactionId)"> {{ row.entity.quoteNumberCaseID }}</a>' +
                '<a ng-if=\'row.entity.processType === "CANCELLATION" && row.entity.product === "SME - Commercial Package" && row.entity.quoteNumber !== null\' ng-click="grid.appScope.getParamEncrytion(3,row.entity.quoteTransactionId)"> {{row.entity.quoteNumberCaseID}}</a>' +
                '<a ng-if=\'row.entity.processType === "CANCELLATION" && row.entity.product === "Commercial Motor" && row.entity.quoteNumber !== null\' ng-click="grid.appScope.getParamEncrytion(4,row.entity.quoteTransactionId)"> {{row.entity.quoteNumberCaseID}}</a>' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.quoteNumber == null && row.entity.product !== "SME - Commercial Package" && row.entity.product !== "Commercial Motor" && row.entity.product !== "Cyber" && row.entity.status == "Declined"\' ng-click="grid.appScope.getParamEncrytion(2,row.entity.quoteTransactionId)"> {{row.entity.quoteNumberCaseID}}</a>' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.quoteNumber !== null  && row.entity.product !== "SME - Commercial Package" && row.entity.product !== "Commercial Motor" && row.entity.product !== "Cyber" && row.entity.status !== "Draft"\' ng-click="grid.appScope.getParamEncrytion(2,row.entity.quoteTransactionId)"> {{row.entity.quoteNumberCaseID}}</a>' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.product === "Home" && row.entity.status == "Draft"\' href  ng-click=\'grid.appScope.vm.validAndRedirect("UpdateHome",row.entity.product,row.entity.caseNumber)\'" > {{row.entity.quoteNumberCaseID }}</a>' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.product === "Motor" && row.entity.status == "Draft"\' href  ng-click=\'grid.appScope.vm.validAndRedirect("UpdateMotor",row.entity.product,row.entity.caseNumber)\'  > {{row.entity.quoteNumberCaseID }}</a>' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.product === "Landlord – Essentials" && row.entity.status == "Draft"\' href  ng-click=\'grid.appScope.vm.validAndRedirect("UpdateLandlordProtection",row.entity.product,row.entity.caseNumber)\' > {{row.entity.quoteNumberCaseID }}</a>' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.product === "Personal Accident" && row.entity.status == "Draft"\' href  ng-click=\'grid.appScope.vm.validAndRedirect("UpdatePersonalAccident",row.entity.product,row.entity.caseNumber)\' > {{row.entity.quoteNumberCaseID }}</a>' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.product === "Landlord – AD and LE" && row.entity.status == "Draft"\' href  ng-click=\'grid.appScope.vm.validAndRedirect("UpdateLandlordStandard",row.entity.product,row.entity.caseNumber)\' > {{row.entity.quoteNumberCaseID }}</a>' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.quoteNumber !== null  && row.entity.product === "SME - Commercial Package" && row.entity.status !== "Draft"\' ng-click="grid.appScope.getParamEncrytion(3,row.entity.quoteTransactionId)"> {{row.entity.quoteNumberCaseID}}</a>' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.quoteNumber == null && row.entity.product === "SME - Commercial Package" && row.entity.status == "Declined"\' ng-click="grid.appScope.getParamEncrytion(3,row.entity.quoteTransactionId)"> {{row.entity.quoteNumberCaseID}}</a>' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.product === "SME - Commercial Package" && row.entity.status == "Draft"\' href  ng-click=\'grid.appScope.vm.validAndRedirectSME(row.entity.quoteTransactionId)\' >{{row.entity.quoteNumberCaseID}}</a>' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.quoteNumber !== null  && row.entity.product === "Commercial Motor" && row.entity.product !== "SME - Commercial Package" && row.entity.status !== "Draft"\' ng-click="grid.appScope.getParamEncrytion(4,row.entity.quoteTransactionId)">{{row.entity.quoteNumberCaseID}}</a>' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.quoteNumber == null && row.entity.product === "Commercial Motor" && row.entity.status == "Declined"\' ng-click="grid.appScope.getParamEncrytion(4,row.entity.quoteTransactionId)">{{row.entity.quoteNumberCaseID}}</a>' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.product === "Commercial Motor" && row.entity.status == "Draft"\' href  ng-click=\'grid.appScope.vm.validAndRedirectCommercialMotor(row.entity.quoteTransactionId)\' >{{row.entity.quoteNumberCaseID}}</a>' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.quoteNumber !== null  && row.entity.product === "Cyber" && row.entity.product !== "SME - Commercial Package" && row.entity.status !== "Draft"\' ng-click="grid.appScope.getParamEncrytion(5,row.entity.quoteTransactionId)">{{row.entity.quoteNumberCaseID}}</a>' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.quoteNumber == null && row.entity.product === "Cyber" && row.entity.status == "Declined"\' ng-click="grid.appScope.getParamEncrytion(5,row.entity.quoteTransactionId)">{{row.entity.quoteNumberCaseID}}</a>' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.product === "Cyber" && row.entity.status == "Draft"\' href  ng-click=\'grid.appScope.vm.validAndRedirectCyber(row.entity.quoteTransactionId)\' >{{row.entity.quoteNumberCaseID}}</a>' +
                '</div>';
        }

        function getParamEncrytion(mode, paramString) {
            if (mode === 1) {
                var encryptedParam = sessionStorageService.getEncryption("qid=" + paramString);
                $window.location.href = "/Cancellation/Quote?" + encryptedParam;
            }
            else if (mode === 2) {
                encryptedParam = sessionStorageService.getEncryption("quoteTransactionId=" + paramString);
                $window.location.href = "/QuoteCase/Index?" + encryptedParam;
            }
            else if (mode === 3) {
                encryptedParam = sessionStorageService.getEncryption("quoteTransactionId=" + paramString);
                portalV2Service.getV2Token().then(function (resp) {
                    portalV2Service.setKeyToLocalStorage(resp.data.data);
                    $window.location.href = window.location.protocol + '//' + window.location.host + rootModel.SMESearchQuoteURL + '?' + encryptedParam;
                });
            }
            else if (mode === 4) {
                encryptedParam = sessionStorageService.getEncryption("quoteTransactionId=" + paramString + '&productId=' + keyConstService.CommercialMotorProductId);
                portalV2Service.getV2Token().then(function (resp) {
                    var redirectTo = rootModel.CommercialMotorSearchQuoteURL + '/' + encryptedParam;
                    portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, rootModel.BrokerPortalV2Debugging);
                });
            }
            else if (mode === 5) {
                encryptedParam = sessionStorageService.getEncryption("quoteTransactionId=" + paramString + '&productId=' + keyConstService.CyberProductId);
                portalV2Service.getV2Token().then(function (resp) {
                    var redirectTo = rootModel.CommercialMotorSearchQuoteURL + '/' + encryptedParam;
                    portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, rootModel.BrokerPortalV2Debugging);
                });
            }
        }

        rootModel.validAndRedirect = function (productUrl, product, caseNumber) {
            sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
            $window.location.href = "/Home/" + productUrl + "?" + sessionStorageService.getEncryption("productName=" + product + "&&quoteCaseNumber=" + caseNumber);
        };

        rootModel.validAndRedirectSME = function (quoteTransactionId) {
            sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
            portalV2Service.getV2Token().then(function (resp) {
                portalV2Service.setKeyToLocalStorage(resp.data.data);
                $window.location.href = window.location.protocol + '//' + window.location.host + rootModel.SMESearchQuoteURL + '?' + sessionStorageService.getEncryption("quoteTransactionId=" + quoteTransactionId);
            });
        };  

        rootModel.validAndRedirectCommercialMotor = function (quoteTransactionId) {
            sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
            portalV2Service.getV2Token().then(function (resp) {
                var redirectTo = rootModel.CommercialMotorEditQuoteURL + '/' + sessionStorageService.getEncryption("quoteTransactionId=" + quoteTransactionId + '&productId=' + keyConstService.CommercialMotorProductId);
                portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, rootModel.BrokerPortalV2Debugging);
            });            
        }

        rootModel.validAndRedirectCyber = function (quoteTransactionId) {
            sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
            portalV2Service.getV2Token().then(function (resp) {
                var redirectTo = keyConstService.CyberUrlPrefix + keyConstService.CyberEditQuote + sessionStorageService.getEncryption("quoteTransactionId=" + quoteTransactionId + '&productId=' + keyConstService.CyberProductId);
                portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, rootModel.BrokerPortalV2Debugging);
            });
        }
       
        rootModel.getTableStyle = function () {
            var marginHeight = 40; // optional
            var length;
            if (rootModel.quoteOptions.data.length > 10) {
                length = 10;
            }
            else {
                length = rootModel.quoteOptions.data.length;
            }
            // this is unique to my cellTemplate
            return {
                height: (length * rootModel.quoteOptions.rowHeight + rootModel.quoteOptions.headerRowHeight + marginHeight) + "px"
            };
        };

        rootModel.searchItem = function (object) {
            if (rootModel.selectedProduct === null) {
                rootModel.selectedProduct = "All";
            }

            if (object === 1)
                initPaginationSettings();

            var insuredName = null;
            var searchQuote = null;
            var productName = null;
            var packageNumber = null;
            if (rootModel.searchName) {
                insuredName = rootModel.searchName;
            }
            if (rootModel.searchQuoteNumber) {
                searchQuote = rootModel.searchQuoteNumber;
            }
            if (rootModel.searchQuote) {
                searchQuote = rootModel.searchQuote;
            }
            if (rootModel.selectedProduct) {
                if (rootModel.selectedProduct === "All") {
                    productName = rootModel.selectedProduct;
                }
                else {
                    productName = rootModel.selectedProduct.Description;
                }
            }
            if (rootModel.packageNumber) {
                packageNumber = rootModel.packageNumber;
            }
            //rootModel.quoteOptions.paginationCurrentPage = 1;
            var quoteSearchData = {
                "InsuredName": insuredName,
                "SearchQuote": searchQuote,
                "ProductName": productName,
                "PackageNumber": packageNumber,
                "PageNumber": $scope.quote.paginationOptions.pageNumber,
                "PageSize": $scope.quote.paginationOptions.pageSize
            };

            quotesService.getSearchQuotes(quoteSearchData).then(function (searchdata) {
                if (searchdata.status) {
                    $scope.quote.totalItems = searchdata.data.quotesCount;
                    $scope.quote.totalPage = Math.ceil($scope.quote.totalItems / $scope.quote.pageSize);
                    rootModel.quoteOptions.data = searchdata.data.quoteViewModelVM;
                    rootModel.quoteOptions.totalItems = searchdata.data.quotesCount;
                    $scope.quote.currentPage = $scope.quote.paginationOptions.pageNumber;
                    rootModel.quoteOptions.paginationCurrentPage = $scope.quote.currentPage;
                    if (rootModel.quoteOptions.data === null || rootModel.quoteOptions.data.length === 0) {
                        rootModel.message = true;
                    }
                    else {
                        rootModel.message = false;
                        rootModel.IsReset = false;

                    }
                    sessionStorageService.set('searchState', rootModel.quoteOptions.data.quoteViewModelVM);
                }

            }, function (error) {
                toastr.error(messageConstService.errServiceUnavailable);
            });
        };

        rootModel.Reset = function () {
            rootModel.quoteOptions.data = null;
            rootModel.selectionBasis = null;
            rootModel.message = false;
            rootModel.searchName = null;
            rootModel.searchQuote = null;
            rootModel.selectedProduct = "All";
            rootModel.packageNumber = null;
            rootModel.quoteOptions.paginationCurrentPage = 1;
            rootModel.quoteOptions.paginationPageSize = $scope.quote.paginationOptions.pageSize;
        };

        rootModel.ResetPageOnInputChange = function () {
            rootModel.IsReset = true;
            $scope.quote.paginationOptions.pageSize = 10;
            $scope.quote.paginationOptions.pageNumber = 1;
        };

        rootModel.setProduct = function () {
            if (rootModel.selectedProduct === null) {
                rootModel.selectedProduct = "All";
            }
        };
    }
})();
;
(function () {
    'use strict';

    var appUI = angular.module('appUI');

    appUI.controller('bindCtrl', ['$rootScope', '$q', '$log', 'bindService', 'sessionStorageService', 'keyConstService', 'utilityService', '$window', 'webUrlConstService', 'messageConstService', 'FileSaver', 'Blob', '$http', '$scope', bindCtrl]);

    function bindCtrl($rootScope, $q, $log, bindService, sessionStorageService, keyConstService, utilityService, $window, webUrlConstService, messageConstService, FileSaver, Blob, $http, $scope) {
        var vm = this;
        vm.policyData = {};
        vm.quoteCasenumber;
        vm.showNBQuoteDocGrid = false;
        vm.CoverType = "";
        vm.docDetail = [];
        vm.docDetails = [];
        vm.CoverType;
        vm.activatePayment;
        vm.productType;
        vm.numberOfInstallment;
        vm.showBrokerFee = true;
        vm.attchedQuote = false;
        vm.getTableStyle = getTableStyle;
        vm.validateButtons = validateButtons;
        vm.disablebuttonsForlandlord = false;
        vm.showCancellationReason = false;
        vm.periodOfInsurance = null;
        $scope.getParamEncrytion = getParamEncrytion;
        vm.automaticPayment = null;
        vm.isAnnual = false;
        vm.brokerbranchcheck;
        vm.PolicyStatus = "";
        vm.continueOrNavigateBackToPackageManager = continueOrNavigateBackToPackageManager;
        vm.GetCopyQuoteLink = GetCopyQuoteLink;
        vm.processTypeId;
        vm.quoteTransacionId;
        vm.disbaleCopyQuote = false;

        var prevUrl = '';
        if (sessionStorage.getItem(keyConstService.Home) !== null) {
            prevUrl = sessionStorage.getItem(keyConstService.Home);
        }
        if (prevUrl === '' && sessionStorage.getItem(keyConstService.Motor) !== null) {
            prevUrl = sessionStorage.getItem(keyConstService.Motor);
        }
        if (window.history && history.pushState) {
            if (prevUrl !== '') {
                history.pushState(null, null, null);
                addEventListener('load', function () {
                    history.pushState(null, null, null); // creates new history entry with same URL
                    addEventListener('popstate', function () {
                        openModalWindow(this);
                    });
                });
            }
        }

        function openModalWindow(ev) {
            var modalTitle = 'Confirmation';
            var modalMessage = 'Back button will take you to Home Page of the BZ portal and quote details may be lost. Please use the edit or view action to go back into the quote. Do you want to proceed?';
            $mdDialog.show({
                controller: DialogController,
                templateUrl: 'app/pages/shared/modal-form.html',
                parent: angular.element(document.body),
                targetEvent: ev,
                locals: { modalTitle: modalTitle, modalMessage: modalMessage },
                clickOutsideToClose: true,
                escapeToClose: false,
            })
                .then(function (answer) {
                    if (answer === 'Yes') {
                        sessionStorage.removeItem(keyConstService.Home);
                        sessionStorage.removeItem(keyConstService.Motor);
                        window.location = '/home';
                    } else {
                        history.pushState(null, null, null);
                    }
                }, function () {
                    history.pushState(null, null, null);
                });
        }

        function DialogController($scope, $mdDialog, modalTitle, modalMessage) {
            $scope.modalTitle = modalTitle;
            $scope.modalMessage = modalMessage;
            $scope.hide = function () {
                $mdDialog.hide();
            };

            $scope.cancel = function () {
                $mdDialog.cancel();
            };

            $scope.answer = function (answer) {
                $mdDialog.hide(answer);
            };
        }

        vm.init = function (model) {
            var renewalCounter = sessionStorageService.get('RenewalCounter');
            if (renewalCounter !== null) {
                vm.showManagePkg = true;
            }
            vm.CoverType = model.CoverType;
            vm.productType = model.ProductType;
            vm.CoverageType = model.CoverageType;
            vm.CoverageName = model.CoverageName;
            vm.quoteCasenumber = model.QuoteCaseData.CaseNumber;
            vm.brokerbranchcheck = sessionStorageService.get('IsBranchViewOnly') !== "false";
            vm.automaticPayment = model.BrokerManagedPayment;
            vm.isAnnual = model.IsBranchAnnualPayment;
            vm.PolicyStatus = model.PolicyStatus;
            vm.quoteTransacionId = model.PolicyDetailData.QuoteTransactionId;
            vm.processTypeId = model.QuoteCaseData.DDLProcessTypeId;
            vm.hasAgencyFeeDistributed = model.HasAgencyFeeDistributed;
            var sessionModel = JSON.parse(sessionStorageService.get(keyConstService.bindData));
            sessionStorageService.remove(keyConstService.IsCopyQuote);
            if (!model) {
                if (sessionModel != null) {
                    vm.policyData = sessionModel;
                }
                else {
                    $window.location.href = webUrlConstService.homeIndex;
                }
            }
            else {
                vm.policyData = utilityService.toCamel(model);
            }

            //// disable copy quote for specified product
            if (vm.productType === keyConstService.PaProductDescription) {
                vm.disbaleCopyQuote = true;
            }

            vm.ifPaymentInfoExist = model.PaymentInfoExist;
            vm.activatePayment = model.ActivatePaymentModule;
            //if (vm.policyData.processType === 'ENDORSEMENT') {
            //    if (vm.policyData.effectiveDate === vm.policyData)
            //}
            //if (vm.policyData.processType == 'NEWBUSINESS' || vm.policyData.processType == 'ENDORSEMENT' ) {
            //    vm.showBrokerFee = true;
            //}
            //else {
            //    vm.showBrokerFee = false;
            //}

            if (vm.policyData.processType === 'CANCELLATION') {
                vm.showCancellationReason = true;
            }

            if (vm.policyData.listTransactionHistory[0] !== null) {
                vm.periodOfInsurance = vm.policyData.listTransactionHistory[0].policyEffectiveDate;
                var expiryDate = moment(vm.policyData.expirationDate);
                var startDate = moment(vm.periodOfInsurance);
                var duration = moment.duration(expiryDate.diff(startDate));
                vm.policyTenure = duration.asDays();
                vm.annualizedTermRatio = keyConstService.annualizedConst / vm.policyTenure;
            }

            function paymentforPolicy() {
                var totalPayment = 0;
                for (var i = 0; i < vm.policyData.listTransactionHistory.length; i++) {
                    totalPayment = totalPayment + vm.policyData.listTransactionHistory[i].premium;
                }
                vm.totalPayment = totalPayment;
            }

            paymentforPolicy();

            //// monthly breakup
            function totalInstallments(d1, d2) {
                var diff = Date.parse(d2) - Date.parse(d1);
                var monthDiff = Math.floor(diff / (1000 * 60 * 60 * 24 * 30));
                if (monthDiff > 4) {
                    vm.numberOfInstallment = monthDiff - 2;
                    vm.showMonthlyBreakDown = true;
                }
                else {
                    vm.showMonthlyBreakDown = false;
                }
            }
            var effectiveDate = vm.policyData.effectiveDate;
            var expirationDate = vm.policyData.expirationDate;
            totalInstallments(effectiveDate, expirationDate);

            sessionStorageService.remove(keyConstService.caseId);
            sessionStorageService.remove(keyConstService.caseNumber);
            sessionStorageService.remove(keyConstService.newBusinessCaseData);
            sessionStorageService.remove(keyConstService.quoteState);
            sessionStorageService.remove(keyConstService.quoteTransactionId);
            sessionStorageService.remove(keyConstService.quoteDetail);
            sessionStorageService.remove(keyConstService.transactionNumber);
            sessionStorageService.remove(keyConstService.endorsementRequestVM);
            sessionStorageService.remove(keyConstService.IsEndorsementEdit);
            sessionStorageService.remove(keyConstService.IsNewBusinessReadOnly);
            sessionStorageService.remove(keyConstService.IsNewEditTransaction);

            $scope.quoteOptions = {
                data: 'quoteData',
                paginationPageSize: 1,
                paginationPageSizes: [1],
                enablePagination: true,
                enableHorizontalScrollbar: 2,
                enableRowHeaderSelection: false,
                enableColumnMenus: true,
                gridMenuShowHideColumns: true,
                enableHiding: false,
                ////hasActions: true,
                columnDefs: [
                    { name: 'Quote/Case Number', field: 'QuoteNumberCaseID', cellTemplate: getQuoteLink(), width: "230" },
                    { name: 'PackageNumber', width: "200" },
                    { name: 'InsuredName', width: "250" },
                    { name: 'Product', cellClass: 'text-left', width: "153" },
                    { name: 'CreationDate', field: 'CreationDate', type: 'date', cellFilter: 'date:\'dd-MM-yyyy\'', width: "200" },
                    { name: 'Status', width: "150" }
                ],
                actionList: [
                    { label: "View", icon: "glyphicon-eye-open", href: 'policies/view/{{row.policyNumber}}' }
                ]
            };
            $scope.quoteData = model.DashboardQuoteVM;

            if (model.DashboardQuoteVM !== null) {
                vm.attchedQuote = true;
            }
            ////To check the expiration of the policy
            vm.verifyExpiry = verifyExpiration(vm.policyData);
        };

        vm.requestCancellation = function () {
            sessionStorageService.set(keyConstService.ActionButtonEnable, true);
            $window.location.href = webUrlConstService.cancellationInitaiation + sessionStorageService.getEncryption("pid=" + vm.policyData.policyTransactionId);
        };

        vm.requestEndorsement = function () {
            sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
            sessionStorageService.set(keyConstService.ActionButtonEnable, true);
            $window.location.href = webUrlConstService.endorsementRequest + sessionStorageService.getEncryption("quoteTransactionId=" + vm.policyData.policyQuoteTransactionId);
        };

        vm.viewPolicy = function () {
            if (vm.productType === keyConstService.Home) {
                sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                location.href = webUrlConstService.viewPolicyHome + sessionStorageService.getEncryption("productName=Home&&quoteCaseNumber=" + vm.quoteCasenumber);
            }
            if (vm.productType === keyConstService.Motor) {
                sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                location.href = webUrlConstService.viewPolicyMotor + sessionStorageService.getEncryption("productName=Motor&&quoteCaseNumber=" + vm.quoteCasenumber);
            }
            if (vm.productType === keyConstService.LandlordADLE) {
                sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                location.href = webUrlConstService.viewLandlordStandard + sessionStorageService.getEncryption("productName=Landlord – AD and LE&&quoteCaseNumber=" + vm.quoteCasenumber);
            }

            if (vm.productType === keyConstService.LandlordEssentials) {
                sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                location.href = webUrlConstService.viewLandlordProtection + sessionStorageService.getEncryption("productName=Landlord – Essentials&&quoteCaseNumber=" + vm.quoteCasenumber);
            }

            if (vm.productType === keyConstService.PaProductDescription) {
                sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                location.href = webUrlConstService.PersonalAccidentView + sessionStorageService.getEncryption("productName=Personal Accident&&quoteCaseNumber=" + vm.quoteCasenumber);
            }
        };

        function getTableStyle() {
            var marginHeight = 15;
            var length = 1.8;
            return {
                height: (length * $scope.quoteOptions.rowHeight + $scope.quoteOptions.headerRowHeight + marginHeight) + "px"
            };
        }

        vm.bindPolicyDocumentGrid = function () {
            bindService.bindPolicyDocumentGrid({
                CoverType: vm.CoverType,
                CoverageType: vm.CoverageType,
                PolicyTransactionId: vm.policyData.policyTransactionId
            })
                .then(function (result) {
                    if (vm.showNBQuoteDocGrid === true)
                        vm.showNBQuoteDocGrid = false;
                    else
                        vm.showNBQuoteDocGrid = true;
                    vm.docDetail = result.data;
                    return result;
                });
        };


        function getQuoteLink(item) {
            return '<div class="ui-grid-cell-contents"><a ng-if=\'row.entity.ProcessType === "CANCELLATION" && row.entity.QuoteNumber !== null\' ng-click="grid.appScope.getParamEncrytion(1,row.entity.QuoteTransactionId)"> {{row.entity.QuoteNumberCaseID}}</a >' +
                '<a ng-if=\'row.entity.ProcessType !== "CANCELLATION" && row.entity.QuoteNumber == null && row.entity.Status == "Declined"\' ng-click="grid.appScope.getParamEncrytion(2,row.entity.QuoteTransactionId)"> {{row.entity.QuoteNumberCaseID}}</a >' +
                '<a ng-if=\'row.entity.ProcessType !== "CANCELLATION" && row.entity.QuoteNumber !== null && row.entity.Status !== "Draft"\' ng-click="grid.appScope.getParamEncrytion(2,row.entity.QuoteTransactionId)"> {{row.entity.QuoteNumberCaseID}}</a >' +
                '<a ng-if=\'row.entity.ProcessType !== "CANCELLATION" && row.entity.Product === "Home" && row.entity.Status == "Draft"\' href  ng-click=\'grid.appScope.vm.validAndRedirect("UpdateHome",row.entity.Product,row.entity.CaseNumber)\'" > {{row.entity.QuoteNumberCaseID }}</a >' +
                '<a ng-if=\'row.entity.ProcessType !== "CANCELLATION" && row.entity.Product === "Motor" && row.entity.Status == "Draft"\' href  ng-click=\'grid.appScope.vm.validAndRedirect("UpdateMotor",row.entity.Product,row.entity.CaseNumber)\'  > {{row.entity.QuoteNumberCaseID }}</a >' +
                '<a ng-if=\'row.entity.ProcessType !== "CANCELLATION" && row.entity.Product === "Landlord – Essentials" && row.entity.Status == "Draft"\' href ng-click=\'grid.appScope.vm.validAndRedirect("UpdateLandlordProtection",row.entity.Product,row.entity.CaseNumber)\'  > {{row.entity.QuoteNumberCaseID }}</a >' +
                '<a ng-if=\'row.entity.ProcessType !== "CANCELLATION" && row.entity.Product === "Landlord – AD and LE" && row.entity.Status == "Draft"\' href ng-click=\'grid.appScope.vm.validAndRedirect("UpdateLandlordStandard",row.entity.Product,row.entity.CaseNumber)\'  > {{row.entity.QuoteNumberCaseID }}</a >' +
                '<a ng-if=\'row.entity.ProcessType !== "CANCELLATION" && row.entity.Product === "Personal Accident" && row.entity.Status === "Draft"\' href ng-click=\'grid.appScope.vm.validAndRedirect("UpdatePersonalAccident", row.entity.Product, row.entity.CaseNumber)\'  > {{row.entity.QuoteNumberCaseID }}</a ></div > ';
        }

        function GetCopyQuoteLink(policyTransactionId) {
            sessionStorageService.set(keyConstService.CopyQuoteOldTransactionId, vm.quoteTransacionId);
            if (vm.processTypeId === 3) {
                bindService.getBoundTransaction(policyTransactionId, true).then(function (result) {
                    vm.quoteTransacionId = result.data;
                    sessionStorageService.set(keyConstService.CopyQuoteOldTransactionId, vm.quoteTransacionId);
                    sessionStorageService.set(keyConstService.IsCopyQuote, true);
                    location.href = webUrlConstService.newBusinessIndex + sessionStorageService.getEncryption("transactionId=" + vm.quoteTransacionId + "&&" + "hasCopyQuote=" + true);
                });
            }
            else 
                location.href = webUrlConstService.newBusinessIndex + sessionStorageService.getEncryption("transactionId=" + vm.quoteTransacionId + "&&" + "hasCopyQuote=" + true);
        }

        function getParamEncrytion(mode, paramString) {
            if (mode === 1) {
                var encryptedParam = sessionStorageService.getEncryption("qid=" + paramString);
                $window.location.href = "/Cancellation/Quote?" + encryptedParam;
            }
            else if (mode === 2) {
                encryptedParam = sessionStorageService.getEncryption("quoteTransactionId=" + paramString);
                $window.location.href = "/QuoteCase/Index?" + encryptedParam;
            }
        }

        vm.validAndRedirect = function (productUrl, product, caseNumber) {
            sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
            $window.location.href = "/Home/" + productUrl + "?" + sessionStorageService.getEncryption("productName=" + product + "&&quoteCaseNumber=" + caseNumber);
        };


        vm.GetPolicyDownloadSelected = function (policyTransactionId) {
            var flag = 0;
            vm.docDetail.forEach(function (trans) {
                if (trans.isChecked === true) {
                    flag++;
                    return $http
                        ({
                            url: webUrlConstService.documentDownloadUrl + policyTransactionId + "&policyDocumentId=" + trans.id,
                            method: "GET",
                            responseType: 'blob'
                        })
                        .then(function (result) {

                            var blob = new Blob([result.data], { type: [result.data.type] });
                            var ext = result.data.type === 'application/pdf' ? keyConstService.pdf : keyConstService.rtf;
                            trans.isDynamic === true ? FileSaver.saveAs(blob, utilityService.RemoveFilePostFix(trans.templateName) + '_' + vm.policyData.policyNumber + ext) : FileSaver.saveAs(blob, trans.templateName + '_' + vm.policyData.policyNumber + ext);
                            return result.data.data;

                        },
                        function (data) {
                            toastr.error("System is currently not working. Please try after sometime.");
                            return;
                        });
                }
            });
            if (flag === 0) {
                toastr.error("Please select atleast one document");
                return;
            }
        };

        vm.GetPolicyEmailSelected = function (policyTransactionId) {
            var idChecked = [];
            var flag = 0;
            vm.docDetail.forEach(function (trans) {
                if (trans.isChecked === true) {
                    idChecked.push(trans.id);
                    flag++;
                }
            });
            if (flag === 0) {
                toastr.error("Please select atleast one document");
                return;
            } else {
                return $http
                    ({
                        url: webUrlConstService.documentSelectedDownloadUrl + policyTransactionId + "&documentDetail=" + JSON.stringify(idChecked),
                        method: "GET"
                    })
                    .then(function (result) {
                        var email = sessionStorageService.get('userEmail');
                        if (result && result.data && result.data.data) {
                            toastr.success("E-mail sent successfully to " + result.data.data);
                        }
                        else {
                            toastr.success("E-mail sent successfully to " + email.split('"')[1]);
                        }
                        return result.data.data;

                    },
                    function (data) {
                        toastr.error("System is currently not working. Please try after sometime.");
                        return;
                    });
            }
        };
        //

        vm.downloadDocument = function (policyTransactionId, id, isDynamic, templateName) {
            return $http
                ({
                    url: webUrlConstService.documentDownloadUrl + policyTransactionId + "&policyDocumentId=" + id,
                    method: "GET",
                    responseType: 'blob'
                })
                .then(function (result) {
                    var blob = new Blob([result.data], { type: [result.data.type] });
                    var ext = result.data.type === 'application/pdf' ? keyConstService.pdf : keyConstService.rtf;
                    isDynamic === true ? FileSaver.saveAs(blob, utilityService.RemoveFilePostFix(templateName) + '_' + vm.policyData.policyNumber + ext) : FileSaver.saveAs(blob, templateName + '_' + vm.policyData.policyNumber + ext);
                    return result.data.data;
                },
                    function (data) {
                        toastr.error(messageConstService.errService3rdAPIUnavailable);
                        return;
                    });
        };

        vm.downloadScheduleDocument = function (CoverType, CoverageType, policyTransactionId, transactiontype) {
            bindService.downloadScheduleDocument({
                CoverType: vm.CoverType,
                CoverageType: vm.CoverageType,
                PolicyTransactionId: policyTransactionId,
                TransactionType: transactiontype
            })
                .then(function (result) {
                    vm.docDetails = result.data;
                    if (vm.docDetails.length !== 0) {
                        vm.downloadDocument(policyTransactionId, vm.docDetails[0].id, vm.docDetails[0].isDynamic, vm.docDetails[0].templateName)
                    }
                    else {
                        toastr.info(messageConstService.errScheduleDocumentsUnavailable);
                        return;
                    }
                    return result;
                });
        };


        vm.moveToPayment = function () {
            window.location.href = webUrlConstService.paymentInfoUrl + "id=" + vm.policyData.policyTransactionId;
        };

        function validateButtons() {
            vm.disablebuttonsForlandlord = false;
            if (vm.productType === "LandlordStandard" || vm.productType === "LandlordProtection") {
                vm.disablebuttonsForlandlord = true;
            }
        }

        function continueOrNavigateBackToPackageManager() {
            var packageNumber = sessionStorageService.get('PackageNumberInformation');
            var renewalCounter = sessionStorageService.get('RenewalCounter');
            sessionStorageService.remove('IsPackageManagerNavigationMode');
            sessionStorageService.remove('PackageNumberInformation');
            sessionStorageService.remove('RenewalCounter');
            $window.location.href = webUrlConstService.getPackageInfo + sessionStorageService.getEncryption("packageNumber=" + JSON.parse(packageNumber) + "&&renewalCounter=" + renewalCounter);
        }

        ////To check the expiration of the policy
        function verifyExpiration(data) {
            var policyExpiryTime = data.policyExpirationTime;
            var currentDate = moment(new Date()).format('YYYY-MM-DD');
            var currentTime = moment(new Date()).format('HH:mm:ss');
            var expirationDate = moment(data.expirationDate).format('YYYY-MM-DD');
            if ((expirationDate < currentDate) || (expirationDate == currentDate && currentTime >= policyExpiryTime)) {
                return true;
            }
            else {
                return false;
            }
        }
    }
})();;
(function () {
    'use strict';

    var appUI = angular.module('appUI');

    appUI.controller('policiesCtrl', ['$rootScope', '$q', '$window', '$scope', 'uiGridConstants', 'policyService', 'apiUrlConstService', 'sessionStorageService', 'keyConstService', '$http', 'webUrlConstService', 'portalV2Service', policiesCtrl]);

    function policiesCtrl($rootScope, $q, $window, $scope, uiGridConstants, policyService, apiUrlConstService, sessionStorageService, keyConstService, $http, webUrlConstService, portalV2Service) {
        var rootModel = this;
        rootModel.selectedProduct = null;
        rootModel.selectionBasis = null;
        var isShown = false;
        rootModel.scope = $rootScope;
        rootModel.message = false;
        rootModel.getLink = getLink;
        $scope.policy = {};
        rootModel.IsReset = false;
        $scope.getParamEncrytion = getParamEncrytion;
        rootModel.BrokerPortalV2Debugging = false;

        angular.element(document).ready(function () {
            angular.element(window).keydown(function () {
                if (event.keyCode == 13) {
                    event.preventDefault();
                    return false;
                }
            });
        });

        rootModel.querySearch = function (query) {
            //var res = /^[a-zA-Z0-9'\s]+$/.test(query);
            var rgxPtrn = new RegExp("\d|[a-z]|\s|\&|\.|\-");
            var res = rgxPtrn.test(query)
            if (!res) {
                query = "";
                rootModel.searchName = "";
            }
            return policyService.getClientDetail(query)
                .then(function (result) {
                    rootModel.data = result.data;
                    rootModel.clientSearchResult = [];
                    for (var i = 0; i < rootModel.data.length; i++) {
                        var client = rootModel.data[i].fullName + "(" + rootModel.data[i].clientCode + ")";
                        rootModel.clientSearchResult.push(client);
                    }
                    return rootModel.clientSearchResult;
                });
        };

        rootModel.partialPolicySearch = function (query) {
            var res = /^[a-zA-Z0-9'\s]+$/.test(query);
            if (!res) {
                query = null;
                rootModel.searchPolicy = "";
            }
            return policyService.getPolicyDetail(query)
                .then(function (result) {
                    rootModel.policy = result.data;
                    return rootModel.policy;
                },
                    function (data) {
                        toastr.error("System is currently not working. Please try after sometime.");
                        return;
                    });
        };

        rootModel.partialPackageSearch = function (query) {
            var res = /^[a-zA-Z0-9'\s]+$/.test(query);
            if (!res) {
                query = null;
                rootModel.packageNumber = "";
            }
            return policyService.getPackageDetail(query)
                .then(function (result) {
                    rootModel.package = result.data;
                    return rootModel.package;
                },
                    function (data) {
                        toastr.error("System is currently not working. Please try after sometime.");
                        return;
                    });
        };

        rootModel.init = function (policysearch) {
            sessionStorageService.remove('IsPackageManagerNavigationMode');
            sessionStorageService.remove('PackageNumberInformation');
            sessionStorageService.remove('RenewalCounter');
            sessionStorageService.remove(keyConstService.Colour);
            sessionStorageService.remove(keyConstService.ActionButtonEnable);
            sessionStorageService.remove(keyConstService.IsCopyQuote);
            sessionStorageService.remove(keyConstService.CopyQuoteOldTransactionId);
            sessionStorageService.remove(keyConstService.IsRenewalPolicy);
            initPaginationSettings();
            rootModel.ready = true;
            var brokerId = "1";

            rootModel.getProduct = policysearch.Products;
            rootModel.SMESearchPolicyURL = policysearch.SMESearchPolicyURL;
            rootModel.CommercialMotorSearchPolicyURL = policysearch.CommercialMotorSearchPolicyURL;
            rootModel.selectionList = [
                { text: 'Client Name', value: 'clientName' },
                { text: 'Policy Number', value: 'policyNumber' },
                { text: 'Product', value: 'product' },
                { text: 'Package Number', value: 'packageId' }
            ];

            rootModel.policyOptions = {
                totalItems: $scope.policy.totalItems,
                paginationPageSize: $scope.policy.paginationOptions.pageSize,
                enablePagination: true,
                paginationPageSizes: [$scope.policy.pageSize, $scope.policy.pageSize * 2, $scope.policy.pageSize * 3],
                enableHorizontalScrollbar: 2,
                enableRowHeaderSelection: false,
                enableColumnMenus: false,
                gridMenuShowHideColumns: false,
                enableHiding: false,
                useExternalPagination: true,
                rowHeight: 50,
                headerRowHeight: 40,
                enableSorting: true,
                enableFiltering: false,
                data: null,
                columnDefs: [
                    { name: 'PolicyNumber', field: 'policyNumber', width: 225, cellTemplate: getLink() },
                    { name: 'PackageNumber', field: 'packageNumber', width: "200" },
                    { name: 'ClientName', field: 'insuredName', width: "200" },
                    { name: 'Product', field: 'product', width: "200" },
                    { name: 'Policy Term', field: 'renewalTerm' , width: "180"},
                    { name: 'Date Created', field: 'creationDate', type: 'date', cellFilter: 'date:\'dd-MM-yyyy\'', width: "200" },
                    { name: 'Start Date', field: 'startDate', type: 'date', cellFilter: 'date:\'dd-MM-yyyy\'', width: "200" },
                    { name: 'Expiration Date', field: 'expirationDate', type: 'date', cellFilter: 'date:\'dd-MM-yyyy\'', width: "200" }

                ],
                onRegisterApi: function (gridApi) {
                    $scope.policy.gridApi = gridApi;
                    gridApi.pagination.on.paginationChanged($scope, function (newPage, pageSize) {
                        $scope.policy.paginationOptions.pageNumber = newPage;
                        $scope.policy.paginationOptions.pageSize = pageSize;
                        $scope.policy.pageSize = pageSize;
                        $scope.policy.currentPage = newPage;
                        $scope.policy.totalPage = Math.ceil($scope.policy.totalItems / $scope.policy.pageSize);
                        rootModel.searchItem();
                    });
                }
            };
            var isBackSearch = sessionStorageService.get('backSearch');
            if (isBackSearch === 1) {
                rootModel.policyOptions.data = JSON.parse(sessionStorageService.get('searchState'));
                sessionStorageService.set(keyConstService.backSearch, 0);
            }
            else {
                sessionStorageService.remove(keyConstService.searchState);
                sessionStorageService.remove(keyConstService.backSearch);
            }
            rootModel.BrokerPortalV2Debugging = policysearch.BrokerPortalV2Debugging;
            //$log(policysearch);
        };

        function initPaginationSettings() {
            $scope.policy.paginationOptions = {
                pageNumber: 1,
                pageSize: 10
            };
            $scope.policy.currentPage = 1;
            $scope.policy.pageSize = $scope.policy.paginationOptions.pageSize;
        }

        rootModel.ResetOnSelection = function () {
            rootModel.searchName = null;
            rootModel.searchPolicy = null;
            rootModel.selectedProduct = null;
            rootModel.selectedPackage = null;
            rootModel.packageNumber = null;
            rootModel.selectedItem = null;
            if (rootModel.selectionBasis === 'product') {
                rootModel.searchName = null;
                rootModel.selectedItem = null;
                rootModel.searchPolicy = null;
                rootModel.selectedPackage = null;
                rootModel.packageNumber = null;
                rootModel.selectedProduct = "All";
            }
            rootModel.policyOptions.paginationCurrentPage = 1;
            rootModel.policyOptions.paginationPageSize = $scope.policy.paginationOptions.pageSize;
        };

        rootModel.ResetPageOnInputChange = function () {
            rootModel.IsReset = true;
            $scope.policy.paginationOptions.pageSize = 10;
            $scope.policy.paginationOptions.pageNumber = 1;
            $scope.policy.currentPage = 1;
        };


        rootModel.pageRedirect = function () {
            $window.location.href = webUrlConstService.newBusinessIndex;
        };

        rootModel.gridShow = function () {

            if (rootModel.policyOptions.data !== null) {
                if (rootModel.policyOptions.data.length > 0) {
                    return true;
                }
                else {
                    return false;
                }
            }
        };

        function getLink(item) {
            return '<div class="ui-grid-cell-contents"><a ng-if=\'row.entity.policyNumber !== null && row.entity.product !== "SME - Commercial Package" && row.entity.product !== "Commercial Motor"\' ng-click="grid.appScope.getParamEncrytion(1,row.entity.policyTransactionId)"> {{row.entity.policyNumber}}</a>' +
                '<a ng-if=\'row.entity.policyNumber !== null && row.entity.product === "SME - Commercial Package"\' ng-click="grid.appScope.getParamEncrytion(2,row.entity.quoteTransactionId)"> {{row.entity.policyNumber}}</a>' +
                '<a ng-if=\'row.entity.policyNumber !== null && row.entity.product === "Commercial Motor"\' ng-click="grid.appScope.getParamEncrytion(3,row.entity.quoteTransactionId)"> {{row.entity.policyNumber}}</a>' +
                //'<a ng-if=\'row.entity.policyNumber !== null && row.entity.product === "Cyber"\' ng-click="grid.appScope.getParamEncrytion(5,row.entity.quoteTransactionId)"> {{row.entity.policyNumber}}</a>' +
                '</div >';
        }

        function getParamEncrytion(mode, paramString) {
            if (mode === 1) {
                var encryptedParam = sessionStorageService.getEncryption("id=" + paramString);
                $window.location.href = "/Bind/Index?" + encryptedParam;
            }
            else if (mode === 2) {
                var encryptedParam = sessionStorageService.getEncryption("quoteTransactionId=" + paramString);
                portalV2Service.getV2Token().then(function (resp) {
                    portalV2Service.setKeyToLocalStorage(resp.data.data);
                    $window.location.href = window.location.protocol + '//' + window.location.host + rootModel.SMESearchPolicyURL + '?' + encryptedParam;
                });
            }
            else if (mode === 3) {
                var encryptedParam = sessionStorageService.getEncryption("quoteTransactionId=" + paramString + '&productId=' + keyConstService.CommercialMotorProductId);
                portalV2Service.getV2Token().then(function (resp) {
                    var redirectTo = rootModel.CommercialMotorSearchPolicyURL + '/' + encryptedParam;
                    portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, rootModel.BrokerPortalV2Debugging);
                });
            }
            else if (mode === 5) {
                var encryptedParam = sessionStorageService.getEncryption("quoteTransactionId=" + paramString + '&productId=' + keyConstService.CyberProductId);
                portalV2Service.getV2Token().then(function (resp) {
                    var redirectTo = rootModel.CommercialMotorSearchPolicyURL + '/' + encryptedParam;
                    portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, rootModel.BrokerPortalV2Debugging);
                });                
            }
        }

        rootModel.getTableStyle = function () {
            var marginHeight = 35; // optional
            var length;
            if (rootModel.policyOptions.data.length > 10) {
                length = 10;
            }
            else {
                length = rootModel.policyOptions.data.length;
            }
            // this is unique to my cellTemplate
            return {
                height: (length * rootModel.policyOptions.rowHeight + rootModel.policyOptions.headerRowHeight + marginHeight) + "px"
            };
        };


        rootModel.searchItem = function () {
            if (rootModel.selectedProduct === null) {
                rootModel.selectedProduct = "All";
            }
            var insuredName = null;
            var searchPolicy = null;
            var productName = null;
            var packageNumber = null;
            if (rootModel.searchName) {
                insuredName = rootModel.searchName;
            }
            if (rootModel.searchPolicy) {
                searchPolicy = rootModel.searchPolicy;
            }

            if (rootModel.selectedProduct) {
                if (rootModel.selectedProduct === "All") {
                    productName = rootModel.selectedProduct;
                }
                else {
                    productName = rootModel.selectedProduct.Description;
                }
            }
            if (rootModel.packageNumber) {
                packageNumber = rootModel.packageNumber;
            }

            var policySearchData = {
                "InsuredName": insuredName,
                "SearchPolicy": searchPolicy,
                "ProductName": productName,
                "PackageNumber": packageNumber,
                "PageNumber": $scope.policy.paginationOptions.pageNumber,
                "PageSize": $scope.policy.paginationOptions.pageSize
            };
            policyService.getSearchPolicy(policySearchData).then(function (searchdata) {
                if (searchdata.status)
                {
                    rootModel.policyOptions.data = searchdata.data.policyViewModelVM;
                    $scope.policyData = searchdata.data.policyViewModelVM;
                    $scope.policy.totalItems = searchdata.data.policyCount;
                    rootModel.policyOptions.totalItems = searchdata.data.policyCount;
                    $scope.policy.totalPage = Math.ceil($scope.policy.totalItems / $scope.policy.pageSize);
                    rootModel.policyOptions.paginationCurrentPage = $scope.policy.currentPage;
                    if (rootModel.policyOptions.data === null || rootModel.policyOptions.data.length === 0) {
                        rootModel.message = true;
                    }
                    else {
                        rootModel.message = false;
                        rootModel.IsReset = false;
                    }
                    sessionStorageService.set('searchState', rootModel.policyOptions.data);
                    return rootModel.policyOptions.data;
                }
            }, function (error) {
                toastr.error("Service is currently not available. Please try again or contact system administrator.");
            });
        }

        rootModel.Reset = function () {
            rootModel.policyOptions.data = null;
            rootModel.selectionBasis = null;
            rootModel.message = false;
            rootModel.searchName = null;
            rootModel.searchPolicy = null;
            rootModel.selectedProduct = null;
            rootModel.packageNumber = null;
            rootModel.selectedPolicy = null;
            rootModel.selectedPackage = null;
            rootModel.policyOptions.paginationCurrentPage = 1;
            rootModel.policyOptions.paginationPageSize = $scope.policy.paginationOptions.pageSize;
        }
    }
})();;
(function () {
    'use strict';

    var appUI = angular.module('appUI');

    appUI.controller('paymentInfoCtrl', ['$rootScope', '$scope', '$q', 'paymentInfoService', 'sessionStorageService', 'keyConstService', 'messageConstService', 'webUrlConstService', '$window', '$mdDialog', 'portalV2Service', paymentInfoCtrl]);

    function paymentInfoCtrl($rootScope, $scope, $q, paymentInfoService, sessionStorageService, keyConstService, messageConstService, webUrlConstService, $window, $mdDialog, portalV2Service) {
        var vm = this;
        vm.hideSave = false;
        vm.isDirectPaymentType = true;
        vm.isBsbInvalid = false;
        vm.IsPackageManagerNavigationMode = false;
        vm.continueOrNavigateBackToPackageManager = continueOrNavigateBackToPackageManager;
        vm.maxCVVLength = 3;
        vm.creditNavigationUrl = null;
        vm.hidefield = false;
        vm.token = '';
        vm.disableUpdateButton = true;
        vm.BrokerPortalV2Debugging = false;

        vm.init = function (model) {
            var isCancelledPolicy = JSON.parse(sessionStorageService.get(keyConstService.isCancelledPolicy, vm.isCancelledPolicy));
            var isPM = sessionStorageService.get('IsPackageManagerNavigationMode');
            var renewalCounter = sessionStorageService.get('RenewalCounter');
            if ((isPM === "true" || renewalCounter !== null) && isCancelledPolicy === true) {
                vm.showManagePkg = true;
            }
            var navigationModeDetail = sessionStorageService.get('IsPackageManagerNavigationMode');
            if (navigationModeDetail === "true") {
                vm.IsPackageManagerNavigationMode = true;
            }
            if (model.PolicyNumber !== null) {
                vm.policyData = model;
                vm.transactionId = vm.policyData.PolicyTransactionId;
                vm.accountName = model.FatZebraCardPaymentDetail.AccountName;
                vm.bsbNumber = model.FatZebraCardPaymentDetail.BSB;
                vm.accountNumber = model.FatZebraCardPaymentDetail.AccountNumber === 0 ? "" : model.FatZebraCardPaymentDetail.AccountNumber;
                vm.paymentType = model.FatZebraCardPaymentDetail.PaymentType;
                sessionStorageService.set('PolicyTransactionId', vm.transactionId);
                sessionStorageService.set('paymentViewData', vm.policyData);
                vm.creditNavigationUrl = vm.policyData.CCNavigationUrl;
                document.cardPaymentForm.action = vm.policyData.CCNavigationUrl;
                document.UpdatecardPaymentForm.action = vm.policyData.CCNavigationUrl;
                vm.productId = vm.policyData.ProductId;
                vm.BrokerPortalV2Debugging = model.BrokerPortalV2Debugging;
                if (vm.IsPackageManagerNavigationMode) {
                    document.getElementById('firstform').style.display = "none";
                }else {
                    document.getElementById('secondform').style.display = "none";
                      }
            } else {
                vm.policyData = JSON.parse(sessionStorageService.get('paymentViewData'));
                vm.creditNavigationUrl = vm.policyData.CCNavigationUrl;
                document.cardPaymentForm.action = vm.policyData.CCNavigationUrl;
            }
            
            function QueryStringToJSON() {
                if (location.search === '')
                {
                    return 0;
                }
                var pairs = location.search.slice(1).split('&');
                var result = {};
                pairs.forEach(function (pair) {
                    pair = pair.split('=');
                    result[pair[0]] = decodeURIComponent(pair[1] || '');
                });

                return JSON.parse(JSON.stringify(result));
            }

            var query_string = QueryStringToJSON();
                        
            //if (Object.keys(query_string).length <= 1)
            {
                // returnPath for payment gateway & Verification Id
                paymentInfoService.getVerificationId(vm.policyData.PackageId).then(function (data) {
                    if (data.status) {
                        if (vm.IsPackageManagerNavigationMode) {
                            document.getElementById('firstform').style.display = "none";
                        } else {
                            document.getElementById('secondform').style.display = "none";
                        }
                        vm.returnPath = data.data.returnUrl;
                        vm.verification = data.data.verificationId;
                    }
                });
            }
            
            if (Object.keys(query_string).length > 1)
            {
                var errors = query_string["errors[]"];
                query_string.errors = errors;
                paymentInfoService.saveAndVerifyFatZebraToken(query_string).then(function (data) {
                    var transactionId = sessionStorageService.get('PolicyTransactionId');
                    if (!data.status && data.errors && data.errors.length > 0) {
                        var errorMessage = data.errors[0].message === null ? messageConstService.errService3rdAPIUnavailable : data.errors[0].message;
                        var messagePopup = $mdDialog.alert()
                            .escapeToClose(false)
                            .htmlContent(errorMessage)
                            .ariaLabel('Lucky day')
                            .ok('OK')
                        $mdDialog.show(messagePopup).then(function () {
                            $window.location.href = webUrlConstService.paymentInfo + 'id=' + transactionId;
                        });                                          
                        return;
                    }
                    toastr.success(messageConstService.succPaymentInfoSaved);                    
                    if (vm.IsPackageManagerNavigationMode) {
                        continueOrNavigateBackToPackageManager();
                    }
                    else {
                        if (vm.policyData.ProductId === keyConstService.SMEProductId) {
                            portalV2Service.getV2Token().then(function (resp) {
                                portalV2Service.setKeyToLocalStorage(resp.data.data);
                                $window.location.href = window.location.protocol + '//' + window.location.host + keyConstService.SMEBoundPageURL + '?' + sessionStorageService.getEncryption('id=' + transactionId);
                            });
                        } else if (vm.policyData.ProductId === keyConstService.CommercialMotorProductId) {
                            portalV2Service.getV2Token().then(function (resp) {
                                var redirectTo = keyConstService.CommercialMotorUrlPrefix + keyConstService.CommercialMotorPolicyBound + sessionStorageService.getEncryption('id=' + vm.policyData.QuoteTransactionId + '&productId=' + keyConstService.CommercialMotorProductId);
                                portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                            });
                        } else if (vm.policyData.ProductId === keyConstService.CyberProductId) {
                            portalV2Service.getV2Token().then(function (resp) {
                                var redirectTo = keyConstService.CyberUrlPrefix + keyConstService.CyberPolicyBound + sessionStorageService.getEncryption('id=' + vm.policyData.QuoteTransactionId + '&productId=' + keyConstService.CyberProductId);
                                portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                            });
                        } else {
                            $window.location.href = webUrlConstService.bindIndex + sessionStorageService.getEncryption('id=' + transactionId);
                        }
                    }
                }, function (error) {
                    toastr.error(messageConstService.errServiceUnavailable);
                });
            }
        }

        vm.OnBlur = function (form) {
            var value = form.card_number.$viewValue;
            vm.CVV = '123';
            if (value) {
                var cctype = "";
                if (value.replace(/-/g, '').replace(/ /g, '').length < 15) {
                    form.card_number.$invalid = form.$invalid = true;
                    return value;
                }
                var copiedInput = angular.copy(value);
                var transformedInput = copiedInput.replace(/[^0-9]/g, '');

                if (transformedInput.length === 16 || transformedInput.length === 15) {
                    cctype =
                        (/^5[1-5][0-9]{14}$/.test(transformedInput)) ? "mastercard"
                            : (/^4[0-9]{12}(?:[0-9]{3})?$/.test(transformedInput)) ? "visa"
                                : (/^6(?:011|5[0-9]{2})[0-9]{12}$/.test(transformedInput)) ? 'discover'
                                    : (/^3(?:0[0-5]|[68][0-9])[0-9]{11}$/.test(transformedInput)) ? 'diners'
                                        : (/(?:2131|1800|35\d{3})\d{11}$/.test(transformedInput)) ? 'jcb'
                                            : (/^3[47][0-9]{13}$/.test(transformedInput)) ? 'amex'
                                                : undefined;

                    if (cctype === undefined) {
                        form.card_number.$invalid = form.$invalid = true;
                        return value;
                    }
                    if (cctype === 'amex') {
                        vm.CVV = '1234';
                        if (vm.CVV && vm.CVV.length < 4) {
                            vm.maxCVVLength = 4;
                        } else if (vm.maxCVVLength !== null && vm.maxCVVLength < 4) {
                            vm.maxCVVLength = 4;
                        }
                    } else {
                        if (vm.CVV && vm.CVV.length > 3) {
                            vm.maxCVVLength = 3;
                            field.cvv.$setValidity('minlength', false);
                        } else if (vm.maxCVVLength !== null && vm.maxCVVLength > 3) {
                            vm.maxCVVLength = 3;
                        }
                    }

                    // form.card_number.$invalid = form.$invalid = false;
                    form.card_number.$invalid = false;
                    return value;
                }
            }
        };

        vm.save = function (user, form) {
            var requestData = {
                'account_name': user.accountName,
                'account_number': user.accountNumber,
                'bsb': user.bsbNumber,
                'account_type': 'AU',
                'policyNumber': vm.policyData.PolicyNumber,
                'isDirectPaymentType': user.isDirectPaymentType,
                'packageId': vm.policyData.PackageId
            };
            paymentInfoService.getFatZebraBankToken(requestData).then(function (data) {
                vm.bankDetailData = data;
                if (!data.status && data.errors && data.errors.length > 0) {
                    toastr.error(data.errors[0].message);
                    return;
                }
                else if (data.status)
                {
                    toastr.success(messageConstService.succPaymentInfoSaved);
                    if (vm.IsPackageManagerNavigationMode) {
                        continueOrNavigateBackToPackageManager();
                    }
                    else {
                        var transactionId = (vm.transactionId == undefined) ? vm.policyData.PolicyTransactionId : vm.transactionId; 
                        if (vm.policyData.ProductId === keyConstService.SMEProductId) {
                            portalV2Service.getV2Token().then(function (resp) {
                                portalV2Service.setKeyToLocalStorage(resp.data.data);
                                $window.location.href = window.location.protocol + '//' + window.location.host + keyConstService.SMEBoundPageURL + '?' + sessionStorageService.getEncryption('id=' + transactionId);
                            });
                        } else if (vm.policyData.ProductId === keyConstService.CommercialMotorProductId) {
                            portalV2Service.getV2Token().then(function (resp) {
                                var redirectTo = keyConstService.CommercialMotorUrlPrefix + keyConstService.CommercialMotorPolicyBound + sessionStorageService.getEncryption('id=' + vm.policyData.QuoteTransactionId + '&productId=' + keyConstService.CommercialMotorProductId);
                                portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                            });
                        } else if (vm.policyData.ProductId === keyConstService.CyberProductId) {
                            portalV2Service.getV2Token().then(function (resp) {
                                var redirectTo = keyConstService.CyberUrlPrefix + keyConstService.CyberPolicyBound + sessionStorageService.getEncryption('id=' + vm.policyData.QuoteTransactionId + '&productId=' + keyConstService.CyberProductId);
                                portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                            });
                        } else {
                            $window.location.href = webUrlConstService.bindIndex + sessionStorageService.getEncryption('id=' + transactionId);
                        }
                    }
                }
            }, function (error) {
                toastr.error(messageConstService.errServiceUnavailable);
            });
        };

        vm.validateBSB = function (bsbNumber) {
            if (bsbNumber) {
                paymentInfoService.validateBSBNumber(bsbNumber).then(function (data) {
                    if (data.status === true) {
                        if (!data.data.valid) {
                            vm.isBsbInvalid = true;
                        } else {
                            vm.isBsbInvalid = false;
                        }
                    }
                }, function (error) {
                    vm.isBsbInvalid = false;
                });
            } else {
                vm.isBsbInvalid = false;
            }
        };

        vm.continue = function () {
            var transactionId = (vm.transactionId == undefined) ? vm.policyData.PolicyTransactionId : vm.transactionId;
            if (vm.policyData.ProductId === keyConstService.SMEProductId) {
                portalV2Service.getV2Token().then(function (resp) {
                    portalV2Service.setKeyToLocalStorage(resp.data.data);
                    $window.location.href = window.location.protocol + '//' + window.location.host + keyConstService.SMEBoundPageURL + '?' + sessionStorageService.getEncryption('id=' + transactionId);
                });
            } else if (vm.policyData.ProductId === keyConstService.CommercialMotorProductId) {
                portalV2Service.getV2Token().then(function (resp) {
                    var redirectTo = keyConstService.CommercialMotorUrlPrefix + keyConstService.CommercialMotorPolicyBound + sessionStorageService.getEncryption('id=' + vm.policyData.QuoteTransactionId + '&productId=' + keyConstService.CommercialMotorProductId);
                    portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                });
            } else if (vm.policyData.ProductId === keyConstService.CyberProductId) {
                portalV2Service.getV2Token().then(function (resp) {
                    var redirectTo = keyConstService.CyberUrlPrefix + keyConstService.CyberPolicyBound + sessionStorageService.getEncryption('id=' + vm.policyData.QuoteTransactionId + '&productId=' + keyConstService.CyberProductId);
                    portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                });
            } else {
                $window.location.href = webUrlConstService.bindIndex + sessionStorageService.getEncryption('id=' + transactionId);
            }
        }

        function continueOrNavigateBackToPackageManager() {
            var packageNumber = sessionStorageService.get('PackageNumberInformation');
            var renewalCounter = sessionStorageService.get('RenewalCounter');
            sessionStorageService.remove('IsPackageManagerNavigationMode');
            sessionStorageService.remove('PackageNumberInformation');
            sessionStorageService.remove('RenewalCounter');
            $window.location.href = webUrlConstService.getPackageInfo + sessionStorageService.getEncryption("packageNumber=" + JSON.parse(packageNumber) + "&&renewalCounter=" + renewalCounter);
        }
        
        vm.resetValue = function (isDirectPaymentType, form) {
            if (isDirectPaymentType) {
                vm.cardholderName = ''; 
                vm.cardNumber = '';
                vm.expiry_month = '';
                vm.expiry_year = '';
                vm.CVV = '';
                if (document.getElementById("update")) {
                    if (document.getElementById("update").checked) {
                        document.getElementById("addnew").checked = true;
                        vm.hidefield = false;
                    }
                }
            } else {
                if (!vm.IsPackageManagerNavigationMode) {
                    vm.accountName = '';
                    vm.bsbNumber = '';
                    vm.accountNumber = '';
                }
                vm.banktandc = false;  
                vm.hidefield = false;
            }

            let controlNames = Object.keys(form).filter(key => key.indexOf('$') !== 0);

            // Set each control back to undefined. This is the only way to clear validation messages.
            // Calling `form.$setPristine()` won't do it (even though you wish it would).
            for (let name of controlNames) {
                let control = form[name];
                control.$modelValue = undefined;
                control.$$element[0].value = '';
                control.$setViewValue(undefined);
            }

            form.$setPristine();
            form.$setUntouched();
        };

        vm.updateField = function (data) {
            vm.hidefield = data; 
            if (!data) {
                vm.cardholderName = '';
                vm.cardNumber = '';
                vm.expiry_month = '';
                vm.expiry_year = '';
                document.UpdatecardPaymentForm.action = vm.policyData.CCNavigationUrl;
            }
           
        };

        vm.getDetails = function () {
            paymentInfoService.getTokenDetials(vm.policyData.PackageId).then(function (data) {
                
                vm.cardholderName = data.result.card_Holder;
                var tempcard = data.result.card_Number;
                var parts = tempcard.split(/(.{4})/).filter(O => O);
                vm.cardNumber = parts.join('-');
                var tempdate = data.result.card_Expiry;
                parts = tempdate.split('-');
                vm.expiry_year = parts[0];
                vm.expiry_month = parts[1];
                vm.token = data.result.token;
            });
        };      

        vm.changedetails = function (data) {
            vm.disableUpdateButton = data;
        }

        vm.updateCardDetails = function (cardDetails, form) {
            var expiryDate = cardDetails.expiry_month + '/' + cardDetails.expiry_year;
            paymentInfoService.updateCardDetial(expiryDate, vm.policyData.PackageId).then(function (data) {
                if ((data.data.errors == null || data.data.errors.length == 0) && data.data.successful == true) {
                    toastr.success(messageConstService.updatePaymentInfo);
                    if (vm.IsPackageManagerNavigationMode) {
                        continueOrNavigateBackToPackageManager();
                    }
                    else {
                        var transactionId = (vm.transactionId == undefined) ? vm.policyData.PolicyTransactionId : vm.transactionId;
                        if (vm.policyData.ProductId === keyConstService.SMEProductId) {
                            portalV2Service.getV2Token().then(function (resp) {
                                portalV2Service.setKeyToLocalStorage(resp.data.data);
                                $window.location.href = window.location.protocol + '//' + window.location.host + keyConstService.SMEBoundPageURL + '?' + sessionStorageService.getEncryption('id=' + transactionId);
                            });
                        } else if (vm.policyData.ProductId === keyConstService.CommercialMotorProductId) {
                            portalV2Service.getV2Token().then(function (resp) {
                                var redirectTo = keyConstService.CommercialMotorUrlPrefix + keyConstService.CommercialMotorPolicyBound + sessionStorageService.getEncryption('id=' + vm.policyData.QuoteTransactionId + '&productId=' + keyConstService.CommercialMotorProductId);
                                portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                            });
                        } else if (vm.policyData.ProductId === keyConstService.CyberProductId) {
                            portalV2Service.getV2Token().then(function (resp) {
                                var redirectTo = keyConstService.CyberUrlPrefix + keyConstService.CyberPolicyBound + sessionStorageService.getEncryption('id=' + vm.policyData.QuoteTransactionId + '&productId=' + keyConstService.CyberProductId);
                                portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                            });
                        } else {
                            $window.location.href = webUrlConstService.bindIndex + sessionStorageService.getEncryption('id=' + transactionId);
                        }
                    }
                }
                else if ((data.data.errors == null || data.data.errors.length == 0) && data.data.successful == false) {
                    toastr.error(messageConstService.errServiceUnavailable);
                }
                else {
                    toastr.error(data.data.errors[0]);
                }
            }, function (error) {
                toastr.error(messageConstService.errServiceUnavailable);
            });
        }
    }
})();;
(function () {
    'use strict';

    angular.module('appUI')
        .service('paymentInfoService', ['$rootScope','$http', '$resource', '$q', paymentInfoService]);
    
    var paymentInfoUrl = '/Proxy/PaymentInfo/GetBankPaymentToken';
    var saveAndVerifyTokenUrl = '/Proxy/PaymentInfo/VerifyAndSaveFatZebraResponse';
    var getVerificationUrl = '/Proxy/PaymentInfo/GetVerificationId';
    var validateBSBApi = '/Proxy/PaymentInfo/ValidateBSB';
    var gettokendetailsUrl = '/Proxy/PaymentInfo/GetTokenDetails';
    var updateCardDetailsUrl = '/Proxy/PaymentInfo/UpdateTokenizedCardDetails';

    function paymentInfoService($rootScope, $http, $resource, $q) {
        return {
            getFatZebraBankToken: getFatZebraBankToken,
            saveAndVerifyFatZebraToken: saveAndVerifyFatZebraToken,
            getVerificationId: getVerificationId,
            validateBSBNumber: validateBSBNumber,
            getTokenDetials: getTokenDetials,
            updateCardDetial: updateCardDetial
        };

        function getFatZebraBankToken(getTokenRequest) {
            var getTokenApi = $resource(paymentInfoUrl, {},
                    { request: { method: 'POST', isArray: false } });
            return getTokenApi.save(getTokenRequest).$promise;
        };

        function saveAndVerifyFatZebraToken(saveAndVerifyTokenRequest) {
            var saveAndVerifyTokenApi = $resource(saveAndVerifyTokenUrl,
                {}, { request: { method: 'POST', isArray: false } });
            return saveAndVerifyTokenApi.save(saveAndVerifyTokenRequest).$promise;
        };
        
        function getVerificationId(packageId) {
            var getVerificationIdApi = $resource(getVerificationUrl,
                { packageId: packageId }, { get: { method: 'GET', isArray: false } });
            return getVerificationIdApi.get().$promise;
        };

        function validateBSBNumber(bsbNumber) {
            var validateBSB = $resource(validateBSBApi,
                { bsbNumber: bsbNumber }, { get: { method: 'GET', isArray: false } });
            return validateBSB.get().$promise;
        };

        function getTokenDetials(packageId) {
            var gettokendetailsApi = $resource(gettokendetailsUrl,
                { packageId: packageId }, { get: { method: 'GET', isArray: false } });
            return gettokendetailsApi.get().$promise;
        };

        function updateCardDetial(expiryDate, packageId) {
            var cardDetailsApi = $resource(updateCardDetailsUrl,
                {
                    expiryDate: expiryDate,
                    packageId: packageId
                }, { upate: { method: 'PUT', isArray: false } });
            return cardDetailsApi.upate(expiryDate, packageId).$promise;
        };
    }
})();;
(function () {
    'use strict';

    angular.module('appUI')
        .service('documentLibraryService', ['apiUrlConstService', '$rootScope', '$resource', '$http', '$q', 'webUrlConstService', documentLibraryService]);


    function documentLibraryService(apiUrlConstService, $rootScope, $resource, $http, $q, webUrlConstService) {
        this.getDocumentList = getDocumentList;
        this.downloadDocument = downloadDocument;

        function getDocumentList(setResponseValue) {

            var url = apiUrlConstService.documentLibraryList;
            $http({ url: url, method: "GET"}).then(successCallback, errorCallback, setResponseValue);

            function successCallback(response) {               
                setResponseValue(response.data);
            }

            function errorCallback(error) {
                setResponseValue(error)
            }
        }

        function downloadDocument(fileName, setResponseValue) {
            var url = apiUrlConstService.getDocument;
            $http({ url: url, method: "GET", responseType: 'blob', params: { filename: fileName } })
                .then(successCallback, errorCallback, setResponseValue);

            function successCallback(response) {
                setResponseValue(response)
            }

            function errorCallback(error) {
                setResponseValue(error);
            }
        }
    }
})();;
(function () {
    'use strict';

    angular.module('appUI')
        .service('claimTabService', ['apiUrlConstService', '$rootScope', '$resource', '$http', '$q', 'webUrlConstService', claimTabService]);

    function claimTabService(apiUrlConstService, $rootScope, $resource, $http, $q, webUrlConstService) {
        this.getDocumentList = getDocumentList;
        this.downloadDocument = downloadDocument;

        function getDocumentList(setResponseValue) {

            var url = apiUrlConstService.claimTabList;
            $http({ url: url, method: "GET"}).then(successCallback, errorCallback, setResponseValue);

            function successCallback(response) {               
                setResponseValue(response.data);
            }

            function errorCallback(error) {
                setResponseValue(error)
            }
        }

        function downloadDocument(fileName, setResponseValue) {
            var url = apiUrlConstService.getclaimTab;
            $http({ url: url, method: "GET", responseType: 'blob', params: { filename: fileName } })
                .then(successCallback, errorCallback, setResponseValue);

            function successCallback(response) {
                setResponseValue(response)
            }

            function errorCallback(error) {
                setResponseValue(error);
            }
        }
    }
})();;
(function () {
    'use strict';

    angular.module('appUI')
        .controller('claimTabCtrl', ['claimTabService', 'FileSaver', claimTabCtrl]);


    function claimTabCtrl(claimTabService, FileSaver) {
        var vm = this;
        vm.data = {};        
        vm.downloadDocument = downloadDocument;        
        documentLibraryList();        

        function getList() {
            claimTabService.getDocumentList(function getResponseFromService(response) {
                vm.data = response.data;               
            });
        }

        function documentLibraryList() {
            getList();
        }

        function downloadDocument(fileName, filepath) {               
            vm.isDisabled = true;
            var log = console.log;
            if (fileName && fileName != null && fileName !== '' && fileName != undefined) {
                var fileStatus = false;
                checkFileFormat(fileName, function getResponse(bool) {
                    fileStatus = bool;
                });
                if (fileStatus) {
                    claimTabService.downloadDocument(filepath, function getResponseFromService(result) {
                        if (result.status === 200) {
                            var content = result.data;
                            var blob = new Blob([content], { type: result.type });
                            vm.isDisabled = false;
                            FileSaver.saveAs(blob, fileName);
                        } else {
                            toastr.error("file does not exist.");
                        }
                    });
                } else {
                    toastr.warning("file format is not correct.");
                    vm.isDisabled = false;
                }

            } else {
                toastr.error("file does not exist.");
                vm.isDisabled = false;
            }
        };

        function checkFileFormat(file, setResponse) {
            var fileArray = file.split('.');
            var arrayLength = fileArray.length;
            var objItem = fileArray[arrayLength - 1];
            var checkdata = false;
            switch (objItem) {
                case 'pdf': {
                    checkdata = true;
                    break;
                }
                case 'docx': {
                    checkdata = true;
                    break;
                }               
                default: {
                    checkdata = false;
                    break;
                }
            }
            setResponse(checkdata);
        }  
    }
})();
;
(function () {
    "use strict";
    angular
        .module("appUI")
        .controller("clientCtrl", [
            "responsiveService",
            "$window",
            "$log",
            "messageConstService",
            "clientService",
            "cfpLoadingBar",
            "dateService",
            "quotesService",
            "sessionStorageService",
            "keyConstService",
            "apiUrlConstService",
            "webUrlConstService",
            "$http",
            clientCtrl
        ]);

    function clientCtrl(
        responsiveService,
        $window,
        $log,
        messageConstService,
        clientService,
        cfpLoadingBar,
        dateService,
        quotesService,
        sessionStorageService,
        keyConstService,
        apiUrlConstService,
        webUrlConstService,
        $http
    ) {
        var vm = this;

        vm.init = init;
        vm.addClient = addClient;
        vm.updateClient = updateClient;
        vm.deleteClient = deleteClient;
        vm.getConvertedDate = getConvertedDate;
        vm.getConvertedDateSecondary = getConvertedDateSecondary;
        vm.lookupACN = lookupACN;
        vm.secondrylookupACN = secondrylookupACN;
        vm.clientDetails = null;
        vm.client = null;
        vm.showOtherInfo;
        vm.storeAddress = storeAddress;
        var ClientType;
        vm.secondaryInsuredInitialData = [];
        vm.deleteSecondaryInsured;
        vm.isdeletedSecondaryInsured = []
        vm.secondaryInsuredNew = [];
        vm.secondaryInsuredData = [];
        vm.resetAddressData = resetAddressData;
        vm.existingQuotePolicy = existingQuotePolicy;
        vm.showQuoteMessage = false;
        vm.showDeletemessage = false;
        vm.submit = false;
        vm.previousAddressline1 = null;
        vm.previousSelectedMannualAddress = null;
        vm.isManualAddressonEdit = false;
        vm.previousSelectedAddress = null;
        vm.viewMannualAddress = null;
        vm.viewAddress = null;
        vm.changeClient = changeClient;
        vm.changeSecondaryClient = changeSecondaryClient;
        vm.storeSecondaryAddress = storeSecondaryAddress;
        vm.resetSecondaryAddress = resetSecondaryAddress;
        vm.checkSameAsPrimary = checkSameAsPrimary;
        vm.addressLogDetails = "";
        vm.unFocusSecondaryAddress = unFocusSecondaryAddress;
        vm.resetAddress = resetAddress;
        vm.setSecondariesAddressWhenPrimaryAddressChange = setSecondariesAddressWhenPrimaryAddressChange;
        vm.showManualAddressSecondry = showManualAddressSecondry;
        vm.resetSearchTextSecondry = resetSearchTextSecondry;

        function init(clientDetails, isAllReadonly, isEditReadonly) {
            vm.clientDetails = clientDetails.ClientViewModel;
            vm.secondaryDetails = clientDetails.SecondaryInsuredClientVM;
            vm.addressLogDetails = clientDetails.AddressLogVM;
            vm.IsExistingQuote = clientDetails.IsExistingQuote;
            if (clientDetails.AddressLogVM) {
                vm.isManualAddressonEdit = angular.copy(clientDetails.AddressLogVM.IsManualAddress);
            }
            if (clientDetails.SecondaryInsuredClientVM) {
                vm.secondaryInsuredInitialData = clientDetails.SecondaryInsuredClientVM;
                // extractiong data from array in case of edit clients
                for (let i = 0; i < vm.secondaryInsuredInitialData.length; i++) {
                    if (vm.secondaryInsuredInitialData[i].AddressLogVM.IsManualAddress === false) {
                        vm.secondaryInsuredInitialData[i].secondryselectAddress = vm.secondaryInsuredInitialData[i].AddressLogVM.Address;
                    }
                }
            }
            if (clientDetails.AddressLogVM !== null) {
                if (clientDetails.AddressLogVM.IsManualAddress) {
                    vm.viewMannualAddress = clientDetails.AddressLogVM.Address;
                }
                else {
                    vm.viewAddress = clientDetails.AddressLogVM.Address;
                }
               
            }
            if (clientDetails.AddressLogVM !== null) {
              if (!clientDetails.AddressLogVM.IsManualAddress) {
                    vm.selectedItem = clientDetails.AddressLogVM.Address;
                }
                else {
                    vm.selectedMannualAddress = clientDetails.AddressLogVM.Address;
                }
            }
       
            if (vm.clientDetails !== null) {

                if (vm.clientDetails.DateOfBirth === null) {
                    vm.clientDetails.dateOfBirthApp = null;
                } else {
                    var newDate = new Date(vm.clientDetails.DateOfBirth);
                    vm.clientDetails.dateOfBirthApp = newDate;
                }
            }
            vm.isAllReadonly = isAllReadonly;
            vm.isEditReadonly = isEditReadonly;

            $log.log(clientDetails.ClientViewModel);
            $log.log(clientDetails.SecondaryInsuredClientVM);

            this.myDate = new Date();

            this.minDate = new Date(
                this.myDate.getFullYear(),
                this.myDate.getMonth() - 17,
                this.myDate.getDate()
            );

            this.maxDate = new Date(
                this.myDate.getFullYear(),
                this.myDate.getMonth() + 0,
                this.myDate.getDate()
            );

            var clientcode;
            vm.secondaryDetail = sessionStorageService.get(keyConstService.quoteState);
            if (vm.secondaryDetail === null) {
                vm.secondaryDetail = quotesService.getSecondaryInsured();
                vm.secondaryDetail.currentStep = 1;
            }
            else {
                vm.secondaryDetail = JSON.parse(vm.client);
            }
            if (!vm.clientDetails.ClientType) {
                vm.clientDetails.ClientType = '0'; // default value
            }
            // Add logic for stampduty
            if (vm.addressLogDetails && vm.addressLogDetails.DelimeterAddress) {
                var splitSate = vm.addressLogDetails.DelimeterAddress.split('|');
                var AddressState = splitSate[0];
                if (AddressState === "NSW") {
                    vm.showStampDuty = true;
                }
                else {
                    vm.showStampDuty = false;
                }
            }
        }

        vm.edit = function () {
            var code = vm.clientDetails.ClientCode;
            window.location = "/Client/Edit?" + sessionStorageService.getEncryption("code=" + code);

        };

        vm.showOtherInfo = function () {
            if (c.ClientType === "Business") {
                vm.showdata = true;
            }
            else {
                vm.showdata = false;
            }
        };

        vm.addSecondaryInsured = function () {
            vm.showme = true;
            // disable save if we add secondary client in case of edit
            vm.isDisabled = true;
            vm.secondaryInsuredInitialData.push({ ClientType: '0', FirstName: null, LastName: null, DateOfBirth: null, Email: null, Phone: null, AlternateContact: null, ABN: null, ITC: null, WebsiteURL: null, IsStampDutyExempted: false, ShowLookup: vm.clientDetails.ShowLookup, AddressLogVM: {} });

        };

         //function to show the mannual address options for primary client
        vm.showManualAddressOption = function () {
            if (vm.addressLogDetails !== null) {
                vm.addressLogDetails.IsManualAddress = true;
            }
            else  {
                vm.addressLogDetails = {
                    IsManualAddress: true
                };
            }
            vm.searchText = null;
            if (!vm.isManualAddressonEdit) {
                vm.resetAddress();
            }
            else {
                vm.resetAddressData();
            }

        };

        // reset the data while searching the address for primary client
        vm.resetSearchText = function () {
            if (vm.addressLogDetails !== null) {
                vm.addressLogDetails.IsManualAddress = false;
            }
            else if (vm.addressLogDetails === null){
                vm.addressLogDetails = {
                    IsManualAddress: false
                };
            }
            if (!vm.isManualAddressonEdit) {
                vm.resetAddress();
            }
            else {
               
                vm.resetAddressData();
            }
        };

        //function to show the mannual address options for secondry client
        function showManualAddressSecondry(index) {
            vm.secondaryInsuredInitialData[index].AddressLogVM.IsManualAddress = true;
            vm.secondaryInsuredInitialData[index].SearchAddress = null;
        };

        // reset the data while searching the address for secondry client
        function resetSearchTextSecondry(index) {
            vm.secondaryInsuredInitialData[index].AddressLogVM.IsManualAddress = false;
            resetSecondaryAddress(index);
        };


        function resetAddressData() {
            if (vm.addressLogDetails) {
                if (vm.isManualAddressonEdit) {
                    if (!vm.addressLogDetails.IsManualAddress) {
                        vm.previousAddressline1 = vm.addressLogDetails.AddressLine1;
                        //vm.previousSelectedMannualAddress = vm.previousSelectedAddress = [{
                        //    postcode: vm.addressLogDetails.PostCode,
                        //    text: vm.addressLogDetails.Address,
                        //    value: vm.addressLogDetails.DelimeterAddress,
                        //}];
                        vm.selectedMannualAddress = null;
                       // vm.addressLogDetails.AddressLine1 = null;
                        vm.selectedItem = null;
                       // vm.searchText = null;
                    }
                    else {
                        //if (vm.previousSelectedMannualAddress) {
                        //    vm.selectedMannualAddress = vm.previousSelectedMannualAddress[0];
                        //}
                        //else {
                        //    vm.selectedMannualAddress = null;
                        //}
                        //vm.addressLogDetails.AddressLine1 = vm.previousAddressline1;
                        vm.selectedItem = null;
                        //vm.searchText = null;
                    }
                    

                }
                else {
                    if (vm.addressLogDetails.IsManualAddress) {
                        vm.previousSelectedAddress = [{
                            postcode: vm.addressLogDetails.PostCode,
                            text: vm.addressLogDetails.Address,
                            value: vm.addressLogDetails.DelimeterAddress,
                        }];
                        vm.selectedItem = null;
                        vm.searchText = null;
                        vm.addressLogDetails.AddressLine1 = null;
                        vm.addressLogDetails.Address = null;
                        vm.mannualSearchText = null;
                    }
                    else {                       
                        vm.addressLogDetails.Address = vm.previousSelectedAddress;
                        if (vm.previousSelectedAddress) {
                            vm.selectedItem = vm.previousSelectedAddress[0];
                        }
                        else {
                            vm.selectedItem = null;
                            vm.searchText = null;
                        }
                    }
                }
            }
        }

        function existingQuotePolicy() {
            vm.showDeletemessage = true;
            if (vm.IsExistingQuote === true) {
                vm.showQuoteMessage = true;
                vm.showDeletemessage = false;
            }
        }

        vm.removeSecondaryInsured = function (item) {
            // disable save if we add secondary client in case of edit
            vm.isDisabled = false;
            if (vm.secondaryDetails === null) {
                var index = vm.secondaryInsuredInitialData.indexOf(item);
                vm.secondaryInsuredInitialData.splice(index, 1);
            }
            //value isdeleted =true
            index = vm.secondaryInsuredInitialData.indexOf(item);
            vm.secondaryDetails[index].IsDeleted = true;

            //arr push
            var abc = vm.secondaryDetails[index];
            vm.isdeletedSecondaryInsured.push(abc);
            vm.secondaryInsuredInitialData.splice(index, 1);

        };

        vm.deleteSecondaryInsured = function (item) {
            var index = vm.secondaryInsuredInitialData.indexOf(item);
            vm.secondaryInsuredInitialData.splice(index, 1);
            var request = clientService.deleteClientData({
                clientCode: vm.clientDetails.ClientCode
            });
            request.then(successMoveToIndex, failure);
        };

        vm.querySearch = function (query) {
            return $http.get(apiUrlConstService.addressURL + 'IntechAddressListAsync?address=' + query, { skipInterceptor: true })
                .then(function (result) {
                    let obj = {
                        text: messageConstService.manualAddressList,
                        value: 'N/A',
                        postCode: null
                    };

                    let resultantdata = result.data.data;
                    if (resultantdata.length > 0) {
                        resultantdata.push(obj);
                    }
                    return resultantdata;
                });
        };

        vm.mannualSearchQuery = function (query) {
            return $http.get(apiUrlConstService.addressURL + 'MannualAddressList?searchAddress=' + query, { skipInterceptor: true })
                .then(function (result) {
                    return result.data.data;
                });
        };

        //Check Is Address is valid or not
        vm.checkValidManualAddress = function (field) {
            if (vm.mannualSearchText) {
                if (!vm.selectedMannualAddress) {
                    field.$setValidity('invalid', false);
                }
                else {
                    field.$setValidity('invalid', true);
                }
            }
        };

        function storeAddress(address) {


            if (address && address.value == 'N/A') {
                address = null;
                vm.selectedItem = null;
                vm.showManualAddressOption();
            }
            
            if (address !== null && address !== undefined) {
                if (address.value) {
                    vm.clientDetails.IsStampDutyExempted = false;
                    var splitSate = address.value.split('|');
                    var AddressState = splitSate[0];
                    vm.clientDetails.IsStampDutyExempted = false;
                    if (AddressState === "NSW") {
                        vm.showStampDuty = true;
                    }
                    else {
                        vm.showStampDuty = false;
                    }

                    if (vm.addressLogDetails) {
                        vm.addressLogDetails.Address = address.text;
                        vm.addressLogDetails.DelimeterAddress = address.value;
                        vm.addressLogDetails.PostCode = address.postCode === null ? null : address.postCode;
                    }
                    else {
                        vm.addressLogDetails = {
                            Address: address.text,
                            DelimeterAddress: address.value,
                            PostCode: address.postCode === null ? null : address.postCode
                        };
                    }
                }
            }
            else {
                // if primary address change then null is set to secondary address
                // whose IsSameAsPrimaryAddress is true.
                setSecondariesAddressWhenPrimaryAddressChange();
            }
        }


        function addClient() {
            cfpLoadingBar.start();
            vm.submit = true;
            // if blank DOB from UI then save null value or default value in DB
            if (!vm.clientDetails.dateOfBirthApp) {
                vm.clientDetails.DateOfBirth = null;
            }

            $log.log("client data for adding:", vm.clientDetails, vm.secondaryDetails, vm.addressLogDetails);
            var client = {
                ClientViewModel: vm.clientDetails,
                SecondaryInsuredClientVM: vm.secondaryInsuredInitialData,
                AddressLogVM: vm.addressLogDetails
            };
            var request = clientService.saveClientData({
                client: client

            });
            request.then(successMoveToIndex, failure);
        }

        function updateClient() {
            cfpLoadingBar.start();
            vm.submit = true;
            // if blank DOB from UI then save null value or default value in DB
            if (!vm.clientDetails.dateOfBirthApp) {
                vm.clientDetails.DateOfBirth = null;
            }

            $log.log("client data for update:", vm.clientDetails, vm.secondaryDetails, vm.addressLogDetails);
            vm.secondaryInsuredData = vm.isdeletedSecondaryInsured.concat(vm.secondaryInsuredInitialData);


            var client = {
                ClientViewModel: vm.clientDetails,
                SecondaryInsuredClientVM: vm.secondaryInsuredData,
                AddressLogVM: vm.addressLogDetails
            };

            var request = clientService.updateClientData({
                client: client

            });
            request.then(successMoveToIndex, failure);
        }

        function deleteClient() {
            cfpLoadingBar.start();
            var request = clientService.deleteClientData({
                clientCode: vm.clientDetails.ClientCode

            });
            request.then(successMoveToIndex, failure);
        }

        function success(response) {
            $log.log("response:", response);
            cfpLoadingBar.complete();

            toastr.info(messageConstService.succUpdated);
        }

        function successMoveToIndex(response) {
            success(response);
            cfpLoadingBar.complete();
            //if sessionStorage IsFromNewBusinessPage exists then move newbusiness
            if (JSON.parse(sessionStorageService.get(keyConstService.IsFromNewBusinessPage))) {
                sessionStorageService.set(keyConstService.IsFromNewBusinessPage, false);
                if (response.status) {
                    sessionStorageService.set(keyConstService.clientFullNameandCode, response.data.clientFullNameandCode);
                    sessionStorageService.set(keyConstService.PrimaryClientId, response.data.id);
                }
                sessionStorageService.set(keyConstService.IsFromNewBusinessPage, false);
                $window.location.href = webUrlConstService.newBusinessIndex;
            }
            else {
                $window.location.href = webUrlConstService.clientIndex;
            }
        }

        function failure(error) {
            $log.error("error:", error);
            cfpLoadingBar.complete();

            toastr.error(messageConstService.errServiceUnavailable);
        }

        function getConvertedDate() {

            if (vm.clientDetails !== null) {
                var dateOfBirth = vm.clientDetails.dateOfBirthApp;
            }
            else {
                dateOfBirth = dob;
            }

            if (dateOfBirth) {
                var response = dateService.validateDate(dateOfBirth);
                var rangeResponse = dateService.validateRange(
                    "years",
                    -150,
                    0,
                    dateOfBirth
                );
                if (!rangeResponse.isValid) {
                    vm.clientDetails.DateOfBirth = "";
                    vm.clientDetails.dateOfBirthApp = "";
                    toastr.warning(rangeResponse.errorMsg);
                    return;
                }
                vm.clientDetails.DateOfBirth = response.date;
            }
        }

        function getConvertedDateSecondary(dob,index) {

            if (vm.secondaryInsuredInitialData[index] !== null) {
                var dateOfBirthS = vm.secondaryInsuredInitialData[index].DateOfBirthStringAsDDMMYYYY;
            }
            else {
                dateOfBirthS = dob;
            }

            if (dateOfBirthS) {
                var response = dateService.validateDate(dateOfBirthS);
                var rangeResponse = dateService.validateRange(
                    "years",
                    -150,
                    0,
                    dateOfBirthS
                );
                if (!rangeResponse.isValid) {
                    vm.secondaryInsuredInitialData[index].DateOfBirth = "";
                    vm.secondaryInsuredInitialData[index].DateOfBirthStringAsDDMMYYYY = "";
                    toastr.warning(rangeResponse.errorMsg);
                    return;
                }
            }
        }

        function changeClient() {
            vm.clientDetails.dateOfBirthApp = null;
            vm.clientDetails.FirstName = null;
            vm.clientDetails.LastName = null;
            vm.clientDetails.ABN = null;
            vm.clientDetails.OrganisationName = null;
            vm.clientDetails.TradingName = null;
            vm.clientDetails.Website = null;
            vm.clientDetails.Email = null;
            vm.clientDetails.Phone = null;
            vm.clientDetails.AlternateContact = null;
            vm.showStampDuty = false;
            resetAddressData();
        }
        function changeSecondaryClient(index) {
            vm.secondaryInsuredInitialData[index].DateOfBirthStringAsDDMMYYYY = null;
            vm.secondaryInsuredInitialData[index].FirstName = null;
            vm.secondaryInsuredInitialData[index].LastName = null;
            vm.secondaryInsuredInitialData[index].ABN = null;
            vm.secondaryInsuredInitialData[index].OrganisationName = null;
            vm.secondaryInsuredInitialData[index].TradingName = null;
            vm.secondaryInsuredInitialData[index].WebsiteURL = null;
            vm.secondaryInsuredInitialData[index].Email = null;
            vm.secondaryInsuredInitialData[index].Phone = null;
            vm.secondaryInsuredInitialData[index].AlternateContact = null;
            vm.secondaryInsuredInitialData[index].ShowStampDuty = false;
            vm.resetSecondaryAddress(index);
            // disable save if we add secondary client in case of edit
            vm.isDisabled = false;
            vm.secondaryInsuredInitialData[index].AddressLogVM.IsManualAddress = false;
        }
        function storeSecondaryAddress(address, index) {

            if (address && address.value == 'N/A') {
                address = null;
                vm.secondaryInsuredInitialData[index].secondryselectAddress = null;
                vm.showManualAddressSecondry(index);
            }

            if (address !== null) {
                if (address.value) {
                    //resetSecondaryAddress(index);
                    var splitSate = address.value.split('|');
                    var AddressState = splitSate[0];
                    vm.secondaryInsuredInitialData[index].IsStampDutyExempted = false;
                    if (AddressState === "NSW") {
                        vm.secondaryInsuredInitialData[index].ShowStampDuty = true;
                    }
                    else {
                        vm.secondaryInsuredInitialData[index].ShowStampDuty = false;
                    }
                    if (vm.secondaryInsuredInitialData[index].AddressLogVM) {
                        vm.secondaryInsuredInitialData[index].AddressLogVM.Address = address.text;
                        vm.secondaryInsuredInitialData[index].AddressLogVM.DelimeterAddress = address.value;
                        vm.secondaryInsuredInitialData[index].AddressLogVM.PostCode = address.postCode === null ? null : address.postCode;
                        if (vm.secondaryInsuredInitialData[index].AddressLogVM.IsManualAddress === false) {
                            vm.secondaryInsuredInitialData[index].secondryselectAddress = vm.secondaryInsuredInitialData[index].AddressLogVM.Address;
                        }
                        //else {
                        //    vm.secondaryInsuredInitialData[index].secondry = vm.secondaryInsuredInitialData[index].AddressLogVM.Address;
                        
                        //}
                       
                    }
                    else {
                        vm.secondaryInsuredInitialData[index].AddressLogVM = {
                            Address: address.text,
                            DelimeterAddress: address.value,
                            PostCode: address.postCode === null ? null : address.postCode
                        };
                    }
                }
            }
        }
        function resetSecondaryAddress(index) {
            vm.secondaryInsuredInitialData[index].AddressLogVM.AddressLine1 = null;
            vm.secondaryInsuredInitialData[index].AddressLogVM.Address = null;
            vm.secondaryInsuredInitialData[index].ShowStampDuty = false;
            vm.secondaryInsuredInitialData[index].IsStampDutyExempted = false;
            vm.secondaryInsuredInitialData[index].IsSameAsPrimaryAddress = false;
            vm.secondaryInsuredInitialData[index].SearchMannualAddress = null;
            vm.secondaryInsuredInitialData[index].IsStampDutyExempted = false;
        }

        function checkSameAsPrimary(index) {
            // if Primary Addess is null then show valid message and reset secondary address fields 
            if (vm.addressLogDetails.IsManualAddress && (!vm.addressLogDetails.AddressLine1 || !vm.selectedMannualAddress)) {
                inValidAddressonSameAsPrimary(index);
                return;
            }
            else if (!vm.addressLogDetails.IsManualAddress && !vm.selectedItem) {
                inValidAddressonSameAsPrimary(index);
                return;
            }

            if (vm.secondaryInsuredInitialData[index].IsSameAsPrimaryAddress) {
                vm.secondaryInsuredInitialData[index].AddressLogVM = angular.copy(vm.addressLogDetails);
                if (vm.secondaryInsuredInitialData[index].AddressLogVM.IsManualAddress === false) {
                    vm.secondaryInsuredInitialData[index].secondryselectAddress = angular.copy(vm.secondaryInsuredInitialData[index].AddressLogVM.Address);
                }
              
                // in case of isMannualAddress of primary client is true.
                if (vm.secondaryInsuredInitialData[index].AddressLogVM.IsManualAddress && vm.selectedMannualAddress !== null) {
                    if (vm.selectedMannualAddress.text !== undefined) {
                        vm.secondaryInsuredInitialData[index].AddressLogVM.Address = vm.selectedMannualAddress.text;
                    }
                    else {
                        vm.secondaryInsuredInitialData[index].AddressLogVM.Address = vm.selectedMannualAddress;
                    }
                    if (vm.selectedMannualAddress.value !== undefined) {
                        vm.secondaryInsuredInitialData[index].AddressLogVM.DelimeterAddress = vm.selectedMannualAddress.value;
                    }
                    else  {
                        vm.secondaryInsuredInitialData[index].AddressLogVM.DelimeterAddress = vm.selectedMannualAddress;
                    }
                    vm.secondaryInsuredInitialData[index].AddressLogVM.PostCode = vm.selectedMannualAddress.postCode === null ? null : vm.selectedMannualAddress.postCode;
                    vm.secondaryInsuredInitialData[index].secondryselectAddress = "";
                    
                }   
                var splitSate = vm.secondaryInsuredInitialData[index].AddressLogVM.DelimeterAddress.split('|');
                var AddressState = splitSate[0];

                if (AddressState === "NSW") {
                    vm.secondaryInsuredInitialData[index].ShowStampDuty = true;
                }
                else {
                    vm.secondaryInsuredInitialData[index].ShowStampDuty = false;
                }
            }
        }

        function lookupACN(index, value) {
            var abnNumber = '';
            if (value) {
                abnNumber = value;
            }
            else {
                abnNumber = vm.clientDetails.ABN;
            }
            if (abnNumber !== "" && abnNumber !== null && abnNumber !== undefined) {

                return clientService.getABNDetail(abnNumber)
                    .then(function (abnresult) {

                        if (abnresult.data.status === false) {
                            toastr.error(messageConstService.errServiceUnavailable);
                        }
                        else if (abnresult.data.exception === 1) {
                            toastr.error(abnresult.data.errors[0].message);
                        }
                        else {
                            var addresssToShow = "";
                            var addresslist = $http.get(apiUrlConstService.addressURL + 'IntechAddressListAsync?address=' + abnresult.data.data.intechAddress)
                                .then(function (result) {
                                    if (result.data.status === null) {
                                        toastr.error(messageConstService.errServiceUnavailable);
                                    }
                                    else {
                                        var address = result.data.data[0];

                                        if (index !== null && index !== undefined) {
                                            address !== null && address !== undefined ? storeSecondaryAddress(address, index) : resetSecondaryAddress(index);
                                            vm.secondaryInsuredInitialData[index].OrganisationName = abnresult.data.data.businessName;
                                            vm.secondaryInsuredInitialData[index].TradingName = abnresult.data.data.tradingName;
                                            vm.secondaryInsuredInitialData[index].WebsiteURL = abnresult.data.data.website;
                                            vm.secondaryInsuredInitialData[index].DateOfBirthStringAsDDMMYYYY = "01/01/" + abnresult.data.data.yearStarted;
                                            vm.secondaryInsuredInitialData[index].Email = abnresult.data.data.email;
                                            vm.secondaryInsuredInitialData[index].Phone = abnresult.data.data.phoneNumber;
                                            vm.secondaryInsuredInitialData[index].AlternateContact = abnresult.data.data.AlternateContact;
                                            //vm.secondaryInsuredInitialData[index].AddressLogVM.Address = result.intechAddress;
                                            vm.secondaryInsuredInitialData[index].AddressLogVM.Address = address !== null && address !== undefined ? address.text : "";
                                            //vm.selectedItem = result.intechAddress;
                                        }
                                        else {
                                            address !== null && address !== undefined ? storeAddress(address) : resetAddressData();
                                            vm.clientDetails.OrganisationName = abnresult.data.data.businessName;
                                            vm.clientDetails.TradingName = abnresult.data.data.tradingName;
                                            vm.clientDetails.Website = abnresult.data.data.website;
                                            vm.clientDetails.dateOfBirthApp = "01/01/" + abnresult.data.data.yearStarted;
                                            vm.clientDetails.Email = abnresult.data.data.email;
                                            vm.clientDetails.Phone = abnresult.data.data.phoneNumber;
                                            vm.clientDetails.AlternateContact = abnresult.data.data.AlternateContact;
                                            //vm.selectedItem = result.intechAddress;
                                            vm.selectedItem = address !== null && address !== undefined ? address.text : null;
                                        }
                                        getConvertedDate();
                                    }
                                });
                        }
                    });
            }
        }

        function secondrylookupACN(index, value) {
            this.lookupACN(index, value);
        }

        function unFocusSecondaryAddress(index) {
            // On blur check if address is null then deisable save button 
            //if (vm.secondaryInsuredInitialData[index].SearchMannualAddress) {
            //    if (vm.secondaryInsuredInitialData[index].AddressLogVM.Address) {
            //        field.$setValidity('invalid', false);
            //    }
            //    else {
            //        field.$setValidity('invalid', true);
            //    }
            //}
            if (vm.secondaryInsuredInitialData[index].AddressLogVM.Address === null) {
               if (vm.secondaryInsuredInitialData[index].secondryselectAddress == null) {
               vm.secondaryInsuredInitialData[index].SearchAddress = null;
            }
                resetSecondaryAddress(index);
            }
        }

        function inValidAddressonSameAsPrimary(index) {
            vm.secondaryInsuredInitialData[index].IsSameAsPrimaryAddress = false;
            toastr.error(messageConstService.errAddressIsNotValid);
            resetSecondaryAddress(index);
        }

        // Reset Addess when primary address change from mannuall to address or vice versa
        function resetAddress() {
            vm.selectedMannualAddress = null;
            vm.selectedItem = null;
            vm.addressLogDetails.Address = null;
            vm.addressLogDetails.AddressLine1 = null;
            vm.addressLogDetails.DelimeterAddress = null;
            vm.addressLogDetails.PostCode = null;
            vm.showStampDuty = false;
            vm.clientDetails.IsStampDutyExempted = false;
            //vm.searchText = null;
            vm.mannualSearchText = null;
        }
        // if primary address change then null is set to secondary address
        // whose IsSameAsPrimaryAddress is true.
        function setSecondariesAddressWhenPrimaryAddressChange() {
            if (vm.secondaryInsuredInitialData && vm.secondaryInsuredInitialData.length > 0) {
                for (var i = 0; i < vm.secondaryInsuredInitialData.length; i++) {
                    if (vm.secondaryInsuredInitialData[i].IsSameAsPrimaryAddress) {
                        vm.secondaryInsuredInitialData[i].AddressLogVM = null;
                        vm.secondaryInsuredInitialData[i].IsSameAsPrimaryAddress = false;
                        vm.secondaryInsuredInitialData[i].ShowStampDuty = false;
                        vm.secondaryInsuredInitialData[i].IsStampDutyExempted = false;
                    }
                }
            }
        }
    }
})();
;
(function () {
    "use strict";
    angular
        .module("appUI")
        .controller("clientListCtrl", [
            "responsiveService",
            "$window",
            "$scope",
            "cfpLoadingBar",
            "dateService",
            "clientService",
            "webUrlConstService",
            "sessionStorageService",
            "keyConstService",
            "utilityService",
            clientListCtrl
        ]);

    function clientListCtrl(
        responsiveService,
        $window,
        $scope,
        cfpLoadingBar,
        dateService,
        clientService,
        webUrlConstService,
        sessionStorageService,
        keyConstService,
        utilityService)   {

        var vm = this;
        vm.isfound = false;
        vm.message;
        vm.searchCode = null;
        vm.searchtxt = null;
        vm.init = init;
        vm.getConvertedDate = getConvertedDate;
        vm.reset = reset;
        vm.addClient = addClient;
        vm.disableData = false;
        vm.clientSearchData;
        vm.clientsData;
        vm.clients;
        vm.clientCount = null;
        vm.getTableStyle = getTableStyle;
        $scope.client = {};
        $scope.getParamEncrytion = getParamEncrytion;
        vm.searchText = null;
        vm.selectedItem = null;
        vm.querySearch = querySearch;
        vm.textChange = textChange;
        


        function init(isFirstLoad, isUneditable, isNameUneditable) {
            sessionStorageService.remove(keyConstService.IsCopyQuote);

            initPaginationSettings();

            $scope.loadClients();

            vm.gridOptions = {
                totalItems: $scope.client.totalItems,
                paginationPageSize: $scope.client.paginationOptions.pageSize,
                paginationPageSizes: [$scope.client.pageSize, $scope.client.pageSize * 2, $scope.client.pageSize * 3],
                enablePagination: true,
                enableHorizontalScrollbar: 2,
                enableRowHeaderSelection: false,
                enableColumnMenus: false,
                gridMenuShowHideColumns: false,
                enableHiding: false,
                useExternalPagination: true,
                columnDefs: [
                    { name: "name", field: "fullName", width: "250", cellTemplate: getlink() },
                    { name: "Client Code", field: "clientCode", width: "250" },
                    { name: "Phone", field: "phone", width: "260" },
                    { name: "Email", field: "email", width: "260" },
                    { name: "BrokerId", field: "brokerId", width: "150" }
                ],
                onRegisterApi: function (gridApi) {
                    $scope.client.gridApi = gridApi;
                    gridApi.pagination.on.paginationChanged($scope, function (newPage, pageSize) {
                        $scope.client.paginationOptions.pageNumber = newPage;
                        $scope.client.paginationOptions.pageSize = pageSize;
                        $scope.client.pageSize = pageSize;
                        $scope.client.currentPage = newPage;                        
                        $scope.loadClients();
                    });
                }
            };
        }

        function initPaginationSettings() {
            $scope.client.paginationOptions = {
                pageNumber: 1,
                pageSize: 10
            };
            $scope.loadClients();
            $scope.client.currentPage = 1;
            $scope.client.pageSize = $scope.client.paginationOptions.pageSize;
        }

        function getlink() {
            return '<a ng-click="grid.appScope.getParamEncrytion(row.entity.clientCode)">{{row.entity.fullName}}</a>';
        }

        function getParamEncrytion(paramString) {
            var encryptedParam = sessionStorageService.getEncryption("code=" + paramString);
            $window.location.href = "/Client/View?" + encryptedParam;
        }

        function addClient() {
            sessionStorageService.set(keyConstService.IsFromNewBusinessPage, false);
            window.location = webUrlConstService.clientAdd;
        }

        function searchClient() {
            vm.disableData = false;
            if (clients.Clients === 0) {
                vm.message = "No Records found";
            }
        }

        function reset() {
            vm.selectedItem = null;
            vm.ClientName = null;
            vm.ClientCode = null;
            vm.searchText = null; 
            vm.searchCode = null;
            initPaginationSettings();
            vm.searchtxt = null;
            vm.disableData = true;
            vm.noClientFound = false;
            vm.gridOptions.paginationCurrentPage = 1;
            vm.gridOptions.paginationPageSize = $scope.client.paginationOptions.pageSize;
            vm.filterClientName();
        }

        $scope.loadClients = function () {
            var request = {
                ClientName: vm.searchText,
                ClientCode: vm.searchCode,
                PageNumber: $scope.client.paginationOptions.pageNumber,
                PageSize: $scope.client.paginationOptions.pageSize
            }
            clientService.getClients(request).then(function (data) {
                vm.gridOptions.data = data.data.clients;
                $scope.client.totalItems = data.data.clientCount;
                $scope.client.totalPage = Math.ceil($scope.client.totalItems / $scope.client.pageSize);
                vm.gridOptions.totalItems = data.data.clientCount;
                if (data.data.clientCount === 0) {
                    vm.disableData = true;
                }

                else {
                    vm.disableData = false;
                }
            });

        };

        function getByClientCode() {
            cfpLoadingBar.start();
            var request = clientService.GetByCode({
                clientCode: vm.clientDetails.ClientCode
            });
            request.$promise.then(success, failure);
        }

        vm.filterClientName = function () {
            var request = {
                ClientName: vm.selectedItem,
                ClientCode: vm.searchCode,
                PageNumber: $scope.client.paginationOptions.pageNumber,
                PageSize: $scope.client.paginationOptions.pageSize
            };

            var getClients = clientService.getClients(request)
                .then(function (result) {
                    vm.gridOptions.data = result.data.clients;
                    $scope.client.totalItems = result.data.clientCount;
                    $scope.client.totalPage = Math.ceil($scope.client.totalItems / $scope.client.pageSize);
                    vm.gridOptions.totalItems = result.data.clientCount;
                    if (result.data.clientCount !== 0)
                        vm.disableData = false;
                    else
                        vm.disableData = true;
                });
        };

        function getConvertedDate() {
            var dateofBirth = vm.clientDetails.StartDate;
            var newDate = getDateDDMMtoMMDD(dateofBirth);
            vm.clientDetails.StartDate = newDate;
        }

        function getLink() {
            return (
                '<a href="/Client/View?code={{row.entity.ClientCode}}">View</a> ' +
                "/" +
                '<a href="/Client/Edit?code={{row.entity.ClientCode}}">Edit</a> ' +
                "/" +
                ' <a href="/client/delete?code={{row.entity.ClientCode}}">Delete</a>'
            );
        }

        function getTableStyle()  {
            var marginHeight = 15;
            var length = 10;
            return {
                height: (length * vm.gridOptions.rowHeight + vm.gridOptions.headerRowHeight + marginHeight) + "px"
            };
        };       
        function querySearch(query) {
            vm.client1 = clientService.AutoSearchResult(encodeURIComponent(query));
            var log = console.log;
            log('Keybord textChange is', query);
            return vm.client1;
        };
        function textChange(query) {
            vm.client1 = clientService.AutoSearchResult(query);
            var log = console.log;
            log('Keybord textChange is', query);
            return vm.client1;
        };
    }
})();
;
(function () {
    'use strict';

    var appUI = angular.module('appUI');

    appUI.controller('dashboardCtrl', ['$compile', '$rootScope', '$scope', '$window', '$q', 'keyConstService', 'policyService', 'dateService', 'quotesService', 'sessionStorageService', 'messageConstService', 'portalV2Service', dashboardCtrl]);

    function dashboardCtrl($compile, $rootScope, $scope, $window, $q, keyConstService, policyService, dateService, quotesService, sessionStorageService, messageConstService, portalV2Service) {
        var vm = this;
        vm.Month = null;
        vm.quoteCounter = null;
        vm.policyCounter = null;
        vm.premium = null;
        vm.Status = null;
        vm.Products = null;
        vm.policyStatus = "All";
        vm.productSelect = "All";
        vm.processTypeSelect = "All";
        vm.quotePolicyQuery = quotePolicyQuery;
        vm.policyQuery = policyQuery;
        vm.applicationBanner = [];
        $scope.quote = {};
        $scope.policy = {};
        vm.effectiveFrom =  null;
        vm.effectiveTo = null;
        $scope.getParamEncrytion = getParamEncrytion;
        vm.BrokerPortalV2Debugging = false;
        vm.init = function (model) {           
            vm.applicationBanner = model.DashboardDetail.ApplicationBanner;
            sessionStorageService.remove(keyConstService.Colour);
            sessionStorage.removeItem(keyConstService.Home);
            sessionStorage.removeItem(keyConstService.Motor);
            sessionStorageService.remove(keyConstService.getTransactionIdWithoutSaving);
            sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
            sessionStorageService.remove(keyConstService.resetNonRegoData);
            sessionStorageService.remove(keyConstService.newBusinessCaseData);
            sessionStorageService.remove(keyConstService.endorsementRequestVM);
            sessionStorageService.remove(keyConstService.NVIcNotFound);
            sessionStorageService.remove(keyConstService.specialContentvalidity);
            sessionStorageService.remove(keyConstService.IsCopyQuote);
            sessionStorageService.remove(keyConstService.CopyQuoteOldTransactionId);
            sessionStorageService.remove(keyConstService.IsRenewalPolicy);
            vm.SMEHomePageQuoteListURL = model.SMEHomePageQuoteListURL;
            vm.SMEHomePagePolicyListURL = model.SMEHomePagePolicyListURL;
            vm.CommotorUrl = model.CommotorUrl;
            vm.CommercialMotorHomePageQuoteListURL = model.CommercialMotorHomePageQuoteListURL;
            vm.CommercialMotorHomePagePolicyListURL = model.CommercialMotorHomePagePolicyListURL;
            vm.BrokerPortalV2Debugging = model.BrokerPortalV2Debugging;
            sessionStorageService.remove('IsPackageManagerNavigationMode');
            sessionStorageService.remove(keyConstService.ActionButtonEnable);
            sessionStorageService.remove('RenewalCounter');
            
            $scope.quote.paginationOptions = {
                pageNumber: 1,
                pageSize: 10,
            };

            $scope.quote.currentPage = 1;
            $scope.quote.pageSize = $scope.quote.paginationOptions.pageSize;

            $scope.policy.paginationOptions = {
                pageNumber: 1,
                pageSize: 10,
            };

            $scope.policy.currentPage = 1;
            $scope.policy.pageSize = $scope.policy.paginationOptions.pageSize;
            vm.ready = true;
            vm.effectiveFrom = moment(new Date(new Date().setDate(new Date().getDate() - 30))).format("DD/MM/YYYY");
            vm.effectiveTo = moment(new Date()).format("DD/MM/YYYY");
            vm.arrayMonth = [];
            vm.demoMonth = [];
            var month = moment().format('MMM YYYY ');
            vm.Month = month;
            for (var i = 1; i <= 3; i++) {
                vm.demoMonth.push(moment().subtract(i, 'months').format('MMM YYYY '));
            }
            for (var j = 3; j >= 1; j--) {
                vm.arrayMonth.push(vm.demoMonth[j - 1]);
            }
            vm.arrayMonth.push(month);
            for (var k = 1; k <= 3; k++) {
                vm.arrayMonth.push(moment().add(k, 'months').format('MMM YYYY '));
            }

            $scope.loadPoliciesQuotesGrid();

            $scope.quoteOptions = {
                data: 'quoteData',
                paginationPageSize: $scope.quote.paginationOptions.pageSize,
                paginationPageSizes: [$scope.quote.pageSize, $scope.quote.pageSize * 2, $scope.quote.pageSize * 3],
                enablePagination: true,
                enableHorizontalScrollbar: 2,
                enableRowHeaderSelection: false,
                enableColumnMenus: false,
                gridMenuShowHideColumns: false,
                enableHiding: false,
                useExternalPagination: true,
                columnDefs: [
                    { name: 'quoteNumber', cellTemplate: getQuoteLink(), width: "225" },
                    { name: 'policyNumber', field: 'policyNumber',width: "225" },
                    { name: 'quoteType', field: 'processType', width: "230" },
                    { name: 'insuredName', width: "195" },
                    { name: 'product', cellClass: 'text-left', width: "230" },
                    { name: 'creationDate', field: 'creationDate', type: 'date', cellFilter: 'date:\'dd-MM-yyyy\'', width: "200" },
                    { name: 'effectiveDate', field: 'effectiveDate', type: 'date', cellFilter: 'date:\'dd-MM-yyyy\'', width: "200" },
                    { name: 'status', width: "200" }
                ],
                actionList: [
                    { label: "View", icon: "glyphicon-eye-open", href: 'policies/view/{{row.policyNumber}}' }
                ],
                onRegisterApi: function (gridApi) {
                    $scope.quote.gridApi = gridApi;
                    gridApi.pagination.on.paginationChanged($scope, function (newPage, pageSize) {
                        $scope.quote.paginationOptions.pageNumber = newPage;
                        $scope.quote.paginationOptions.pageSize = pageSize;
                        $scope.quote.pageSize = pageSize;
                        $scope.quote.currentPage = newPage;
                        $scope.quote.totalPage = Math.ceil($scope.quoteOptions.totalItems / $scope.quote.pageSize);
                        $scope.loadQuotes();
                    });
                }
            };

            $scope.policyOptions = {
                data: 'policyData',
                paginationPageSize: $scope.policy.paginationOptions.pageSize,
                paginationPageSizes: [$scope.policy.pageSize, $scope.policy.pageSize * 2, $scope.policy.pageSize * 3],
                enableHorizontalScrollbar: 2,
                enableRowHeaderSelection: false,
                enableColumnMenus: false,
                gridMenuShowHideColumns: false,
                enableHiding: false,
                enablePagination: true,
                useExternalPagination: true,
                columnDefs: [
                    { name: 'policyNumber', cellTemplate: getPolicyLink(), width: "230" },
                    { name: 'packageNumber', width: "200" },
                    { name: 'insuredName', width: "200" },
                    { name: 'product', cellClass: 'text-left', width: "200" },
                    { name: 'policyTerm', field: 'renewalTerm', width: "180"},
                    { name: 'creationDate', field: 'dateCreation', type: 'date', cellFilter: 'date:\'dd-MM-yyyy\'', width: "200" },
                    { name: 'startDate', field: 'startDate', type: 'date', cellFilter: 'date:\'dd-MM-yyyy\'', width: "200" },
                    { name: 'status', width: "200" }
                ],
                onRegisterApi: function (gridApi) {
                    $scope.policy.gridApi = gridApi;
                    gridApi.pagination.on.paginationChanged($scope, function (newPage, pageSize) {
                        $scope.policy.paginationOptions.pageNumber = newPage;
                        $scope.policy.paginationOptions.pageSize = pageSize;
                        $scope.policy.pageSize = pageSize;
                        $scope.policy.currentPage = newPage;
                        $scope.policy.totalPage = Math.ceil($scope.policyOptions.totalItems / $scope.policy.pageSize);
                        $scope.loadPolicies();
                    });
                }
            };
        };

        function getQuoteLink() {
            return '<a ng-if=\'row.entity.processType === "CANCELLATION" && row.entity.product !== "SME - Commercial Package" && row.entity.product !== "Commercial Motor"\' ng-click="grid.appScope.getParamEncrytion(1,row.entity.quoteTransactionId)">{{row.entity.quoteNumber}}</a>' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.product !== "SME - Commercial Package" && row.entity.product !== "Commercial Motor"\'  ng-click="grid.appScope.getParamEncrytion(2,row.entity.quoteTransactionId)">{{row.entity.quoteNumber}}</button>' +
                '<a ng-if=\'row.entity.product === "SME - Commercial Package"\'  ng-click="grid.appScope.getParamEncrytion(5,row.entity.quoteTransactionId)">{{row.entity.quoteNumber}}</button>' +
                '<a ng-if=\'row.entity.product === "Commercial Motor"\'  ng-click="grid.appScope.getParamEncrytion(7,row.entity.quoteTransactionId)">{{row.entity.quoteNumber}}</button>';
        }

        function getPolicyLink(item) {
            return '<a ng-if=\'row.entity.status === "Cancelled" && row.entity.product !== "SME - Commercial Package" && row.entity.product !== "Commercial Motor"\' ng-click="grid.appScope.getParamEncrytion(3,row.entity.policyTransactionId)">{{row.entity.policyNumber}}</a>' +
                '<a ng-if=\'row.entity.status !== "Cancelled" && row.entity.product !== "SME - Commercial Package" && row.entity.product !== "Commercial Motor"\'  ng-click="grid.appScope.getParamEncrytion(4,row.entity.policyTransactionId)">{{row.entity.policyNumber}}</button>' +
                '<a ng-if=\'row.entity.product === "SME - Commercial Package"\'  ng-click="grid.appScope.getParamEncrytion(6,row.entity.quoteTransactionId)">{{row.entity.policyNumber}}</button>' +
                '<a ng-if=\'row.entity.product === "Commercial Motor"\'  ng-click="grid.appScope.getParamEncrytion(8,row.entity.quoteTransactionId)">{{row.entity.policyNumber}}</button>';
        }

        function getParamEncrytion(mode, paramString) {
            
            if (mode === 1) {
                var encryptedParam = sessionStorageService.getEncryption("qid=" + paramString);
                $window.location.href = "/Cancellation/Quote?" + encryptedParam;
            }
            else if (mode === 2) {
                encryptedParam = sessionStorageService.getEncryption("quoteTransactionId=" + paramString);
                $window.location.href = "/QuoteCase?" + encryptedParam;
            }
            else if (mode === 3) {
                encryptedParam = sessionStorageService.getEncryption("id=" + paramString);
                $window.location.href = "/Bind/Index?" + encryptedParam;
            }
            else if (mode === 4) {
                encryptedParam = sessionStorageService.getEncryption("id=" + paramString);
                $window.location.href = "/Bind/Index?" + encryptedParam;
            }
            else if (mode === 5 || mode === 6) {
                encryptedParam = sessionStorageService.getEncryption("quoteTransactionId=" + paramString);
                var url = null;
                if (mode === 5) {
                    url = vm.SMEHomePageQuoteListURL;
                }
                else {
                    url = vm.SMEHomePagePolicyListURL;
                }
                portalV2Service.getV2Token().then(function (resp) {
                    portalV2Service.setKeyToLocalStorage(resp.data.data);
                    $window.location.href = window.location.protocol + '//' + window.location.host + url + '?' + encryptedParam;
                });
            }
            else if (mode === 7) {
                encryptedParam = sessionStorageService.getEncryption("quoteTransactionId=" + paramString + '&productId=' + keyConstService.CommercialMotorProductId);
                portalV2Service.getV2Token().then(function (resp) {
                    var redirectTo = vm.CommercialMotorHomePageQuoteListURL + '/' + encryptedParam;
                    portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                });
            }
            else if (mode === 8) {
                encryptedParam = sessionStorageService.getEncryption("quoteTransactionId=" + paramString + '&productId=' + keyConstService.CommercialMotorProductId);
                portalV2Service.getV2Token().then(function (resp) {
                    var redirectTo = vm.CommercialMotorHomePagePolicyListURL + '/' + encryptedParam;
                    portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                }); 
            }
    }
    
        $(document).ready(function () {
            $('[data-toggle="tooltip"]').tooltip();
        });

        function quotePolicyQuery(dateToValidate, isFrom) {

            var mEffectiveFromDate = moment(vm.effectiveFrom, 'DD/MM/YYYY').toDate();
            var mEffectiveToDate = moment(vm.effectiveTo, 'DD/MM/YYYY').toDate();
            if ((mEffectiveFromDate > mEffectiveToDate) && dateToValidate) {
                toastr.warning(messageConstService.errDashboardRangeDate);
                return;
            }
            var currentDate = new Date();
            var minDate = new Date();
            minDate.setDate(minDate.getDate() - 90);
            var maxDate = new Date();
            maxDate.setDate(maxDate.getDate() + 60);
            var dateRangeResponse = dateService.validateDateRange(dateToValidate, minDate, maxDate);
            if (!dateRangeResponse.isValid && dateToValidate) {
                toastr.warning(messageConstService.errDateNotAllowed);
                if (isFrom) {
                    vm.effectiveFrom = '';
                }
                else {
                    vm.effectiveTo = '';
                }
                return;
            }
            if (!dateToValidate && typeof(isFrom) !== 'undefined') {
                return;
            }
            if (vm.productSelect === null) {
                vm.productSelect = "All";
            }
            if (vm.processTypeSelect === null) {
                vm.processTypeSelect = "All";
            }
            $scope.quote.paginationOptions = {
                pageNumber: 1,
                pageSize: 10,
            };
            $scope.policy.paginationOptions = {
                pageNumber: 1,
                pageSize: 10,
            };
            $scope.policyOptions.paginationCurrentPage = $scope.policy.paginationOptions.pageNumber;
            $scope.quoteOptions.paginationCurrentPage = $scope.quote.paginationOptions.pageNumber;
            $scope.policyOptions.paginationPageSize = $scope.policy.paginationOptions.pageSize;
            $scope.quoteOptions.paginationPageSize = $scope.quote.paginationOptions.pageSize;
            $scope.quote.pageSize = 1;
            $scope.loadPoliciesQuotesGrid();
        }

        function policyQuery() {
            if (vm.Month === null) {
                vm.Month = moment().format('MMM YYYY ');
            }
            if (vm.policyStatus === null) {
                vm.policyStatus = "All";
            }
            $scope.loadPolicies();
        }
       
        

        $scope.loadQuotes = function () {
            quotesService.getQuotes(vm.effectiveFrom, vm.effectiveTo, $scope.quote.paginationOptions.pageNumber, $scope.quote.paginationOptions.pageSize, vm.productSelect, vm.processTypeSelect).then(function (data) {
                $scope.quoteData = data.data.dashboarQuoteList;
                $scope.quoteOptions.totalItems = data.data.dashboarQuoteListCount;
                $scope.quote.totalPage = Math.ceil($scope.quoteOptions.totalItems / $scope.quote.pageSize);
            });
        };

        $scope.loadPolicies = function () {
            var status = vm.policyStatus;

            if (vm.policyStatus === 'Endorsement Pending') {
                status = 'EndorsementPending';
            }
            else if (vm.policyStatus === 'Cancellation Pending') {
                status = 'CancellationPending';
            }

            policyService.getPolicies(vm.effectiveFrom, vm.effectiveTo, $scope.policy.paginationOptions.pageNumber, $scope.policy.paginationOptions.pageSize, vm.productSelect, status).then(function (data) {
                $scope.policyData = data.data.dashboarPolicyList;
                $scope.policyOptions.totalItems = data.data.dashboardPolicyListCount;
                $scope.policy.totalPage = Math.ceil($scope.policyOptions.totalItems / $scope.policy.pageSize);
                vm.policyCounter = data.data.policyCount;
            });
        };

        $scope.loadPoliciesQuotesGrid = function () {
            var status = vm.policyStatus;

            if (vm.policyStatus === 'Endorsement Pending') {
                status = 'EndorsementPending';
            }
            else if (vm.policyStatus === 'Cancellation Pending') {
                status = 'CancellationPending';
            }

            policyService.getPoliciesQuotes(vm.effectiveFrom, vm.effectiveTo, $scope.quote.paginationOptions.pageNumber, $scope.quote.paginationOptions.pageSize, vm.productSelect, status, vm.processTypeSelect).then(function (data) {
                $scope.quoteData = data.data.dashboarQuoteList;
                $scope.policyData = data.data.dashboarPolicyList;
                vm.quoteCounter = data.data.quoteCount;
                vm.policyCounter = data.data.policyCount;
                vm.premium = data.data.premium;
                vm.Products = data.data.productList;
                vm.Status = data.data.status;
                vm.ProcessType = data.data.processType;
                $scope.policyOptions.totalItems = data.data.dashboardPolicyListCount;
                $scope.policy.totalPage = Math.ceil($scope.policyOptions.totalItems / $scope.policy.pageSize);
                $scope.quoteOptions.totalItems = data.data.dashboarQuoteListCount;
                $scope.quote.totalPage = Math.ceil($scope.quoteOptions.totalItems / $scope.quote.pageSize);
            })
            angular.element('carousel').carousel({ interval: 10000});
        };
    }
})();;
(function () {
    'use strict';

    var appUI = angular.module('appUI');
    appUI.controller('newBusinessCtrl', ['$rootScope', '$q', 'responsiveService', 'sessionStorageService', 'apiUrlConstService', 'dateService', '$http', '$log', 'messageConstService', 'keyConstService', 'webUrlConstService', 'stringService', '$window', 'quoteCaseService', 'packageService', 'clientService', 'portalV2Service', '$mdDialog', newBusinessCtrl]);

    function newBusinessCtrl($rootScope, $q, responsiveService, sessionStorageService, apiUrlConstService, dateService, $http, $log, messageConstService, keyConstService, webUrlConstService, stringService, $window, quoteCaseService, packageService, clientService, portalV2Service, $mdDialog) {
        var vm = this;
        vm.data = null;
        vm.existingPackage = false;
        vm.automaticPayment = false;
        vm.selectedItem = null;
        vm.searchText = null;
        vm.isNonAnnualTerm = false;
        vm.isEditEnabled = false;
        vm.today;
        vm.effevctiveDate;
        vm.getProduct;
        vm.packages;
        vm.getCoverage = null;
        vm.selectCoverage;
        vm.selectedPackage;
        vm.selectedProduct;
        vm.DisableProductDDL = false;
        vm.DisableAutomaticPayment = false;
        vm.IsReadOnly = false;
        var quoteTransactionId = 0;
        var newBusinessCaseData = null;
        vm.init = init;
        vm.querySearch = querySearch;
        vm.textChange = textChange;
        vm.onPackageChange = onPackageChange;
        vm.validateEffective = validateEffective;
        vm.resetExistingPackage = resetExistingPackage;
        vm.onProductChange = onProductChange;
        vm.next = next;
        vm.onEffectiveDateChange = onEffectiveDateChange;
        vm.searchClient = searchClient;
        vm.addClient = addClient;
        vm.validateExpiration = validateExpiration;
        vm.isDisabledDate = false;
        vm.showPackageDetail = false;
        vm.IsNewPackage = true;
        vm.instalmentDayOfMonthList = [];
        var quoteTransactionDetail = null;
        vm.paymentType;
        vm.installmentDate;
        var upperBounds;
        vm.PolicyBoundWithPackage = false;
        var resetNonRegoData = false;
        var getEffectiveDate;
        vm.transactionId = 0;
        vm.IsExpirationDateEditable = true;
        vm.IsPaymentEditable = true;
        vm.IsEffectiveDateEditable = true;
        vm.IsPackageEditable = true;
        vm.onPaymentChange = onPaymentChange;
        vm.EffectiveDateOnProductChange = EffectiveDateOnProductChange;
        vm.clients;
        vm.selectedInsuredId;
        vm.selectedInsured;
        vm.setSelectedInsured = setSelectedInsured;
        vm.SelectedProductChangeSME = SelectedProductChangeSME;
        vm.DDLProcessTypeId = null;
        vm.showManagePkg = false;
        vm.continueOrNavigateBackToPackageManager = continueOrNavigateBackToPackageManager;
        vm.primaryClient = null;
        vm.selectedPackageId = null;
        vm.renewalCounterFlag = 0;
        vm.PackageIdOnPrevious = 0;
        vm.packageEffectiveDate;
        vm.isHome = false;
        vm.isMotor = false;
        vm.isLandLordEssentials = false;
        vm.isLandLordADLE = false;
        vm.isPA = false;
        vm.IsPASelected = false;
        vm.isSME = false;
        vm.isCommMotor = false;
        ///vm.IsCommMotorSelected = false;
        vm.isCyber = false;
        vm.isCyberSelected = false;
        vm.effectiveDate = null;
        vm.clientSelect = clientSelect;
        vm.secondryclientType = null;
        vm.BrokerPortalV2Debugging = false;

        $('#mycheckbox').change(function () {
            $('#mycheckboxdiv').toggle();
        });
        vm.IsCopyQuote = false;

        function setSelectedInsured() {
            vm.clients.forEach(function (item, index) {
                if (parseInt(item.value) === vm.selectedInsuredId) {

                    vm.selectedInsured = item;
                    if (vm.selectedProduct && vm.selectedProduct.Description === 'SME - Commercial Package') {
                        if (vm.selectedInsured && vm.selectedInsured.clientType !== 'Business') {
                            vm.selectedProduct.Description = null;
                            vm.selectedInsuredId = "";
                            var error = messageConstService.errSelectedInsured
                            toastr.error(messageConstService.errSelectedInsured);
                            $log.error('error', error);
                        }
                    }
                    if (vm.selectedProduct && vm.selectedProduct.Description === 'Cyber') {
                        if (vm.selectedInsured && vm.selectedInsured.clientType !== 'Business') {
                            vm.selectedProduct = null;
                            vm.selectedInsuredId = "";
                            var error = messageConstService.errSelectedInsured
                            toastr.error(messageConstService.errSelectedInsured);
                            $log.error('error', error);
                        }
                    }
                    if (vm.selectedProduct && vm.selectedProduct.Description === 'Personal Accident') {
                        if (vm.selectedInsured.clientType !== 'Individual') {
                            vm.selectedInsuredId = "";
                            var error = messageConstService.errSelectedInsuredNotIndividual
                            toastr.error(messageConstService.errSelectedInsuredNotIndividual);
                            $log.error('error', error);
                        }
                    }

                }
            });
            effectiveDateWiseProductVisibility();
        };

        function querySearch(query) {
            return $http.get(apiUrlConstService.clientURL + 'GetClientAllSearch?searchClient=' + encodeURIComponent(query), { skipInterceptor: true })
                .then(function (result) {
                    vm.data = result.data.data;
                    // store information of primary client to find primary insured id at client selection
                    vm.primaryClient = vm.data;
                    vm.client1 = [];
                    if (vm.data) {
                        var arr = vm.data;
                        vm.client1 = arr.map(function (val, i, arr) {
                            return val.fullName + "(" + val.clientCode + ")";
                        });
                    }
                    return vm.client1;
                });
        };

        function textChange(field) {

            if (vm.selectedItem === null) {
                field.$setValidity('invalid', false);
                vm.selectedInsuredId = "";
            }
            else {
                field.$setValidity('invalid', true);

                getInsuredClients();

                //get the packages for the selected the client.
                if (vm.transactionId === 0) {
                    packageService.getClientPackages(vm.selectedItem).then(function (data) {
                        if (data.status) {

                            //getting start date and end date for each package. 
                            for (var i = 0; i < data.data.length; i++) {
                                data.data[i].effectiveYear = moment(data.data[i].startDate).format('YYYY');
                                data.data[i].expirationYear = moment(data.data[i].expirationDate).format('YY');
                            }
                            if (vm.IsCopyQuote) {
                                var paymentFrequency = vm.packages.paymentFrequency;
                                var instalmentDate = vm.packages.InstallmentDate;
                            }
                          
                            var allpackages = data.data
                            vm.packages = allpackages.filter(function (val) {
                                return val.isCommercial == false;
                            });

                            if (vm.IsCopyQuote) {
                                vm.packages.paymentFrequency = paymentFrequency;
                                if (vm.packages.paymentFrequency === 'Monthly')
                                    vm.packages.InstallmentDate = instalmentDate;
                            }
                        }
                    }, function (error) {
                        $log.log('error', error);
                        toastr.error(messageConstService.errServiceUnavailable);
                    });
                }
            }
        }

        function onPackageChange() {
            var selectedPackageNumber = "";
            var selectedPackageid = vm.selectedPackageId;
            var packagesArr = [];
            packagesArr = vm.packages;
            if (selectedPackageid) {
                //var selectedPackageDetail = packagesArr.filter(function (val) {
                //    return val.id === selectedPackageNumber;
                //});
                var selectedPackageDetail = packagesArr.filter(function (val) {
                    return val.id === selectedPackageid;
                });

                vm.showPackageDetail = true;
                vm.selectedPackage = selectedPackageDetail[0].packageNumber;
                vm.expirationDate = selectedPackageDetail[0].expirationDate;
                vm.packages.paymentFrequency = selectedPackageDetail[0].paymentFrequency;
                vm.packages.InstallmentDate = selectedPackageDetail[0].installmentDate;
                vm.automaticPayment = selectedPackageDetail[0].brokerManagedPayment == false ? true : false;
                vm.IsPaymentEditable = vm.IsExpirationDateEditable = false;
                vm.DisableAutomaticPayment = true;
                vm.IsNewPackage = false;
                vm.renewalCounterFlag = selectedPackageDetail[0].renewalCounter;
                vm.packageEffectiveDate = moment(selectedPackageDetail[0].startDate).format("YYYY/MM/DD");

                if (vm.packages.paymentFrequency === 'Monthly') {
                    var expirationDate = dateService.getExpiryDateMoment(vm.expirationDate);
                    var expirationDateMoment = dateService.getMomentDateforDDMM(expirationDate);
                    if (vm.minExpirationDate && expirationDateMoment < vm.minExpirationDate.minExpirationDate) {
                        toastr.error(messageConstService.errMinExpirationDateInstallment);
                        setEffectiveDate();
                        vm.minExpirationDate = null;
                        return;
                    }
                }

                if (vm.effectiveDate) {
                    vm.expirationDate = dateService.getExpiryDateMoment(vm.expirationDate);
                    validateEffective();
                }

            }
        };

        function resetExistingPackage() {
            vm.selectedPackage = null;
            vm.packageDescription = null;
            vm.paymentType = null;
            vm.installmentDate = null;
            vm.IsNewPackage = true;
            vm.selectedPackageId = null;
            if (vm.packages) {
                vm.packages.paymentFrequency = null;
                vm.packages.InstallmentDate = null;
            }
            vm.automaticPayment = false;
            if (vm.selectedPackage === null || vm.selectedPackage === undefined) {
                vm.IsPaymentEditable = vm.IsEffectiveDateEditable = vm.IsExpirationDateEditable = true;
                vm.DisableAutomaticPayment = false;
            }

            effectiveDateWiseProductVisibility();
        };

        //get the getFilteredCoverage on Product Change //now obsolete
        function onProductChange() {
            vm.getFilteredCoverage = [];
            var currentSelectedProduct = vm.selectedProduct;

            var products = [];
            products = vm.getProduct;

            for (var i = 0; i < products.length; i++) {
                $log.log(products[i]);
                if (products[i].ProductCode === currentSelectedProduct.ProductCode) {
                    var getProductVersionId = vm.getProduct[i].ProductVersionId;

                    var coveragesFilterd1 = [];

                    vm.getCoverage.forEach(function (item, index) {
                        if (item.ProductVersionId === getProductVersionId) {

                            var coveragesFilterd = item;
                            vm.getFilteredCoverage.push(coveragesFilterd);
                        }
                    });

                }
            }
        };

        function SelectedProductChangeSME() {
            //vm.existingPackage = false;
            //resetExistingPackage();
            var seperateDate = null;
            //vm.IsCommMotorSelected = false;     
            if (vm.selectedProduct) {
                // Changes Related to SME, about product retaining on NB
                var products = angular.copy(vm.getProduct);
                products.forEach((element) => {
                    if (element.Description === vm.selectedProduct.Description) {
                        vm.selectedProduct = element;
                    }
                });
            }

            if (vm.selectedProduct && vm.selectedProduct.Description === 'Motor') {
                seperateDate = dateService.getSeperatedDate(keyConstService.MotorLiveDate);
                vm.IsPASelected = false;
            }
            else if (vm.selectedProduct && vm.selectedProduct.Description === 'Home') {
                seperateDate = dateService.getSeperatedDate(keyConstService.HomeLiveDate);
                vm.IsPASelected = false;
            }
            else if (vm.selectedProduct && (vm.selectedProduct.Description === 'Landlord – Essentials' || vm.selectedProduct.Description === 'Landlord – AD and LE')) {
                seperateDate = dateService.getSeperatedDate(keyConstService.LandlordsLiveDate);
                vm.IsPASelected = false;
            }
            else if (vm.selectedProduct && vm.selectedProduct.Description === 'SME - Commercial Package') {
                if (vm.selectedInsured && vm.selectedInsured.clientType !== 'Business') {
                    vm.selectedProduct.Description = null;
                    vm.selectedInsuredId = "";
                    var error = messageConstService.errSelectedInsured
                    toastr.error(messageConstService.errSelectedInsured);
                    $log.error('error', error);
                }
            }
            // Live date for PA in key const service which will block the calander to that date on newbusiness screen
            else if (vm.selectedProduct && vm.selectedProduct.Description === keyConstService.PaProductDescription) {
                seperateDate = dateService.getSeperatedDate(keyConstService.PaLiveDate);
                if (vm.selectedInsured && vm.selectedInsured.clientType !== 'Individual') {
                    vm.selectedProduct = null;
                    vm.selectedInsuredId = "";
                    var error = messageConstService.errSelectedInsuredNotIndividual
                    toastr.error(messageConstService.errSelectedInsuredNotIndividual);
                    $log.error('error', error);
                }
                vm.IsPASelected = true;
            }
            else if (vm.selectedProduct && vm.selectedProduct.Description === keyConstService.CommercialMotorProductDescription) {
                seperateDate = dateService.getSeperatedDate(keyConstService.CommercialMotorLiveDate);
                if (vm.packages !== null) {
                    vm.automaticPayment = false;
                }
              
                //vm.IsCommMotorSelected = true;
            }
            else if (vm.selectedProduct && vm.selectedProduct.Description === keyConstService.CyberProductDescription) {
                seperateDate = dateService.getSeperatedDate(keyConstService.CyberLiveDate);
                if (vm.selectedInsured && vm.selectedInsured.clientType !== 'Business') {
                    vm.selectedProduct = null;
                    vm.selectedInsuredId = "";
                    var error = messageConstService.errSelectedInsured
                    toastr.error(messageConstService.errSelectedInsured);
                    $log.error('error', error);
                }
                vm.isCyberSelected = true;
            }

            if (seperateDate) {
                vm.licenseAcquireDay = seperateDate.Day;
                vm.licenseAcquireMonth = seperateDate.Month;
                vm.licenseAcquireYear = seperateDate.Year;
                //vm.effectiveDate = '';
            }
            onEffectiveDateChange(true);

        }

        function EffectiveDateOnProductChange() {
            var seperateDate = null;
            if (vm.selectedProduct && vm.selectedProduct.Description === 'Motor') {
                seperateDate = dateService.getSeperatedDate(keyConstService.MotorLiveDate);

            }
            else if (vm.selectedProduct && vm.selectedProduct.Description === 'Home') {
                seperateDate = dateService.getSeperatedDate(keyConstService.HomeLiveDate);
            }
            else if (vm.selectedProduct && (vm.selectedProduct.Description === 'Landlord – Essentials' || vm.selectedProduct.Description === 'Landlord – AD and LE')) {
                seperateDate = dateService.getSeperatedDate(keyConstService.LandlordsLiveDate);
            }
            else if (vm.selectedProduct && vm.selectedProduct.Description === 'SME - Commercial Package') {
                seperateDate = dateService.getSeperatedDate(keyConstService.LandlordsLiveDate);
                if (vm.selectedInsured != null && vm.selectedInsured.clientType !== 'Business') {
                    vm.selectedInsuredId = "";
                    var error = messageConstService.errSelectedInsured
                    toastr.error(messageConstService.errSelectedInsured);
                    $log.error('error', error);
                }
            }
            // Live date for PA in key const service which will block the calander to that date on newbusiness screen
            else if (vm.SelectedProduct === keyConstService.PaProductDescription) {
                seperateDate = dateService.getSeperatedDate(keyConstService.PaLiveDate);

            }
            else if (vm.SelectedProduct === keyConstService.CommercialMotorProductDescription) {
                seperateDate = dateService.getSeperatedDate(keyConstService.CommercialMotorLiveDate);
                //vm.IsCommMotorSelected = true;
            }
            else if (vm.selectedProduct && vm.selectedProduct.Description === keyConstService.CyberProductDescription) {
                seperateDate = dateService.getSeperatedDate(keyConstService.CyberLiveDate);
                if (vm.selectedInsured != null && vm.selectedInsured.clientType !== 'Business') {
                    vm.selectedInsuredId = "";
                    var error = messageConstService.errSelectedInsured
                    toastr.error(messageConstService.errSelectedInsured);
                    $log.error('error', error);
                }
            }

            if (seperateDate) {
                vm.licenseAcquireDay = seperateDate.Day;
                vm.licenseAcquireMonth = seperateDate.Month;
                vm.licenseAcquireYear = seperateDate.Year;
                vm.effectiveDate = '';
            }
        }

        function effectiveDateWiseProductVisibility() {
            var textdates = vm.effectiveDate;
            if (textdates) {
                let existingPackage = vm.existingPackage;
                let textdate = moment(textdates, 'DD/MM/YYYY');
                if (textdate._isValid == false) {
                    textdate = moment(textdates.toString().substring(0, 10), 'YYYY/MM/DD')
                }

                if (vm.selectedProduct != null) {
                    let currentProduct = vm.getProduct.filter(x => x.Id === vm.selectedProduct.Id)[0];
                    
                    if (existingPackage && currentProduct.IsCommercial)
                    {
                        vm.selectedProduct = null;
                    }
                    else if (currentProduct) {
                        let brokerbranchproductstartdate = moment(currentProduct.BrokerBranchProductStartDate.toString().substring(0, 10), 'YYYY/MM/DD');
                        let brokerbranchproductenddate = moment(currentProduct.BrokerBranchProductEndDate.toString().substring(0, 10), 'YYYY/MM/DD');
                        let productstartdate = moment(currentProduct.StartDate.toString().substring(0, 10), 'YYYY/MM/DD');
                        let productenddate = moment(currentProduct.EndDate.toString().substring(0, 10), 'YYYY/MM/DD');
                        let isActive = currentProduct.IsActive;
                        if (vm.DisableProductDDL && !(isActive && brokerbranchproductstartdate <= textdate && brokerbranchproductenddate >= textdate && productstartdate <= textdate && productenddate >= textdate)) {
                            toastr.warning(messageConstService.errDateInvalidDueToProduct);
                            vm.effectiveDate = '';
                            return;
                        }
                    }
                }

                hideproducts();
                if (vm.getProduct.length > 0) {
                    for (var j = 0; j < vm.getProduct.length; j++) {
                        let currentProduct = vm.getProduct[j];
                        let brokerbranchproductstartdate = moment(currentProduct.BrokerBranchProductStartDate.toString().substring(0, 10), 'YYYY/MM/DD');
                        let brokerbranchproductenddate = moment(currentProduct.BrokerBranchProductEndDate.toString().substring(0, 10), 'YYYY/MM/DD');
                        let productstartdate = moment(currentProduct.StartDate.toString().substring(0, 10), 'YYYY/MM/DD');
                        let productenddate = moment(currentProduct.EndDate.toString().substring(0, 10), 'YYYY/MM/DD');
                        let isActive = currentProduct.IsActive;

                        if (existingPackage && currentProduct.IsCommercial) {                            
                            break;
                        }

                        if (isActive && brokerbranchproductstartdate <= textdate && brokerbranchproductenddate >= textdate && productstartdate <= textdate && productenddate >= textdate) {
                            if (currentProduct.Description === "Home" && textdate >= moment(keyConstService.HomeLiveDate, 'DD/MM/YYYY')) {
                                vm.isHome = true;
                            }
                            else if (currentProduct.Description === "Motor" && textdate >= moment(keyConstService.MotorLiveDate, 'DD/MM/YYYY')) {
                                vm.isMotor = true;
                            }
                            else if (currentProduct.Description === "Landlord – Essentials" && textdate >= moment(keyConstService.LandlordsLiveDate, 'DD/MM/YYYY')) {
                                vm.isLandLordEssentials = true;
                            }
                            else if (currentProduct.Description === "Landlord – AD and LE" && textdate >= moment(keyConstService.LandlordsLiveDate, 'DD/MM/YYYY')) {
                                vm.isLandLordADLE = true;
                            }
                            else if (vm.getProduct[j].Description === "Personal Accident" && textdate >= moment(keyConstService.PaLiveDate, 'DD/MM/YYYY')) {
                                let changePA = false;
                                if (vm.primaryClient != null) {
                                    let primaryclient = vm.primaryClient.filter(function (obj) {
                                        if (vm.selectedItem.toString().search(obj.clientCode) != -1) {
                                            return true;
                                        }
                                    });
                                    changePA = primaryclient[0].clientType === "Individual" ? true : false;
                                }
                                else if (vm.selectedInsured != null) {
                                    let primaryaddedclient = vm.clients.filter(function (obj) {
                                        let val = vm.selectedItem.toString();
                                        if (val.search(obj.name) != -1) {
                                            return true;
                                        }
                                    });

                                    let a = primaryaddedclient[0].clientType === "Individual";
                                    changePA = vm.selectedInsured.clientType === "Individual" && primaryaddedclient[0].clientType === "Individual" ? true : false;
                                }
                                else if (vm.secondryclientType != null) {
                                    changePA = vm.secondryclientType === "Individual" ? true : false;
                                }

                                if (!vm.caseData) {
                                    if (changePA) {
                                        vm.isPA = true;
                                    }
                                    else {
                                        vm.isPA = false;
                                    }
                                }
                                else {
                                    vm.isPA = true;
                                }
                            }
                            else if (vm.getProduct[j].Description === "Commercial Motor" && textdate >= moment(keyConstService.CommercialMotorLiveDate, 'DD/MM/YYYY')) {
                                vm.isCommMotor = true;                              
                            }
                            else if (currentProduct.Description === "Cyber" && textdate >= moment(keyConstService.CyberLiveDate, 'DD/MM/YYYY')) {
                                let change = false;
                                if (vm.primaryClient != null) {
                                    let primaryclient = vm.primaryClient.filter(function (obj) {
                                        if (vm.selectedItem.toString().search(obj.clientCode) != -1) {
                                            return true;
                                        }
                                    });
                                    change = primaryclient[0].clientType === "Business" ? true : false;
                                }
                                else if (vm.selectedInsured != null) {
                                    let primaryaddedclient = vm.clients.filter(function (obj) {
                                        let val = vm.selectedItem.toString();
                                        if (val.search(obj.name) != -1) {
                                            return true;
                                        }
                                    });

                                    let a = primaryaddedclient[0].clientType === "Business";
                                    change = vm.selectedInsured.clientType === "Business" && primaryaddedclient[0].clientType === "Business" ? true : false;                                                                        
                                }
                                else if (vm.secondryclientType != null) {
                                    change = vm.secondryclientType === "Business"  ? true : false;
                                }

                                if (!vm.caseData) {

                                    if (change) {
                                        vm.isCyber = true;
                                    }
                                    else {
                                        vm.isCyber = false;
                                        if (vm.selectedProduct != null && vm.selectedProduct.Id === 51) {
                                            vm.selectedProduct = null;
                                        }
                                    }
                                }
                                else {
                                    vm.isCyber = true;
                                }
                            }
                            else if (currentProduct.Description === "SME - Commercial Package" && textdate >= moment(keyConstService.LandlordsLiveDate, 'DD/MM/YYYY')) {
                                vm.isSME = true;
                            }
                        }
                    }
                }
            }
        }

        function ProductEffectiveDatecommonfunction(textdate, callforproduct = false) {
            
            if (vm.selectedProduct) {
                if (vm.selectedProduct.Description === 'Motor') {
                    vm.LiveDate = keyConstService.MotorLiveDate;

                }
                else if (vm.selectedProduct.Description === 'Home') {
                    vm.LiveDate = keyConstService.HomeLiveDate;
                }
                else if (vm.selectedProduct.Description === 'Landlord – Essentials' || vm.selectedProduct.Description === 'Landlord – AD and LE') {
                    vm.LiveDate = keyConstService.LandlordsLiveDate;
                }
                else if (vm.selectedProduct.Description === keyConstService.PaProductDescription) {
                    vm.LiveDate = keyConstService.PaLiveDate;
                }
                else if (vm.selectedProduct.Description === keyConstService.CommercialMotorProductDescription) {
                    vm.LiveDate = keyConstService.CommercialMotorLiveDate;
                    //vm.IsCommMotorSelected = true;
                }
                else if (vm.selectedProduct.Description === keyConstService.CyberProductDescription) {
                    vm.LiveDate = keyConstService.CyberLiveDate;
                }
            }

            if (vm.effectiveDate && vm.selectedProduct) {
                var LiveDateMoment = moment(vm.LiveDate, 'DD/MM/YYYY');
                var effectiveDateMoment = moment(vm.effectiveDate, 'DD/MM/YYYY');
                if (effectiveDateMoment < LiveDateMoment) {
                    toastr.warning(messageConstService.errEffectiveDateNotAllowed);
                    hideproducts();
                    vm.effectiveDate = '';
                    return;
                }
            }

            var dateRangeResponse = dateService.validateRange("days", vm.daysInEffectiveDateBeforeCurrentDate, vm.daysInEffectiveDateAfterCurrentDate, textdate);
            if (!dateRangeResponse.isValid) {
                toastr.warning(messageConstService.errEffectiveDateNotAllowed);
                hideproducts();
                vm.effectiveDate = '';
                return;
            }

            // validate date based on live date for various products
            checkValidExpiratonDate();
            validateEffective();

            if (!vm.existingPackage) {
                var expiration_date = dateService.add(textdate, 1, 'years');
                let forproductchange = true
                if (callforproduct) { forproductchange = vm.expirationDate == undefined ? true : expiration_date == vm.expirationDate; }
                vm.expirationDate = vm.IsExpirationDateEditable == true && forproductchange ? expiration_date : vm.expirationDate;
                var expirationDateM = moment(vm.expirationDate, 'DD/MM/YYYY');
                if (vm.minExpirationDate && expirationDateM < vm.minExpirationDate.minExpirationDate && vm.packages !== null && vm.packages.paymentFrequency === 'Monthly') {
                    toastr.error(messageConstService.errMinExpirationDateInstallment);
                    setEffectiveDate();
                    vm.minExpirationDate = null;
                    return;
                }
            }

        }

        function init(CreateVM) {
            vm.isPckg = JSON.parse(sessionStorageService.get(keyConstService.IsPackageManagerNavigationMode));
            if (vm.isPckg !== "preTrue") {
                sessionStorageService.remove('IsPackageManagerNavigationMode');
                sessionStorageService.remove('RenewalCounter');
            }
            else {
                sessionStorageService.set(keyConstService.IsPackageManagerNavigationMode, "true");
                vm.showManagePkg = true;
            }
            sessionStorage.removeItem(keyConstService.Home);
            sessionStorage.removeItem(keyConstService.Motor);
            if (sessionStorageService.get(keyConstService.newBusinessCaseData) === "null" || sessionStorageService.get(keyConstService.newBusinessCaseData) === undefined) {
                sessionStorageService.remove(keyConstService.specialContentvalidity);
            }
            for (var i = 1; i <= 28; i++) {
                vm.instalmentDayOfMonthList.push({ Value: i.toString(), Text: i });
            }

            if (CreateVM.IsCopyQuote) {
                sessionStorageService.set(keyConstService.IsCopyQuote, true);
                CreateVM.IsCopyQuote = vm.IsCopyQuote = true;
                if (CreateVM.Packages[0].RenewalCounter > 0)
                    sessionStorageService.set(keyConstService.IsRenewalPolicy, true);
            }
            else {
                sessionStorageService.remove(keyConstService.IsCopyQuote);
                CreateVM.IsCopyQuote = vm.IsCopyQuote = false;
            }
            vm.selectedProduct = null;
            vm.IsAnnual = CreateVM.IsAnnual;
            vm.getProduct = CreateVM.Products;
            vm.selectCoverage = null;
            vm.getCoverage = CreateVM.Coverages;
            vm.packages = CreateVM.Packages;
            vm.numberOfDays = 5;
            vm.IsCopyQuote = CreateVM.IsCopyQuote;
            vm.daysInEffectiveDateBeforeCurrentDate = CreateVM.DaysInEffectiveDateBeforeCurrentDate;
            vm.daysInEffectiveDateAfterCurrentDate = CreateVM.DaysInEffectiveDateAfterCurrentDate;
            vm.minDaysinExpirationFromCurrentDate = CreateVM.MinDaysinExpirationFromCurrentDate;
            vm.licenseAcquireDay = CreateVM.LicenseAcquireDay;
            vm.licenseAcquireMonth = CreateVM.LicenseAcquireMonth;
            vm.licenseAcquireYear = CreateVM.LicenseAcquireYear;
            vm.product = 'all';
            vm.isInstallment = CreateVM.IsInstallment;
            vm.isAnnual = CreateVM.IsAnnual;
            quoteTransactionId = CreateVM.TransactionId;
            vm.SMENewBusinessUrl = CreateVM.SMENewBusinessUrl;
            vm.CommercialMotorNewBusinessUrl = CreateVM.CommercialMotorNewBusinessUrl;
            vm.CommercialMotorEditQuoteURL = CreateVM.CommercialMotorEditQuoteURL;
            if (!CreateVM.IsCopyQuote)
                vm.TransactionId = CreateVM.TransactionId;
            else
                vm.TransactionId = 0;
            vm.DDLProcessTypeId = CreateVM.DDLProcessTypeId;
            vm.isHome = false;
            vm.isMotor = false;
            vm.isLandLordEssentials = false;
            vm.isLandLordADLE = false;
            vm.isPA = false;
            vm.isCommMotor = false;
            vm.isCyber = false;
            vm.isSME = false;
            vm.BrokerPortalV2Debugging = CreateVM.BrokerPortalV2Debugging;

            if (CreateVM.TransactionId !== 0) {
                vm.IsPackageEditable = JSON.parse(sessionStorageService.get(keyConstService.IsPackageEditable)) === null || JSON.parse(sessionStorageService.get(keyConstService.IsPackageEditable)) === undefined ? true : JSON.parse(sessionStorageService.get(keyConstService.IsPackageEditable));
                vm.IsEffectiveDateEditable = vm.IsExpirationDateEditable = vm.IsPaymentEditable = vm.IsPackageEditable;
                if (CreateVM.IsCopyQuote === false) {
                    vm.isEditEnabled = true;
                    vm.DisableProductDDL = true;
                    //  View Case
                    vm.IsReadOnly = JSON.parse(sessionStorageService.get(keyConstService.IsNewBusinessReadOnly));
                    if (vm.IsReadOnly === true) {
                        vm.isDisabledDate = true;
                    }
                }
                var newBusinessCaseDataString = sessionStorageService.get(keyConstService.newBusinessCaseData);
                newBusinessCaseData = JSON.parse(newBusinessCaseDataString);
                vm.packages = {};
                //For edit we have to get effective date from session
                if (newBusinessCaseData) {
                    vm.effectiveDate = dateService.getDateMMDDtoDDMM(newBusinessCaseData.data.EffectiveDate);
                    vm.expirationDate = dateService.getDateMMDDtoDDMM(newBusinessCaseData.data.ExpirationDate);
                    vm.packages.paymentFrequency = newBusinessCaseData.data.PaymentFrequency;
                    vm.packages.InstallmentDate = newBusinessCaseData.data.InstallmentDate;
                    checkValidExpiratonDate();
                }
                if (CreateVM.Packages != null) {
                    vm.automaticPayment = CreateVM.Packages["0"].BrokerManagedPayment == false ? true : false;
                    vm.PackageIdOnPrevious = CreateVM.Packages["0"].Id;
                }

                //ToDO:if not found then load from server.
                quoteCaseService.get(CreateVM.TransactionId, CreateVM.IsCopyQuote).then(function (data) {
                    if (data.status) {
                        newBusinessCaseData = data.data;
                        quoteTransactionDetail = data.data.quoteTransactionData;
                        if (newBusinessCaseData.quoteTransactionData) {
                            if (newBusinessCaseData.quoteTransactionData.id === CreateVM.TransactionId) {
                                //bind  the data to the fields

                                vm.caseData = newBusinessCaseData.data;
                                vm.IsEffectiveDateEditable = true;

                                if (CreateVM.IsCopyQuote === true) {
                                    //vm.existingPackage = false;
                                    //vm.caseData.packageDescription = vm.selectedPackage = vm.caseNumber = null;
                                    vm.DDLProcessTypeId = 1;
                                    vm.IsPaymentEditable = vm.IsExpirationDateEditable = true;
                                }
                                else {
                                    vm.DDLProcessTypeId = vm.caseData.ddlProcessTypeId;
                                    vm.existingPackage = vm.caseData.existingPackage;
                                    vm.packageDescription = vm.caseData.packageDescription;
                                    vm.selectedPackage = vm.caseData.packageNumber;
                                    vm.caseNumber = newBusinessCaseData.caseNumber;
                                    vm.transactionNumber = newBusinessCaseData.quoteTransactionData.transactionNumber;
                                    vm.caseId = newBusinessCaseData.quoteTransactionData.quoteCaseId;
                                    vm.transactionId = newBusinessCaseData.quoteTransactionData.id;
                                    if (vm.IsReadOnly === true)
                                        vm.IsEffectiveDateEditable = vm.IsExpirationDateEditable = vm.IsPaymentEditable = vm.IsPackageEditable = false;
                                    else if (vm.existingPackage === true)
                                        vm.IsExpirationDateEditable = vm.IsPaymentEditable = vm.IsPackageEditable = false;
                                }
                                vm.selectedItem = vm.caseData.clientNameandId;
                                vm.selectedInsuredId = vm.caseData.selectedInsuredClient.id;
                                vm.automaticPayment = data.data.data.brokerManagedPayment == false ? true : false;
                                var neweditBusinessCaseData = JSON.parse(sessionStorageService.get(keyConstService.newBusinessCaseData));
                                if (neweditBusinessCaseData) {
                                    vm.automaticPayment = neweditBusinessCaseData.data.BrokerManagedPayment == false ? true : false;
                                }

                                sessionStorageService.set(keyConstService.caseId, data.data.quoteTransactionData.quoteCaseId);
                                sessionStorageService.set(keyConstService.caseNumber, newBusinessCaseData.caseNumber);
                                sessionStorageService.set(keyConstService.quoteTransactionId, data.data.quoteTransactionData.id);
                                sessionStorageService.set(keyConstService.rowVersion, data.data.quoteTransactionData.rowVersion);
                                sessionStorageService.set(keyConstService.transactionNumber, data.data.quoteTransactionData.transactionNumber);

                                //var arrClients = vm.clients;
                                //if (vm.caseData.selectedInsuredClient) {
                                //    arrClients.map(function (val, i, arrClients) {
                                //        if (val.id === vm.caseData.selectedInsuredClient.id) {
                                //            vm.selectedInsuredId = val;
                                //        }
                                //    });
                                //}

                                //ddl is list of objects not getting assigned.....
                                var arrProduct = vm.getProduct;
                                if (vm.caseData.selectedProduct) {
                                    arrProduct.map(function (val, i, arrProduct) {
                                        if (val.ProductCode === vm.caseData.selectedProduct.productCode) {
                                            vm.selectedProduct = val;
                                            ////vm.IsCommMotorSelected = false;
                                        }
                                    });
                                }
                                else {
                                    arrProduct.map(function (val, i, arrProduct) {
                                        if (val.Id === vm.caseData.productId) {
                                            vm.selectedProduct = val;
                                        }
                                    });
                                }

                                //effective dates on basis of products
                                var seperateDate = null;
                                if (vm.selectedProduct && vm.selectedProduct.Description === 'Motor') {
                                    seperateDate = dateService.getSeperatedDate(keyConstService.MotorLiveDate);

                                }
                                else if (vm.selectedProduct && vm.selectedProduct.Description === 'Home') {
                                    seperateDate = dateService.getSeperatedDate(keyConstService.HomeLiveDate);
                                }
                                else if (vm.selectedProduct && (vm.selectedProduct.Description === 'Landlord – Essentials' || vm.selectedProduct.Description === 'Landlord – AD and LE')) {
                                    seperateDate = dateService.getSeperatedDate(keyConstService.LandlordsLiveDate);
                                }
                                else if (vm.selectedProduct && (vm.selectedProduct.Description === 'SME - Commercial Package')) {
                                    seperateDate = dateService.getSeperatedDate(keyConstService.SMELiveDate);
                                }
                                else if (vm.SelectedProduct === keyConstService.PaProductDescription) {
                                    seperateDate = dateService.getSeperatedDate(keyConstService.PaLiveDate);
                                }
                                else if (vm.SelectedProduct === keyConstService.CommercialMotorProductDescription) {
                                    seperateDate = dateService.getSeperatedDate(keyConstService.CommercialMotorLiveDate);
                                    //vm.IsCommMotorSelected = true;
                                }
                                else if (vm.SelectedProduct === keyConstService.CyberProductDescription) {
                                    seperateDate = dateService.getSeperatedDate(keyConstService.CyberLiveDate);
                                }

                                if (seperateDate) {
                                    vm.licenseAcquireDay = seperateDate.Day;
                                    vm.licenseAcquireMonth = seperateDate.Month;
                                    vm.licenseAcquireYear = seperateDate.Year;
                                }

                                //vm.effectiveDate = dateService.getDateMMDDtoDDMM(quoteTransactionDetail.effectiveDate);
                                //vm.expirationDate = dateService.getDateMMDDtoDDMM(quoteTransactionDetail.expirationDate);
                                //for new business case effective date from server
                                if (!newBusinessCaseDataString) {
                                    // In case of cancellation(ddlProcessTypeId == 3), set effective date from start date of quote transaction
                                    if (newBusinessCaseData.data && newBusinessCaseData.data.ddlProcessTypeId === 3)
                                        vm.effectiveDate = quoteTransactionDetail.startDate;
                                    else
                                        vm.effectiveDate = quoteTransactionDetail.effectiveDate;
                                    vm.expirationDate = quoteTransactionDetail.expirationDate;
                                    vm.packages.paymentFrequency = newBusinessCaseData.data.paymentFrequency;
                                    vm.packages.InstallmentDate = newBusinessCaseData.data.installmentDate;
                                    vm.packages.InstallmentDate = vm.packages.InstallmentDate == 0 ? null : vm.packages.InstallmentDate;

                                }
                                vm.isNonAnnualTerm = vm.caseData.isNonAnnualTerm;
                                var effectivedateformoment = dateService.convertDatetoDDMMYYYFormat(vm.effectiveDate);
                                var effectivedatemoment = moment(effectivedateformoment, 'DD/MM/YYYY');
                                if (effectivedatemoment < moment()) {
                                    vm.minExpirationDate = dateService.checkValidExpiratonDate(effectivedateformoment, vm.minDaysinExpirationFromCurrentDate);
                                }
                            }
                        }
                    }
                    else {
                        toastr.error(messageConstService.errServiceUnavailable);
                        $log.error("quoteCaseService:server data error >>", data);
                    }
                    effectiveDateWiseProductVisibility();
                }, function (err) {
                    toastr.error(messageConstService.errServiceUnavailable);
                    $log.error("quoteCaseService:err >> ", err);

                });
                if (CreateVM.IsCopyQuote === false) {
                    vm.renewalCounterFlag = CreateVM.Packages[0].RenewalCounter;
                    vm.packageEffectiveDate = moment(CreateVM.Packages[0].StartDate).format("YYYY/MM/DD");
                }
            }
            else {
                //reset the sessionStorageData for the New Business Quote

                //check if the clientFullNameandCode already exists
                var clientFullNameandCode = sessionStorageService.get(keyConstService.clientFullNameandCode);
                if (clientFullNameandCode) {
                    vm.selectedItem = JSON.parse(clientFullNameandCode);
                    sessionStorageService.remove(keyConstService.clientFullNameandCode);
                }

                // set selected primary insured id with added primary clientby using Add New Client button.
                var primaryClientId = sessionStorageService.get(keyConstService.PrimaryClientId);
                if (primaryClientId) {
                    vm.selectedInsuredId = parseInt(primaryClientId);
                    sessionStorageService.remove(keyConstService.PrimaryClientId);
                }

                effectiveDateWiseProductVisibility();

                sessionStorageService.remove(keyConstService.package);
                sessionStorageService.remove(keyConstService.caseId);
                sessionStorageService.remove(keyConstService.caseNumber);
                sessionStorageService.remove(keyConstService.quoteTransactionId);
                sessionStorageService.remove(keyConstService.transactionNumber);
                sessionStorageService.remove(keyConstService.newBusinessCaseData);
                sessionStorageService.remove(keyConstService.bindData);
                sessionStorageService.remove(keyConstService.quoteDetail);
                sessionStorageService.remove(keyConstService.quoteState);
                sessionStorageService.remove(keyConstService.IsNewBusinessReadOnly);
                sessionStorageService.remove(keyConstService.IsNewEditTransaction);
                sessionStorageService.remove(keyConstService.IsNewBusinessEdit);
                sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
                sessionStorageService.remove(keyConstService.specialContentvalidity);
                sessionStorageService.remove(keyConstService.IsPackageEditable);
                sessionStorageService.remove(keyConstService.Colour);
            }

            
            // get insured client By: Vikas Mishra 111
            if (vm.selectedItem !== null) {
                getInsuredClients();
            }
            effectiveDateWiseProductVisibility();
        }

        function hideproducts() {
            vm.isHome = false;
            vm.isMotor = false;
            vm.isLandLordEssentials = false;
            vm.isLandLordADLE = false;
            vm.isPA = false;
            vm.isCommMotor = false;
            vm.isCyber = false;
            vm.isSME = false;
        }

        function next() {
            var newBusinessRequestData = {
                "ClientNameandId": vm.selectedItem,
                "ProductId": vm.selectedProduct.Id,
                "DDLProcessTypeId": 1,
                "EffectiveDate": dateService.getDateDDMMtoMMDD(vm.effectiveDate),
                "ExpirationDate": dateService.getDateDDMMtoMMDD(vm.expirationDate),
                "BrokerOrganisationId": 0,
                "PolicyId": 0,
                "CaseNumber": vm.caseNumber,
                "TransactionNumber": vm.transactionNumber,
                "QuoteCaseId": vm.caseId,
                "QuoteTransactionId": vm.transactionId,
                "Reason": "",
                "IsNonAnnualTerm": vm.isNonAnnualTerm,
                "ExistingPackage": vm.existingPackage,
                "PackageDescription": vm.packageDescription,
                "PackageNumber": vm.selectedPackage,
                "SelectedProduct": vm.selectedProduct,
                "PaymentFrequency": vm.packages.paymentFrequency,
                "InstallmentDate": vm.packages.paymentFrequency === 'Monthly' ? vm.packages.InstallmentDate : null,
                "BrokerManagedPayment": vm.packages.paymentFrequency === 'Monthly' ? 0 : (vm.automaticPayment === true && vm.packages.paymentFrequency === 'Annual') ? 0 : 1,
                "InsuredClientId": vm.selectedInsuredId,
                "PackageId": vm.selectedPackageId === null ? 0 : vm.selectedPackageId
            };

            if (newBusinessRequestData.ProductId === keyConstService.CyberProductId && !checkcyber(newBusinessRequestData)) {
                return;
            } else if (newBusinessRequestData.ProductId === keyConstService.SMEProductId && !checkSME(newBusinessRequestData)) {
                return;
            } else if (newBusinessRequestData.ProductId === keyConstService.PersonalAccidentProductId && !validationForPaOnNext(newBusinessRequestData, newBusinessRequestData.ProductId)) {
                return;
            } else if (newBusinessRequestData.ProductId === keyConstService.CommercialMotorProductId && !validationForPaOnNext(newBusinessRequestData, newBusinessRequestData.ProductId)) {
                return;
            } else if (newBusinessRequestData.ProductId === keyConstService.CommercialMotorProductId && !validationForPaOnNext(newBusinessRequestData)) {
                return;
            }
            else {
                goAheadOnNext(newBusinessRequestData);
            }

            //$http.post(apiUrlConstService.quoteURL + 'ValidateEffectiveDate', newBusinessRequestData)
            //    .then(function (result) {
            //        $log.log('result', result);
            //        if (result.data.status === true) {
            //            nextlogic();
            //        }
            //        else {
            //            toastr.error(messageConstService.effectiveDateNotAllowed);
            //            $log.error("error data:", result.data);
            //            return -1;
            //        }
            //    }, function (error) {
            //        toastr.error(messageConstService.errServiceUnavailable);
            //        $log.error('error', error);
            //    }
            //    );

        }

        function goAheadOnNext(requestData) {
            $http.post(apiUrlConstService.quoteURL + 'ValidateEffectiveDate', requestData)
                .then(function (result) {
                    $log.log('result', result);
                    if (result.data.status === true) {
                        nextlogic();
                    }
                    else {
                        toastr.error(messageConstService.effectiveDateNotAllowed);
                        $log.error("error data:", result.data);
                        return -1;
                    }
                }, function (error) {
                    toastr.error(messageConstService.errServiceUnavailable);
                    $log.error('error', error);
                }
                );
        }

        function checkcyber(newBusinessRequestData) {
            let choice = false;
            if (newBusinessRequestData.PaymentFrequency === "Monthly") {
                toastr.error("Payment Type should be 'Annual' for Cyber.");
                choice = true;
            }
            if (newBusinessRequestData.PaymentFrequency === "Annual" && newBusinessRequestData.BrokerManagedPayment === 0) {
                toastr.error("Broker Collection should be selected as 'Yes' for Cyber");
                choice = true;
            }

            if (newBusinessRequestData.ExistingPackage === true) {
                toastr.error("Add to Existing Package should be 'No' for Cyber");
                choice = true;
            }

            var effecDate = moment(newBusinessRequestData.EffectiveDate)
            // // var isBackDated = moment().isAfter(effecDate, 'day');
            // // if (isBackDated) {
            // //     //toastr.error("Backdated quote is not allowed for Cyber.");
            // //     //choice = true;
            // // }

            if (choice == true) {
                return false;
            }

            var config1 = {
                params: { lookUpShortDescription: keyConstService.CyberMaxQuoteForwardDate },
                headers: { 'Accept': 'application/json' }
            };
            $http.get(apiUrlConstService.getLookUpValueFromShortDescription, config1)
                .then(function (result) {
                    $log.log('result', result);
                    if (result.data.status === true) {
                        var numberOfDays = parseInt(result.data.data);
                        var maxAllowedDate = moment().add(numberOfDays, 'days');
                        var isNotAllowed = maxAllowedDate.isBefore(effecDate, 'day');
                        if (isNotAllowed) {
                            var msg = "Policy start date has to be within " + numberOfDays + " days of current date.";
                            toastr.error(msg);
                            return;
                        } else {
                            goAheadOnNext(newBusinessRequestData);
                        }
                    }
                    else {
                        toastr.error(messageConstService.errServiceUnavailable);
                        $log.error("error data:", result.data);
                        return false;
                    }
                }, function (error) {
                    toastr.error(messageConstService.errServiceUnavailable);
                    $log.error('error', error);
                    return false;
                });
        }

        function checkSME(newBusinessRequestData) {
            if (newBusinessRequestData.SelectedProduct.Description === 'SME - Commercial Package') {
                let change = true;
                if (vm.selectedInsured != null) {
                    change = vm.selectedInsured.clientType === "Business" ? true : false;
                }
                else if (vm.secondryclientType != null) {
                    change = vm.secondryclientType === "Business" ? true : false;
                }

                if (change == false) {
                    toastr.error("Primary Insured should be business for sme product.");
                    return false;
                } else {
                    goAheadOnNext(newBusinessRequestData);
                }
            } else {
                goAheadOnNext(newBusinessRequestData);
            }
        }

        //// validation on next if product selected is PA, currently only for payment type
        function validationForPaOnNext(newBusinessRequestData,productId) {
            if (newBusinessRequestData !== null && newBusinessRequestData.SelectedProduct !== null) {
                //if (newBusinessRequestData.PaymentFrequency === keyConstService.MonthlyPaymentType && productId === keyConstService.PersonalAccidentProductId) {
                //    toastr.error(keyConstService.PaPaymentFrequencyError);
                //    return false;
                //}
                //else
                if (newBusinessRequestData.PaymentFrequency === keyConstService.AnnualPaymentType && newBusinessRequestData.BrokerManagedPayment === 0) {
                    toastr.error(keyConstService.PaBrokerManageTypeError);
                    return false;
                }
            }
            goAheadOnNext(newBusinessRequestData);
        }

        function nextlogic() {
            //gather the data
            //convert the date format          
            //if (!vm.selectedProduct.IsActive) {
            //    toastr.error(messageConstService.productDeactivatedInfo);
            //    $log.error('error', error);
            //    return -1;
            //}

            resetNonRegoData = false;
            var newEffectiveDate = dateService.getDateDDMMtoMMDD(vm.effectiveDate);
            var newExpirationDate = dateService.getDateDDMMtoMMDD(vm.expirationDate);
            vm.IsReadOnly = JSON.parse(sessionStorageService.get(keyConstService.IsNewBusinessReadOnly));
            
            // comparinig effective date to reset non-rego functionality
            if (vm.isEditEnabled) {
                var getEffectiveDate = JSON.parse(sessionStorageService.get(keyConstService.newBusinessCaseData));
                if (getEffectiveDate) {
                    var newConvertedEffectiveDate = moment(getEffectiveDate.data.EffectiveDate).format('DD/MM/YYYY');
                    if (newConvertedEffectiveDate !== vm.effectiveDate) {
                        resetNonRegoData = true;
                        sessionStorageService.set(keyConstService.resetNonRegoData, resetNonRegoData);
                        sessionStorageService.set(keyConstService.OldEffectiveDate, getEffectiveDate);
                    }
                }
                if ((sessionStorageService.get(keyConstService.newBusinessCaseData)) === null) {
                    vm.effectiveDateOnEdit = JSON.parse(sessionStorageService.get(keyConstService.effectiveDateInEdit));
                    var previousConvertedEffectiveDate = moment(vm.effectiveDateOnEdit).format('DD/MM/YYYY');
                    if (previousConvertedEffectiveDate !== vm.effectiveDate) {
                        resetNonRegoData = true;
                        sessionStorageService.set(keyConstService.resetNonRegoData, resetNonRegoData);
                    }
                }
            }
            //if transaction is for new business then set EditEnabled false
            if (newBusinessCaseData) {
                if (newBusinessCaseData.quoteTransactionData.id === quoteTransactionId && (newBusinessCaseData.quoteTransactionData.status == null || newBusinessCaseData.quoteTransactionData.status === undefined) && vm.IsCopyQuote === false) {
                    vm.isEditEnabled = false;
                }
            }
            if (vm.selectedPackageId === null) {
                vm.selectedPackageId = vm.PackageIdOnPrevious;
            }
            var oldQuoteTransactionId = sessionStorageService.get(keyConstService.CopyQuoteOldTransactionId);
            var newBusinessRequestData = {
                "ClientNameandId": vm.selectedItem,
                "ProductId": vm.selectedProduct.Id,
                "DDLProcessTypeId": 1,
                "EffectiveDate": newEffectiveDate,
                "ExpirationDate": newExpirationDate,
                "BrokerOrganisationId": 0,
                "PolicyId": 0,
                "CaseNumber": vm.caseNumber,
                "TransactionNumber": vm.transactionNumber,
                "QuoteCaseId": vm.caseId,
                "QuoteTransactionId": vm.transactionId,
                "Reason": "",
                "IsNonAnnualTerm": vm.isNonAnnualTerm,
                "ExistingPackage": vm.existingPackage,
                "PackageDescription": vm.packageDescription,
                "PackageNumber": vm.selectedPackage,
                "SelectedProduct": vm.selectedProduct,
                "PaymentFrequency": vm.packages.paymentFrequency,
                "InstallmentDate": vm.packages.paymentFrequency === 'Monthly' ? vm.packages.InstallmentDate : null,
                "BrokerManagedPayment": vm.packages.paymentFrequency === 'Monthly' ? 0 : (vm.automaticPayment === true && vm.packages.paymentFrequency === 'Annual') ? 0 : 1,
                "InsuredClientId": vm.selectedInsuredId,
                "PackageId": vm.selectedPackageId === null ? 0 : vm.selectedPackageId,
                "CopyQuoteOldTransactionId": vm.IsCopyQuote ? oldQuoteTransactionId : 0
            };
            //if View then go to static view page.
            if (vm.IsReadOnly === true) {
                vm.IsReadOnly = false;
                if (vm.selectedProduct.Description === "Home") {
                    $window.location.href = webUrlConstService.HomeView + '?' + sessionStorageService.getEncryption('productName=' + vm.selectedProduct.Description + '&&quoteCaseNumber=' + vm.caseNumber + '&&startDate=' + newEffectiveDate); //redirect to static View pages
                }

                if (vm.selectedProduct.Description === "Motor") {
                    $window.location.href = webUrlConstService.MotorView + '?' + sessionStorageService.getEncryption('productName=' + vm.selectedProduct.Description + '&&quoteCaseNumber=' + vm.caseNumber); //redirect to static View pages
                }

                if (vm.selectedProduct.Description === "Landlord – Essentials") {
                    $window.location.href = webUrlConstService.LandlordProtectionView + '?' + sessionStorageService.getEncryption('productName=' + vm.selectedProduct.Description + '&&quoteCaseNumber=' + vm.caseNumber); //redirect to static View pages
                }

                if (vm.selectedProduct.Description === "Landlord – AD and LE") {
                    $window.location.href = webUrlConstService.LandlordStandardView + '?' + sessionStorageService.getEncryption('productName=' + vm.selectedProduct.Description + '&&quoteCaseNumber=' + vm.caseNumber + '&&startDate=' + newEffectiveDate); //redirect to static View pages
                }

                // redirecting to Personal Accident Page
                if (vm.selectedProduct.Description === keyConstService.PaProductDescription) {
                    $window.location.href = webUrlConstService.PersonalAccidentView + sessionStorageService.getEncryption('productName=' + vm.selectedProduct.Description + '&&quoteCaseNumber=' + vm.caseNumber);
                }

                if (vm.selectedProduct.Description === keyConstService.CommercialMotorProductDescription) {
                    sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                    portalV2Service.getV2Token().then(function (resp) {
                        var redirectTo = keyConstService.CommercialMotorUrlPrefix + keyConstService.CommercialMotorViewQuote +
                            sessionStorageService.getEncryption('quoteTransactionId=' + vm.transactionId + '&productId=' + keyConstService.CommercialMotorProductId); //redirect to CM page.
                        portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                    });
                }

                if (vm.selectedProduct.Description === keyConstService.CyberProductDescription) {
                    sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                    portalV2Service.getV2Token().then(function (resp) {
                        var redirectTo = keyConstService.CyberUrlPrefix + keyConstService.CyberViewQuote +
                            sessionStorageService.getEncryption('quoteTransactionId=' + vm.transactionId + '&productId=' + keyConstService.CyberProductId); //redirect to CM page.
                        portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                    });
                }
            }
            else if (vm.isEditEnabled) {
                //load the data from the sessionStorage
                vm.caseNumber = JSON.parse(sessionStorageService.get(keyConstService.caseNumber));
                vm.transactionNumber = JSON.parse(sessionStorageService.get(keyConstService.transactionNumber));
                sessionStorageService.set(keyConstService.IsNewBusinessEdit, true);

                var newBusinessData = { "transactiondata": quoteTransactionDetail, "data": newBusinessRequestData };
                //store the newBusiness Page data on the session storage...which need to be retrived later
                sessionStorageService.set(keyConstService.newBusinessCaseData, newBusinessData);

                vm.isEditEnabled = false;
                if (vm.selectedProduct.Description === "Home") {
                    sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                    // get uiversion
                    getUIversion(vm.selectedProduct.Description, newBusinessData);
                }
                if (vm.selectedProduct.Description === "Motor") {
                    sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                    $window.location.href = webUrlConstService.MotorUpdate + '?' + sessionStorageService.getEncryption('productName=' + vm.selectedProduct.Description + '&&quoteCaseNumber=' + vm.caseNumber); //redirect to static View pages
                }
                if (vm.selectedProduct.Description === "Landlord – Essentials") {
                    sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                    $window.location.href = webUrlConstService.LandlordProtectionUpdate + '?' + sessionStorageService.getEncryption('productName=' + vm.selectedProduct.Description + '&&quoteCaseNumber=' + vm.caseNumber); //redirect to static View pages
                }

                if (vm.selectedProduct.Description === "Landlord – AD and LE") {
                    sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                    // get uiversion
                    getUIversion(vm.selectedProduct.Description, newBusinessData);
                }

                // redirecting to Personal Accident Page
                if (vm.selectedProduct.Description === keyConstService.PaProductDescription) {
                    sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                    $window.location.href = webUrlConstService.PersonalAccidentUpdate + "?" + sessionStorageService.getEncryption('productName=' + vm.selectedProduct.Description + '&&quoteCaseNumber=' + vm.caseNumber);
                }

                if (vm.selectedProduct.Description === keyConstService.CommercialMotorProductDescription) {
                    sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                    portalV2Service.getV2Token().then(function (resp) {
                        var redirectTo = vm.CommercialMotorEditQuoteURL + '/' +
                            sessionStorageService.getEncryption('quoteTransactionId=' + vm.transactionId + '&productId=' + keyConstService.CommercialMotorProductId);
                        portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                    });
                }

                if (vm.selectedProduct.Description === keyConstService.CyberProductDescription) {
                    sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                    portalV2Service.getV2Token().then(function (resp) {
                        var redirectTo = keyConstService.CyberUrlPrefix + keyConstService.CyberEditQuote +
                            sessionStorageService.getEncryption('quoteTransactionId=' + vm.transactionId + '&productId=' + keyConstService.CyberProductId);
                        portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                    });
                }
                else if (vm.selectedProduct.Id === 5) {
                    // Save dates and redirect to SME portal
                    $http.post(apiUrlConstService.quoteURL + 'QuoteCase', newBusinessRequestData)
                        .then(function (result) {
                            if (result.data.status === true) {
                                sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                                portalV2Service.getV2Token().then(function (resp) {
                                    portalV2Service.setKeyToLocalStorage(resp.data.data);
                                    $window.location.href = window.location.protocol + '//' + window.location.host + vm.SMENewBusinessUrl + '?' + sessionStorageService.getEncryption('quoteTransactionId=' + vm.transactionId); //redirect to SME page.
                                });
                            }
                            else {
                                toastr.error(messageConstService.errServiceUnavailable);
                                $log.error("error data:", result.data);
                            }
                        }, function (error) {
                            toastr.error(messageConstService.errServiceUnavailable);

                            $log.error('error', error);
                        });
                }

            }
            else {
                //and send the data to the api/quote/QuoteCase
                $http.post(apiUrlConstService.quoteURL + 'QuoteCase', newBusinessRequestData)
                    .then(function (result) {
                        if (result.data.status === true) {
                            sessionStorageService.set(keyConstService.caseId, result.data.data.caseId);
                            sessionStorageService.set(keyConstService.caseNumber, result.data.data.caseNumber);
                            sessionStorageService.set(keyConstService.quoteTransactionId, result.data.data.transactionId);
                            sessionStorageService.set(keyConstService.transactionNumber, result.data.data.transactionNumber);
                            sessionStorageService.set(keyConstService.brokerData, result.data.data.brokerData);
                            sessionStorageService.set(keyConstService.rowVersion, result.data.data.rowVersion);
                            newBusinessRequestData.selectedProduct = vm.selectedProduct;
                            newBusinessRequestData.selectCoverage = vm.selectCoverage;
                            var quoteCaseNumber = result.data.data.caseNumber;
                            var newBusinessData = { "transactiondata": quoteTransactionDetail, "data": newBusinessRequestData };
                            //store the newBusiness Page data on the session storage...which need to be retrived later
                            sessionStorageService.set(keyConstService.newBusinessCaseData, newBusinessData);
                            //sessionStorageService.remove(keyConstService.IsCopyQuote);

                            if (vm.IsCopyQuote) {
                                var productUrl;

                                if (vm.selectedProduct.Id === 1)
                                    productUrl = webUrlConstService.HomeUpdate;
                                else if (vm.selectedProduct.Id === 2)
                                    productUrl = webUrlConstService.MotorUpdate;
                                else if (vm.selectedProduct.Id === 3)
                                    productUrl = webUrlConstService.LandlordProtectionUpdate;
                                else if (vm.selectedProduct.Id === 4)
                                    productUrl = webUrlConstService.LandlordStandardUpdate;
                                else if (vm.selectedProduct.Id === keyConstService.CommercialMotorProductId) {
                                    portalV2Service.getV2Token().then(function (resp) {
                                        var redirectTo = vm.CommercialMotorEditQuoteURL + '/' +
                                            sessionStorageService.getEncryption('quoteTransactionId=' + result.data.data.transactionId + '&productId=' + keyConstService.CommercialMotorProductId);
                                        portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                                    });
                                }
                                else if (vm.selectedProduct.Id === keyConstService.CyberProductId) {
                                    portalV2Service.getV2Token().then(function (resp) {
                                        var redirectTo = keyConstService.CyberUrlPrefix + keyConstService.CyberEditQuote +
                                            sessionStorageService.getEncryption('quoteTransactionId=' + result.data.data.transactionId + '&productId=' + keyConstService.CyberProductId);
                                        portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                                    });
                                }
                                else
                                    productUrl = webUrlConstService.PersonalAccidentUpdate;
                                if (vm.selectedProduct.Id !== keyConstService.CommercialMotorProductId && vm.selectedProduct.Id !== keyConstService.CyberProductId) {
                                    if (vm.selectedProduct.Id === 1 || vm.selectedProduct.Id === 4) {
                                        $window.location.href = productUrl + "?" + sessionStorageService.getEncryption('productName=' + vm.selectedProduct.Description + '&&quoteCaseNumber=' + result.data.data.caseNumber + "&&startDate=" + newEffectiveDate);
                                    }
                                    else {

                                        $window.location.href = productUrl + "?" + sessionStorageService.getEncryption('productName=' + vm.selectedProduct.Description + '&&quoteCaseNumber=' + result.data.data.caseNumber);
                                    }
                                }
                            }
                            else {
                                if (vm.selectedProduct.Id === 1) {
                                    sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                                    //sending package id for binding policy and distinguish duplicate package number.
                                    $window.location.href = webUrlConstService.newBuinessnessHome + '?' + sessionStorageService.getEncryption(('quoteId=' + result.data.data.transactionId) + ('&&packageNumber=' + result.data.data.packageNumber) + ("&&packageId=" + vm.selectedPackageId) + ("&&startDate=" + newEffectiveDate)); //redirect to static pages
                                }
                                else if (vm.selectedProduct.Id === 2) {
                                    sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                                    // this change is for new motor question set
                                    $window.location.href = webUrlConstService.newBuinessnessMotor + '?' + sessionStorageService.getEncryption(('quoteId=' + result.data.data.transactionId) + ('&&packageNumber=' + result.data.data.packageNumber) + ("&&packageId=" + vm.selectedPackageId)); //redirect to static pages
                                }
                                else if (vm.selectedProduct.Id === 4) {
                                    sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                                    $window.location.href = webUrlConstService.LandlordStandard + '?' + sessionStorageService.getEncryption(('quoteId=' + result.data.data.transactionId) + ('&&packageNumber=' + result.data.data.packageNumber) + ("&&packageId=" + vm.selectedPackageId) + '&&startDate=' + newEffectiveDate);  //redirect to static pages
                                }
                                else if (vm.selectedProduct.Id === 3) {
                                    sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                                    $window.location.href = webUrlConstService.LandlordProtection + '?' + sessionStorageService.getEncryption(('packageNumber=' + result.data.data.packageNumber) + ("&&packageId=" + vm.selectedPackageId));  //redirect to static pages
                                }
                                else if (vm.selectedProduct.Id === 5) {
                                    sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                                    //localStorage.quoteTransactionId = result.data.data.transactionId;
                                    //localStorage.quoteCaseId = result.data.data.caseId;
                                    //localStorage.packageNumber = result.data.data.packageNumber;
                                    portalV2Service.getV2Token().then(function (resp) {
                                        portalV2Service.setKeyToLocalStorage(resp.data.data);
                                        $window.location.href = window.location.protocol + '//' + window.location.host + vm.SMENewBusinessUrl + '?' + sessionStorageService.getEncryption('quoteTransactionId=' + result.data.data.transactionId); //redirect to SME page
                                    });
                                }
                                //redirect to Personal Accident Page, when Product Id is 6 which is for Personal Aciident in [dbo].[Product]
                                else if (vm.selectedProduct.Id === keyConstService.PersonalAccidentProductId) {
                                    sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                                    $window.location.href = webUrlConstService.PersonalAccident + sessionStorageService.getEncryption(('packageNumber=' + result.data.data.packageNumber) + ("&&packageId=" + vm.selectedPackageId));
                                }
                                //redirect to Commercial Motor Page, when Product Id is 50 which is for Commercial motor in [dbo].[Product]
                                else if (vm.selectedProduct.Id === keyConstService.CommercialMotorProductId) {
                                    sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                                    portalV2Service.getV2Token().then(function (resp) {
                                        var redirectTo = vm.CommercialMotorNewBusinessUrl + '/' +
                                            sessionStorageService.getEncryption('quoteTransactionId=' + result.data.data.transactionId + '&productId=' + keyConstService.CommercialMotorProductId);
                                        portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                                    });
                                }
                                //redirect to Cyber Page, when Product Id is 51 which is for Cyber in [dbo].[Product]
                                else if (vm.selectedProduct.Id === keyConstService.CyberProductId) {
                                    sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                                    portalV2Service.getV2Token().then(function (resp) {
                                        var redirectTo = keyConstService.CyberUrlPrefix + keyConstService.CyberNewQuote +
                                            sessionStorageService.getEncryption('quoteTransactionId=' + result.data.data.transactionId + '&productId=' + keyConstService.CyberProductId);
                                        portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                                    });
                                }
                            }
                        }
                        else {
                            toastr.error(messageConstService.errServiceUnavailable);
                            $log.error("error data:", result.data);
                        }

                        //set the response in session storage

                    }, function (error) {
                        toastr.error(messageConstService.errServiceUnavailable);

                        $log.error('error', error);
                    });
            }

        };

        function getUIversion(product, newBusinessData) {
            if (newBusinessData) {
                var newEffectiveDate = newBusinessData.data.EffectiveDate;
                var newEffectiveDateFormat = dateService.getDateDDMMtoMMDD(vm.effectiveDate);
                $http.get(apiUrlConstService.quoteURL + 'GetUIVersion?quotetransactionId=' + newBusinessData.data.QuoteTransactionId + '&&policyStartDate=' + newEffectiveDate, { skipInterceptor: true })
                    .then(function (result) {
                        if (result.data.status === true) {
                            var url = null;
                            vm.version = result.data.data;
                            if (product === "Home") {
                                url = webUrlConstService.HomeUpdate; 
                            }
                            else if (product === "Landlord – AD and LE") {
                                url = webUrlConstService.LandlordStandardUpdate;
                            }
                            $window.location.href = url + '?' + sessionStorageService.getEncryption('productName=' + product + '&&quoteCaseNumber=' + newBusinessData.data.CaseNumber + '&&version=' + vm.version + '&&startDate=' + newEffectiveDateFormat); //redirect to static View pages
                        }
                        else {
                            toastr.error(messageConstService.errServiceUnavailable);
                            $log.error("error data:", result.data);
                        }
                    }, function (error) {
                        toastr.error(messageConstService.errServiceUnavailable);

                        $log.error('error', error);
                    });
            }
        }

        function addClient() {
            sessionStorageService.set(keyConstService.IsFromNewBusinessPage, true);
            $window.location.href = webUrlConstService.clientAdd;
        }

        function searchClient() {
            $window.location.href = webUrlConstService.clientIndex;
        }

        function checkValidExpiratonDate() {
            var effectivedatemoment = moment(vm.effectiveDate, 'DD/MM/YYYY');
            if (effectivedatemoment < moment()) {
                vm.minExpirationDate = dateService.checkValidExpiratonDate(vm.effectiveDate, vm.minDaysinExpirationFromCurrentDate);
            }
        }

        function onEffectiveDateChange(callfromproduct = false) {
            //gets the effectiveDate and set it in the expirationDate
            var textdate = vm.effectiveDate;
            vm.LiveDate = null;
            if (textdate) {
                //vm.IsExpirationDateEditable = vm.effectiveDate ? true : false;
                var dateValidResponse = dateService.validateDate(textdate);
                if (!dateValidResponse.isValid) {
                    toastr.warning(messageConstService.errDateInvalid);
                    vm.effectiveDate = '';
                    return;
                }

                ProductEffectiveDatecommonfunction(textdate, callfromproduct);
                effectiveDateWiseProductVisibility();
            }
        }

        function validateExpiration(mode = false) {
            var effectiveDateM = dateService.getMomentDateforDDMM(vm.effectiveDate);
            var expirationDateM = dateService.getMomentDateforDDMM(vm.expirationDate);
            var expirationDateInMMDD = dateService.getDateDDMMtoMMDD(vm.expirationDate);
            var productId = null;
            if (vm.packages) {
                var paymentFrequency = vm.packages.paymentFrequency;
            }
            else {
                var paymentFrequency = null;
            }

            //get the policy period based on the start date.
            if (vm.selectedProduct) {
                productId = vm.selectedProduct.Id;
            }
            //get the policy period based on the start date.            
            var config = {
                params: { startDate: expirationDateInMMDD, PaymentFrequency: paymentFrequency, ProductId: productId },
                headers: { 'Accept': 'application/json' }
            };
            $http.get(apiUrlConstService.lookupURL + 'GetPolicyPeriod', config)
                .then(function (result) {
                    if (result.data.status === true) {
                        vm.minimumPolicyDays = result.data.data.minimumPolicyPeriod;
                        vm.maximumPolicyDays = result.data.data.maximumPolicyPeriod;
                        if (!expirationDateM._isValid) {
                            toastr.warning(messageConstService.errDateInvalid);
                            return false;
                        }
                        if (expirationDateM < effectiveDateM) {
                            setEffectiveDate();
                            toastr.warning(messageConstService.errMinExpirationDate);
                            return false;
                        }

                        var dateRangeResponse = dateService.validateRange("days", vm.minimumPolicyDays, vm.maximumPolicyDays, vm.expirationDate, vm.effectiveDate, vm.expirationDate, null);
                        if (!dateRangeResponse.isValid) {
                            var message = "";
                            if (dateRangeResponse.errorMsg === "Date Below Range.") {
                                //reformat the message
                                message = stringService.stringFormat(messageConstService.errPolicyMinimumPeriod, vm.minimumPolicyDays);
                            }
                            if (dateRangeResponse.errorMsg === "Date Above Range.") {

                                message = stringService.stringFormat(messageConstService.errPolicyMaximumPeriod, vm.maximumPolicyDays);
                            }
                            toastr.error(message);
                            if (vm.minExpirationDate && expirationDateM < vm.minExpirationDate.minExpirationDate && message === "") {
                                if (vm.packages && vm.packages.paymentFrequency === 'Monthly') {
                                    toastr.error(messageConstService.errMinExpirationDateInstallment);
                                    vm.minExpirationDate = null;
                                }
                            }
                            setEffectiveDate();
                            return false;
                        }
                        else if (vm.minExpirationDate && expirationDateM < vm.minExpirationDate.minExpirationDate) {
                            if (vm.packages && vm.packages.paymentFrequency === 'Monthly') {
                                setEffectiveDate();
                                toastr.error(messageConstService.errMinExpirationDateInstallment);
                                vm.minExpirationDate = null;
                                return false;
                            }
                            else if (JSON.parse(sessionStorageService.get(keyConstService.IsCopyQuote)) === true && mode) {
                                vm.next();
                            }
                        }
                        else if (JSON.parse(sessionStorageService.get(keyConstService.IsCopyQuote)) === true && mode) {
                            vm.next();
                        }
                    }


                }, function (error) {
                    $log.error('error', error);
                    toastr.warning(messageConstService.errSelectAgain);
                    return false;
                });
            return true;
        };

        function onPaymentChange() {
            if (vm.packages.paymentFrequency === 'Monthly') {
                if (vm.effectiveDate && vm.expirationDate) {
                    var expirationDateM = dateService.getMomentDateforDDMM(vm.expirationDate);
                    // vm.minExpirationDate validates expiration date with minimum of 1 month from current system date for backdated installment policies
                    if (vm.minExpirationDate && expirationDateM < vm.minExpirationDate.minExpirationDate) {
                        setEffectiveDate();
                        toastr.error(messageConstService.errMinExpirationDateInstallment);
                        return;
                    }
                }
            }
            else if (vm.packages.paymentFrequency === 'Annual' && vm.IsAnnual === false) {
                vm.automaticPayment = false;
            }
            else if (vm.packages.paymentFrequency === 'Annual' && vm.DisableProductDDL === true && vm.IsAnnual === true && vm.IsPaymentEditable) {
                vm.automaticPayment = false;
            }
            let validateEffectiveoutput = validateEffective();
            if (validateEffectiveoutput === 'true')
                validateExpiration();
        }

        function validateEffective() {
            var effectiveDateInMMDD = dateService.getDateDDMMtoMMDD(vm.effectiveDate);
            var paymentFrequency = null;
            var productId = null;
            if (vm.packages) {
                paymentFrequency = vm.packages.paymentFrequency;
            }
            else {
                paymentFrequency = null;
            }
            //get the policy period based on the start date.
            if (vm.selectedProduct) {
                productId = vm.selectedProduct.Id;
            }
            var config = {
                params: { startDate: effectiveDateInMMDD, PaymentFrequency: paymentFrequency, ProductId: productId },
                headers: { 'Accept': 'application/json' }
            };

            $http.get(apiUrlConstService.lookupURL + 'GetPolicyPeriod', config)
                .then(function (result) {
                    $log.log('result', result);
                    if (result.data.status === true) {
                        vm.minimumPolicyDays = result.data.data.minimumPolicyPeriod;
                        vm.maximumPolicyDays = result.data.data.maximumPolicyPeriod;
                        if (vm.expirationDate) {
                            var dateRangeResponse = dateService.validateRange("days", vm.minimumPolicyDays, vm.maximumPolicyDays, vm.expirationDate, vm.effectiveDate, vm.expirationDate, null);
                            if (!dateRangeResponse.isValid) {
                                var message = "";
                                if (dateRangeResponse.errorMsg === "Date Below Range.") {
                                    //reformat the message
                                    message = stringService.stringFormat(messageConstService.errPolicyMinimumPeriod, vm.minimumPolicyDays);
                                }
                                if (dateRangeResponse.errorMsg === "Date Above Range.") {

                                    message = stringService.stringFormat(messageConstService.errPolicyMaximumPeriod, vm.maximumPolicyDays);
                                }
                                toastr.error(message);
                                if (vm.existingPackage) {
                                    var expirationDateM = moment(vm.expirationDate, 'DD/MM/YYYY');
                                    if (vm.minExpirationDate && expirationDateM < vm.minExpirationDate.minExpirationDate && vm.packages.paymentFrequency === 'Monthly') {
                                        toastr.error(messageConstService.errMinExpirationDateInstallment);
                                        setEffectiveDate();
                                        vm.minExpirationDate = null;
                                        return false;
                                    }
                                }

                                setEffectiveDate();
                                return false;
                            }
                            if (vm.existingPackage) {
                                var expirationDateM = moment(vm.expirationDate, 'DD/MM/YYYY');
                                if (vm.minExpirationDate && expirationDateM < vm.minExpirationDate.minExpirationDate && vm.packages.paymentFrequency === 'Monthly') {
                                    toastr.error(messageConstService.errMinExpirationDateInstallment);
                                    setEffectiveDate();
                                    vm.minExpirationDate = null;
                                    return false;
                                }
                            }
                        }
                    }
                }, function (error) {
                    $log.error('error', error);
                    toastr.warning(messageConstService.errSelectAgain);
                    return false;
                });
            return true;
        }

        function setEffectiveDate() {
            vm.effectiveDate = '';
            if (!vm.existingPackage) {
                vm.expirationDate = '';
            }
        }

        function getInsuredClients() {
            clientService.getAllClientsByClientCode(vm.selectedItem.replace(/&/g, "")).then(function (result) {

                if (vm.selectedItem === null && vm.selectedInsuredId === "") {
                    vm.clients = null;
                }
                else {
                    vm.clients = result;
                }
                // Changes Related to SME, update Primary Insured Id
                if (sessionStorageService.get(keyConstService.PrimaryInsuredId) !== null && sessionStorageService.get(keyConstService.PrimaryInsuredId) !== undefined) {
                    vm.selectedInsuredId = parseInt(sessionStorageService.get(keyConstService.PrimaryInsuredId));
                }
                else {
                    // selected primary client as a default policy insured
                    if (vm.selectedItem && vm.primaryClient) {
                        var clientId = vm.selectedItem.replace(/&/g, "").split('(')[1].replace(')', "");
                        var selectedPrimaryClient = vm.primaryClient.filter(function (obj) {
                            return obj.clientCode === clientId;
                        });
                        if (selectedPrimaryClient) {
                            vm.selectedInsuredId = selectedPrimaryClient[0].id;
                        }
                    }
                }

            }, function (error) {
                $log.log('error', error);
            });
        }

        function continueOrNavigateBackToPackageManager() {
            vm.packageNumber = sessionStorageService.get('PackageNumberInformation');
            vm.renewalCounter = sessionStorageService.get('RenewalCounter');
            sessionStorageService.remove('IsPackageManagerNavigationMode');
            sessionStorageService.remove('PackageNumberInformation');
            sessionStorageService.remove('RenewalCounter');
            $window.location.href = webUrlConstService.getPackageInfo + sessionStorageService.getEncryption("packageNumber=" + JSON.parse(vm.packageNumber) + "&&renewalCounter=" + vm.renewalCounter);
        }

        function clientSelect(client) {
            let val = parseInt(client.value) === parseInt(vm.selectedInsuredId);
            if (val) {
                vm.secondryclientType = client.clientType;
                if (vm.secondryclientType !== 'Business') {
                    vm.isCyber = false;
                }
                else {
                    vm.isPA = false;
                }
                effectiveDateWiseProductVisibility();
            }

        }
    }
})();;
(function () {
    'use strict';
    angular.module('appUI').controller('brokerQuestionCtrl', [brokerQuestionCtrl]);

    function brokerQuestionCtrl() {
        var vm = this;

        vm.curPage = 1;
        vm.maxPage = 1;
        vm.a = 1;
        vm.groups = [];
        vm.initgroup = [];
        var questionGroup = [];
        vm.isShow = false;
        vm.broadcast = broadcast;

        vm.init = function (groupsArr) {
            console.log(groupsArr);
            vm.groups = groupsArr;
            vm.initgroup = groupsArr;
            questionGroup = groupsArr;
            for (var i = 0; i < vm.groups.length; i++) {
                if (vm.maxPage < vm.groups[i].PageNumber) {
                    vm.maxPage = vm.groups[i].PageNumber;
                }
            }
        };

        vm.back = function () {
            if (vm.curPage === 1) {
                window.location.href = webUrlConstService.newBusinessIndex;
            }
            else {
                vm.curPage = vm.curPage - 1;
            }
        };

        vm.save = function () {
            var questionAnswer = [];
            for (var i = 0; i < vm.groups.length; i++) {
                var questions = vm.groups[i].QuestionVM;
                if (questions !== null) {
                    for (var j = 0; j < questions.length; j++) {
                        questionAnswer.push(
                            {
                                Question: questions[j].QuestionCode,
                                Answer: questions[j].SelectedValue
                            });
                    }
                }
            }
            console.log(questionAnswer);
        };

        vm.hidequestion = function () {
            console.log(questionGroup);
            for (var i = 0; i < vm.groups.length; i++) {
                var questions = vm.groups[i].QuestionVM;
                if (questions !== null) {
                    for (var j = 1; j < questions.length; j++) {
                        console.log(questions[j].HideCondition);
                        if (questions[j].HideCondition) {
                            console.log('abcd');
                        }
                        else {
                            console.log('error value');
                        }

                    }
                }
            }
        };

        function broadcast() {
            console.log('broadcast this', this);
            $scope.$broadcast("MyEvent", data);
            vm.$broadcast("MyEvent", data);
        }

    }//end of brokerQuestionCtrl
})();;
(function () {
    'use strict';

    var appUI = angular.module('appUI');

    appUI.controller('userCtrl', ['$rootScope', '$q', '$window', '$timeout', 'responsiveService', 'userService', 'sessionStorageService', 'apiUrlConstService', 'cfpLoadingBar', 'webUrlConstService', '$log', 'utilityService', userCtrl]);

    function userCtrl($rootScope, $q, $window, $timeout, responsiveService, userService, sessionStorageService, apiUrlConstService, cfpLoadingBar, webUrlConstService, $log, utilityService) {
        var vm = this;

        //declarations
        vm.password = "";
        vm.confirmPassword = "";
        vm.hash = "";
        vm.init = initialization;
        vm.resetPassword = resetPassword;
        vm.loader = false;

        //implementations
        function initialization(hash) {
            //get the hash from the url..
            vm.hash = utilityService.getQueryString('hash');
            vm.exp = utilityService.getQueryString('exp');
            var expDate = new Date(vm.exp * 1000);
            var utcExpDate = new Date(expDate.getUTCFullYear(), expDate.getUTCMonth(), expDate.getUTCDate(), expDate.getUTCHours(), expDate.getUTCMinutes(), expDate.getUTCSeconds());
            var currentDate = new Date();
            var utcCurrentDate = new Date(currentDate.getUTCFullYear(), currentDate.getUTCMonth(), currentDate.getUTCDate(), currentDate.getUTCHours(), currentDate.getUTCMinutes(), currentDate.getUTCSeconds());            
            if (utcExpDate < utcCurrentDate) {
                toastr.error("Link Expired. Please try again.");
                $log.log("Link Expired. Please try again");
                $timeout(function () {
                    $window.location.href = webUrlConstService.loginURL;
                }, 3000);


            }
            vm.loader = false;
        }

        function resetPassword(event) {
            vm.loader = true;
            cfpLoadingBar.start();
            //validate the username and password.
            if (vm.password || vm.confirmPassword || vm.hash) {
                if (vm.password !== vm.confirmPassword) {
                    toastr.error("Password not matched with the confirm password!");
                    cfpLoadingBar.complete();
                    return;
                }

                userService.passwordPolicyCheck(vm.password).then(function (result) {
                    if (result.data === false) {
                        toastr.error("Please enter a valid password.");
                        vm.loader = false;
                        cfpLoadingBar.complete();
                    }
                    else if (result.data === true) {
                        var request = userService.userResetPassword({ newPassword: vm.password, confirmNewPassword: vm.confirmPassword, hash: vm.hash });
                        request.then(function (data) {
                            cfpLoadingBar.complete();
                            if (data.status) {

                                toastr.info("Updated Password successfully.");
                                $timeout(function () {
                                    $window.location.href = webUrlConstService.loginURL;
                                }, 2000);

                            }
                            else {
                                var error = data.errors[0];
                                var errorMessage = error.message;
                                toastr.error(errorMessage);
                                vm.loader = false;
                            }
                        },
                            function (response) {
                                console.log("Login API Call Error: ", response);
                                cfpLoadingBar.complete();
                                toastr.error("Service is currently not available. Please try again or contact system administrator.");
                                vm.loader = false;
                            });
                    }
                });
            }
            cfpLoadingBar.complete();
        }


        vm.init();
    }
})();;
(function () {
    'use strict';

    var appUI = angular.module('appUI');

    appUI.controller('resetPasswordCtrl', ['$rootScope', '$q', '$window', '$timeout', 'responsiveService', 'userService', 'sessionStorageService', 'apiUrlConstService', 'cfpLoadingBar', 'webUrlConstService', '$log', 'utilityService', resetPasswordCtrl]);

    function resetPasswordCtrl($rootScope, $q, $window, $timeout, responsiveService, userService, sessionStorageService, apiUrlConstService, cfpLoadingBar, webUrlConstService, $log, utilityService) {
        var vm = this;

        //declarations
        vm.newPassword = "";
        vm.confirmPassword = "";
        vm.oldPassword = "";                
        vm.resetPassword = resetPassword;
        vm.loader = false;
        
        function resetPassword(event) {
            vm.loader = true;
            cfpLoadingBar.start();
            //validate the username and password.
            if (vm.newPassword || vm.confirmPassword || vm.oldPassword) {
                if (vm.newPassword !== vm.confirmPassword) {
                    toastr.error("Password not matched with the confirm password!");
                    cfpLoadingBar.complete();
                    return;
                }
                
                userService.passwordPolicyCheck(vm.newPassword).then(function (result) {
                    if (result.data === false) {
                        toastr.error("Please enter a valid password.");
                        vm.loader = false;
                        cfpLoadingBar.complete();
                    }
                    else if (result.data === true) {
                        var request = userService.userChangePassword({ newPassword: vm.newPassword, confirmNewPassword: vm.confirmPassword, oldPassword: vm.oldPassword });
                        request.then(function (data) {
                            cfpLoadingBar.complete();
                            if (data.status) {

                                toastr.info("Updated Password successfully.");
                                $timeout(function () {
                                    $window.location.href = webUrlConstService.loginURL;
                                }, 2000);

                            }
                            else {
                                var error = data.errors[0];
                                var errorMessage = error.message;

                                toastr.error(error.message);
                                vm.loader = false;
                            }
                        },
                            function (response) {
                                console.log("Login API Call Error: ", response);
                                cfpLoadingBar.complete();
                                toastr.error("Service is currently not available. Please try again or contact system administrator.");
                                vm.loader = false;
                            });
                    }
                });
            }
            cfpLoadingBar.complete();
        }        
    }
})();;
(function () {
    'use strict';

    var appUI = angular.module('appUI');

    appUI.controller('loginCtrl', ['$rootScope', '$q', '$window', '$cookies', 'responsiveService', 'disclaimerService', 'loginService', 'userService', 'sessionStorageService', 'webUrlConstService', 'utilityService', 'cfpLoadingBar', 'messageConstService', '$mdDialog', '$log', loginCtrl]);

    function loginCtrl($rootScope, $q, $window, $cookies, responsiveService, disclaimerService, loginService, userService, sessionStorageService, webUrlConstService, utilityService, cfpLoadingBar, messageConstService, $mdDialog, $log) {
        var rootModel = this;
        //$rootScope.tokenTimeOut = null;
        //declarations
        rootModel.username = "";
        rootModel.password = "";
        rootModel.init = initialization;
        rootModel.login = login;
        rootModel.forgotPassword = forgotPassword;
        rootModel.formSubmit = formSubmit;
        rootModel.openModalPopup = openModalPopup;
        rootModel.loader = false;
        
        //implementations

        function initialization(loginData) {
            if (loginData.HasExpired) {
                toastr.error("System has timed out, to process the transaction please log in again.");
            }
            rootModel.ready = true;
            var cookieData = $cookies.get('tokenData');
            rootModel.submitted = false;

            //remove all the data from cookie sessionStorage and localStorage
            if (cookieData != null) {
                $cookies.remove('tokenData', { path: '/' });
            }

            localStorage.clear();
            sessionStorageService.clearAll();
            rootModel.loader = false;
        }

        function formSubmit() {
            rootModel.submitted = true;
        }

        function login(event) {
            rootModel.loader = true;
            cfpLoadingBar.start();
            //validate the username and password.
            if (rootModel.username && rootModel.password) {
                var request = loginService.post({}, { username: rootModel.username, password: rootModel.password });
                //loginService.login(rootModel.username, rootModel.password)

                request.$promise.then(function (data) {
                    cfpLoadingBar.complete();
                    if (data.status) {
                        if (!data.data.IsFirstLoginCompleted) {                                                       
                            $window.location.href = webUrlConstService.changePasswordUrl;
                        }
                        else
                        //rootModel.termsAndConditionData = data.data.disclaimerData;
                        {
                            disclaimerModal(data.data.DisclaimerData, data.data.TokenResponse, event);
                            sessionStorageService.set("tokenTimeOut", data.tokenTimeOut);
                            sessionStorageService.set("tokenLifeStart", (new Date()).getTime());
                            sessionStorageService.set("IsTokenRefreshDeclined", false);
                        }

                        var randomLoginId = utilityService.getRandomIdentity();
                        $cookies.put("randomLoginId", randomLoginId);
                        sessionStorageService.set("randomLoginId", randomLoginId);
                        rootModel.loader = false;
                    }
                    else {
                        var error = data.error;
                        var errorMessage = error.message;
                        toastr.error(errorMessage);
                        rootModel.loader = false;
                    }
                },
                    function (response) {
                        console.log("Login API Call Error: ", response);
                        cfpLoadingBar.complete();
                        toastr.error("Service is currently not available. Please try again or contact system administrator.");
                        rootModel.loader = false;
                    });
            }
            cfpLoadingBar.complete();
        }

        function disclaimerModal(DisclaimerData, TokenResponse, ev) {
            var disclaimerDataId = [];
            if (DisclaimerData.length != 0) {
                var disclaimerData = "";                
                for (var i = 0; i < DisclaimerData.length; i++) {
                    disclaimerDataId.push(DisclaimerData[i].DisclaimerId);
                    disclaimerData = disclaimerData.concat(DisclaimerData[i].Disclaimer);
                }
                var count = null;
                //count the row in brokertermsandcondition
                disclaimerService.getExistingBrokerDetails().then(function (data) {
                    count = data.data;
                    var confirmBankDetails = "";
                    if (count === 1) {
                        confirmBankDetails = $mdDialog.confirm()
                            .title('Some things to update you on....')
                            .htmlContent(disclaimerData)
                            .targetEvent(ev)
                            .ok('I’ve read it - Blue Zebra is awesome');
                    }
                    else {
                        confirmBankDetails = $mdDialog.confirm()
                            .title('Please note')
                            .htmlContent(disclaimerData)
                            .targetEvent(ev)
                            .ok('Accept')
                            .cancel('Decline');
                    }
                    $mdDialog.show(confirmBankDetails).then(function () {
                        //save the token if modal Yes
                        disclaimerService.saveDisclaimerDetail(disclaimerDataId, TokenResponse).then(function () {
                            //saved the disclaimer data successfully
                            $window.location.href = webUrlConstService.homeIndex;
                        }, function (error) {
                            $log.error("error:", error);
                            cfpLoadingBar.complete();
                            toastr.error(messageConstService.errServiceUnavailable);
                        });

                    }, function () {
                        $window.location.href = "/";

                    });
                }); 
            }
            else {
                $window.location.href = webUrlConstService.homeIndex;
            }

        };
        function saveToken(tokenResponse) {
            var tokenData = utilityService.parseJwt(tokenResponse.access_token);
            if (tokenData.exp) {
                var cookieExpiry = new Date(tokenData.exp*1000);
                var config = { secure: true };
                $cookies.put('tokenData', JSON.stringify(tokenResponse), {
                    expires: cookieExpiry,
                    path: "/"
                }, config);
            }
            else {
                $log.error("expiry time missing!")
            }
           
        }

        function openModalPopup() {
            $('#modal-forgotPasswordForm').modal({ show: true, backdrop: 'static', keyboard: false });
        }

        function forgotPassword() {

            userService.userSentResetPasswordEmail(rootModel.forgotPasswordEmail).then(function (data) {
                $log.log("data:", data);
                if (data.status) {
                    //check ur email notification
                    toastr.info("Please check your email.");
                    $window.location.href = "/";
                    hideForgotModal();
                }
                else {
                    if (data.errors.length > 0) {
                        if (data.errors[0].number === 91) {
                            toastr.error(data.errors[0].message);
                        }
                        else {
                            toastr.error("Something went wrong.");
                        }
                    }
                    else {
                        toastr.error("Something went wrong.");
                    }

                }

            }, function (error) {
                $log.error("error:", error);
                toastr.error("Something went wrong.");
            });
        }

        var hideForgotModal = function() {
            $('#modal-forgotPasswordForm').modal('hide');
        }
    }
})();;
(function () {
    'use strict';

    angular.module('appUI')
        .controller('navigationBarCtrl', ['responsiveService', 'routeConstService', 'sessionStorageService', 'keyConstService','$window', navigationBarCtrl]);


    function navigationBarCtrl(responsiveService, routeConstService, sessionStorageService,keyConstService, $window) {
        var vm = this;
        vm.showExpanded = false;
        vm.agent = {};
        /*
        vm.routes = [
            { url: "/home", state: 'dashboard', title: "Home Page", glyph: "fa fa-tachometer", selected: true },            
            { url: "/policies", state: 'policies', title: "Search Policy", glyph: "fa fa-file-text", selected: false },
            { url: "/client", state: 'client', title: "Manage Clients", glyph: "fa fa-user", selected: false },
            { url: "/DocumentLibrary/Index", className: true, state: 'Resourcelibrary', title: "Resource library", glyph: "fa fa-user", selected: false },
            { url: "/ClaimTab/Index", className: true, state: 'Claim', title: "Claims", glyph: "fa fa-user", selected: false }
            //Commented below code as there is no requirement - 27 / 02 / 2018 Ankit
            //{ url: "/reports", state: 'reports', title: "Reports", glyph: "fa fa-file-text", selected: false }
        ];
        */
        vm.routes = []

        vm.routes.push({ url: "/home", state: 'dashboard', title: "Home Page", glyph: "fa fa-tachometer", selected: true });
        var IsBranchViewOnly = sessionStorageService.get('IsBranchViewOnly');
        if (IsBranchViewOnly === "true") {
            vm.routes.push({
                state: 'quotes', title: "Quote", glyph: "fa fa-file", selected: false, subRoutes: [
                    { state: 'searchQuote', url: "/quotes", title: "Search Quote", glyph: "fa fa-file-text", selected: false }
                    , { url: "/newbusiness", state: 'newbusiness', title: "Create Quote", glyph: "fa fa-file-folder", selected: false }
                ],
                expanded: true
            });
        }
        else {
            vm.routes.push({
                state: 'quotes', title: "Quote", glyph: "fa fa-file", selected: false, subRoutes: [
                    { state: 'searchQuote', url: "/quotes", title: "Search Quote", glyph: "fa fa-file-text", selected: false }                    
                ],
                expanded: true
            });
        }
        vm.routes.push({ url: "/policies", state: 'policies', title: "Search Policy", glyph: "fa fa-file-text", selected: false });
        vm.routes.push({ url: "/client", state: 'client', title: "Manage Clients", glyph: "fa fa-user", selected: false });
        
        vm.routes.push({ url: "/DocumentLibrary/Index", className: true, state: 'Resourcelibrary', title: "Resource library", glyph: "fa fa-user", selected: false });
        
        vm.routes.push({ url: "/ClaimTab/Index", className: true, state: 'Claim', title: "Claims", glyph: "fa fa-user", selected: false });


        //Commented below code as there is no requirement - 27 / 02 / 2018 Ankit
        //{ url: "/reports", state: 'reports', title: "Reports", glyph: "fa fa-file-text", selected: false }
        

        var isPackageManagerOn = sessionStorageService.get('IsPackageManagerOn');
        if (isPackageManagerOn === "true") {
            vm.routes.push({ url: "/packageManager", state: 'managePackage', title: "Manage Package", glyph: "fa fa-user", selected: false });
        }    

        vm.routes.push({ url: "/Reports", state: 'Reports', title: "Reports", glyph: "fa fa-file-text", selected: false });
        

        vm.route = vm.routes[0];
        

        /**
         * @description
         * get display styling related information for given route
         */

        vm.getClass = function (route) {
            if (vm.route.state === route.state) {
                return 'active';
            }

            return '';
        };




        vm.getSubClass = function (route) {

            var current = vm.route;
            if (!current || !current.title) {
                return '';
            }

            if (current.name)
            {
                var currState = current.name;

                if (vm.route.state == route.state) {
                    return 'subactive';
                }
            }
            return '';
        };

        vm.showChild = function (route) {
            //Remove PrimaryClientInsuredId
            sessionStorageService.remove(keyConstService.PrimaryInsuredId);
            if (route.subRoutes) {
                vm.showExpanded = true;
            }
        };

        vm.sign = function (route) {
            if (route.subRoutes)
            {
                return true;
            }
        };
        /**
         * @description
         * navigates the clicked item on side-bar menu
         */
        vm.navigate = function () {
            vm.navigateTo(vm.route);
        };

        vm.navigateTo = function (route) {
            if (route.url) {
                if (route.state === 'reports') {
                    return;
                }
                window.localStorage.setItem(routeConstService.routeName, JSON.stringify(route));
                vm.route = route;
                console.log('route.url', route.url);
                sessionStorageService.remove(keyConstService.endorsementRequestVM);
                location = route.url;
                //location = window.location.href.replace(window.location.search, '');
            }
        }

        /**
         * @description
         * on smaller screen, the drop-down popup menu needs to be explicitly collapsed
         */
        vm.collapse = function (event) {
            if (responsiveService.runningOnSmallDevice() || responsiveService.runningOnExtraSmallDevice()) {
                $(".navbar-collapse").collapse('hide');
            }
        };
        if (window.localStorage.getItem(routeConstService.routeName) != null) {
            vm.route = JSON.parse(window.localStorage.getItem(routeConstService.routeName));
        }
    }
})();;
(function () {
    'use strict';

    var appUI = angular.module('appUI');
    angular.module('appUI').controller('cancellationCtrl', ['cancellationConstService', 'sessionStorageService', 'webUrlConstService', 'apiUrlConstService', 'quotesService', 'messageConstService', '$window', 'utilityService', 'dateService', 'keyConstService', 'portalV2Service', cancellationCtrl]);

    function cancellationCtrl(cancellationConstService, sessionStorageService, webUrlConstService, apiUrlConstService, quotesService, messageConstService, $window, utilityService, dateService, keyConstService, portalV2Service) {
        var vm = this;

        vm.onEffectiveDateChange = onEffectiveDateChange;
        vm.onEffectiveDateChangeInsuredRequest = onEffectiveDateChangeInsuredRequest;
        vm.cancellationReason = cancellationReason;
        vm.init = init;
        vm.getCancellationQuote = getCancellationQuote;
        vm.getBackLink = getBackLink;
        vm.brokerFeeChanged = brokerFeeChanged;
        vm.discard = discard;
        vm.reasonChanged = reasonChanged;
        var orignalBrokerFee = 0;
        var orignalBrokerFeeGST = 0;
        var cancellationReason = null;
        vm.disableButtons = false;
        vm.continueOrNavigateBackToPackageManager = continueOrNavigateBackToPackageManager;
        vm.smePrefixUrl = window.location.protocol + '//' + window.location.host + keyConstService.SMEUrlPrefix;
        vm.newQuoteTransactionId = "";
        vm.redirectToSME = redirectToSME;
        vm.BrokerPortalV2Debugging = false;
        function init(model) {
            var isPM = sessionStorageService.get('IsPackageManagerNavigationMode');
            var renewalCounter = sessionStorageService.get('RenewalCounter');
            if (isPM === "true" || renewalCounter !== null) {
                vm.showManagePkg = true;
            }
            vm.BrokerPortalV2Debugging = model.BrokerPortalV2Debugging;
            if (!model.ErrorMessage) {
                vm.data = utilityService.toCamel(model);
                orignalBrokerFee = vm.data.brokerFee;
                orignalBrokerFeeGST = vm.data.brokerFeeGST;
                
                if (vm.data.cancellationReason !== null) {
                    cancellationReason = vm.data.cancellationReason.Value;
                    if (vm.data.cancellationReason.value === cancellationConstService.NotPaid || vm.data.cancellationReason.value === cancellationConstService.ProcessingError)
                        vm.effectiveDateDisabled = true;
                    else if (vm.data.cancellationReason.value === cancellationConstService.InsuredRequest) {
                        vm.isReasonInsuredRequest = true;
                }
                
                }
            } else if (model.ErrorMessage) {
                toastr.error(messageConstService.errServiceUnavailable);
            }
        }

        function createDateObject(dateString) {
            var parts = dateString.split("/");
            return new Date(parts[2], parts[1] - 1, parts[0]);
        }

        function onEffectiveDateChange(field) {
            checkBackdateValidation(field);
        }

        function onEffectiveDateChangeInsuredRequest(field) {
            var dateRangeResponse = dateService.validateDateRange(field.$modelValue, vm.data.minimumCancellationDateInsuredRequest, vm.data.maximumCancellationDate);
            if (!dateRangeResponse.isValid && vm.data.cancellationEffectiveDate) {
                toastr.warning(messageConstService.errEffectiveDateNotAllowed);
                vm.data.cancellationEffectiveDate = '';
                return;
            }
        }

        function getCancellationQuote(form) {            
            vm.disableButtons = true;
            if (form.$valid) {
                if (vm.data.product === keyConstService.CommercialMotorProductDescription) {
                    quotesService.generateCancellationQuoteV2(vm.data).then(function (response) {
                        if (response.errors && response.errors.length > 0) {
                            toastr.error(messageConstService.errCancellationSubmit);
                            vm.disableButtons = false;
                        } else {
                            vm.newQuoteTransactionId = response.data;
                            var encryptedParam = sessionStorageService.getEncryption("quoteTransactionId=" + response.data + '&productId=' + keyConstService.CommercialMotorProductId);
                            portalV2Service.getV2Token().then(function (resp) {
                                var redirectTo = keyConstService.CommercialMotorUrlPrefix + keyConstService.CommercialMotorQuoteSummary + encryptedParam;
                                portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                            });
                        }
                    }, function (error) {
                        toastr.error(messageConstService.errCancellationSubmit);
                        vm.disableButtons = false;
                    });
                } else {
                    quotesService.generateCancellationQuote(vm.data).then(function (response) {
                        if (response.errors && response.errors.length > 0) {
                            toastr.error(messageConstService.errCancellationSubmit);
                            vm.disableButtons = false;
                        } else {
                            vm.newQuoteTransactionId = response.data.transactionId;
                            // redirect to sme screen in case of sme product
                            if (vm.data.productCode === keyConstService.SMEProductCode) {
                                // 2 for Submit button
                                vm.redirectToSME(2);
                                return;
                            }
                            $window.location.href = webUrlConstService.cancellationQuote + sessionStorageService.getEncryption("qid=" + response.data.transactionId);

                        }
                    }, function (error) {
                        toastr.error(messageConstService.errCancellationSubmit);
                        vm.disableButtons = false;
                    });
                }
                return;
            }
        }

        function brokerFeeChanged(field) {
            if (orignalBrokerFee < -vm.data.brokerFee || vm.data.brokerFee > 0) {
                field.$setValidity("brokerFeeGreater", false);
                return;
            } else {
                field.$setValidity("brokerFeeGreater", true);
            }

            quotesService.getGstAmount({
                State: vm.data.state,
                Amount: vm.data.brokerFee,
                StartDateString: vm.data.policyEffectiveDate,
                LineOfBusiness: vm.data.product
            }).then(function (response) {
                if (response.errors && response.errors.length > 0) {
                    toastr.error(messageConstService.errServiceUnavailable);
                } else {
                    vm.data.brokerFeeGST = response.data;
                }
            }, function (error) {
                toastr.error(messageConstService.errServiceUnavailable);
            });
        }

        function discard() {
            vm.disableButtons = true;
            let actionButton = sessionStorageService.get('ActionButtonEnable');
            if (actionButton === null || actionButton === "") {
                actionButton = false;
            }            
            vm.actionEnable = JSON.parse(actionButton);
             // redirect to sme screen in case of sme product
            if (vm.data.productCode === keyConstService.SMEProductCode) {

                if (vm.data.isEditQuote && vm.data.isEditQuote === true) {
                    vm.redirectToSME(4);
                }
                else {
                    // 1 for discard button
                    vm.redirectToSME(1);
                }

                return;
            }            

            if (vm.data.isEditQuote === null)
                if (vm.showManagePkg && vm.actionEnable !== true) {
                    vm.packageNumber = sessionStorageService.get('PackageNumberInformation');
                    vm.renewalCounter = sessionStorageService.get('RenewalCounter');
                    sessionStorageService.remove('IsPackageManagerNavigationMode');
                    sessionStorageService.remove('PackageNumberInformation');
                    sessionStorageService.remove('RenewalCounter');
                    $window.location.href = webUrlConstService.getPackageInfo + sessionStorageService.getEncryption("packageNumber=" + JSON.parse(vm.packageNumber) + "&&renewalCounter=" + vm.renewalCounter);
                }
                else {
                    //// redirect to Commercial Motor Policy summary Page
                    if (vm.data.product === keyConstService.CommercialMotorProductDescription){
                        portalV2Service.getV2Token().then(function (resp) {
                            var redirectTo = keyConstService.CommercialMotorUrlPrefix + keyConstService.CommercialMotorPolicyBound + sessionStorageService.getEncryption("quoteTransactionId=" + vm.data.quoteTransactionId + '&productId=' + keyConstService.CommercialMotorProductId);
                            portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                        });                        
                    }
                    else {
                        $window.location.href = webUrlConstService.bindIndex + sessionStorageService.getEncryption("id=" + vm.data.policyTransactionId);
                    }                    
                }
            else
                if (vm.showManagePkg && vm.actionEnable !== true) {
                    vm.packageNumber = sessionStorageService.get('PackageNumberInformation');
                    vm.renewalCounter = sessionStorageService.get('RenewalCounter');
                    sessionStorageService.remove('IsPackageManagerNavigationMode');
                    sessionStorageService.remove('PackageNumberInformation');
                    sessionStorageService.remove('RenewalCounter');
                    $window.location.href = webUrlConstService.getPackageInfo + sessionStorageService.getEncryption("packageNumber=" + JSON.parse(vm.packageNumber) + "&&renewalCounter=" + vm.renewalCounter);
                }
                else {
                    //// redirect to Commercial Motor QUote summary page
                    if (vm.data.product === keyConstService.CommercialMotorProductDescription) {
                        portalV2Service.getV2Token().then(function (resp) {
                            var redirectTo = keyConstService.CommercialMotorUrlPrefix + keyConstService.CommercialMotorQuoteSummary + sessionStorageService.getEncryption("quoteTransactionId=" + vm.data.quoteTransactionId + '&productId=' + keyConstService.CommercialMotorProductId);
                            portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                        });                        
                    }
                    else {
                        $window.location.href = webUrlConstService.cancellationQuote + sessionStorageService.getEncryption("qid=" + vm.data.quoteTransactionId);
                    }                    
                }
        }

        function reasonChanged(field) {
            if (vm.data.cancellationReason.value === cancellationConstService.NotPaid || vm.data.cancellationReason.value === cancellationConstService.ProcessingError) {
                vm.data.cancellationEffectiveDate = vm.data.policyEffectiveDate;
                vm.effectiveDateDisabled = true;
                field.$setValidity("backdated", true);
            } else {
                vm.effectiveDateDisabled = false;
                vm.data.cancellationEffectiveDate = "";
            }

            if (vm.data.cancellationReason.value === cancellationConstService.InsuredRequest || vm.data.cancellationReason.value === cancellationConstService.TotalLoss) {
                vm.isReasonInsuredRequest = true;
            }
            else {
                vm.isReasonInsuredRequest = false;
            }
            checkBackdateValidation(field);
        }

        function checkBackdateValidation(field) {
            if (field.$viewValue && vm.data.cancellationReason && (vm.data.cancellationReason.value === cancellationConstService.InsuredRequest || vm.data.cancellationReason.value === cancellationConstService.TotalLoss)) {
                var currentDate = new Date();
                var effectiveDate = createDateObject(vm.data.cancellationEffectiveDate);
                if ((currentDate - effectiveDate) / (24 * 3600 * 1000) > vm.data.cancellationNormalBackdateDays) {
                    field.$setValidity("backdated", false);
                }
                else {
                    field.$setValidity("backdated", true);
                }
            }

            if (field.$viewValue && vm.data.cancellationReason) {
                currentDate = new Date();
                effectiveDate = createDateObject(vm.data.cancellationEffectiveDate);
                if ((effectiveDate - currentDate) / (24 * 3600 * 1000) > vm.data.cancellationAllowedForwardDateDays) {
                    field.$setValidity("postdated", false);
                }
                else {
                    field.$setValidity("postdated", true);
                }
            }
        }

        function getBackLink() {
            // redirect to sme screen in case of sme product
            if (vm.data.productCode === keyConstService.SMEProductCode) {
                vm.redirectToSME(3);
                return;
            }

            //// redirect to Commercial Motor
            if (vm.data.product === keyConstService.CommercialMotorProductDescription) {
                portalV2Service.getV2Token().then(function (resp) {
                    var redirectTo = keyConstService.CommercialMotorUrlPrefix + keyConstService.CommercialMotorQuoteSummary + sessionStorageService.getEncryption("quoteTransactionId=" + vm.data.quoteTransactionId + '&productId=' + keyConstService.CommercialMotorProductId);
                    portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                });

                return;
            }

            $window.location.href = webUrlConstService.cancellationQuote + sessionStorageService.getEncryption("qid=" + vm.data.quoteTransactionId);
        }

        function continueOrNavigateBackToPackageManager() {
            var packageNumber = sessionStorageService.get('PackageNumberInformation');
            var renewalCounter = sessionStorageService.get('RenewalCounter');
            sessionStorageService.remove('IsPackageManagerNavigationMode');
            sessionStorageService.remove('PackageNumberInformation');
            sessionStorageService.remove('RenewalCounter');
            sessionStorageService.remove(keyConstService.ActionButtonEnable);
            $window.location.href = webUrlConstService.getPackageInfo + sessionStorageService.getEncryption("packageNumber=" + JSON.parse(packageNumber) + "&&renewalCounter=" + renewalCounter);
        }

         // redirect to sme screen in case of sme product
        function redirectToSME(redirectFrom) {
            var sufix = "";
            // redirect from discard
            if (redirectFrom === 1) {
                sufix = keyConstService.SMEPolicyPound;
            }
            else if (redirectFrom === 2) // redirect from submit
            {
                sufix = keyConstService.SMEPolicyCancel + "?" + sessionStorageService.getEncryption("oldQuoteTransactionId=" + vm.data.quoteTransactionId + "&&oldQuoteCaseId=" + vm.data.quoteCaseId + "&&newQuoteTransactionId=" + vm.newQuoteTransactionId);
            }
            else if (redirectFrom === 3) {
                // redirect to view quote on previous button
                var encryptedParam = sessionStorageService.getEncryption("quoteTransactionId=" + vm.data.quoteTransactionId);
                sufix = keyConstService.SMEViewQuoteLink + '?' + encryptedParam;
            }
            else if (redirectFrom === 4) {
                // redirect to view quote on previous screen
                sufix = keyConstService.CancellationPremiumSummaryLink;
            }

            portalV2Service.getV2Token().then(function (resp) {
                portalV2Service.setKeyToLocalStorage(resp.data.data);
                $window.location.href = vm.smePrefixUrl + sufix;
            });

        }
    }
})();
;
(function () {
    'use strict';

    var appUI = angular.module('appUI');
    angular.module('appUI').controller('cancellationQuoteCtrl', ['cancellationService', 'keyConstService', 'sessionStorageService', 'webUrlConstService', 'apiUrlConstService', 'bindService', 'messageConstService', '$window', 'utilityService', 'quoteCaseService', 'quotesService', '$http', '$timeout', 'Blob', 'FileSaver', '$mdDialog', cancellationQuoteCtrl]);

    function cancellationQuoteCtrl(cancellationService, keyConstService, sessionStorageService, webUrlConstService, apiUrlConstService, bindService, messageConstService, $window, utilityService, quoteCaseService, quotesService, $http, $timeout, Blob, FileSaver, $mdDialog) {
        var vm = this;

        vm.init = init;
        vm.discard = discard;
        vm.confirm = confirm;
        vm.bindDocumentGrid = bindDocumentGrid;
        vm.docDetail = [];
        vm.showNBQuoteDocGrid = false;
        vm.coverageType = null;
        vm.coverType = null;
        vm.GetQuoteDownload = GetQuoteDocDownload;
        vm.GetQuoteEmail = GetQuoteDocEmail;
        vm.getLink = getLink;
        vm.getViewLink = getViewLink;
        vm.referToUnderwriter = referToUnderwriter;
        vm.AttachementData = [{ attachementText: null, file: null }]
        vm.addAttachementData = addAttachementData;
        vm.removeAttachementData = removeAttachementData;
        vm.numberOfInstallment = 1;
        vm.brokerComment = '';
        vm.underwriterComment = '';
        vm.disableValue = false;
        vm.hideUnderwriterComments = true;
        vm.IsEditEnabled = true;
        vm.hideAttachments = false;
        vm.Isdisabletoberef = false;
        vm.disablebrokercomment = false;
        vm.underwriterDeclined = false;
        vm.discardDeclinedQuote = discardDeclinedQuote;
        vm.brokerbranchcheck;
        vm.disableButtons = false;
        vm.lastBoundTransaction = null;
        vm.quoteTransacionId = null;
        vm.continueOrNavigateBackToPackageManager = continueOrNavigateBackToPackageManager;
        vm.disbaleCopyQuote = false;

        function init(model, bbcheck) {
            vm.lastBoundTransaction = model.PolicyTransactionId;
            sessionStorageService.set('IsBranchViewOnly', bbcheck);
            vm.brokerbranchcheck = sessionStorageService.get('IsBranchViewOnly') !== "false";
            var isPM = sessionStorageService.get('IsPackageManagerNavigationMode');
            var renewalCounter = sessionStorageService.get('RenewalCounter');
            if (isPM === "true" || renewalCounter !== null) {
                vm.showManagePkg = true;
            }
            if (model != null && !model.ErrorMessage) {
                vm.responseData = utilityService.toCamel(model);
            } else if (model == null || model.ErrorMessage) {
                toastr.error(messageConstService.errServiceUnavailable);
            }

            if (vm.responseData.status.toLowerCase() === keyConstService.declineQuoteStatus.toLowerCase()) {
                vm.disableValue = true;
                vm.IsEditEnabled = false;
                vm.hideUnderwriterComments = false;
                vm.brokerComment = vm.responseData.brokerComment;
                vm.underwriterComment = vm.responseData.underwriterComment;
                vm.underwriterDeclined = true;
            }

            if (vm.responseData.status.toLowerCase() === keyConstService.referredQuoteStatus.toLowerCase()) {
                vm.disableValue = true;
                vm.IsEditEnabled = false;
            }

            if (vm.responseData.status.toLowerCase() === keyConstService.moreInfoQuoteStatus.toLowerCase()) {
                vm.disableValue = false;
                vm.IsEditEnabled = false;
                vm.hideUnderwriterComments = false;
                vm.underwriterComment = vm.responseData.underwriterComment;
            }   
            if (vm.responseData.status.toLowerCase() === keyConstService.referredReturnQuoteStatus.toLowerCase()) {
                vm.disableValue = false;
                vm.IsEditEnabled = true;
                vm.disablebrokercomment = true;
                vm.hideUnderwriterComments = false;
                vm.hideAttachments = true;
                vm.Isdisabletoberef = true;
                vm.underwriterComment = vm.responseData.underwriterComment;
            }
            if (vm.premiumResponseData) {
                if (vm.premiumResponseData.quoteTransaction.status.toLowerCase() === keyConstService.toBeReferredQuoteStatus.toLowerCase()) {
                    vm.hideUnderwriterComments = false;
                    vm.underwriterComment = vm.premiumResponseData.underWritterComment;
                }
            }

            if (vm.responseData.lineOfBusiness === keyConstService.PaProductDescription) {
                vm.disbaleCopyQuote = true;
            }
        }

        function discard() {
            vm.disableButtons = true;
            vm.actionEnable = JSON.parse(sessionStorageService.get('ActionButtonEnable'));
            let policytransactionid = sessionStorageService.getEncryption('id=' + vm.responseData.policyTransactionId);
            if (vm.disableValue) {
                if (vm.showManagePkg) {
                    continueOrNavigateBackToPackageManager();
                }
                else {
                    $window.location.href = webUrlConstService.bindIndex + policytransactionid;
                }
            }
            else {
                cancellationService.dropCancellationQuote(vm.responseData.quoteTransactionId).then(function (response) {
                    if (response.errors !== null && response.errors.length > 0) {
                        toastr.error(messageConstService.errServiceUnavailable);
                        vm.disableButtons = false;
                        return;
                    }
                    if (vm.showManagePkg && vm.actionEnable !== true) {
                        continueOrNavigateBackToPackageManager();
                    }
                    else {
                        $window.location.href = webUrlConstService.bindIndex + policytransactionid;
                    }
                }, function (error) {
                    toastr.error(messageConstService.errServiceUnavailable);
                    vm.disableButtons = false;
                });
            }
        }

        ////discarding underwriter declined cancellation quote
        function discardDeclinedQuote() {
            vm.disableButtons = true;
            quotesService.quoteDiscardRequest(vm.responseData.quoteTransactionId).then(function (result) {
                if (result.data) {
                    if (vm.showManagePkg) {                        
                            continueOrNavigateBackToPackageManager();
                    }
                    else {
                        $timeout(function () {
                            var Id = vm.responseData.policyTransactionId;
                            window.location = "/Bind?" + sessionStorageService.getEncryption("id=" + Id);
                        }, 1000);
                    }
                } else {
                    toastr.error(messageConstService.errServiceUnavailable);
                    vm.disableButtons = false;
                }
            },
                function (error) {
                    $log.error('error', error);
                    toastr.error(messageConstService.errServiceUnavailable);
                    vm.disableButtons = false;
                });
        }

        function confirm() {   
            vm.disableButtons = true;
            //var verifyExpiration = verifyExpiry(vm.responseData);
            var verifyExpiration = false;
            if (!verifyExpiration) {
                bindService.bind(vm.responseData.quoteTransactionId, null, vm.responseData.brokermanagedPayment).then(function (response) {
                    if (response.data.errors !== null && response.data.errors.length > 0) {
                        if (response.data.errors[0].number === 3) {
                            toastr.error(messageConstService.quoteExpired);
                            vm.disableButtons = false;
                        }
                        else if (response.data.errors[0].number === 2) {
                            quoteReferralRequest(vm.responseData.quoteTransactionId);
                            vm.disableButtons = false;
                        }
                        else {
                            toastr.error(messageConstService.errService3rdAPIUnavailable);
                            vm.disableButtons = false;
                        }
                        return;
                    }
                    sessionStorageService.set(keyConstService.bindData, response.data);
                    $window.location.href = webUrlConstService.bindIndex + sessionStorageService.getEncryption("id=" + response.data.policyTransactionId);
                }, function (error) {
                    toastr.error(messageConstService.errServiceUnavailable);
                    vm.disableButtons = false;
                });
            }
            else {
                var endorsedetail = $mdDialog.alert()
                    .escapeToClose(false)
                    .title('Policy has been expired')
                    .htmlContent('We can not cancel this policy')
                    .ariaLabel('Lucky day')
                    .ok('Close')
                $mdDialog.show(endorsedetail)
                vm.disableButtons = false;
            }
        }

        function quoteReferralRequest(transactionId) {
           quotesService.quoteReferralRequest(transactionId).then(function (result) {
                if (result.data) {
                    $window.location.reload();
                }
            }, function (error) { $log.error('error', error); });
        }

        ////To check the expiration of the policy when cancellation is pending
        function verifyExpiry(data) {
            var policyExpiryTime = data.policyExpirationTime;
            var currentDate = moment(new Date()).format('YYYY-MM-DD');
            var expirationDate = moment(data.expirationDate).format('YYYY-MM-DD');
            var currentTime = moment(new Date()).format('HH:mm:ss');
            if ((expirationDate < currentDate) || (expirationDate == currentDate && currentTime >= policyExpiryTime)) {
                return true;
            }
            else {
                return false;
            }
        }

        function bindDocumentGrid(coverage, quoteTransactionid) {
            var quoteDocGrid = quoteCaseService.bindDocumentGrid({
                coverType: vm.coverType,
                coverageType: vm.coverageType,
                quoteTransactionId: vm.responseData.quoteTransactionId
            })
                .then(function (result) {
                    if (vm.showNBQuoteDocGrid === true)
                        vm.showNBQuoteDocGrid = false;
                    else
                        vm.showNBQuoteDocGrid = true;
                    vm.docDetail = result.data;
                    return result;
                });           
        }

        function GetQuoteDocDownload(quoteTransactionId, referenceNumber) {
            return cancellationService.GetQuoteDownloadSelected(quoteTransactionId, referenceNumber, vm.docDetail, vm.responseData.quoteNumber); 
        }

        function GetQuoteDocEmail(quoteTransactionId, referenceNumber) {
            return cancellationService.GetQuoteEmailSelected(quoteTransactionId, referenceNumber, vm.docDetail, vm.responseData.quoteNumber);
        }
           

        function getViewLink() {

            $window.location.href = webUrlConstService.CancellationViewQuote + sessionStorageService.getEncryption("quoteId=" + vm.responseData.quoteTransactionId);
        }

        function getLink()
        {
            $window.location.href = webUrlConstService.CancellationViewQuote + sessionStorageService.getEncryption("quoteId=" + vm.responseData.quoteTransactionId + "&&hasEdit=true");
        }

        vm.GetCopyQuoteLink = function () {
            bindService.getBoundTransaction(vm.lastBoundTransaction, false).then(function (result) {
                vm.quoteTransacionId = result.data;
                sessionStorageService.set(keyConstService.CopyQuoteOldTransactionId, vm.quoteTransacionId);
                location.href = webUrlConstService.newBusinessIndex + sessionStorageService.getEncryption("transactionId=" + vm.quoteTransacionId + "&&" + "hasCopyQuote=" + true);
            });
        };

        function continueOrNavigateBackToPackageManager() {
            var packageNumber = sessionStorageService.get('PackageNumberInformation');
            var renewalCounter = sessionStorageService.get('RenewalCounter');
            sessionStorageService.remove('IsPackageManagerNavigationMode');
            sessionStorageService.remove('PackageNumberInformation');
            sessionStorageService.remove('RenewalCounter');
            sessionStorageService.remove(keyConstService.ActionButtonEnable);
            $window.location.href = webUrlConstService.getPackageInfo + sessionStorageService.getEncryption("packageNumber=" + JSON.parse(packageNumber) + "&&renewalCounter=" + renewalCounter);
        }

        function referToUnderwriter() {            
            vm.disableButtons = true;
            var detailsForReferral = { QuoteTransactionId: vm.responseData.quoteTransactionId, BrokerComment: vm.brokerComment, QuoteStatus: vm.responseData.status };

            quotesService.quoteReferralAttachement(detailsForReferral, vm.AttachementData).then(function (data) {
                if (data.data) {
                    toastr.info(messageConstService.succdetailUpdated);
                    $timeout(function () {
                        if (vm.showManagePkg) {
                            continueOrNavigateBackToPackageManager();
                        }
                        else {
                            $window.location.href = webUrlConstService.homeIndex;
                        }
                    }, 2000);
                }
                else {
                    toastr.error(messageConstService.errServiceUnavailable);
                    vm.disableButtons = false;
                }
            }, function (error) {
                toastr.error(messageConstService.errServiceUnavailable);
                $log.error('error', error);
                vm.disableButtons = false;
            });

        }

        function addAttachementData() {
            vm.AttachementData.push({ attachementText: null, file: null });
        }

        function removeAttachementData(index) {
            if (vm.AttachementData.length > 1) {
                vm.AttachementData.splice(index, 1);
            }
        }
    }
})();;
var app = angular.module('appUI');


app.directive("numbersOnly", function () {

    return {
        require: 'ngModel',
        link: function (scope, element, attrs, modelCtrl) {
            modelCtrl.$parsers.push(function (inputValue) {
                // this next if is necessary for when using ng-required on your input. 
                // In such cases, when a letter is typed first, this parser will be called
                // again, and the 2nd time, the value will be undefined
                if (inputValue == undefined) return ''
                var transformedInput = inputValue.replace(/[^0-9]/g, '');
                if (transformedInput != inputValue) {
                    modelCtrl.$setViewValue(transformedInput);
                    modelCtrl.$render();
                }

                return transformedInput;
            });
        }
    };
});

app.directive("numbersWithHyphenOnly", function () {

    return {
        require: 'ngModel',
        link: function (scope, element, attrs, modelCtrl) {
            modelCtrl.$parsers.push(function (inputValue) {
                // this next if is necessary for when using ng-required on your input.
                // In such cases, when a letter is typed first, this parser will be called
                // again, and the 2nd time, the value will be undefined
                if (inputValue === undefined) return ''
                var transformedInput = inputValue.replace(/[^0-9-]/g, '');
                if (transformedInput !== inputValue) {
                    modelCtrl.$setViewValue(transformedInput);
                    modelCtrl.$render();
                }

                return transformedInput;
            });
        }
    };
});

function countDecimalPlaces(value) {
    var decimalPos = String(value).indexOf('.');
    if (decimalPos === -1) {
        return 0;
    } else {
        return String(value).length - decimalPos - 1;
    }
}

app.directive('sbPrecision', function () {
    return {
        restrict: 'A',
        require: 'ngModel',
        link: function (scope, element, attributes, ngModel) {
            var precision = attributes.sbPrecision;

            function setPrecision() {
                var value = ngModel.$modelValue;
                var numericContent;
                if (value != undefined && value != null)
                    numericContent = value.toString().replace(',', '');
                //since this is just a mask, don't hide decimal values that
                //go beyond our precision and don't format empty values
                if (value && !isNaN(numericContent) && countDecimalPlaces(value) <= precision) {
                    var formatted = Number(value).toFixed(precision);
                    ngModel.$viewValue = formatted;
                    ngModel.$render();
                }
            }

            element.bind('blur', setPrecision);
            setTimeout(setPrecision, 0); //after initial page render
        }

    };
})


app.directive('sbMin', function () {
    return {
        restrict: 'A',
        require: 'ngModel',
        link: function (scope, element, attributes, ngModel) {

            function minimum(value) {
                if (value != undefined && value != null)
                    value = value.toString().replace(',', '');
                if (!isNaN(value)) {
                    var validity = Number(value) >= attributes.sbMin;
                    ngModel.$setValidity('minvalue', validity)
                }
                return value;
            }

            ngModel.$parsers.push(minimum);
            ngModel.$formatters.push(minimum);
        }

    };
})

app.directive('sbMax', function () {
    return {
        restrict: 'A',
        require: 'ngModel',
        link: function (scope, element, attributes, ngModel) {


            function maximum(value) {
                if (value != undefined && value != null)
                    value = value.toString().replace(',', '');
                if (!isNaN(value)) {
                    var validity = Number(value) <= attributes.sbMax;
                    ngModel.$setValidity('maxvalue', validity);
                }

                return value;
            }

            ngModel.$parsers.push(maximum);
            ngModel.$formatters.push(maximum);
        }

    };
})

app.directive('sbNumber', function () {
    return {
        restrict: 'A',
        require: 'ngModel',
        link: function (scope, element, attributes, ngModel) {


            function validateNumber(value) {
                var validity = !isNaN(value);
                ngModel.$setValidity('number', validity)
                return value;
            }

            ngModel.$parsers.push(validateNumber);
            ngModel.$formatters.push(validateNumber);
        }

    };
})

app.directive('sbMaxPrecision', function () {
    return {
        restrict: 'A',
        require: 'ngModel',
        link: function (scope, element, attributes, ngModel) {

            function maxPrecision(value) {
                if (value != undefined && value != null)
                    value = value.toString().replace(',', '');
                if (!isNaN(value)) {
                    var validity = countDecimalPlaces(value) <= attributes.sbMaxPrecision;
                    ngModel.$setValidity('maxprecision', validity);
                }

                return value;
            }

            ngModel.$parsers.push(maxPrecision);
            ngModel.$formatters.push(maxPrecision);
        }

    };
})

app.directive('twoDecimal', function () {
    return {
        restrict: 'A',
        require: 'ngModel',
        link: function (scope, element, attrs, ngModelCtrl) {
            if (!ngModelCtrl) {
                return;
            }

            ngModelCtrl.$parsers.push(function (val) {
                if (angular.isUndefined(val)) {
                    var val = '';
                }
                var clean = val.replace(/[^0-9\.]/g, '');
                var decimalCheck = clean.split('.');
                
                if (!angular.isUndefined(decimalCheck[1])) {
                    decimalCheck[1] = decimalCheck[1].slice(0, 2);
                    clean = decimalCheck[0] + '.' + decimalCheck[1];
                }

                if (val !== clean) {
                    ngModelCtrl.$setViewValue(clean);
                    ngModelCtrl.$render();
                }
                return clean;
            });

            element.bind('keypress', function (event) {
                if (event.keyCode === 32) {
                    event.preventDefault();
                }
            });
        }
    }
});
;
var app = angular.module('appUI');

app.directive
    ('creditCardType', function () {
        return {
            restrict: 'A',
            require: 'ngModel',
            replace: true,
            transclude: true,
            template: '<input ng-transclude ui-mask-raw="false" ng-blur=validateCard()  placeholder="XXXX-XXXX-XXXX-XXXX"/>',
            link: function (scope, elem, attrs, ctrl) {
                ctrl.$parsers.unshift(function (value) {
                    scope.validateCard = validateCard;
              
                    function validateCard() {
                        if (value.length > 19) {
                            value = value.slice(0, -1);
                            return value;
                        } else if (value.length < 18) {
                            ctrl.$setValidity('pattern', false);
                            scope.cardPaymentForm.cvv.$setValidity('minlength', true);
                            return value;
                        }
                        var copiedInput = angular.copy(value);
                        var transformedInput = copiedInput.replace(/[^0-9]/g, '');

                        if (transformedInput.length === 16 || transformedInput.length === 15) {
                            scope.cctype =
                                (/^5[1-5][0-9]{14}$/.test(transformedInput)) ? "mastercard"
                                    : (/^4[0-9]{12}(?:[0-9]{3})?$/.test(transformedInput)) ? "visa"
                                        : (/^6(?:011|5[0-9]{2})[0-9]{12}$/.test(transformedInput)) ? 'discover'
                                            : (/^3(?:0[0-5]|[68][0-9])[0-9]{11}$/.test(transformedInput)) ? 'diners'
                                                : (/(?:2131|1800|35\d{3})\d{11}$/.test(transformedInput)) ? 'jcb'
                                                    : (/^3[47][0-9]{13}$/.test(transformedInput)) ? 'amex'
                                                        : undefined;

                            if (scope.cctype === undefined) {
                                ctrl.$setValidity('pattern', false);
                                scope.cardPaymentForm.cvv.$setValidity('minlength', true);
                                return value;
                            }
                            if (scope.cctype == 'amex') {
                                if (scope.vm.CVV && scope.vm.CVV.length < 4) {
                                    scope.vm.maxCVVLength = 4;
                                } else if (scope.vm.maxCVVLength != null && scope.vm.maxCVVLength < 4) {
                                    scope.vm.maxCVVLength = 4;
                                }
                            } else {
                                if (scope.vm.CVV && scope.vm.CVV.length > 3) {
                                    scope.vm.maxCVVLength = 3;
                                    scope.cardPaymentForm.cvv.$setValidity('minlength', false);
                                } else if (scope.vm.maxCVVLength != null && scope.vm.maxCVVLength > 3) {
                                    scope.vm.maxCVVLength = 3;
                                }
                            }

                            ctrl.$setValidity('pattern', true);
                            return value;
                        }
                    }
                    ctrl.$setValidity('pattern', true);
                    return value;

                });
            }
        };
    });

app.directive
    ('cardExpirationType', function () {
        return {
            restrict: 'A',
            require: 'ngModel',
            link: function (scope, elem, attrs, ctrl) {
                scope.$watch('[vm.expiry_month, vm.expiry_year]', function (value) {

                    if (scope.vm.expiry_year && scope.vm.expiry_year.length == 4 && scope.vm.expiry_month) {
                        if (scope.vm.expiry_month > 12 || scope.vm.expiry_month <= 0) {
                            ctrl.$setValidity('invalidDate', false);
                            ctrl.$setValidity('pattern', true);
                            return value;
                        }

                        var currentDate = new Date();
                        var cardDate = new Date(scope.vm.expiry_year, scope.vm.expiry_month, 0);
                        if (cardDate < currentDate) {
                            ctrl.$setValidity('pattern', false);
                            ctrl.$setValidity('invalidDate', true);
                            return value;
                        }
                    }
                    ctrl.$setValidity('pattern', true);
                    ctrl.$setValidity('invalidDate', true);
                    return value;
                },true);
            }
        };
});

app.directive("onlyLettersInput", function () {
    return {
        require: 'ngModel',
        link: function (scope, element, attr, ngModelCtrl) {
            function fromUser(text) {
                var transformedInput = text.replace(/[^a-zA-Z &.\s]/g, '');
                if (transformedInput !== text) {
                    ngModelCtrl.$setViewValue(transformedInput);
                    ngModelCtrl.$render();
                }
                return transformedInput;
            }
            ngModelCtrl.$parsers.push(fromUser);
        }
    };
});
;
angular.module('appUI')
    .directive('convertToNumber', function () {
    return {
        require: 'ngModel',
        link: function (scope, element, attrs, ngModel) {
            ngModel.$parsers.push(function (val) {
                return val != null ? parseInt(val, 10) : null;
            });
            ngModel.$formatters.push(function (val) {
                return val != null ? '' + val : null;
            });
        }
    };
});;

(function () {
    'use strict';

    var appUI = angular.module('appUI');



    appUI.controller('homeProductCtrl', ['$rootScope', '$q', '$window', '$filter', 'responsiveService', 'quotesService', 'sessionStorageService', 'apiUrlConstService', 'webUrlConstService', 'dateService', 'disclaimerService', '$http', '$log', 'messageConstService', 'keyConstService', 'occupationService', '$scope', '$mdDialog', '$timeout', 'clientService', 'utilityService', homeProductCtrl]);

    function homeProductCtrl($rootScope, $q, $window, $filter, responsiveService, quotesService, sessionStorageService, apiUrlConstService, webUrlConstService, dateService, disclaimerService, $http, $log, messageConstService, keyConstService, occupationService, $scope, $mdDialog, $timeout, clientService, utilityService) {
        var vm = this;
        var transactionId = 0;
        var caseId = "0";
        vm.CaseNumber = null;
        vm.ContentSiFlag = false;
        vm.BuildingSiFlag = false;
        vm.DOBFlag = false;
        var transactionDetail = null;
        var brokerData;
        var brokerdetail;
        var endorsementState = null;
        var previousTransactionId = null;
        var IsNewBusinessEdit = null;
        vm.AddressState = null;
        vm.fileName = null;
        vm.rowVersion = null;
        /// vm.uploadFile = uploadFile;
        vm.DisableAddClaim = false;
        vm.AdditionalPolicyHolderListLength = 1;
        vm.findAddress = findAddress;
        vm.previousAddressLine1 = null;
        vm.previousAddressValue = null;
        vm.manualAddressText = null;
        vm.sumInsuredEstimate = sumInsuredEstimate;
        vm.isSecondaryDisabled = true;
        vm.message = "";
        vm.ExcessValueFlag = false;
        vm.ContentChanges = ContentChanges;
        vm.BuildingSumInsuredRange = BuildingSumInsuredRange;
        vm.BuildingSumInsuredValue = 0;
        vm.BuildingSumInsuredFlag = true;
        vm.BuildingSumInsuredErrorFlag = false;
        vm.showBrokerFee = false;
        vm.DisableSpecifiedItem = true;
        vm.checkNullClaimList = false;
        vm.isNullContentInsured = true;
        vm.removePortableSpecifiedItems;
        vm.addPortableSpecifiedItems;;
        vm.buildingSumInsuredFlag = true;
        vm.policyTransactionId = null;
        vm.ReadOnly = null;
        vm.CordellStateBeforeEstimate = null;
        vm.FinalSaving = finalSaving;
        vm.FinalGetQuote = finalGetQuote;
        vm.addNote = addNote;
        vm.removeNote = removeNote;
        vm.isAdditionalPolicyHolderChange = isAdditionalPolicyHolderChange;
        vm.changeNotesPrintable = changeNotesPrintable;
        vm.nextPremium = nextPremium;
        vm.resetAddressData = resetAddressData;
        vm.ResetBuildingTypeSection = ResetBuildingTypeSection;                                              //Reset functions for version 2.0
        vm.ResetInsurancePolicyCancelledSection = ResetInsurancePolicyCancelledSection;                      //Reset functions for version 2.0
        vm.resetPolicyHolderCurrentlyHoldInsuranceSection = resetPolicyHolderCurrentlyHoldInsuranceSection;  //Reset functions for version 2.0
        vm.costOfRenovationReset = costOfRenovationReset;                                                    //Reset functions for version 2.0
        vm.onClickAddressNotFound = onClickAddressNotFound;                                                   // function for On click of adress not found
        vm.resetAddressNotFound = resetAddressNotFound;                                                        // function to reset on change Addres 
        vm.onClickAddressNotFoundOtherInsured = onClickAddressNotFoundOtherInsured;                           // function for On click of adress not found OtherInsured
        vm.resetAddressNotFoundOtherInsured = resetAddressNotFoundOtherInsured;                                // function to reset on change Addres OtherInsured
        vm.addressMapped = addressMapped;
        vm.validateConstructionPeriod = validateConstructionPeriod;
        vm.ResetSumInsuredValue = resetSumInsuredValue;
        vm.homeData;
        vm.selectedMannualAddress;
        vm.selectedItem;
        vm.endorsementVM = null;
        vm.IsEndorsement = false;
        vm.IsEndorsementPolicyEffectiveDate = false;
        vm.getTermsAndConditons = getTermsAndConditons;
        vm.rowVersion = null;
        var isNewEditTransaction = false;
        var ExpirationDate = null;
        vm.isClaimsInLast3YearsChanged = isClaimsInLast3YearsChanged;
        vm.ResetSpecifiedPortableItems = resetSpecifiedPortableItems;
        vm.ResetUnspecifiedItemsCover = resetUnspecifiedItemsCover;
        vm.resetAlarmSecurity = resetAlarmSecurity;
        vm.doorChecked = doorChecked;
        vm.IsDoorNoneOfTheAboveFirstLoad = 0;
        vm.toggleSelectionDoorSecurity = toggleSelectionDoorSecurity;
        vm.AnnualRevenueRange = AnnualRevenueRange;
        vm.validateCalculateSumInsuredButton = validateCalculateSumInsuredButton;
        vm.changeInOccupation = changeInOccupation;
        vm.RestoreCordellData = RestoreCordellData;
        vm.ResetCordellData = ResetCordellData;
        vm.ResetPropertySection = resetPropertySection;
        vm.SetNonFloorAreaDetail = setNonFloorAreaDetail;
        vm.DeclineonRewireCondition = declineOnRewireCondition;
        vm.brokerFeeGST;
        vm.addressState;
        vm.resetBrokerFee;
        vm.maxOccupationTurnover = [];
        vm.EffectiveDate = null;
        vm.StartDate = null;
        vm.IsManualBuildingSumInsured = false;
        vm.activatePayment;
        vm.data = null;
        vm.brokerCommissionLimitMessage = false;
        vm.chnageBrokerCommission = chnageBrokerCommission;
        vm.enablePopUp = false;
        vm.transactionStatus = null;
        var getQuestionSetWithoutSaving;
        var getTransactionIdWithoutSaving;
        var getParsedQuestionSetWithoutSaving;
        var getQuoteTransactionId;
        vm.maxbrokerCommissionPercentage;
        vm.minbrokerCommissionPercentage;
        vm.getSecondaryInsuredList = getSecondaryInsuredList;
        var caseNumberForSecondaryInsured;
        vm.ResetotherInterestedPartyText = ResetotherInterestedPartyText;
        vm.getNewBusinessCaseData;
        vm.RestoreCordellFields = RestoreCordellFields;
        vm.CordellDataState = CordellDataState;
        vm.stampDutyEligibilty;
        vm.storeAddress;
        vm.sDHide;
        vm.lessOrMoreMessage = 'less';
        vm.checkedDoorList = [];
        vm.NoneOfTheAboveIndex = 0;
        vm.validDOBOtherInsurer = true;
        vm.isUnspecifiedPortableItems = true;
        vm.checkClaims = null;
        vm.EnableDisableButton = EnableDisableButton;
        vm.policyHolderNameExists = policyHolderNameExists;
        vm.brokerFeeChange = brokerFeeChange;
        vm.brokerManagedPayment = 0;
        vm.brokerbranchcheck;
        vm.disableButtons = false;
        vm.showMessageGrt100OtherInsuredName = false;
        vm.changeOtherInsuredName = changeOtherInsuredName;
        vm.continueOrNavigateBackToPackageManager = continueOrNavigateBackToPackageManager;
        vm.packageNumber = null;
        vm.renewalCounter = null;
        vm.showManagePkg = false;
        vm.addSecondaryClient = [];
        vm.addOtherInsured = addOtherInsured;
        vm.otherInsuredAddress = null;
        vm.storeOtherInsuredAddress = storeOtherInsuredAddress;
        vm.resetAddress = resetAddress;
        vm.cancelOtherInsured = cancelOtherInsured;
        vm.checkSameAsPrimary = checkSameAsPrimary;
        vm.ClientDetail = {};
        vm.otherreadonly = false;
        vm.OtherSubmitEnabled = OtherSubmitEnabled;
        vm.getQuoteV2 = getQuoteV2;

        vm.showDomesticWorkerCompensation = false;
        vm.OtherInsuredName = null;
        vm.DateOfBirthApp = null;
        vm.help_text_for_Endorsement = keyConstService.help_text_for_Endorsement;
        vm.tempPrimaryInsured;
        vm.tempAdditonalPolicyHolders;
        vm.AdditionalPolicyHolderIndex;
        vm.IsOpenAddInsuredPopup = false;
        vm.disablecover = disablecover;
        vm.BindBuildingType = BindBuildingType;
        vm.BindBuiltOnType = BindBuiltOnType;
        vm.BindApartmentType = BindApartmentType;
        vm.BindSemiDetached = BindSemiDetached;
        vm.BindOtherDwellingType = BindOtherDwellingType;
        vm.OnOccupancyChange = OnOccupancyChange;
        vm.OnRenovationDateChange = OnRenovationDateChange;
        vm.ResetBuildingSumInsureforV2 = ResetBuildingSumInsureforV2;
        vm.illionClaimResponse = null;
        vm.AddressChange = false;
        vm.checkManualAddressChange = checkManualAddressChange;
        vm.previousAddressTextForIllion = null;
        vm.previousAddressLine1ForIllion = null;
        vm.checkAddressLine1 = false;
        vm.startDateForYear = null;
        vm.showReferralHint = false;

        function initializeDoorSecurityCheckBox(mode) {
            vm.checkedDoorList = [];
            for (var index = 0; index < vm.state.SecurityDetails.DoorSecuritiesList.length; index++) {
                vm.checkedDoorList.push(false);
            }
            if (mode === 0)
                vm.state.SecurityDetails.DoorSecurities = [];
            if (vm.state.SecurityDetails.DoorSecurities.length === 0) {
                vm.state.SecurityDetails.DoorSecurities.push("NoneOfTheAbove");
                vm.checkedDoorList[vm.NoneOfTheAboveIndex] = true;
            }
        }

        /* Add Client from Home Question Page */
        function addOtherInsured() {
            vm.ClientDetail.SecondaryInsuredClientVM = vm.addSecondaryClient;
            vm.ClientDetail.SecondaryInsuredClientVM[0].AddressLogVM = vm.otherInsuredAddress;

            var client = {
                ClientViewModel: (vm.ClientDetail.clientViewModel !== null ? vm.ClientDetail.clientViewModel : null),
                SecondaryInsuredClientVM: vm.ClientDetail.SecondaryInsuredClientVM
            };

            var request = clientService.updateClientData({
                client: client
            });
            request.then(function success(response) {
                if (vm.ClientDetail.SecondaryInsuredClientVM[0].ClientType == 'Individual') {
                    if (vm.IsOpenAddInsuredPopup) {
                        vm.state.PolicyHolder.InsuredName = vm.ClientDetail.SecondaryInsuredClientVM[0].FirstName + " " + vm.ClientDetail.SecondaryInsuredClientVM[0].LastName;
                        vm.state.PolicyHolder.DateOfBirthApp = vm.ClientDetail.SecondaryInsuredClientVM[0].DateOfBirthStringAsDDMMYYYY;
                        vm.IsOpenAddInsuredPopup = false;
                    } else {
                        vm.state.PolicyHolder.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].AdditionalPolicyHolder = vm.ClientDetail.SecondaryInsuredClientVM[0].FirstName + " " + vm.ClientDetail.SecondaryInsuredClientVM[0].LastName;
                        vm.state.PolicyHolder.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].DateOfBirthApp = "2000-01-01T00:00:00";
                        vm.state.PolicyHolder.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].AdditionalPolicyHolderType = "Secondary";
                    }
                } else {
                    if (vm.IsOpenAddInsuredPopup) {
                        vm.state.PolicyHolder.InsuredName = vm.ClientDetail.SecondaryInsuredClientVM[0].OrganisationName;
                        vm.state.PolicyHolder.DateOfBirthApp = "2000-01-01T00:00:00";
                        vm.IsOpenAddInsuredPopup = false;
                    } else {
                        vm.state.PolicyHolder.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].AdditionalPolicyHolder = vm.ClientDetail.SecondaryInsuredClientVM[0].OrganisationName;
                        vm.state.PolicyHolder.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].DateOfBirthApp = "2000-01-01T00:00:00";
                        vm.state.PolicyHolder.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].AdditionalPolicyHolderType = "Secondary";
                    }
                }
                return getInsuredNameList(false);
            });

        }

        function getInsuredNameList(isEdit) {
            var qCheckDate = new Date(vm.tempHomeData.DWCAdjustmentDate);
            var referralEffectiveDate = new Date(vm.tempHomeData.SpecifiedValueNewReferralDate);
            var newBusinessCaseData = sessionStorageService.get(keyConstService.newBusinessCaseData);
            var newBusinessCaseDetail = JSON.parse(newBusinessCaseData);
            var qStartDate = newBusinessCaseDetail != null ? new Date(newBusinessCaseDetail.data.EffectiveDate) : new Date(vm.tempHomeData.StartDate);
            caseId = sessionStorageService.get(keyConstService.caseId);
                if (qStartDate >= referralEffectiveDate) {

                    vm.showReferralHint = true;
                }
                else {
                    vm.showReferralHint = false;
                }
            quotesService.getInsuredNameList(caseId).then(function (ResponseData) {
                if (ResponseData.data !== null) {
                    if (!isEdit) {
                        vm.state.PolicyHolder.InsuredNameList = ResponseData.data.policyHolder.insuredNameList;
                        vm.state.PolicyHolder.SecondaryInsuredsList = ResponseData.data.policyHolder.secondaryInsuredsList;

                        ////vm.state.PolicyHolder.InsuredClientId = ResponseData.data.policyHolder.insuredClientId;
                        vm.ClientDetail = ResponseData.data.clientDetail;
                        vm.addSecondaryClient = ResponseData.data.clientDetail.secondaryInsuredClientVM;
                        vm.otherInsuredAddress = ResponseData.data.clientDetail.addressLogVM;
                        vm.PropertyDetail = angular.copy(ResponseData.data.buildingInfo);
                        //Comeented old Other option not working in case of adding new other insured
                        //if (vm.getParsedQuestionSetWithoutSaving !== undefined && !vm.getParsedQuestionSetWithoutSaving && getQuoteTransactionId !== vm.getTransactionIdWithoutSaving) {
                        if (vm.state.PolicyHolder.InsuredName === "Other") {
                            var indexOfInsured = vm.state.PolicyHolder.InsuredNameList.findIndex(p => p.value === "Other");
                            if (indexOfInsured === -1) {
                                vm.state.PolicyHolder.InsuredNameList.push({ clientType: "Secondary", name: vm.state.PolicyHolder.InsuredName, value: vm.state.PolicyHolder.InsuredName, dateOfBirth: vm.state.PolicyHolder.DateOfBirth, Id: 0 });
                                //vm.state.PolicyHolder.SecondaryInsuredsList.push({ clientType: "Secondary", name: vm.state.PolicyHolder.InsuredName, value: vm.state.PolicyHolder.InsuredName, dateOfBirth: vm.state.PolicyHolder.DateOfBirth, Id: 0 });
                            }
                            vm.OtherInsuredName = vm.state.PolicyHolder.OtherInsuredName;
                            vm.DateOfBirthApp = vm.state.PolicyHolder.DateOfBirthApp;
                            vm.otherreadonly = true;
                        } else {
                            var indexOfInsured = vm.state.PolicyHolder.InsuredNameList.findIndex(p => p.value === "Other");
                            if (indexOfInsured >= 0) {
                                vm.state.PolicyHolder.InsuredNameList.splice(indexOfInsured, 1);
                            }
                        }
                        //else 
                        if ((vm.state.PolicyHolder.AdditionalPolicyHolderList.findIndex(p => p.AdditionalPolicyHolder === "Other")) >= 0) {
                            //var indexOfInsured = vm.state.PolicyHolder.InsuredNameList.findIndex(p => p.value === "Other");
                            //if (indexOfInsured === -1) {
                            //    vm.state.PolicyHolder.InsuredNameList.push({ clientType: "Secondary", name: "Other", value: "Other", dateOfBirth: null, Id: 0 });
                            //    vm.state.PolicyHolder.SecondaryInsuredsList.push({ clientType: "Secondary", name: "Other", value: "Other", dateOfBirth: null, Id: 0 });
                            //}
                            var indexOfInsured = vm.state.PolicyHolder.SecondaryInsuredsList.findIndex(p => p.value === "Other");
                            if (indexOfInsured === -1) {
                                vm.state.PolicyHolder.SecondaryInsuredsList.push({ clientType: "Secondary", name: "Other", value: "Other", dateOfBirth: null, Id: 0 });
                            }
                            vm.otherreadonly = true;
                        } else {
                            var indexOfInsured = vm.state.PolicyHolder.SecondaryInsuredsList.findIndex(p => p.value === "Other");
                            if (indexOfInsured >= 0) {
                                vm.state.PolicyHolder.SecondaryInsuredsList.splice(indexOfInsured, 1);
                            }
                        }

                        if (vm.state.PolicyHolder.InsuredName !== "Other" && (vm.state.PolicyHolder.AdditionalPolicyHolderList.findIndex(p => p.AdditionalPolicyHolder === "Other")) == -1) {
                            if (vm.state.PolicyHolder.InsuredClientId !== null && vm.state.PolicyHolder.OtherInsuredName === null) {
                                vm.state.PolicyHolder.InsuredName = vm.state.PolicyHolder.InsuredName;//ResponseData.data.policyHolder.insuredName;
                            }
                            //else {
                            //    vm.state.PolicyHolder.InsuredName = ResponseData.data.policyHolder.insuredName;
                            //}
                        }

                        // If Insured name is not other and additional list is having other but Insuredlist and secondaryInsured list is having remove it array.
                        if (vm.state.PolicyHolder.InsuredName !== "Other" && (vm.state.PolicyHolder.AdditionalPolicyHolderList.findIndex(p => p.AdditionalPolicyHolder === "Other")) === -1) {
                            var insuredotherPosition = vm.state.PolicyHolder.InsuredNameList.findIndex(p => p.value === "Other");
                            if (insuredotherPosition !== -1) {
                                vm.state.PolicyHolder.InsuredNameList.splice(insuredotherPosition, 1);
                            }

                            //// commented by ankur
                            ////var secondaryInsuredOtherPos = vm.state.PolicyHolder.SecondaryInsuredsList.findIndex(p => p.value === "Other");
                            ////if (secondaryInsuredOtherPos !== -1) {
                            ////    vm.state.PolicyHolder.SecondaryInsuredsList.splice(secondaryInsuredOtherPos, 1);
                            ////}
                        }
                        // Commented as per bug 7567
                        //vm.state.PropertyDetail.AddressText = ResponseData.data.buildingInfo.addressText;
                        //vm.state.PropertyDetail.AddressValue = ResponseData.data.buildingInfo.addressValue;
                        //vm.state.PropertyDetail.IsManualAddress = ResponseData.data.buildingInfo.isManualAddress;
                        //}

                        if (vm.state.PropertyDetail.AddressValue != null) {
                            var splitSate = vm.state.PropertyDetail.AddressValue.split('|');
                            vm.AddressState = splitSate[0];
                            if (vm.AddressState === "NSW") {
                                vm.showStampDuty = true;
                            }
                        }
                        if ((qStartDate < qCheckDate) && (vm.AddressState === "WA" || vm.AddressState === "ACT" || vm.AddressState === "TAS")) {
                            vm.showDomesticWorkerCompensation = true;

                        }
                        if (getQuoteTransactionId === vm.getTransactionIdWithoutSaving) {
                            vm.address = getParsedQuestionSetWithoutSaving.PropertyDetail.AddressValue;
                            vm.getaddressState = vm.address.split("|");
                            vm.AddressState = vm.getaddressState[0];
                            if ((qStartDate < qCheckDate) && (vm.AddressState === "WA" || vm.AddressState === "ACT" || vm.AddressState === "TAS")) {
                                vm.showDomesticWorkerCompensation = true;

                            }
                            else {
                                vm.showDomesticWorkerCompensation = false;
                                vm.state.OtherInfo.IsDomesticWorkerCompensation = null;
                            }
                        }
                        if (vm.getParsedQuestionSetWithoutSaving !== undefined && !getParsedQuestionSetWithoutSaving) {
                            vm.state.CordellResponse.Propertydata.postcode = ResponseData.data.buildingInfo.postcode;
                            vm.state.PropertyDetail.AddressLine1 = ResponseData.data.buildingInfo.addressLine1;
                            vm.state.PropertyDetail.IsManualAddress = ResponseData.data.buildingInfo.isManualAddress;
                            if (vm.state.PropertyDetail.IsManualAddress) {
                                vm.selectedMannualAddress = vm.state.PropertyDetail.AddressText;
                            }

                            else {
                                if (getQuoteTransactionId != vm.getTransactionIdWithoutSaving) {
                                    vm.selectedAddress = { postCode: vm.state.PropertyDetail.Postcode, text: vm.state.PropertyDetail.AddressText, value: vm.state.PropertyDetail.AddressValue };
                                }
                            }
                        }
                    }
                    else {
                        // test for Other   --------------------------------------------------------------------------
                        //vm.state.PolicyHolder.InsuredName = "Other";
                        //vm.state.PolicyHolder.OtherInsuredName = "Other Ankur";
                        //vm.state.PolicyHolder.DateOfBirthApp = "2000-01-01T00:00:00";

                        vm.ClientDetail = ResponseData.data.clientDetail;
                        vm.addSecondaryClient = ResponseData.data.clientDetail.secondaryInsuredClientVM;
                        vm.otherInsuredAddress = ResponseData.data.clientDetail.addressLogVM;
                        vm.PropertyDetail = angular.copy(ResponseData.data.buildingInfo);
                        if (vm.state.PolicyHolder.InsuredName === "Other") {
                            var indexOfInsured = vm.state.PolicyHolder.InsuredNameList.findIndex(p => p.value === "Other");
                            if (indexOfInsured === -1) {
                                vm.state.PolicyHolder.InsuredNameList.push({ clientType: "Secondary", name: vm.state.PolicyHolder.InsuredName, value: vm.state.PolicyHolder.InsuredName, dateOfBirth: vm.state.PolicyHolder.DateOfBirth, Id: 0 });
                                vm.state.PolicyHolder.SecondaryInsuredsList.push({ clientType: "Secondary", name: vm.state.PolicyHolder.InsuredName, value: vm.state.PolicyHolder.InsuredName, dateOfBirth: vm.state.PolicyHolder.DateOfBirth, Id: 0 });

                            }
                            vm.OtherInsuredName = vm.state.PolicyHolder.OtherInsuredName;
                            vm.DateOfBirthApp = vm.state.PolicyHolder.DateOfBirthApp;
                            vm.otherreadonly = true;
                        }
                        if (vm.state.PropertyDetail.IsManualAddress === false) {
                            vm.selectedAddress = vm.state.PropertyDetail.AddressText;
                        }
                        //test Other  --------------------------------------------------------------------------
                        //vm.state.PolicyHolder.AdditionalPolicyHolderList[0].AdditionalPolicyHolder = "Other";
                        //vm.state.PolicyHolder.AdditionalPolicyHolderList[0].OtherPolicyHolderName = "Test Other ANkur";
                        //vm.state.PolicyHolder.AdditionalPolicyHolderList[0].OtherDateOfBirthApp = "2000-01-01T00:00:00";

                        if ((vm.state.PolicyHolder.AdditionalPolicyHolderList.findIndex(p => p.AdditionalPolicyHolder === "Other")) >= 0) {
                            var indexOfInsured = vm.state.PolicyHolder.InsuredNameList.findIndex(p => p.value === "Other");
                            if (indexOfInsured === -1) {
                                vm.state.PolicyHolder.InsuredNameList.push({ clientType: "Secondary", name: "Other", value: "Other", dateOfBirth: null, Id: 0 });
                                vm.state.PolicyHolder.SecondaryInsuredsList.push({ clientType: "Secondary", name: "Other", value: "Other", dateOfBirth: null, Id: 0 });

                            }
                            vm.otherreadonly = true;
                        }
                        // If Insured name is not other and additional list is having other but Insuredlist and secondaryInsured list is having remove it array.
                        if (vm.state.PolicyHolder.InsuredName !== "Other" && (vm.state.PolicyHolder.AdditionalPolicyHolderList.findIndex(p => p.AdditionalPolicyHolder === "Other")) !== -1) {
                            var insuredotherPosition = vm.state.PolicyHolder.InsuredNameList.findIndex(p => p.value === "Other");
                            if (insuredotherPosition !== -1) {
                                vm.state.PolicyHolder.InsuredNameList.splice(insuredotherPosition, 1);
                            }
                            //var secondaryInsuredOtherPos = vm.state.PolicyHolder.SecondaryInsuredsList.findIndex(p => p.value === "Other");
                            //if (secondaryInsuredOtherPos !== -1) {
                            //    vm.state.PolicyHolder.SecondaryInsuredsList.splice(secondaryInsuredOtherPos, 1);
                            //}
                        }
                        if (vm.state.PolicyHolder.InsuredName === "Other" && (vm.state.PolicyHolder.AdditionalPolicyHolderList.findIndex(p => p.AdditionalPolicyHolder === "Other")) === -1) {
                            var secondaryInsuredOtherPos = vm.state.PolicyHolder.SecondaryInsuredsList.findIndex(p => p.value === "Other");
                            if (secondaryInsuredOtherPos !== -1) {
                                vm.state.PolicyHolder.SecondaryInsuredsList.splice(secondaryInsuredOtherPos, 1);
                            }
                        }
                    }

                    vm.tempPrimaryInsured = vm.state.PolicyHolder.InsuredName;
                    vm.tempAdditonalPolicyHolders = angular.copy(vm.state.PolicyHolder.AdditionalPolicyHolderList);
                }
                if (!isEdit) {
                    if (getParsedQuestionSetWithoutSaving && vm.state.PolicyHolder.BuildingCover) {
                        vm.InvalidZero(null, getParsedQuestionSetWithoutSaving.CordellResponse.BuildingSumInsured);
                    }

                    if (vm.state.PolicyHolder.AdditionalPolicyHolderList.length != 0 && vm.state.PolicyHolder.AdditionalPolicyHolderList[0].OtherDateOfBirthApp != null) {
                        for (var i = 0; i < vm.state.PolicyHolder.AdditionalPolicyHolderList.length; i++) {
                            if (vm.state.PolicyHolder.AdditionalPolicyHolderList[i].AdditionalPolicyHolder === "Other") {
                                var dateofBirth = vm.state.PolicyHolder.AdditionalPolicyHolderList[i].OtherDateOfBirthApp;
                                var response = dateService.validateBirthDDMMYYYY(dateofBirth, 115);
                                if (!response.isValid) {
                                    vm.validDOBOtherInsurer = false;
                                    vm.message = response.errorMsg;
                                    break;
                                }
                                else {
                                    vm.validDOBOtherInsurer = true;
                                }
                            }

                            else {
                                continue;
                            }
                        }

                        if (!vm.validDOBOtherInsurer && vm.message === messageConstService.errFutureDateNotAllowed) {
                            toastr.warning(messageConstService.errFutureDatedForAddHolder);
                        }
                        else if (!vm.validDOBOtherInsurer && vm.message === messageConstService.errDateNotAllowed) {
                            toastr.warning(messageConstService.errDateNotAllowed);
                        }
                    }
                    if (getQuoteTransactionId !== vm.getTransactionIdWithoutSaving) {
                        var newDate = new Date(ResponseData.data.policyHolder.dateOfBirthApp);
                        vm.state.PolicyHolder.DateOfBirthApp = newDate;
                    }

                    // retaining claims validation on previous/next
                    vm.checkClaims();

                    if (vm.state.PolicyHolder.InsuredName != "Other") {
                        var objSelectedInsured = vm.state.PolicyHolder.InsuredNameList.filter(function (e) { return e.value === vm.state.PolicyHolder.InsuredName })
                        vm.state.PolicyHolder.InsuredClientId = objSelectedInsured.length > 0 ? objSelectedInsured[0].id : 0;
                    } else {
                        vm.state.PolicyHolder.InsuredClientId = -2;
                    }

                    for (var i = 0; i < ResponseData.data.policyHolder.secondaryInsuredsList.length; i++) {
                        if (ResponseData.data.policyHolder.secondaryInsuredsList[i].value == vm.state.PolicyHolder.InsuredName && ResponseData.data.policyHolder.secondaryInsuredsList[i].id == vm.state.PolicyHolder.InsuredClientId) {
                            var index = ResponseData.data.policyHolder.secondaryInsuredsList.indexOf(ResponseData.data.policyHolder.secondaryInsuredsList[i]);
                            ResponseData.data.policyHolder.secondaryInsuredsList.splice(index, 1);
                            vm.state.PolicyHolder.SecondaryInsuredsList = ResponseData.data.policyHolder.secondaryInsuredsList;

                            if (getQuoteTransactionId === vm.getTransactionIdWithoutSaving) {
                                vm.getQuestionSetWithoutSavingData = JSON.parse(sessionStorageService.get(keyConstService.getQuestionSetWithoutSaving));
                                if (vm.getQuestionSetWithoutSavingData) {
                                    if (vm.getQuestionSetWithoutSavingData.PolicyHolder.InsuredName === "Other") {
                                        vm.state.PolicyHolder.InsuredName = vm.getQuestionSetWithoutSavingData.PolicyHolder.InsuredName;
                                        vm.state.PolicyHolder.OtherInsuredName = vm.getQuestionSetWithoutSavingData.PolicyHolder.OtherInsuredName;
                                        for (var i = 0; i < vm.getQuestionSetWithoutSavingData.PolicyHolder.SecondaryInsuredsList.length; i++) {
                                            vm.state.PolicyHolder.SecondaryInsuredsList[i] = vm.getQuestionSetWithoutSavingData.PolicyHolder.SecondaryInsuredsList[i];
                                        }
                                    }
                                }
                            }
                            //else {
                            //    if (vm.state.PolicyHolder.InsuredName) {
                            //        vm.state.PolicyHolder.InsuredName = ResponseData.data.policyHolder.insuredName;
                            //    }
                            //}
                        }
                        //else {                        // commented by Ankur as per US 6829
                        //    if (vm.state.PolicyHolder.InsuredName) {
                        //            vm.state.PolicyHolder.InsuredName = ResponseData.data.policyHolder.insuredName;
                        //        }
                        //    }
                    }
                    // commented by Ankur as per US 6829
                    //var secondaryInsuredOtherPos = vm.state.PolicyHolder.SecondaryInsuredsList.findIndex(p => p.value === "Other");
                    //if (secondaryInsuredOtherPos !== -1) {
                    //    vm.state.PolicyHolder.SecondaryInsuredsList.splice(secondaryInsuredOtherPos, 1);
                    //}
                }
            });
            if (!isEdit) {
                resetAddress();
            }

        }

        vm.querySearch = function (query) {
            return $http.get(apiUrlConstService.addressURL + 'IntechAddressListAsync?address=' + query, { skipInterceptor: true })
                .then(function (result) {
                    return result.data.data;
                });
        };

       // function for On click of address not found
        function onClickAddressNotFound() {
            vm.state.PropertyDetail.IsManualAddress = true;
            vm.searchText = null;
            resetAddressData();
        }

        //function to reset values on address input change
        function resetAddressNotFound() {
            vm.state.PropertyDetail.IsManualAddress = false;
            if (vm.state.PropertyDetail.AddressText) {
                vm.previousAddressTextForIllion = vm.state.PropertyDetail.AddressText; 
            }                       
            vm.AddressChange = true;
            vm.resetAddressData();
        }

        //function for On click of address not found other insured
        function onClickAddressNotFoundOtherInsured(){
            vm.otherInsuredAddress.isManualAddress = true;
            vm.searchText1 = null;
            resetAddress();
        }

        //function to reset values on address input change other insured
        function resetAddressNotFoundOtherInsured() {
            vm.otherInsuredAddress.isManualAddress = false;
            resetAddress();
        }
        vm.mannualSearchQuery = function (query) {
            return $http.get(apiUrlConstService.addressURL + 'MannualAddressList?searchAddress=' + query, { skipInterceptor: true })
                .then(function (result) {
                    return result.data.data;
                });
        };

        function storeOtherInsuredAddress(address) {
            
            if (address && address.value == 'N/A') {
                address = null;
                vm.selectedAddress1 = null;
                onClickAddressNotFoundOtherInsured();
            }

            if (address !== null && address !== undefined) {
                if (address.value) {
                    vm.addSecondaryClient[0].IsStampDutyExempted = false;
                    var splitSate = address.value.split('|');
                    var AddressState = splitSate[0];
                    vm.addSecondaryClient[0].IsStampDutyExempted = false;
                    if (AddressState === "NSW") {
                        vm.addSecondaryClient[0].showStampDuty = true;
                    }
                    else {
                        vm.addSecondaryClient[0].showStampDuty = false;
                    }

                    if (vm.addSecondaryClient[0].IsSameAsPrimaryAddress && vm.otherInsuredAddress && vm.PropertyDetail.addressText !== address.text) {
                        vm.addSecondaryClient[0].IsSameAsPrimaryAddress = false;
                    }

                    if (vm.otherInsuredAddress) {
                        vm.otherInsuredAddress.Address = address.text;
                        vm.otherInsuredAddress.DelimeterAddress = address.value;
                        vm.otherInsuredAddress.PostCode = address.postCode === null ? null : address.postCode;
                        if (address.isManualAddress) {
                            vm.selectedOtherMannualItem = vm.selectedOtherMannualAddress.text;
                            vm.otherInsuredAddress.AddressLine1 = vm.selectedOtherMannualAddress.addressLine1;
                        }
                    }
                    else {
                        vm.otherInsuredAddress = {
                            Address: address.text,
                            DelimeterAddress: address.value,
                            PostCode: address.postCode === null ? null : address.postCode
                        };
                    }
                }
            }
        }

        function checkSameAsPrimary() {

            if (vm.addSecondaryClient[0].IsSameAsPrimaryAddress) {

                if (!vm.PropertyDetail.isManualAddress) {
                    vm.selectedAddress1 = { postCode: vm.PropertyDetail.postcode, text: vm.PropertyDetail.addressText, value: vm.PropertyDetail.addressValue };
                    storeOtherInsuredAddress(vm.selectedAddress1);
                }
                else {
                    vm.selectedOtherMannualAddress = { postCode: vm.PropertyDetail.postcode, text: vm.PropertyDetail.addressText, addressLine1: vm.PropertyDetail.addressLine1, value: vm.PropertyDetail.addressValue, isManualAddress: vm.PropertyDetail.isManualAddress };
                    storeOtherInsuredAddress(vm.selectedOtherMannualAddress);
                }
                vm.otherInsuredAddress.isManualAddress = vm.PropertyDetail.isManualAddress;
                if (vm.otherInsuredAddress.isManualAddress === false) {
                    vm.otherInsuredAddress.AddressLine1 = null;
                    vm.mannualOtherSearchText = null;
                    vm.selectedOtherMannualItem = null;
                }
            }
        }

        function resetAddress() {
            vm.selectedAddress1 = null;
            vm.otherInsuredAddress.Address = null;
            vm.otherInsuredAddress.DelimeterAddress = null;
            vm.otherInsuredAddress.PostCode = null;
            vm.showStampDuty = false;
            if (vm.addSecondaryClient.length > 0) {
                vm.addSecondaryClient[0].IsStampDutyExempted = false;
                vm.addSecondaryClient[0].IsSameAsPrimaryAddress = false;
            }          
            if (vm.otherInsuredAddress.isManualAddress === false) {
                vm.otherInsuredAddress.AddressLine1 = null;
                vm.mannualOtherSearchText = null;
                vm.selectedOtherMannualItem = null;
            }
        }

        function cancelOtherInsured(type) {
            if (vm.addSecondaryClient.length > 0) {
                vm.addSecondaryClient[0].FirstName = null;
                vm.addSecondaryClient[0].LastName = null;
                vm.addSecondaryClient[0].DateOfBirthStringAsDDMMYYYY = null;
                vm.addSecondaryClient[0].OrganisationName = null;
                vm.addSecondaryClient[0].TradingName = null;
                vm.searchText1 = null;

                if (type === 'cancelButton') {
                    vm.addSecondaryClient[0].ClientType = null;
                }
            }

            if (type.$name === 'otherInsuredForm' && vm.otherInsuredAddress.isManualAddress === false) {
                type.otherAutocompleteAddress.$invalid = true;
                type.otherAutocompleteAddress.$touched = false;
            }

            if (type === 'cancelButton') {
                if (vm.IsOpenAddInsuredPopup) {
                    vm.state.PolicyHolder.InsuredName = vm.tempPrimaryInsured;
                    vm.IsOpenAddInsuredPopup = false;
                } else if (vm.tempAdditonalPolicyHolders != null) {
                    vm.state.PolicyHolder.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].AdditionalPolicyHolder = vm.tempAdditonalPolicyHolders[vm.AdditionalPolicyHolderIndex] == undefined ? null : vm.tempAdditonalPolicyHolders[vm.AdditionalPolicyHolderIndex].AdditionalPolicyHolder;
                    vm.state.PolicyHolder.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].AdditionalPolicyHolderType = "Secondary";
                } else {
                    vm.state.PolicyHolder.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].AdditionalPolicyHolder = null;
                }
            }

            //vm.tempPrimaryInsured = vm.state.PolicyHolder.InsuredNameList.filter(function (e) { return e.clientType === 'Primary' })
            //vm.state.PolicyHolder.InsuredName = vm.tempPrimaryInsured[0].name;
            vm.otherInsuredAddress.isManualAddress = false;
            resetAddress();
        }

        function OtherSubmitEnabled(otherInsuredForm) {
            if (otherInsuredForm.$invalid || (vm.selectedAddress1 === null && !vm.otherInsuredAddress.isManualAddress)) {
                return true;
            }
            else {
                return false;
            }
        }

        vm.checkValidOtherManualAddress = function (field) {
            if (vm.mannualOtherSearchText) {
                if (!vm.selectedOtherMannualItem) {
                    field.$setValidity('invalid', false);
                }
                else {
                    field.$setValidity('invalid', true);
                }
            }
        }


        /* Add Client from Home Question Page */

        function doorChecked() {
            var index = 0, counter = 0;
            $.each(vm.state.SecurityDetails.DoorSecuritiesList, function (key, value) {
                if (value.Value === "NoneOfTheAbove")
                    vm.NoneOfTheAboveIndex = counter;
                else
                    counter++;
            });

            initializeDoorSecurityCheckBox(1);

            if (vm.state.SecurityDetails.DoorSecurities.length !== 0) {
                for (index = 0; index < vm.state.SecurityDetails.DoorSecuritiesList.length; index++) {
                    var item = vm.state.SecurityDetails.DoorSecuritiesList[index].Value;
                    if (vm.state.SecurityDetails.DoorSecurities.indexOf(item) > -1)
                        vm.checkedDoorList[index] = true;
                }
            }
        }

        function toggleSelectionDoorSecurity(doorSecurity, indexValue) {
            var index = vm.state.SecurityDetails.DoorSecurities.indexOf(doorSecurity);
            if (index < 0) {
                if (doorSecurity !== 'NoneOfTheAbove') {
                    vm.state.SecurityDetails.DoorSecurities = vm.state.SecurityDetails.DoorSecurities.filter(function (e) { return e !== 'NoneOfTheAbove' })
                    vm.checkedDoorList[vm.NoneOfTheAboveIndex] = false;
                }
                else {
                    initializeDoorSecurityCheckBox(0);
                }
                if (doorSecurity !== 'NoneOfTheAbove') {
                    vm.state.SecurityDetails.DoorSecurities.push(doorSecurity);
                }
                vm.checkedDoorList[indexValue] = true;
            }
            else {
                if (doorSecurity === 'NoneOfTheAbove' && vm.state.SecurityDetails.DoorSecurities.length === 1) {
                    vm.checkedDoorList[indexValue] = true;
                }
                else if (doorSecurity === 'NoneOfTheAbove') {
                    initializeDoorSecurityCheckBox(0);
                }
                else {
                    vm.state.SecurityDetails.DoorSecurities.splice(index, 1);
                    if (vm.state.SecurityDetails.DoorSecurities.length === 0)
                        initializeDoorSecurityCheckBox();
                    vm.checkedDoorList[indexValue] = false;
                }
            }
            $log.log('vm.state.SecurityDetails.DoorSecurities', vm.state.SecurityDetails.DoorSecurities);
        }

        function resetAlarmSecurity() {
            if (!vm.state.SecurityDetails.IsAlarmSecurity) {
                vm.state.SecurityDetails.AlarmType = null;
            }
            else if (vm.IsEndorsement && vm.state.SecurityDetails.IsAlarmSecurity) {
                vm.state.SecurityDetails.AlarmType = endorsementState.SecurityDetails.AlarmType;
            }
        }
        function addDoorSecurity(doorSecurity) {

            if (doorSecurity) {
                if (doorSecurity === 'NoneOfTheAbove') {
                    vm.state.SecurityDetails.DoorSecurities = [];
                    return;
                }

                vm.state.SecurityDetails.DoorSecurities.push(doorSecurity);
            }
        }

        function isClaimsInLast3YearsChanged() {
            if (!vm.state.Claims.IsClaimsInLast3Years) {
                vm.state.Claims.ClaimsList = [{ ClaimYear: null, ClaimType: null, CostOfClaim: 0 }];
                vm.checkNullClaimList = false;
            }
            else if (vm.IsEndorsement && vm.state.Claims.IsClaimsInLast3Years) {
                vm.state.Claims.ClaimsList = angular.copy(endorsementState.Claims.ClaimsList);
                vm.checkNullClaimList = true;
            }
            else
                vm.checkNullClaimList = true;

        }

        vm.decimalConfig = {
            sbMin: 0,
            sbMax: keyConstService.AmountMax999999999,
            sbPrecision: 2,
            sbMaxPrecision: 2
        }

        vm.querySearch = function (query) {
            return $http.get(apiUrlConstService.addressURL + 'IntechAddressListAsync?address=' + query, { skipInterceptor: true })
                .then(function (result) {
                    let obj = {
                        text: messageConstService.manualAddressList,
                        value: 'N/A',
                        postCode: null
                    };

                    let resultantdata = result.data.data;
                    if (resultantdata.length > 0) {
                        resultantdata.push(obj);
                    }
                    return resultantdata;
                });
        }

        vm.mannualSearchQuery = function (query) {
            return $http.get(apiUrlConstService.addressURL + 'MannualAddressList?searchAddress=' + query, { skipInterceptor: true })
                .then(function (result) {
                    return result.data.data;
                });
        }
        vm.textChange = function (field) {
            if (vm.selectedAddress === null) {
                field.$setValidity('invalid', false);
            } else {
                field.$setValidity('invalid', true);
            }
        };

        function addressMapped(address, field) {
            if (!address) {
                vm.state.PropertyDetail.AddressText = null;
                //vm.ResetBuildingSection();
                vm.ResetPropertySection();
                $scope.IsChangeAddress = false;
            }

            if (address && address.value == 'N/A') {
                address = null;
                vm.selectedAddress = null;
                onClickAddressNotFound()
            }

            if (address) {
                var newBusinessCaseData = sessionStorageService.get(keyConstService.newBusinessCaseData);
                var newBusinessCaseDetail = JSON.parse(newBusinessCaseData);
                var qStartDate = newBusinessCaseDetail != null ? new Date(newBusinessCaseDetail.data.EffectiveDate) : new Date(vm.tempHomeData.StartDate);
                var qCheckDate = new Date(vm.tempHomeData.DWCAdjustmentDate);
                $scope.IsChangeAddress = true;
                if (!address.text) {
                    vm.state.PropertyDetail.AddressText = address;
                }
                if (address.text) {
                    vm.state.PropertyDetail.AddressText = address.text;
                    if (address.value) {
                        vm.state.PropertyDetail.AddressValue = address.value;
                        vm.state.CordellResponse.Propertydata.postcode = address.postCode === null ? null : address.postCode;
                        if ($scope.subFormContent != undefined) {
                            validateConstructionPeriod($scope.subFormContent.OriginalYearBuilt);
                            setValidity();
                        }
                        var splitSate = address.value.split('|');
                        vm.AddressState = splitSate[0];
                        if (vm.AddressState === "NSW") {
                            vm.showStampDuty = true;
                        }

                        else {
                            vm.state.OtherInfo.IsStampDutyExemption = null;
                            vm.showStampDuty = false;
                        }
                        if (vm.AddressState) {
                            if ((qStartDate < qCheckDate) && (vm.AddressState.toUpperCase() === "WA" || vm.AddressState.toUpperCase() === "ACT" || vm.AddressState.toUpperCase() === "TAS")) {
                                vm.showDomesticWorkerCompensation = true;
                                vm.state.OtherInfo.IsDomesticWorkerCompensation = vm.state.OtherInfo.IsDomesticWorkerCompensation;

                            }
                            else {
                                vm.showDomesticWorkerCompensation = false;
                                vm.state.OtherInfo.IsDomesticWorkerCompensation = null;
                            }
                        }

                        if (vm.IsEndorsement && vm.stampDutyEligibilty) {
                            if (vm.AddressState !== vm.storeAddress) {
                                vm.showStampDuty = false;
                            }
                            else {
                                vm.showStampDuty = true;
                                vm.state.OtherInfo.IsStampDutyExemption = vm.state.OtherInfo.IsStampDutyExemption;
                                if (vm.state.OtherInfo.IsStampDutyExemption !== null) {
                                    vm.stampDutyEligibilty = true;
                                }
                                else {
                                    vm.sDExemption = JSON.parse(sessionStorageService.get(keyConstService.stampDutyExemption));
                                    vm.state.OtherInfo.IsStampDutyExemption = vm.sDExemption;
                                }
                            }

                        }
                        if (vm.IsEndorsement) {
                            if (vm.state.OtherInfo.IsStampDutyExemption === null) {
                                vm.showStampDuty = false;
                            }
                        }
                        if (!vm.state.PropertyDetail.IsManualAddress) {
                            findAddress(field);
                        }
                    }
                }                
                if (vm.AddressChange) {
                    vm.getAdressEnquiryDetails();
                }                
            }
        }

        vm.checkValidManualAddress = function (field) {
            if (vm.mannualSearchText) {
                if (!vm.selectedMannualAddress) {
                    field.$setValidity('invalid', false);
                }
                else {
                    field.$setValidity('invalid', true);
                }
            }
        }

        function resetAddressData() {
            var newBusinessCaseData = sessionStorageService.get(keyConstService.newBusinessCaseData);
            var newBusinessCaseDetail = JSON.parse(newBusinessCaseData);
            var qStartDate = newBusinessCaseDetail != null ? new Date(newBusinessCaseDetail.data.EffectiveDate) : new Date(vm.tempHomeData.EffectiveDate);
            var qCheckDate = new Date(vm.tempHomeData.DWCAdjustmentDate);
            if (!vm.IsEndorsement) {
                if (vm.state.PropertyDetail.IsManualAddress) {

                    vm.cordellBackupForFloorReset = null;
                    vm.previousAddress = [{
                        postcode: vm.state.PropertyDetail.Postcode,
                        text: vm.state.PropertyDetail.AddressText,
                        value: vm.state.PropertyDetail.AddressValue,
                    }];

                    vm.previousSelectedAddress = vm.state.PropertyDetail.AddressText;
                    vm.state.PropertyDetail.Address = null;
                    vm.selectedMannualAddress = null;
                    vm.state.PropertyDetail.AddressLine1 = null;
                    vm.state.PropertyDetail.AddressText = null;
                    vm.state.PropertyDetail.AddressValue = null;
                    vm.ResetPropertySection();
                } else {
                    //restore the address
                    vm.RestoreCordellData();
                    vm.state.PropertyDetail.AddressText = vm.previousSelectedAddress;
                    vm.selectedAddress = null;
                    if (vm.state.PropertyDetail.IsManualAddress) {
                        vm.selectedAddress = null;
                    }
                    if (vm.previousAddress && vm.previousAddress[0].text) {
                        vm.selectedAddress = vm.previousAddress[0];
                    }
                    else {
                        vm.ResetPropertySection();
                    }
                }
            }
            else {
                if (endorsementState.PropertyDetail.IsManualAddress) {
                    if (!vm.state.PropertyDetail.IsManualAddress) {
                        if (vm.state.PropertyDetail.AddressLine1 !== null) {
                            vm.previousAddressLine1 = vm.state.PropertyDetail.AddressLine1;
                            vm.manualAddressText = vm.state.PropertyDetail.AddressText;
                        }
                        vm.state.PropertyDetail.AddressLine1 = null;
                        vm.state.PropertyDetail.AddressText = null;
                        vm.selectedMannualAddress = null;
                        vm.selectedAddress = null;
                    }
                    else {
                        vm.state.PropertyDetail.AddressLine1 = vm.previousAddressLine1;
                        vm.state.PropertyDetail.AddressText = vm.manualAddressText;
                        vm.selectedMannualAddress = vm.manualAddressText;
                        vm.RestoreCordellData();
                        setNonFloorAreaDetail();
                    }
                }
                else {
                    if (!vm.state.PropertyDetail.IsManualAddress) {
                        vm.RestoreCordellData();
                        vm.state.PropertyDetail.AddressText = vm.previousAddress;
                        vm.state.PropertyDetail.AddressValue = vm.previousAddressValue;
                        ////Replace this line with next line.... bcoz that will create issue in case of AddressValue = null
                        ////var splitSates = vm.state.PropertyDetail.AddressValue.split('|');
                        var splitSates = vm.state.PropertyDetail.AddressValue != null ? vm.state.PropertyDetail.AddressValue.split('|') : [];
                        vm.AddressState = splitSates[0];
                        if ((qStartDate < qCheckDate) && (vm.AddressState.toUpperCase() === "WA" || vm.AddressState.toUpperCase() === "ACT" || vm.AddressState.toUpperCase() === "TAS")) {
                            vm.showDomesticWorkerCompensation = true;
                            vm.state.OtherInfo.IsDomesticWorkerCompensation = vm.state.OtherInfo.IsDomesticWorkerCompensation;

                        }
                        else {
                            vm.showDomesticWorkerCompensation = false;
                            vm.state.OtherInfo.IsDomesticWorkerCompensation = null;
                        }
                        vm.selectedAddress = vm.previousSelectedAddress;
                        setNonFloorAreaDetail();
                    }
                    else {
                        vm.previousAddress = vm.state.PropertyDetail.AddressText;
                        vm.previousAddressValue = vm.state.PropertyDetail.AddressValue;
                        if (vm.selectedMannualAddress) {
                            if (vm.selectedMannualAddress.value) {
                                var compState = vm.selectedMannualAddress.value;
                                splitSates = compState != null ? compState.split('|') : [];
                                vm.AddressState = splitSates[0];
                                if ((qStartDate < qCheckDate) && (vm.AddressState.toUpperCase() === "WA" || vm.AddressState.toUpperCase() === "ACT" || vm.AddressState.toUpperCase() === "TAS")) {
                                    vm.showDomesticWorkerCompensation = true;
                                    vm.state.OtherInfo.IsDomesticWorkerCompensation = vm.state.OtherInfo.IsDomesticWorkerCompensation;

                                }
                                else {
                                    vm.showDomesticWorkerCompensation = false;
                                    vm.state.OtherInfo.IsDomesticWorkerCompensation = null;
                                }
                            }
                        }
                        vm.previousSelectedAddress = vm.selectedAddress;
                        vm.state.PropertyDetail.AddressText = null;
                        vm.state.PropertyDetail.AddressLine1 = null;
                        vm.selectedAddress = null;
                        vm.selectedMannualAddress = null;
                    }
                }
            }

        }
        function RestoreCordellData() {
            if (vm.cordellDataBackup) {
                vm.state.CordellResponse.Propertydata.periodName = vm.cordellDataBackup.periodName;
                vm.state.CordellResponse.Propertydata.yearBuilt = vm.cordellDataBackup.yearBuilt;
                vm.state.CordellResponse.Propertydata.externalWallMaterial = vm.cordellDataBackup.externalWallMaterial;
                vm.state.CordellResponse.Propertydata.roof = vm.cordellDataBackup.roof;
                vm.state.CordellResponse.Propertydata.quality = vm.cordellDataBackup.quality;
                vm.state.CordellResponse.Propertydata.levels = vm.cordellDataBackup.levels;
                vm.state.CordellResponse.Propertydata.knowTheArea = vm.cordellDataBackup.knowTheArea;
                vm.state.CordellResponse.Propertydata.floorArea = vm.cordellDataBackup.floorArea;
                vm.state.CordellResponse.Propertydata.bushland = vm.cordellDataBackup.bushland;
                vm.state.CordellResponse.Propertydata.slope = vm.cordellDataBackup.slope;
                vm.state.CordellResponse.Propertydata.roomBathSizeList = vm.cordellDataBackup.roomBathSizeList;
                vm.state.CordellResponse.Propertydata.roomBath1Size = vm.cordellDataBackup.roomBath1Size;
                vm.state.CordellResponse.Propertydata.roomBath2Size = vm.cordellDataBackup.roomBath2Size;
                vm.state.CordellResponse.Propertydata.roomBath3Size = vm.cordellDataBackup.roomBath3Size;
                vm.state.CordellResponse.Propertydata.roomBath4Size = vm.cordellDataBackup.roomBath4Size;
                vm.state.CordellResponse.Propertydata.roomBath5Size = vm.cordellDataBackup.roomBath5Size;
                vm.state.CordellResponse.Propertydata.roomBath6Size = vm.cordellDataBackup.roomBath6Size;
                vm.state.CordellResponse.Propertydata.knowTheArea = vm.cordellDataBackup.knowTheArea;
                if (vm.version > keyConstService.Version) {
                    vm.state.CordellResponse.Propertydata.roomBed = vm.cordellDataBackup.roomBed;
                    vm.state.CordellResponse.Propertydata.roomBath = vm.cordellDataBackup.roomBath;
                }

            }
        }

        function ResetCordellData() {
            vm.state.CordellResponse.Propertydata.periodName = null,
                vm.state.CordellResponse.Propertydata.yearBuilt = null;
            vm.state.CordellResponse.Propertydata.bushland = null;
            vm.state.CordellResponse.Propertydata.slope = null;
            vm.state.CordellResponse.Propertydata.externalWallMaterial = null;
            vm.state.CordellResponse.Propertydata.roof = null;
            vm.state.CordellResponse.Propertydata.floorArea = null;
            vm.state.CordellResponse.Propertydata.quality = null;
            vm.state.CordellResponse.Propertydata.levels = 0;
            vm.state.CordellResponse.Propertydata.knowTheArea = null;
            resetCordellRestData();

        }

        function resetCordellRestData() {
            vm.state.CordellResponse.Propertydata.roomBed = 0;
            vm.state.CordellResponse.Propertydata.roomBedSizeList = null;
            vm.state.CordellResponse.Propertydata.roomBed1Size = null,
                vm.state.CordellResponse.Propertydata.roomBed2Size = null,
                vm.state.CordellResponse.Propertydata.roomBed3Size = null,
                vm.state.CordellResponse.Propertydata.roomBed4Size = null,
                vm.state.CordellResponse.Propertydata.roomBed5Size = null,
                vm.state.CordellResponse.Propertydata.roomBed6Size = null,
                vm.state.CordellResponse.Propertydata.roomBed7Size = null,
                vm.state.CordellResponse.Propertydata.roomBed8Size = null,
                vm.state.CordellResponse.Propertydata.roomBed9Size = null,
                vm.state.CordellResponse.Propertydata.roomBath = 0;
            vm.state.CordellResponse.Propertydata.roomBathSizeList = null;
            vm.state.CordellResponse.Propertydata.roomBath1Size = null,
                vm.state.CordellResponse.Propertydata.roomBath2Size = null,
                vm.state.CordellResponse.Propertydata.roomBath3Size = null,
                vm.state.CordellResponse.Propertydata.roomBath4Size = null,
                vm.state.CordellResponse.Propertydata.roomBath5Size = null,
                vm.state.CordellResponse.Propertydata.roomBath6Size = null,
                vm.state.CordellResponse.Propertydata.roomToilet = 0;
            vm.state.CordellResponse.Propertydata.garage = 0;
            vm.state.CordellResponse.Propertydata.roomKitchen = 0;
            vm.state.CordellResponse.Propertydata.kitchenSizeList = null;
            vm.state.CordellResponse.Propertydata.roomKitchen1Size = null,
                vm.state.CordellResponse.Propertydata.roomKitchen2Size = null,
                vm.state.CordellResponse.Propertydata.roomLaundry = 0;
            vm.state.CordellResponse.Propertydata.roomLaundrySizeList = null;
            vm.state.CordellResponse.Propertydata.roomLaundry1Size = null,
                vm.state.CordellResponse.Propertydata.roomLaundry2Size = null,
                vm.state.CordellResponse.Propertydata.roomEntryFoyerSize = null;
            vm.state.CordellResponse.Propertydata.roomLivingSize = null;
            vm.state.CordellResponse.Propertydata.roomDiningSize = null;
            vm.state.CordellResponse.Propertydata.roomFamilySize = null;
            vm.state.CordellResponse.Propertydata.roomRumpusSize = null;
            vm.state.CordellResponse.Propertydata.roomSunSize = null;
            vm.state.CordellResponse.Propertydata.roomBilliardSize = null;
            vm.state.CordellResponse.Propertydata.roomHomeTheatreSize = null;
            vm.state.CordellResponse.Propertydata.roomOther = null;
            vm.state.CordellResponse.Propertydata.roomOtherSizeList = null;
            vm.state.CordellResponse.Propertydata.roomOther1Size = null,
                vm.state.CordellResponse.Propertydata.roomOther2Size = null,
                vm.state.CordellResponse.Propertydata.roomWardrobeBuiltin = null;
            vm.state.CordellResponse.Propertydata.roomLinenCloset = null;
            vm.state.CordellResponse.Propertydata.roomWardrobeWalkin = null;
            vm.state.CordellResponse.Propertydata.carport = 0;
            vm.state.CordellResponse.Propertydata.balconyDeck = 0;
            vm.state.CordellResponse.Propertydata.porchVerandah = 0;
            vm.state.CordellResponse.Propertydata.retainingWalls = null;
            vm.state.CordellResponse.Propertydata.cabin = 0;
            vm.state.CordellResponse.Propertydata.cabinSizeList = null;
            vm.state.CordellResponse.Propertydata.cabin1Size = null,
                vm.state.CordellResponse.Propertydata.cabin2Size = null,
                vm.state.CordellResponse.Propertydata.cabin3Size = null,
                vm.state.CordellResponse.Propertydata.heatingCooling_Included = null;
            vm.state.CordellResponse.Propertydata.heatingCooling_airConDuctedType = null;
            vm.state.CordellResponse.Propertydata.heatingCooling_airConStandalone = null;
            vm.state.CordellResponse.Propertydata.heatingCooling_fireplace = null;
            vm.state.CordellResponse.Propertydata.solar_Included = null;
            vm.state.CordellResponse.Propertydata.solar_HotWater = null;
            vm.state.CordellResponse.Propertydata.solar_Electricity = null;
            vm.state.CordellResponse.Propertydata.shed_Included = null;
            vm.state.CordellResponse.Propertydata.shed_Small = 0;
            vm.state.CordellResponse.Propertydata.shed_Large = 0;
            vm.state.CordellResponse.Propertydata.poolSpa_Included = null;
            vm.state.CordellResponse.Propertydata.poolSpa_SpaType = null;
            vm.state.CordellResponse.Propertydata.poolSpa_ConcretePoolSize = null;
            vm.state.CordellResponse.Propertydata.poolSpa_FibreglassPoolSize = null;
            vm.state.CordellResponse.Propertydata.poolSpa_VinylPoolSize = null;
            vm.state.CordellResponse.Propertydata.tennisCourt_Included = null;
            vm.state.CordellResponse.Propertydata.tennisCourt_Number = 0;
            vm.state.CordellResponse.Propertydata.tennisCourt_SurfaceType = null;
            vm.state.CordellResponse.Propertydata.tennisCourt_Lighting = null;
            //vm.state.CordellResponse.Propertydata.propertyId = null;
            //vm.state.CordellResponse.Propertydata.postcode = null;
        }

        function setNonFloorAreaDetail() {
            if (!vm.state.CordellResponse.Propertydata.knowTheArea) {
                if (vm.cordellBackupForFloorReset) {
                    vm.state.CordellResponse.Propertydata.floorArea = vm.cordellBackupForFloorReset.floorArea;
                    vm.state.CordellResponse.Propertydata.roomBed = vm.cordellBackupForFloorReset.roomBed;
                    vm.state.CordellResponse.Propertydata.roomBed1Size = vm.cordellBackupForFloorReset.roomBed1Size,
                        vm.state.CordellResponse.Propertydata.roomBed2Size = vm.cordellBackupForFloorReset.roomBed2Size,
                        vm.state.CordellResponse.Propertydata.roomBed3Size = vm.cordellBackupForFloorReset.roomBed3Size,
                        vm.state.CordellResponse.Propertydata.roomBed4Size = vm.cordellBackupForFloorReset.roomBed4Size,
                        vm.state.CordellResponse.Propertydata.roomBed5Size = vm.cordellBackupForFloorReset.roomBed5Size,
                        vm.state.CordellResponse.Propertydata.roomBed6Size = vm.cordellBackupForFloorReset.roomBed6Size,
                        vm.state.CordellResponse.Propertydata.roomBed7Size = vm.cordellBackupForFloorReset.roomBed7Size,
                        vm.state.CordellResponse.Propertydata.roomBed8Size = vm.cordellBackupForFloorReset.roomBed8Size,
                        vm.state.CordellResponse.Propertydata.roomBed9Size = vm.cordellBackupForFloorReset.roomBed9Size,
                        vm.state.CordellResponse.Propertydata.roomBedSizeList = vm.cordellBackupForFloorReset.roomBedSizeList;
                    vm.state.CordellResponse.Propertydata.roomBath = vm.cordellBackupForFloorReset.roomBath;
                    vm.state.CordellResponse.Propertydata.roomBathSizeList = vm.cordellBackupForFloorReset.roomBathSizeList;
                    vm.state.CordellResponse.Propertydata.roomBath1Size = vm.cordellBackupForFloorReset.roomBath1Size;
                    vm.state.CordellResponse.Propertydata.roomBath2Size = vm.cordellBackupForFloorReset.roomBath2Size;
                    vm.state.CordellResponse.Propertydata.roomBath3Size = vm.cordellBackupForFloorReset.roomBath3Size;
                    vm.state.CordellResponse.Propertydata.roomBath4Size = vm.cordellBackupForFloorReset.roomBath4Size;
                    vm.state.CordellResponse.Propertydata.roomBath5Size = vm.cordellBackupForFloorReset.roomBath5Size;
                    vm.state.CordellResponse.Propertydata.roomBath6Size = vm.cordellBackupForFloorReset.roomBath6Size;
                    vm.state.CordellResponse.Propertydata.roomToilet = vm.cordellBackupForFloorReset.roomToilet;
                    vm.state.CordellResponse.Propertydata.garage = vm.cordellBackupForFloorReset.garage;
                    vm.state.CordellResponse.Propertydata.roomKitchen = vm.cordellBackupForFloorReset.roomKitchen;
                    vm.state.CordellResponse.Propertydata.kitchenSizeList = vm.cordellBackupForFloorReset.kitchenSizeList;
                    vm.state.CordellResponse.Propertydata.roomKitchen1Size = vm.cordellBackupForFloorReset.roomKitchen1Size;
                    vm.state.CordellResponse.Propertydata.roomKitchen2Size = vm.cordellBackupForFloorReset.roomKitchen2Size;
                    vm.state.CordellResponse.Propertydata.roomLaundry = vm.cordellBackupForFloorReset.roomLaundry;
                    vm.state.CordellResponse.Propertydata.roomLaundrySizeList = vm.cordellBackupForFloorReset.roomLaundrySizeList;
                    vm.state.CordellResponse.Propertydata.roomLaundry1Size = vm.cordellBackupForFloorReset.roomLaundry1Size;
                    vm.state.CordellResponse.Propertydata.roomLaundry2Size = vm.cordellBackupForFloorReset.roomLaundry2Size;
                    vm.state.CordellResponse.Propertydata.roomEntryFoyerSize = vm.cordellBackupForFloorReset.roomEntryFoyerSize;
                    vm.state.CordellResponse.Propertydata.roomLivingSize = vm.cordellBackupForFloorReset.roomLivingSize;
                    vm.state.CordellResponse.Propertydata.roomDiningSize = vm.cordellBackupForFloorReset.roomDiningSize;
                    vm.state.CordellResponse.Propertydata.roomFamilySize = vm.cordellBackupForFloorReset.roomFamilySize;
                    vm.state.CordellResponse.Propertydata.roomRumpusSize = vm.cordellBackupForFloorReset.roomRumpusSize;
                    vm.state.CordellResponse.Propertydata.roomSunSize = vm.cordellBackupForFloorReset.roomSunSize;
                    vm.state.CordellResponse.Propertydata.roomBilliardSize = vm.cordellBackupForFloorReset.roomBilliardSize;
                    vm.state.CordellResponse.Propertydata.roomHomeTheatreSize = vm.cordellBackupForFloorReset.roomHomeTheatreSize;
                    vm.state.CordellResponse.Propertydata.roomOther = vm.cordellBackupForFloorReset.roomOther;
                    vm.state.CordellResponse.Propertydata.roomOtherSizeList = vm.cordellBackupForFloorReset.roomOtherSizeList;
                    vm.state.CordellResponse.Propertydata.roomOther1Size = vm.cordellBackupForFloorReset.roomOther1Size;
                    vm.state.CordellResponse.Propertydata.roomOther2Size = vm.cordellBackupForFloorReset.roomOther2Size;
                    vm.state.CordellResponse.Propertydata.roomWardrobeBuiltin = vm.cordellBackupForFloorReset.roomWardrobeBuiltin;
                    vm.state.CordellResponse.Propertydata.roomLinenCloset = vm.cordellBackupForFloorReset.roomLinenCloset;
                    vm.state.CordellResponse.Propertydata.roomWardrobeWalkin = vm.cordellBackupForFloorReset.roomWardrobeWalkin;
                    vm.state.CordellResponse.Propertydata.carport = vm.cordellBackupForFloorReset.carport;
                    vm.state.CordellResponse.Propertydata.balconyDeck = vm.cordellBackupForFloorReset.balconyDeck;
                    vm.state.CordellResponse.Propertydata.porchVerandah = vm.cordellBackupForFloorReset.porchVerandah;
                    vm.state.CordellResponse.Propertydata.retainingWalls = vm.cordellBackupForFloorReset.retainingWalls;
                    vm.state.CordellResponse.Propertydata.cabin = vm.cordellBackupForFloorReset.cabin;
                    vm.state.CordellResponse.Propertydata.cabinSizeList = vm.cordellBackupForFloorReset.cabinSizeList;
                    vm.state.CordellResponse.Propertydata.cabin1Size = vm.cordellBackupForFloorReset.cabin1Size;
                    vm.state.CordellResponse.Propertydata.cabin2Size = vm.cordellBackupForFloorReset.cabin2Size;
                    vm.state.CordellResponse.Propertydata.cabin3Size = vm.cordellBackupForFloorReset.cabin3Size;
                    vm.state.CordellResponse.Propertydata.heatingCooling_Included = vm.cordellBackupForFloorReset.heatingCooling_Included;
                    vm.state.CordellResponse.Propertydata.heatingCooling_airConDuctedType = vm.cordellBackupForFloorReset.heatingCooling_airConDuctedType;
                    vm.state.CordellResponse.Propertydata.heatingCooling_airConStandalone = vm.cordellBackupForFloorReset.heatingCooling_airConStandalone;
                    vm.state.CordellResponse.Propertydata.heatingCooling_fireplace = vm.cordellBackupForFloorReset.heatingCooling_fireplace;
                    vm.state.CordellResponse.Propertydata.solar_Included = vm.cordellBackupForFloorReset.solar_Included;
                    vm.state.CordellResponse.Propertydata.solar_HotWater = vm.cordellBackupForFloorReset.solar_HotWater;
                    vm.state.CordellResponse.Propertydata.solar_Electricity = vm.cordellBackupForFloorReset.solar_Electricity;
                    vm.state.CordellResponse.Propertydata.shed_Included = vm.cordellBackupForFloorReset.shed_Included;
                    vm.state.CordellResponse.Propertydata.shed_Small = vm.cordellBackupForFloorReset.shed_Small;
                    vm.state.CordellResponse.Propertydata.shed_Large = vm.cordellBackupForFloorReset.shed_Large;
                    vm.state.CordellResponse.Propertydata.poolSpa_Included = vm.cordellBackupForFloorReset.poolSpa_Included;
                    vm.state.CordellResponse.Propertydata.poolSpa_SpaType = vm.cordellBackupForFloorReset.poolSpa_SpaType;
                    vm.state.CordellResponse.Propertydata.poolSpa_ConcretePoolSize = vm.cordellBackupForFloorReset.poolSpa_ConcretePoolSize;
                    vm.state.CordellResponse.Propertydata.poolSpa_FibreglassPoolSize = vm.cordellBackupForFloorReset.poolSpa_FibreglassPoolSize;
                    vm.state.CordellResponse.Propertydata.poolSpa_VinylPoolSize = vm.cordellBackupForFloorReset.poolSpa_VinylPoolSize;
                    vm.state.CordellResponse.Propertydata.tennisCourt_Included = vm.cordellBackupForFloorReset.tennisCourt_Included;
                    vm.state.CordellResponse.Propertydata.tennisCourt_Number = vm.cordellBackupForFloorReset.tennisCourt_Number;
                    vm.state.CordellResponse.Propertydata.tennisCourt_SurfaceType = vm.cordellBackupForFloorReset.tennisCourt_SurfaceType;
                    vm.state.CordellResponse.Propertydata.tennisCourt_Lighting = vm.cordellBackupForFloorReset.tennisCourt_Lighting;
                    SetCordelFields();
                }
                if (vm.IsEndorsement && vm.state.PropertyDetail.AddressText === endorsementState.PropertyDetail.AddressText) {
                    vm.state.CordellResponse.Propertydata.floorArea = angular.copy(endorsementState.CordellResponse.Propertydata.floorArea);
                    vm.state.CordellResponse.Propertydata.roomBed = angular.copy(endorsementState.CordellResponse.Propertydata.roomBed);
                    vm.state.CordellResponse.Propertydata.roomKitchen = angular.copy(endorsementState.CordellResponse.Propertydata.roomKitchen);
                    vm.state.CordellResponse.Propertydata.kitchenSizeList = angular.copy(endorsementState.CordellResponse.Propertydata.kitchenSizeList);
                    vm.state.CordellResponse.Propertydata.roomKitchen1Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomKitchen1Size);
                    vm.state.CordellResponse.Propertydata.roomKitchen2Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomKitchen2Size);
                    vm.state.CordellResponse.Propertydata.roomBedSizeList = angular.copy(endorsementState.CordellResponse.Propertydata.roomBedSizeList);
                    vm.state.CordellResponse.Propertydata.roomBed1Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomBed1Size);
                    vm.state.CordellResponse.Propertydata.roomBed2Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomBed2Size);
                    vm.state.CordellResponse.Propertydata.roomBed3Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomBed3Size);
                    vm.state.CordellResponse.Propertydata.roomBed4Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomBed4Size);
                    vm.state.CordellResponse.Propertydata.roomBed5Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomBed5Size);
                    vm.state.CordellResponse.Propertydata.roomBed6Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomBed6Size);
                    vm.state.CordellResponse.Propertydata.roomBed7Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomBed7Size);
                    vm.state.CordellResponse.Propertydata.roomBed8Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomBed8Size);
                    vm.state.CordellResponse.Propertydata.roomBed9Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomBed9Size);
                    vm.state.CordellResponse.Propertydata.roomBath = angular.copy(endorsementState.CordellResponse.Propertydata.roomBath);
                    vm.state.CordellResponse.Propertydata.roomBathSizeList = angular.copy(endorsementState.CordellResponse.Propertydata.roomBathSizeList);
                    vm.state.CordellResponse.Propertydata.roomBath1Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomBath1Size);
                    vm.state.CordellResponse.Propertydata.roomBath2Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomBath2Size);
                    vm.state.CordellResponse.Propertydata.roomBath3Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomBath3Size);
                    vm.state.CordellResponse.Propertydata.roomBath4Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomBath4Size);
                    vm.state.CordellResponse.Propertydata.roomBath5Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomBath5Size);
                    vm.state.CordellResponse.Propertydata.roomBath6Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomBath6Size);
                    vm.state.CordellResponse.Propertydata.roomToilet = angular.copy(endorsementState.CordellResponse.Propertydata.roomToilet);
                    vm.state.CordellResponse.Propertydata.garage = angular.copy(endorsementState.CordellResponse.Propertydata.garage);
                    vm.state.CordellResponse.Propertydata.roomLaundry = angular.copy(endorsementState.CordellResponse.Propertydata.roomLaundry);
                    vm.state.CordellResponse.Propertydata.roomLaundrySizeList = angular.copy(endorsementState.CordellResponse.Propertydata.roomLaundrySizeList);
                    vm.state.CordellResponse.Propertydata.roomLaundry1Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomLaundry1Size);
                    vm.state.CordellResponse.Propertydata.roomLaundry2Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomLaundry2Size);
                    vm.state.CordellResponse.Propertydata.roomEntryFoyerSize = angular.copy(endorsementState.CordellResponse.Propertydata.roomEntryFoyerSize);
                    vm.state.CordellResponse.Propertydata.roomLivingSize = angular.copy(endorsementState.CordellResponse.Propertydata.roomLivingSize);
                    vm.state.CordellResponse.Propertydata.roomDiningSize = angular.copy(endorsementState.CordellResponse.Propertydata.roomDiningSize);
                    vm.state.CordellResponse.Propertydata.roomFamilySize = angular.copy(endorsementState.CordellResponse.Propertydata.roomFamilySize);
                    vm.state.CordellResponse.Propertydata.roomRumpusSize = angular.copy(endorsementState.CordellResponse.Propertydata.roomRumpusSize);
                    vm.state.CordellResponse.Propertydata.roomSunSize = angular.copy(endorsementState.CordellResponse.Propertydata.roomSunSize);
                    vm.state.CordellResponse.Propertydata.roomBilliardSize = angular.copy(endorsementState.CordellResponse.Propertydata.roomBilliardSize);
                    vm.state.CordellResponse.Propertydata.roomHomeTheatreSize = angular.copy(endorsementState.CordellResponse.Propertydata.roomHomeTheatreSize);
                    vm.state.CordellResponse.Propertydata.roomOther = angular.copy(endorsementState.CordellResponse.Propertydata.roomOther);
                    vm.state.CordellResponse.Propertydata.roomOtherSizeList = angular.copy(endorsementState.CordellResponse.Propertydata.roomOtherSizeList);
                    vm.state.CordellResponse.Propertydata.roomOther1Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomOther1Size);
                    vm.state.CordellResponse.Propertydata.roomOther2Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomOther2Size);
                    vm.state.CordellResponse.Propertydata.roomWardrobeBuiltin = angular.copy(endorsementState.CordellResponse.Propertydata.roomWardrobeBuiltin);
                    vm.state.CordellResponse.Propertydata.roomLinenCloset = angular.copy(endorsementState.CordellResponse.Propertydata.roomLinenCloset);
                    vm.state.CordellResponse.Propertydata.roomWardrobeWalkin = angular.copy(endorsementState.CordellResponse.Propertydata.roomWardrobeWalkin);
                    vm.state.CordellResponse.Propertydata.carport = angular.copy(endorsementState.CordellResponse.Propertydata.carport);
                    vm.state.CordellResponse.Propertydata.balconyDeck = angular.copy(endorsementState.CordellResponse.Propertydata.balconyDeck);
                    vm.state.CordellResponse.Propertydata.porchVerandah = angular.copy(endorsementState.CordellResponse.Propertydata.porchVerandah);
                    vm.state.CordellResponse.Propertydata.retainingWalls = angular.copy(endorsementState.CordellResponse.Propertydata.retainingWalls);
                    vm.state.CordellResponse.Propertydata.cabin = angular.copy(endorsementState.CordellResponse.Propertydata.cabin);
                    vm.state.CordellResponse.Propertydata.cabinSizeList = angular.copy(endorsementState.CordellResponse.Propertydata.cabinSizeList);
                    vm.state.CordellResponse.Propertydata.cabin1Size = angular.copy(endorsementState.CordellResponse.Propertydata.cabin1Size);
                    vm.state.CordellResponse.Propertydata.cabin2Size = angular.copy(endorsementState.CordellResponse.Propertydata.cabin2Size);
                    vm.state.CordellResponse.Propertydata.cabin3Size = angular.copy(endorsementState.CordellResponse.Propertydata.cabin3Size);
                    vm.state.CordellResponse.Propertydata.heatingCooling_Included = angular.copy(endorsementState.CordellResponse.Propertydata.heatingCooling_Included);
                    vm.state.CordellResponse.Propertydata.heatingCooling_airConDuctedType = angular.copy(endorsementState.CordellResponse.Propertydata.heatingCooling_airConDuctedType);
                    vm.state.CordellResponse.Propertydata.heatingCooling_airConStandalone = angular.copy(endorsementState.CordellResponse.Propertydata.heatingCooling_airConStandalone);
                    vm.state.CordellResponse.Propertydata.heatingCooling_fireplace = angular.copy(endorsementState.CordellResponse.Propertydata.heatingCooling_fireplace);
                    vm.state.CordellResponse.Propertydata.solar_Included = angular.copy(endorsementState.CordellResponse.Propertydata.solar_Included);
                    vm.state.CordellResponse.Propertydata.solar_HotWater = angular.copy(endorsementState.CordellResponse.Propertydata.solar_HotWater);
                    vm.state.CordellResponse.Propertydata.solar_Electricity = angular.copy(endorsementState.CordellResponse.Propertydata.solar_Electricity);
                    vm.state.CordellResponse.Propertydata.shed_Included = angular.copy(endorsementState.CordellResponse.Propertydata.shed_Included);
                    vm.state.CordellResponse.Propertydata.shed_Small = angular.copy(endorsementState.CordellResponse.Propertydata.shed_Small);
                    vm.state.CordellResponse.Propertydata.shed_Large = angular.copy(endorsementState.CordellResponse.Propertydata.shed_Large);
                    vm.state.CordellResponse.Propertydata.poolSpa_Included = angular.copy(endorsementState.CordellResponse.Propertydata.poolSpa_Included);
                    vm.state.CordellResponse.Propertydata.poolSpa_SpaType = angular.copy(endorsementState.CordellResponse.Propertydata.poolSpa_SpaType);
                    vm.state.CordellResponse.Propertydata.poolSpa_ConcretePoolSize = angular.copy(endorsementState.CordellResponse.Propertydata.poolSpa_ConcretePoolSize);
                    vm.state.CordellResponse.Propertydata.poolSpa_FibreglassPoolSize = angular.copy(endorsementState.CordellResponse.Propertydata.poolSpa_FibreglassPoolSize);
                    vm.state.CordellResponse.Propertydata.poolSpa_VinylPoolSize = angular.copy(endorsementState.CordellResponse.Propertydata.poolSpa_VinylPoolSize);
                    vm.state.CordellResponse.Propertydata.tennisCourt_Included = angular.copy(endorsementState.CordellResponse.Propertydata.tennisCourt_Included);
                    vm.state.CordellResponse.Propertydata.tennisCourt_Number = angular.copy(endorsementState.CordellResponse.Propertydata.tennisCourt_Number);
                    vm.state.CordellResponse.Propertydata.tennisCourt_SurfaceType = angular.copy(endorsementState.CordellResponse.Propertydata.tennisCourt_SurfaceType);
                    vm.state.CordellResponse.Propertydata.tennisCourt_Lighting = angular.copy(endorsementState.CordellResponse.Propertydata.tennisCourt_Lighting);
                    SetCordelFields();
                }
            }
        }

        function nextPremium() {
            if (vm.policyTransactionId) {
                $window.location.href = webUrlConstService.bindIndex + sessionStorageService.getEncryption('id=' + vm.policyTransactionId);
            }
            else {
                window.location = webUrlConstService.quoteCasePremiumURL + sessionStorageService.getEncryption('quoteTransactionId=' + vm.TransactionId);
            }
        }

        vm.Back = function () {
            var isactivePM = sessionStorageService.get('IsPackageManagerNavigationMode');
            if (isactivePM === "true") {
                sessionStorageService.set(keyConstService.IsPackageManagerNavigationMode, "preTrue");
            }
            vm.disableButtons = true;
            if (vm.IsEndorsement) {
                if (vm.state.PropertyDetail.IsManualAddress === false) {
                    vm.selectedMannualAddress = null;
                    vm.state.PropertyDetail.AddressLine1 = null;
                }
            }
            if (vm.state.PropertyDetail.IsManualAddress) {
                if (!vm.state.PropertyDetail.AddressText) {
                    vm.state.PropertyDetail.AddressText = null;
                    vm.state.PropertyDetail.AddressValue = null;
                }
            }
            sessionStorageService.remove(keyConstService.resetNonRegoData);
            sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
            sessionStorageService.remove(keyConstService.isManualRegoEnabled);
            getQuestionSetWithoutSaving = sessionStorageService.set(keyConstService.getQuestionSetWithoutSaving, vm.state);
            var quoteTransactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
            sessionStorageService.get(keyConstService.newBusinessCaseData);
            sessionStorageService.set(keyConstService.sessionStorageState, true);
            getTransactionIdWithoutSaving = sessionStorageService.set(keyConstService.getTransactionIdWithoutSaving, quoteTransactionId);
            var transactionId = sessionStorageService.get(keyConstService.quoteTransactionId);

            if (vm.IsEndorsement) {
                window.location = webUrlConstService.endorsementRequest + sessionStorageService.getEncryption("quoteTransactionId=" + transactionId);
            }
            else {
                if (sessionStorageService.get(keyConstService.IsNewEditTransaction) !== "true") {
                    sessionStorageService.set(keyConstService.IsNewEditTransaction, isNewEditTransaction);
                }
                window.location = webUrlConstService.newBusinessIndex + sessionStorageService.getEncryption("transactionId=" + transactionId);
            }
        };

        vm.Cancel = function () {
            vm.disableButtons = true;
            if (vm.IsEndorsement) {
                quotesService.quoteDiscardRequest(sessionStorageService.get(keyConstService.quoteTransactionId)).then(function (result) {
                    if (result.data) {
                        if (vm.showManagePkg) {
                            vm.packageNumber = sessionStorageService.get('PackageNumberInformation');
                            vm.renewalCounter = sessionStorageService.get('RenewalCounter');
                            sessionStorageService.remove('IsPackageManagerNavigationMode');
                            sessionStorageService.remove('PackageNumberInformation');
                            sessionStorageService.remove('RenewalCounter');
                            $window.location.href = webUrlConstService.getPackageInfo + sessionStorageService.getEncryption("packageNumber=" + JSON.parse(vm.packageNumber) + "&&renewalCounter=" + vm.renewalCounter);
                        }
                        else {
                            $timeout(function () {
                                var Id = vm.dataState.PolicyId;
                                window.location = "/Bind?" + sessionStorageService.getEncryption("id=" + Id);
                            }, 1000);
                        }
                    } else {
                        toastr.error(messageConstService.errServiceUnavailable);
                        vm.disableButtons = false;
                    }
                },
                    function (error) {
                        $log.error('error', error);
                        toastr.error(messageConstService.errServiceUnavailable);
                        vm.disableButtons = false;
                    });
            }
            else {
                if (vm.showManagePkg) {
                    vm.packageNumber = sessionStorageService.get('PackageNumberInformation');
                    vm.renewalCounter = sessionStorageService.get('RenewalCounter');
                    sessionStorageService.remove('IsPackageManagerNavigationMode');
                    sessionStorageService.remove('PackageNumberInformation');
                    sessionStorageService.remove('RenewalCounter');
                    $window.location.href = webUrlConstService.getPackageInfo + sessionStorageService.getEncryption("packageNumber=" + JSON.parse(vm.packageNumber) + "&&renewalCounter=" + vm.renewalCounter);
                }
                else {
                    $window.location = webUrlConstService.homeIndex;
                }
            }
        };

        function isAdditionalPolicyHolderChange() {
            if (!vm.state.Insured.IsAdditionalPolicyHolder) {
                vm.state.Insured.AdditionalPolicyHolderList = [{ AdditionalPolicyHolder: null, AdditionalDateOfBirth: null, AdditionalPolicyHolderType: null, OtherPolicyHolderName: null, OtherDateOfBirth: null }];
            }
        }

        function changeNotesPrintable(currentNote) {
            if (vm.state.Notes.length > 1) {
                var currentIndex = vm.state.Notes.indexOf(currentNote);
                var index = 1 - currentIndex;
                vm.state.Notes[index].IsPrintable = !currentNote.IsPrintable;
            }
        }

        vm.removeClaims = function (item) {
            var index = vm.state.Claims.ClaimsList.indexOf(item);
            vm.state.Claims.ClaimsList.splice(index, 1);
            vm.DisableAddClaim = false;
            if (vm.state.Claims.ClaimsList.length <= 1) {
                if (vm.state.Claims.ClaimsList[0].ClaimYear === null) {
                    vm.checkNullClaimList = true;
                    vm.state.Claims.ClaimsList = [{ ClaimYear: null, ClaimType: null, CostOfClaim: 0 }];
                }
            }
        };

        vm.addClaims = function () {
            if (vm.state.Claims.ClaimsList.length <= 6) {
                vm.state.Claims.ClaimsList.push({ ClaimYear: null, ClaimType: null, CostOfClaim: 0 });
            }
            else {
                vm.DisableAddClaim = true;
            }

            if (vm.state.Claims.ClaimsList.length > 1) {
                for (var i = 0; i < vm.state.Claims.ClaimsList.length; i++) {
                    if (vm.state.Claims.ClaimsList[i].ClaimYear === null) {
                        vm.checkNullClaimList = true;
                    }
                    else if (vm.state.Claims.ClaimsList[i].ClaimType === null) {
                        vm.checkNullClaimList = true;
                    }
                }
            }
        };

        vm.checkClaims = function () {
            if (vm.state.Claims.ClaimsList.length >= 1 && vm.state.Claims.IsClaimsInLast3Years) {
                for (var i = 0; i < vm.state.Claims.ClaimsList.length; i++) {
                    if (!vm.state.Claims.ClaimsList[i].ClaimYear) {
                        vm.checkNullClaimList = true;
                    }
                    else if (!vm.state.Claims.ClaimsList[i].ClaimType) {
                        vm.checkNullClaimList = true;
                    }
                }
            }
        };

        vm.disableCoverOnOccupancy = function (cover, field) {
            //if (!$scope.tempBuildingSumInsured && vm.state.CordellResponse.BuildingSumInsured > 0) {
            //    $scope.tempBuildingSumInsured = vm.state.CordellResponse.BuildingSumInsured;
            //}
            //if ((vm.state.CordellResponse.BuildingSumInsured == 0 || vm.state.CordellResponse.BuildingSumInsured == null) && $scope.tempBuildingSumInsured) {
            //    vm.state.CordellResponse.BuildingSumInsured = $scope.tempBuildingSumInsured;
            //}
            //else {
            //    $scope.tempBuildingSumInsured = vm.state.CordellResponse.BuildingSumInsured;
            //}

            if (!vm.state.PolicyHolder.BuildingCover && !vm.state.PolicyHolder.ContentCover) {
                if (cover === 'Content') {
                    vm.state.PolicyHolder.BuildingCover = true;
                    if (vm.state.CordellResponse.BuildingSumInsured == 0) {
                        vm.BuildingSiFlag = true;
                    }
                    else {
                        vm.BuildingSiFlag = false;
                    }
                    if (!vm.IsEndorsement && vm.homeData.DDlProcessTypeId !== 4) {
                        if (vm.state.Excess.BuildingExcess1 === null) {
                            vm.state.Excess.BuildingExcess1 = "500";
                        }
                        if (vm.state.Excess.BuildingExcess2 === null) {
                            vm.state.Excess.BuildingExcess2 = "750";
                        }
                        if (vm.state.Excess.BuildingExcess3 === null) {
                            vm.state.Excess.BuildingExcess3 = "1000";
                        }
                    }
                    if (vm.IsEndorsement) {
                        //vm.state.CordellResponse.BuildingSumInsured = endorsementState.CordellResponse.BuildingSumInsured;
                        vm.state.CordellResponse.BuildingSumInsuredEstimate = endorsementState.CordellResponse.BuildingSumInsuredEstimate;
                        if (vm.endorsementVM && vm.endorsementVM.BuildingExcess) {
                            vm.state.Excess.BuildingExcess1 = vm.endorsementVM.BuildingExcess;
                        }
                        else {
                            vm.state.Excess.BuildingExcess1 = endorsementState.Excess.BuildingExcess1;
                        }
                        if (endorsementState.Excess.BuildingExcess1 === null) {
                            vm.state.Excess.BuildingExcess1 = "500";
                        }

                        if (vm.state.CordellResponse.BuildingSumInsured == 0) {
                            vm.BuildingSiFlag = true;
                        }
                        else {
                            vm.BuildingSiFlag = false;
                        }
                    }
                }
                else if (cover === 'Building') {
                    field.$setValidity('validcurrency', true);
                    vm.BuildingSiFlag = false;
                    vm.state.PolicyHolder.ContentCover = true;
                    var item = { Value: "DamageCausedByChildren,PetsOrOtherAccidentalDamage", Text: "Damage caused by children, pets or other accidental damage" };
                    var index = -1;
                    vm.state.Claims.ClaimTypeList.some(function (x, i) {
                        if (x.Value === "DamageCausedByChildren,PetsOrOtherAccidentalDamage") {
                            index = i;
                        }
                    });

                    if (vm.state.PolicyHolder.ContentCover && index == -1) {
                        vm.state.Claims.ClaimTypeList.splice(vm.state.Claims.ClaimTypeList.length - 1, 0, item);
                    } else if (!vm.state.PolicyHolder.ContentCover && index != -1) {
                        vm.state.Claims.ClaimTypeList.splice(index, 1);
                    }
                    if (vm.state.ContentsSumInsured.GeneralContentSumInsured == 0) {
                        vm.ContentSiFlag = true;
                    }
                    else {
                        vm.ContentSiFlag = false;
                    }
                    if (!vm.IsEndorsement && vm.homeData.DDlProcessTypeId !== 4) {
                        if (vm.state.Excess.ContentExcess1 === null) {
                            vm.state.Excess.ContentExcess1 = "500";
                        }

                        if (vm.state.Excess.ContentExcess2 === null) {
                            vm.state.Excess.ContentExcess2 = "750";
                        }
                        if (vm.state.Excess.ContentExcess3 === null) {
                            vm.state.Excess.ContentExcess3 = "1000";
                        }
                    }
                    if (vm.IsEndorsement) {
                        vm.state.ContentsSumInsured.GeneralContentSumInsured = endorsementState.ContentsSumInsured.GeneralContentSumInsured;
                        vm.state.SecurityDetails.WindowSecurities = endorsementState.SecurityDetails.WindowSecurities;
                        vm.state.SecurityDetails.IsAlarmSecurity = endorsementState.SecurityDetails.IsAlarmSecurity;
                        vm.state.SecurityDetails.AlarmType = endorsementState.SecurityDetails.AlarmType;
                        vm.state.SecurityDetails.DoorSecurities = angular.copy(endorsementState.SecurityDetails.DoorSecurities);
                        vm.state.ContentsSumInsured.IsValuableContent = endorsementState.ContentsSumInsured.IsValuableContent;
                        vm.state.ContentsSumInsured.IsPortableValueCover = endorsementState.ContentsSumInsured.IsPortableValueCover;
                        vm.state.ContentsSumInsured.IsSpecifiedPortableItems = endorsementState.ContentsSumInsured.IsSpecifiedPortableItems;
                        vm.state.ContentsSumInsured.IsUnspecifiedPortableItems = endorsementState.ContentsSumInsured.IsUnspecifiedPortableItems;
                        vm.state.ContentsSumInsured.UnspecifiedPortableItem = endorsementState.ContentsSumInsured.UnspecifiedPortableItem;
                        vm.state.ContentsSumInsured.ValuableContents = angular.copy(endorsementState.ContentsSumInsured.ValuableContents);
                        vm.state.ContentsSumInsured.SpecifiedPortableItems = angular.copy(endorsementState.ContentsSumInsured.SpecifiedPortableItems);
                        vm.state.OtherInfo.IsBuyBusinessExtensionOption = endorsementState.OtherInfo.IsBuyBusinessExtensionOption;
                        vm.state.OtherInfo.BusinessName = endorsementState.OtherInfo.BusinessName;
                        vm.state.OtherInfo.OccupationName = endorsementState.OtherInfo.OccupationName;
                        vm.state.OtherInfo.AnnualRevenue = endorsementState.OtherInfo.AnnualRevenue;
                        vm.state.OtherInfo.OccupationANZSIC = endorsementState.OtherInfo.OccupationANZSIC;
                        vm.state.OtherInfo.IsStampDutyExemption = endorsementState.OtherInfo.IsStampDutyExemption;
                        if (vm.endorsementVM && vm.endorsementVM.ContentExcess) {
                            vm.state.Excess.ContentExcess1 = vm.endorsementVM.ContentExcess;
                        }
                        else {
                            vm.state.Excess.ContentExcess1 = endorsementState.Excess.ContentExcess1;
                        }
                        if (vm.state.Excess.ContentExcess1 === null) {
                            vm.state.Excess.ContentExcess1 = "500";
                        }
                    }

                }

            }
            else if (vm.state.PolicyHolder.HomeOccupancyType === 'Renting') {
                if (vm.state.PropertyDetail.IsManualAddress) {
                    vm.state.CordellResponse.BuildingSumInsuredEstimate = 0;
                }
                vm.state.PolicyHolder.BuildingCover = false;
                field.$setValidity('validcurrency', true);
                vm.BuildingSiFlag = false;
                vm.state.PolicyHolder.ContentCover = true;
                vm.disableBuilding = true;
                vm.disableContent = true;
                if (vm.state.Excess.ContentExcess1 === null) {
                    vm.state.Excess.ContentExcess1 = "500";
                }

                if (vm.state.Excess.ContentExcess2 === null) {
                    vm.state.Excess.ContentExcess2 = "750";
                }
                if (vm.state.Excess.ContentExcess3 === null) {
                    vm.state.Excess.ContentExcess3 = "1000";
                }
                if (vm.state.ContentsSumInsured.GeneralContentSumInsured !== 0) {
                    vm.ContentSiFlag = false;
                }
            }
            else {
                vm.disableBuilding = false;
                vm.disableContent = false;               
            }
        };


        function AnnualRevenueRange(field) {
            var prevValue = 0;
            var total = vm.maxOccupationTurnover.reduce(function (prevValue, elem) {
                if (vm.state.OtherInfo.OccupationName === elem.Text) {
                    vm.maxTurnOver = elem.MaxTurnOver;
                    vm.state.OtherInfo.OccupationANZSIC = elem.Value;
                }
                return elem;
            }, 0);

            if ((vm.state.OtherInfo.AnnualRevenue !== 0) && (vm.state.OtherInfo.AnnualRevenue > vm.maxTurnOver)) {
                field.$setValidity('invalid', false);
            } else {
                field.$setValidity('invalid', true);
            }
        }
        function BuildingSumInsuredRange(field) {
            vm.IsManualBuildingSumInsured = true;
            if (vm.state.CordellResponse.BuildingSumInsured !== undefined) {
                var minRange = vm.state.CordellResponse.BuildingSumInsuredEstimate - (vm.state.CordellResponse.BuildingSumInsuredEstimate * vm.AllowedBuildingSumInsuredRange);
                var maxRange = vm.state.CordellResponse.BuildingSumInsuredEstimate + (vm.state.CordellResponse.BuildingSumInsuredEstimate * vm.AllowedBuildingSumInsuredRange);

                if (vm.state.CordellResponse.BuildingSumInsured < minRange) {
                    vm.lessOrMoreMessage = 'less';
                    vm.IsBuildingSumInsuredOutRange = true;
                }
                else {
                    vm.IsBuildingSumInsuredOutRange = false;
                    field.$setValidity('validcurrency', true);
                }
            }
        }

        vm.removeSpecifiedItems = function (item) {
            var index = vm.state.ContentsSumInsured.ValuableContents.indexOf(item);
            vm.state.ContentsSumInsured.ValuableContents.splice(index, 1);
        };

        vm.removePortableSpecifiedItems = function (item) {
            var index = vm.state.ContentsSumInsured.SpecifiedPortableItems.indexOf(item);
            vm.state.ContentsSumInsured.SpecifiedPortableItems.splice(index, 1);
        };


        vm.addPortableSpecifiedItems = function () {
            vm.state.ContentsSumInsured.SpecifiedPortableItems.push({ PortableCategory: null, PortableDescription: null, PortableValue: null });
        };

        vm.addSpecifiedItems = function () {
            vm.state.ContentsSumInsured.ValuableContents.push({ Category: null, Description: null, Value: null, AwayFromHome: false });

        };

        function removeNote(item) {
            vm.state.Notes.splice(vm.state.Notes.indexOf(item), 1);
        }

        function addNote(currentNote) {
            var newNote = {
                Note: null,
                IsPrintable: !currentNote.IsPrintable
            };
            if (vm.state.Notes.length < 2) {
                vm.state.Notes.push(newNote);
            }
        }

        vm.checkConstructionPeriod = function () {
            var defaultStart = '01/01/' + new Date().getFullYear();
            vm.state.CordellResponse.Propertydata.yearBuilt
        };


        vm.addSecondaryInsured = function () {
            vm.state.PolicyHolder.AdditionalPolicyHolderList.push({ AdditionalPolicyHolder: null, AdditionalDateOfBirth: null, AdditionalPolicyHolderType: null, OtherPolicyHolderName: null, OtherDateOfBirth: null });
            vm.AdditionalPolicyHolderListLength = vm.state.PolicyHolder.AdditionalPolicyHolderList.length;
        };

        vm.removeSecondaryInsured = function (item) {
            var index = vm.state.PolicyHolder.AdditionalPolicyHolderList.indexOf(item);
            var isvalidDOB = true;
            vm.state.PolicyHolder.AdditionalPolicyHolderList.splice(index, 1);
            vm.AdditionalPolicyHolderListLength = vm.state.PolicyHolder.AdditionalPolicyHolderList.length;
            for (var i = 0; i < vm.AdditionalPolicyHolderListLength; i++) {
                var dateofBirth = vm.state.PolicyHolder.AdditionalPolicyHolderList[i].OtherDateOfBirthApp;
                isvalidDOB = dateService.validateBirthDDMMYYYY(dateofBirth, 150);
            }
            if (isvalidDOB.isValid) {
                vm.validDOBOtherInsurer = true;
            }
            vm.checkFutureDate(vm.AdditionalPolicyHolderListLength);
            // for additional insured
            //checkAdditionalInsuredInList();
        };

        vm.checkFutureDate = function (length) {
            var isvalidDOB = true;
            for (var i = 0; i < length; i++) {
                if (vm.state.PolicyHolder.AdditionalPolicyHolderList[i].AdditionalPolicyHolder === "Other") {
                    var dateofBirth = vm.state.PolicyHolder.AdditionalPolicyHolderList[i].OtherDateOfBirthApp;
                    isvalidDOB = dateService.validateBirthDDMMYYYY(dateofBirth, 150);

                    if (isvalidDOB.isValid) {
                        vm.validDOBOtherInsurer = true;
                    }
                    else {
                        vm.validDOBOtherInsurer = false;
                        break;
                    }
                }
                else {
                    break;
                }

            }
        };
        vm.defaultCheck = function (field, cover) {
            $scope.isDefaultCheckClick = true;
            $scope.IsChangeAddress = false;
            //if (!$scope.tempBuildingSumInsured && vm.state.CordellResponse.BuildingSumInsured > 0) {
            //    $scope.tempBuildingSumInsured = vm.state.CordellResponse.BuildingSumInsured;
            //}

            //if ((vm.state.CordellResponse.BuildingSumInsured == 0 || vm.state.CordellResponse.BuildingSumInsured == null) && $scope.tempBuildingSumInsured) {
            //    vm.state.CordellResponse.BuildingSumInsured = $scope.tempBuildingSumInsured;
            //}
            //else {
            //    $scope.tempBuildingSumInsured = vm.state.CordellResponse.BuildingSumInsured;
            //}

            vm.brokerCommissionLimitMessage = false;
            if (!vm.IsEndorsementPolicyEffectiveDate) {
                var item = { Value: "DamageCausedByChildren,PetsOrOtherAccidentalDamage", Text: "Damage caused by children, pets or other accidental damage" };
                var index = -1;
                vm.state.Claims.ClaimTypeList.some(function (x, i) {
                    if (x.Value === "DamageCausedByChildren,PetsOrOtherAccidentalDamage") {
                        index = i;
                    }
                });

                if (vm.state.PolicyHolder.ContentCover && index === -1) {
                    vm.state.Claims.ClaimTypeList.splice(vm.state.Claims.ClaimTypeList.length - 1, 0, item);
                } else if (!vm.state.PolicyHolder.ContentCover && index !== -1) {
                    vm.state.Claims.ClaimTypeList.splice(index, 1);
                }
            }

            if (vm.state.PolicyHolder.ContentCover) {
                if (vm.state.ContentsSumInsured.GeneralContentSumInsured === 0) {
                    vm.ContentSiFlag = true;
                }
                else {
                    vm.ContentSiFlag = false;
                }
                if (!vm.IsEndorsement) {
                    if (vm.homeData.DDlProcessTypeId !== 4) {
                        if (vm.state.Excess.ContentExcess1 === null) {
                            vm.state.Excess.ContentExcess1 = "500";
                        }

                        if (vm.state.Excess.ContentExcess2 === null) {
                            vm.state.Excess.ContentExcess2 = "750";
                        }
                        if (vm.state.Excess.ContentExcess3 === null) {
                            vm.state.Excess.ContentExcess3 = "1000";
                        }
                    }
                }
                if (vm.IsEndorsement && cover === "Content") {
                    vm.state.ContentsSumInsured.GeneralContentSumInsured = endorsementState.ContentsSumInsured.GeneralContentSumInsured;
                    vm.state.SecurityDetails.WindowSecurities = endorsementState.SecurityDetails.WindowSecurities;
                    vm.state.SecurityDetails.IsAlarmSecurity = endorsementState.SecurityDetails.IsAlarmSecurity;
                    vm.state.SecurityDetails.AlarmType = endorsementState.SecurityDetails.AlarmType;
                    vm.state.SecurityDetails.DoorSecurities = angular.copy(endorsementState.SecurityDetails.DoorSecurities);
                    vm.state.ContentsSumInsured.IsValuableContent = endorsementState.ContentsSumInsured.IsValuableContent;
                    vm.state.ContentsSumInsured.IsPortableValueCover = endorsementState.ContentsSumInsured.IsPortableValueCover;
                    vm.state.ContentsSumInsured.IsSpecifiedPortableItems = endorsementState.ContentsSumInsured.IsSpecifiedPortableItems;
                    vm.state.ContentsSumInsured.IsUnspecifiedPortableItems = endorsementState.ContentsSumInsured.IsUnspecifiedPortableItems;
                    vm.state.ContentsSumInsured.UnspecifiedPortableItem = endorsementState.ContentsSumInsured.UnspecifiedPortableItem;
                    vm.state.ContentsSumInsured.ValuableContents = angular.copy(endorsementState.ContentsSumInsured.ValuableContents);
                    vm.state.ContentsSumInsured.SpecifiedPortableItems = angular.copy(endorsementState.ContentsSumInsured.SpecifiedPortableItems);
                    vm.state.OtherInfo.IsBuyBusinessExtensionOption = endorsementState.OtherInfo.IsBuyBusinessExtensionOption;
                    vm.state.OtherInfo.BusinessName = endorsementState.OtherInfo.BusinessName;
                    vm.state.OtherInfo.OccupationName = endorsementState.OtherInfo.OccupationName;
                    vm.state.OtherInfo.AnnualRevenue = endorsementState.OtherInfo.AnnualRevenue;
                    vm.state.OtherInfo.OccupationANZSIC = endorsementState.OtherInfo.OccupationANZSIC;
                    vm.state.OtherInfo.IsStampDutyExemption = endorsementState.OtherInfo.IsStampDutyExemption;
                    if (vm.endorsementVM && vm.endorsementVM.ContentExcess) {
                        vm.state.Excess.ContentExcess1 = vm.endorsementVM.ContentExcess;
                    }
                    else {
                        vm.state.Excess.ContentExcess1 = endorsementState.Excess.ContentExcess1;
                    }
                    if (vm.state.Excess.ContentExcess1 === null || vm.state.Excess.ContentExcess1 === '0') {
                        vm.state.Excess.ContentExcess1 = "500";
                    }
                }
            }
            else if (!vm.state.PolicyHolder.ContentCover && !vm.IsEndorsement) {
                vm.state.Excess.ContentExcess1 = null;
                vm.state.Excess.ContentExcess2 = null;
                vm.state.Excess.ContentExcess3 = null;
                vm.ContentSiFlag = false;
            }
            if (vm.state.PolicyHolder.BuildingCover) {
                vm.InvalidZero(field, vm.state.CordellResponse.BuildingSumInsured);
                if (!vm.IsEndorsement) {
                   
                    if (vm.homeData.DDlProcessTypeId !== 4) {
                        if (vm.state.Excess.BuildingExcess1 === null) {
                            vm.state.Excess.BuildingExcess1 = "500";
                        }

                        if (vm.state.Excess.BuildingExcess2 === null) {
                            vm.state.Excess.BuildingExcess2 = "750";
                        }
                        if (vm.state.Excess.BuildingExcess3 === null) {
                            vm.state.Excess.BuildingExcess3 = "1000";
                        }
                    }
                }
                if (vm.IsEndorsement && cover === "Building") {
                    //vm.state.CordellResponse.BuildingSumInsured = endorsementState.CordellResponse.BuildingSumInsured;
                    vm.state.CordellResponse.BuildingSumInsuredEstimate = endorsementState.CordellResponse.BuildingSumInsuredEstimate;
                    if (vm.endorsementVM && vm.endorsementVM.BuildingExcess) {
                        vm.state.Excess.BuildingExcess1 = vm.endorsementVM.BuildingExcess;
                    }
                    else {
                        vm.state.Excess.BuildingExcess1 = endorsementState.Excess.BuildingExcess1;
                    }
                    if (endorsementState.Excess.BuildingExcess1 === null) {
                        vm.state.Excess.BuildingExcess1 = "500";
                    }

                    vm.state.CordellResponse.Propertydata.quality = endorsementState.CordellResponse.Propertydata.quality;
                    vm.state.CordellResponse.Propertydata.levels = endorsementState.CordellResponse.Propertydata.levels;
                    vm.InvalidZero(field, vm.state.CordellResponse.BuildingSumInsured);
                }
            }
            else if (!vm.state.PolicyHolder.BuildingCover && !vm.IsEndorsement) {
                vm.cordellDataBackup = angular.copy(vm.state.CordellResponse.Propertydata);
                vm.state.Excess.BuildingExcess1 = null;
                vm.state.Excess.BuildingExcess2 = null;
                vm.state.Excess.BuildingExcess3 = null;
                //if (vm.homeData.DDlProcessTypeId !== 4)
                //    vm.state.CordellResponse.BuildingSumInsured = 0;
                //vm.state.CordellResponse.BuildingSumInsuredEstimate = 0;
                vm.BuildingSiFlag = false;
                field.$setValidity('validcurrency', true);
            }
            if (!vm.state.PolicyHolder.ContentCover && !vm.state.PolicyHolder.BuildingCover) {
                vm.cordellDataBackup = angular.copy(vm.state.CordellResponse.Propertydata);
            }
            vm.isDuplicateExcess();
            vm.ContentChanges(cover, field);

            if ((vm.state.PolicyHolder.ContentCover || cover === 'Content') && !vm.state.PolicyHolder.BuildingCover) {
                if (vm.state.Excess.ContentExcess1 === null && vm.state.Excess.ContentExcess2 === null && vm.state.Excess.ContentExcess3 === null)
                    vm.state.Excess.ContentExcess1 = "500";
            }
            else if ((vm.state.PolicyHolder.BuildingCover || cover === 'Building') && !vm.state.PolicyHolder.ContentCover) {
                if (vm.state.Excess.BuildingExcess1 === null && vm.state.Excess.BuildingExcess2 === null && vm.state.Excess.BuildingExcess3 === null)
                    vm.state.Excess.BuildingExcess1 = "500";
            }
        };

        function ContentChanges(cover, field) {
            vm.disableCoverOnOccupancy(cover, field);
            if (vm.state.PolicyHolder.HomeOccupancyType === "Renting") {
                vm.state.CordellResponse.BuildingSumInsured = null;
            }
            if (vm.homeData.LOB && !vm.IsEndorsement) {
                var startDate = vm.homeData.StartDate;
                var productName = vm.homeData.LOB;
                var brokerCommissionRequestOnEdit = quotesService.getBrokerCommissiononEdit({
                    EffectiveDate: startDate,
                    ProductName: productName,
                    Productid: null
                })
                    .then(function (result) {
                        vm.data = result.data.brokerBranchCommissionFeeVM;
                    });
            }

            if (vm.data && !vm.IsEndorsement) {
                for (var i = 0; i < vm.data.length; i++) {
                    if ((vm.state.PolicyHolder.BuildingCover && !vm.state.PolicyHolder.ContentCover && vm.data[i].coverCode === "BUILDING") || (!vm.state.PolicyHolder.BuildingCover && vm.state.PolicyHolder.ContentCover && vm.data[i].coverCode === "CONTENT") || (vm.state.PolicyHolder.BuildingCover && vm.state.PolicyHolder.ContentCover && vm.data[i].coverCode === "BUILDING,CONTENT")) {
                        vm.state.BrokerCommission.BrokerCommissionPercentage = vm.data[i].brokerCommissionFee;
                        vm.maxbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMax;
                        vm.minbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMin;
                        vm.checkBrkerCommissionLimit();
                    }
                }
            }

            if (!vm.state.PolicyHolder.ContentCover && !vm.IsEndorsement) {
                vm.state.ContentsSumInsured.GeneralContentSumInsured = null;
                vm.state.ContentsSumInsured.UnspecifiedPortableItem = null;
                vm.state.ContentsSumInsured.ValuableContents = [{ Category: null, Description: null, Value: null, AwayFromHome: false }];
                vm.state.ContentsSumInsured.SpecifiedPortableItems = [{ PortableCategory: null, PortableDescription: null, PortableValue: null }];
                vm.state.ContentsSumInsured.IsValuableContent = false;
                vm.state.ContentsSumInsured.IsPortableValueCover = false;
                vm.state.ContentsSumInsured.IsSpecifiedPortableItems = false;
                vm.state.ContentsSumInsured.IsUnspecifiedPortableItems = false;
                vm.state.SecurityDetails.WindowSecurities = null;
                vm.state.SecurityDetails.IsAlarmSecurity = null;
                vm.state.SecurityDetails.AlarmType = null;
                vm.state.SecurityDetails.DoorSecurities = [];
                vm.isNullContentInsured = false;
                vm.state.OtherInfo.IsBuyBusinessExtensionOption = false;
                vm.state.OtherInfo.BusinessName = null;
                vm.state.OtherInfo.OccupationName = null;
                vm.state.OtherInfo.AnnualRevenue = null;
                vm.state.OtherInfo.OccupationANZSIC = null;
                vm.state.OtherInfo.IsStampDutyExemption = null;
            }
            else {
                if (vm.state.ContentsSumInsured.ContentsSumInsured == 0 || vm.state.ContentsSumInsured.ContentsSumInsured == 0.00) {
                    vm.isNullContentInsured = true;
                }
            }

        }

        function findAddress(field) {
            var addressLogVM = {
                Address: vm.state.PropertyDetail.AddressText,
                DelimeterAddress: vm.state.PropertyDetail.AddressValue,
                IsManualAddress: vm.state.PropertyDetail.IsManualAddress
            }
            if ($scope.IsChangeAddress) {
                //$scope.tempBuildingSumInsured = 0;
                vm.state.CordellResponse.BuildingSumInsured = 0;
            }
            //// if there is already an entered address before going for manual address then restore data back on valid address
            if (vm.previousAddress && vm.previousSelectedAddress) {
                vm.RestoreCordellData();
                vm.state.PropertyDetail.AddressText = vm.previousSelectedAddress;
                vm.selectedAddress = null;
                if (vm.state.PropertyDetail.IsManualAddress) {
                    vm.selectedAddress = null;
                }
                if (vm.previousAddress[0].text) {
                    vm.selectedAddress = vm.previousAddress[0];
                }
            }
            else if (vm.state.PropertyDetail.AddressText !== null) {
                quotesService.intechCrordellApi(addressLogVM).then(function (response) {
                    if (response.data !== null) {
                        if (response.data.cordellResponse === null && response.data.errorCode === 0) {
                            toastr.warning(messageConstService.errCordellWarning);
                            //if (!vm.IsManualBuildingSumInsured && !vm.IsEndorsement && vm.homeData.DDlProcessTypeId !== 4) {
                            //    vm.state.CordellResponse.BuildingSumInsured = 0;
                            //}
                            vm.state.CordellResponse.BuildingSumInsuredEstimate = 0;
                        }
                        else if (response.data.errorCode === 400) {
                            toastr.warning(messageConstService.errCordellPropertyType);
                            //vm.state.CordellResponse.BuildingSumInsured = 0;
                            vm.state.CordellResponse.BuildingSumInsuredEstimate = 0;
                        }
                        else if (response.data.errorCode === 405) {
                            toastr.info(messageConstService.errCompleteAddress);
                        }
                        else if (response.data.errorCode === 0 && response.data.cordellResponse !== null) {
                            if (vm.state.PolicyHolder.BuildingCover) {
                                vm.BuildingSumInsuredValue = response.data.cordellResponse.buildingSumInsured;
                                if ($scope.IsChangeAddress) {
                                    vm.state.CordellResponse.BuildingSumInsured = 0;
                                }
                                vm.state.CordellResponse.BuildingSumInsuredEstimate = response.data.cordellResponse.buildingSumInsuredEstimate;
                                //vm.InvalidZero(field, vm.state.CordellResponse.BuildingSumInsured);
                                vm.InvalidZero(field, vm.state.CordellResponse.BuildingSumInsuredEstimate);
                            }
                            if (response.data.cordellResponse.propertydata !== null) {
                                vm.state.CordellResponse.Propertydata = response.data.cordellResponse.propertydata;
                                vm.cordellBackupForFloorReset = angular.copy(vm.state.CordellResponse.Propertydata);
                                SetCordelFields();
                            }
                        }
                        //// if bedroom and bathroom are 0 make them blank
                        MakeBedRoomBathRoomBlank();
                    }

                }, function (error) {
                    $log.log("Cordell Error:", error);
                    toastr.error(messageConstService.errSumInsuredCalculation);
                    vm.isCordellResponseNotValid = true;

                });
            }
        }

        function sumInsuredEstimate(field) {

            var roomBathObject = vm.state.CordellResponse.Propertydata.roomBathSizeList;
            if (roomBathObject) {
                vm.state.CordellResponse.Propertydata.roomBath1Size = Object.keys(roomBathObject).length > 0 ? roomBathObject[Object.keys(roomBathObject)[0]] : null;
                vm.state.CordellResponse.Propertydata.roomBath2Size = Object.keys(roomBathObject).length > 1 ? roomBathObject[Object.keys(roomBathObject)[1]] : null;
                vm.state.CordellResponse.Propertydata.roomBath3Size = Object.keys(roomBathObject).length > 2 ? roomBathObject[Object.keys(roomBathObject)[2]] : null;
                vm.state.CordellResponse.Propertydata.roomBath4Size = Object.keys(roomBathObject).length > 3 ? roomBathObject[Object.keys(roomBathObject)[3]] : null;
                vm.state.CordellResponse.Propertydata.roomBath5Size = Object.keys(roomBathObject).length > 4 ? roomBathObject[Object.keys(roomBathObject)[4]] : null;
                vm.state.CordellResponse.Propertydata.roomBath6Size = Object.keys(roomBathObject).length > 5 ? roomBathObject[Object.keys(roomBathObject)[5]] : null;
            }

            var roomBedObject = vm.state.CordellResponse.Propertydata.roomBedSizeList;
            if (roomBedObject) {
                vm.state.CordellResponse.Propertydata.roomBed1Size = Object.keys(roomBedObject).length > 0 ? roomBedObject[Object.keys(roomBedObject)[0]] : null;
                vm.state.CordellResponse.Propertydata.roomBed2Size = Object.keys(roomBedObject).length > 1 ? roomBedObject[Object.keys(roomBedObject)[1]] : null;
                vm.state.CordellResponse.Propertydata.roomBed3Size = Object.keys(roomBedObject).length > 2 ? roomBedObject[Object.keys(roomBedObject)[2]] : null;
                vm.state.CordellResponse.Propertydata.roomBed4Size = Object.keys(roomBedObject).length > 3 ? roomBedObject[Object.keys(roomBedObject)[3]] : null;
                vm.state.CordellResponse.Propertydata.roomBed5Size = Object.keys(roomBedObject).length > 4 ? roomBedObject[Object.keys(roomBedObject)[4]] : null;
                vm.state.CordellResponse.Propertydata.roomBed6Size = Object.keys(roomBedObject).length > 5 ? roomBedObject[Object.keys(roomBedObject)[5]] : null;
                vm.state.CordellResponse.Propertydata.roomBed7Size = Object.keys(roomBedObject).length > 6 ? roomBedObject[Object.keys(roomBedObject)[6]] : null;
                vm.state.CordellResponse.Propertydata.roomBed8Size = Object.keys(roomBedObject).length > 7 ? roomBedObject[Object.keys(roomBedObject)[7]] : null;
                vm.state.CordellResponse.Propertydata.roomBed9Size = Object.keys(roomBedObject).length > 8 ? roomBedObject[Object.keys(roomBedObject)[8]] : null;
            }

            var roomLaundryObject = vm.state.CordellResponse.Propertydata.roomLaundrySizeList;
            if (roomLaundryObject) {
                vm.state.CordellResponse.Propertydata.roomLaundry1Size = Object.keys(roomLaundryObject).length > 0 ? roomLaundryObject[Object.keys(roomLaundryObject)[0]] : null;
                vm.state.CordellResponse.Propertydata.roomLaundry2Size = Object.keys(roomLaundryObject).length > 1 ? roomLaundryObject[Object.keys(roomLaundryObject)[1]] : null;
            }

            var roomOtherObject = vm.state.CordellResponse.Propertydata.roomOtherList;
            if (roomOtherObject) {
                vm.state.CordellResponse.Propertydata.roomOther1Size = Object.keys(roomOtherObject).length > 0 ? roomOtherObject[Object.keys(roomOtherObject)[0]] : null;
                vm.state.CordellResponse.Propertydata.roomOther2Size = Object.keys(roomOtherObject).length > 1 ? roomOtherObject[Object.keys(roomOtherObject)[1]] : null;
            }

            var cabinSizeObject = vm.state.CordellResponse.Propertydata.cabinSizeList;
            if (cabinSizeObject) {
                vm.state.CordellResponse.Propertydata.cabin1Size = Object.keys(cabinSizeObject).length > 0 ? cabinSizeObject[Object.keys(cabinSizeObject)[0]] : null;
                vm.state.CordellResponse.Propertydata.cabin2Size = Object.keys(cabinSizeObject).length > 1 ? cabinSizeObject[Object.keys(cabinSizeObject)[1]] : null;
                vm.state.CordellResponse.Propertydata.cabin3Size = Object.keys(cabinSizeObject).length > 2 ? cabinSizeObject[Object.keys(cabinSizeObject)[2]] : null;
            }

            var kitchenSizeObject = vm.state.CordellResponse.Propertydata.kitchenSizeList;
            if (kitchenSizeObject) {
                vm.state.CordellResponse.Propertydata.roomKitchen1Size = Object.keys(kitchenSizeObject).length > 0 ? kitchenSizeObject[Object.keys(kitchenSizeObject)[0]] : null;
                vm.state.CordellResponse.Propertydata.roomKitchen2Size = Object.keys(kitchenSizeObject).length > 1 ? kitchenSizeObject[Object.keys(kitchenSizeObject)[1]] : null;
            }

            quotesService.sumInsuredEstimateApi(vm.state.CordellResponse.Propertydata).then(function (response) {
                if (response === null || response.data === 0 || response.data === null) {
                    $('#calculate-sum-insured').modal('hide');
                    $log.log("Cordell Error:Building Sum Insured Not Calculated!");
                    toastr.warning(messageConstService.errCordellWarning);
                    //if (!vm.IsManualBuildingSumInsured && !vm.IsEndorsement && vm.homeData.DDlProcessTypeId !== 4) {
                    //    vm.state.CordellResponse.BuildingSumInsured = 0;
                    //}
                    vm.state.CordellResponse.BuildingSumInsuredEstimate = 0;
                    return;
                }
                if (response.data !== 0 || response.data !== null) {
                    $('#calculate-sum-insured').modal('hide');
                    //if (vm.IsEndorsement) {
                    //    vm.state.CordellResponse.BuildingSumInsured = vm.BuildingSumInsuredValue;
                    //}
                    //else
                    if (vm.homeData.DDlProcessTypeId !== 4) {
                        //vm.BuildingSumInsuredValue = response.data;
                        vm.IsManualBuildingSumInsured = false;
                    }

                    field.$setValidity('invalid', true);
                }
               //// if else removed for sonar qube report bug
                vm.state.CordellResponse.BuildingSumInsuredEstimate = response.data;
                vm.InvalidZero(field, vm.state.CordellResponse.BuildingSumInsured);
            }, function (error) {
                $log.log("Cordell Error:", error);
                toastr.error(messageConstService.errService3rdAPIUnavailable);

            });
        }

        vm.IsAdditionalButtonDisabled = function (name, index, nameObj) {
            if (name && !vm.otherreadonly) {
                vm.isSecondaryDisabled = false;
                if (name !== "Other") {
                    nameObj.OtherDateOfBirth = null;
                    nameObj.OtherDateOfBirthApp = null;
                    nameObj.OtherPolicyHolderName = null;
                }
            }

            var duplicateCount = 0;
            //check if the name already exists twice if yes then remove
            vm.state.PolicyHolder.AdditionalPolicyHolderList.forEach(function (ele, index) {
                if (ele.AdditionalPolicyHolder !== "Other" && ele.AdditionalPolicyHolder === name) {
                    duplicateCount++;
                }
            });

            if (duplicateCount > 1) {
                toastr.error(messageConstService.errDuplicatePolicyHolder);
                nameObj.AdditionalPolicyHolder = "";
                return;
            }

            if (vm.otherreadonly && name === "Other" && index === vm.state.PolicyHolder.AdditionalPolicyHolderList.length - 1) {
                if (vm.state.PolicyHolder.AdditionalPolicyHolderList[index].OtherPolicyHolderName === null) {
                    toastr.error("Other is not allowed");
                    nameObj.AdditionalPolicyHolder = "";
                    return;
                }
            }


            for (var i = 0; i < vm.state.PolicyHolder.InsuredNameList.length; i++) {
                if (vm.state.PolicyHolder.InsuredNameList[i].value === name) {

                    for (var j = 0; j < vm.state.PolicyHolder.AdditionalPolicyHolderList.length; j++) {
                        if (vm.state.PolicyHolder.AdditionalPolicyHolderList[j].AdditionalPolicyHolder === name) {
                            vm.state.PolicyHolder.AdditionalPolicyHolderList[j].AdditionalDateOfBirth = vm.state.PolicyHolder.InsuredNameList[i].dateOfBirth;
                            vm.state.PolicyHolder.AdditionalPolicyHolderList[j].AdditionalPolicyHolderType = vm.state.PolicyHolder.InsuredNameList[i].clientType;
                        }
                    }
                }
            }

            //checkAdditionalInsuredInList();

            if (name === 'OtherInsured') {
                vm.AdditionalPolicyHolderIndex = index;
                angular.element('#add-insured').modal('show');
            }
            else if (name != "OtherInsured") {
                vm.tempAdditonalPolicyHolders = angular.copy(vm.state.PolicyHolder.AdditionalPolicyHolderList);
            }
        };

        vm.IsAdditionalClaimDisabled = function (item, index) {

            if (item !== null) {
                vm.DisableAddClaim = false;
            }

            if (vm.state.Claims.ClaimsList.length <= 1) {
                if (!item) {
                    vm.checkNullClaimList = true;
                    vm.state.Claims.ClaimsList = [{ ClaimYear: null, ClaimType: null, CostOfClaim: 0 }];
                }
            }

            if (item === 'TheftWithoutBreakIn' || item === 'Bushfire' || item === 'Storm') {
                vm.state.Claims.ClaimsList[index].CostOfClaim = 0;
            }
            vm.checkClaims();
        };

        vm.IsSpecifiedItemDisabled = function (item) {
            if (item !== null) {
                vm.DisableSpecifiedItem = false;
            }
        };

        vm.ResetAdditionalPolicyHolder = function () {
            if (!vm.state.PolicyHolder.IsAdditionalPolicyHolder) {
                vm.state.PolicyHolder.AdditionalPolicyHolderList = [{ AdditionalPolicyHolder: null, OtherPolicyHolderName: null, OtherDateOfBirth: null }];
                vm.validDOBOtherInsurer = true;
            }
            else if (vm.IsEndorsement && vm.state.PolicyHolder.IsAdditionalPolicyHolder && endorsementState != null) {
                vm.state.PolicyHolder.AdditionalPolicyHolderList = angular.copy(endorsementState.PolicyHolder.AdditionalPolicyHolderList);
            }
        }

        function resetSumInsuredValue() {
            if (vm.state.PolicyHolder.BuildingCover) {
                if (vm.IsEndorsement) {
                    vm.state.CordellResponse.BuildingSumInsuredEstimate = 0;
                }
                else {
                    if (vm.cordellBackupForFloorReset) {
                        ////During Page Load Condition at new business
                        if (vm.version >= keyConstService.Version) {
                            //// adding roombed and roombath for version > 2
                            if ((vm.state.CordellResponse.Propertydata.externalWallMaterial !== vm.cordellBackupForFloorReset.externalWallMaterial) || (vm.state.CordellResponse.Propertydata.roof !== vm.cordellBackupForFloorReset.roof) || (vm.state.CordellResponse.Propertydata.quality !== vm.cordellBackupForFloorReset.quality) || (vm.state.CordellResponse.Propertydata.levels !== vm.cordellBackupForFloorReset.levels) || (vm.state.CordellResponse.Propertydata.yearBuilt !== vm.cordellBackupForFloorReset.yearBuilt) || (vm.state.CordellResponse.Propertydata.periodName !== vm.cordellBackupForFloorReset.periodName) || (vm.state.CordellResponse.Propertydata.roomBath !== vm.cordellBackupForFloorReset.roomBath) || (vm.state.CordellResponse.Propertydata.roomBed !== vm.cordellBackupForFloorReset.roomBed)) {
                                if (vm.homeData.DDlProcessTypeId !== 4)
                                    vm.state.CordellResponse.BuildingSumInsured = 0;
                                vm.state.CordellResponse.BuildingSumInsuredEstimate = 0;
                                if (vm.homeData.DDlProcessTypeId !== 4)
                                    vm.BuildingSiFlag = true;
                                else
                                    vm.BuildingSiFlag = false;
                            }
                        }
                        else {
                            if ((vm.state.CordellResponse.Propertydata.externalWallMaterial != vm.cordellBackupForFloorReset.externalWallMaterial) || (vm.state.CordellResponse.Propertydata.roof != vm.cordellBackupForFloorReset.roof) || (vm.state.CordellResponse.Propertydata.quality != vm.cordellBackupForFloorReset.quality) || (vm.state.CordellResponse.Propertydata.levels != vm.cordellBackupForFloorReset.levels) || (vm.state.CordellResponse.Propertydata.yearBuilt != vm.cordellBackupForFloorReset.yearBuilt) || (vm.state.CordellResponse.Propertydata.periodName != vm.cordellBackupForFloorReset.periodName)) {
                                if (vm.homeData.DDlProcessTypeId !== 4)
                                    vm.state.CordellResponse.BuildingSumInsured = 0;
                                vm.state.CordellResponse.BuildingSumInsuredEstimate = 0;
                                if (vm.homeData.DDlProcessTypeId !== 4)
                                    vm.BuildingSiFlag = true;
                                else
                                    vm.BuildingSiFlag = false;
                            }
                        }
                    }
                    else if($scope.isDefaultCheckClick === false){
                        if (vm.homeData.DDlProcessTypeId !== 4)
                            vm.state.CordellResponse.BuildingSumInsured = 0;
                        vm.state.CordellResponse.BuildingSumInsuredEstimate = 0;
                        if (vm.homeData.DDlProcessTypeId !== 4)
                            vm.BuildingSiFlag = true;
                        else
                            vm.BuildingSiFlag = false;
                    }
                }
            }
            $scope.isDefaultCheckClick = false;
        }

        vm.ResetBusinessSection = function () {
            if (!vm.state.OtherInfo.IsBusinessConductedHome) {
                vm.state.OtherInfo.IsBuyBusinessExtensionOption = false;
                vm.state.OtherInfo.BusinessName = null;
                vm.state.OtherInfo.OccupationName = null;
                vm.state.OtherInfo.AnnualRevenue = 0;
                vm.state.OtherInfo.OccupationANZSIC = null;
                vm.state.OtherInfo.IsStampDutyExemption = null;
            }
            else if (vm.IsEndorsement && vm.state.OtherInfo.IsBusinessConductedHome) {
                vm.state.OtherInfo.IsBuyBusinessExtensionOption = endorsementState.OtherInfo.IsBuyBusinessExtensionOption;
                vm.state.OtherInfo.BusinessName = endorsementState.OtherInfo.BusinessName;
                vm.state.OtherInfo.OccupationName = endorsementState.OtherInfo.OccupationName;
                vm.state.OtherInfo.AnnualRevenue = endorsementState.OtherInfo.AnnualRevenue;
                vm.state.OtherInfo.OccupationANZSIC = endorsementState.OtherInfo.OccupationANZSIC;
                vm.state.OtherInfo.IsStampDutyExemption = endorsementState.OtherInfo.IsStampDutyExemption;
            }
        };

        vm.ResetBusinessExtensionSection = function () {
            if (!vm.state.OtherInfo.IsBuyBusinessExtensionOption) {
                vm.state.OtherInfo.BusinessName = null;
                vm.state.OtherInfo.OccupationName = null;
                vm.state.OtherInfo.AnnualRevenue = null;
                vm.state.OtherInfo.OccupationANZSIC = null;
                vm.state.OtherInfo.IsStampDutyExemption = null;
            }
            else if (vm.IsEndorsement && vm.state.OtherInfo.IsBuyBusinessExtensionOption) {
                vm.state.OtherInfo.BusinessName = endorsementState.OtherInfo.BusinessName;
                vm.state.OtherInfo.OccupationName = endorsementState.OtherInfo.OccupationName;
                vm.state.OtherInfo.AnnualRevenue = endorsementState.OtherInfo.AnnualRevenue;
                vm.state.OtherInfo.OccupationANZSIC = endorsementState.OtherInfo.OccupationANZSIC;
                vm.state.OtherInfo.IsStampDutyExemption = endorsementState.OtherInfo.IsStampDutyExemption;
            }
        };

        vm.ResetPreviousInsurer = function () {
            if (vm.state.OtherInfo.PreviousInsurer !== "Other") {
                vm.state.OtherInfo.OtherPreviousInsurer = null;
            }
        };

        vm.ResetDeclineSection = function () {
            if (!vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsEverInsuranceDeclined) {
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.ReasonEverInsuranceDeclined = null;
            }
            if (!vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsClaimDeclinedIn3Years) {
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.ReasonClaimDeclinedIn3Years = null;
            }
        };

        vm.ResetUnOccupiedProperty = function () {
            if (!vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsUnoccupiedProperty100days) {
                if (vm.version >= keyConstService.Version) {
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsPropertyBeingChecked = null;
                }
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.UnoccupiedProperty100days = null;
            }
            else if (vm.IsEndorsement && vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsUnoccupiedProperty100days) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.UnoccupiedProperty100days = endorsementState.UnderwritingCriteria.AnswerYesToFollowingData.UnoccupiedProperty100days;
            }
        };

        vm.ResetHomeConstructionSection = function () {
            if (!vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsHomeUnderConstructionRenovation) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.IsCostofRenovation = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.IsOpeningExternalRoofWalls = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.IsBuildingSecured = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.IsBuildingRainWaterProtected = null;
                if (vm.version >= keyConstService.Version) {
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.IsContractWorksPolicy = null;
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.ValueOfRenovation = null;
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate = null;
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate = null;
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.WorkUndertaken = null;
                }
            }
            else if (vm.IsEndorsement && vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsHomeUnderConstructionRenovation) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData = angular.copy(endorsementState.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData);
            }
        };
        function disablecover(field) {
            if (vm.state.PropertyDetail.BuildingType !== null) {
                //// making building si 0 when building type or dependent questions are clicked
                if ($scope.isDefaultCheckClick === false && vm.state.PolicyHolder.BuildingCover === true) {
                    if (vm.homeData.DDlProcessTypeId !== 4)
                        vm.state.CordellResponse.BuildingSumInsured = 0;
                    vm.state.CordellResponse.BuildingSumInsuredEstimate = 0;
                    if (vm.homeData.DDlProcessTypeId !== 4)
                        vm.BuildingSiFlag = true;
                    else
                        vm.BuildingSiFlag = false;
                }

                if (vm.state.PropertyDetail.BuildingType === keyConstService.Apartments || vm.state.PropertyDetail.BuildingType === keyConstService.OtherDwellingType) {
                    vm.state.PolicyHolder.BuildingCover = false;
                    vm.state.PolicyHolder.ContentCover = true;
                    vm.disableBuilding = true;
                    vm.disableContent = true;
                    vm.BuildingSiFlag = false;
                    vm.ResetBuildingSumInsureforV2(field);
                    DefaultContentExcessOnCoverChange();
                    //vm.state.CordellResponse.Propertydata.externalWallMaterial = null;
                    //vm.state.CordellResponse.Propertydata.roof = null;
                }
                else if (vm.state.PropertyDetail.BuildingType === keyConstService.SemiDetachedHome && vm.state.PropertyDetail.IsStrataManagement) {
                    vm.state.PolicyHolder.BuildingCover = false;
                    vm.state.PolicyHolder.ContentCover = true;
                    vm.disableBuilding = true;
                    vm.disableContent = true;
                    vm.BuildingSiFlag = false;
                    vm.ResetBuildingSumInsureforV2(field);
                    DefaultContentExcessOnCoverChange();
                }
                else if (vm.state.PolicyHolder.HomeOccupancyType !== 'Renting') {
                    vm.disableBuilding = false;
                    vm.disableContent = false;
                }
            }
        }

        function ResetBuildingSumInsureforV2(field) {
            field.$setValidity('validcurrency', true);
        }
        function OnOccupancyChange(field1,field2) {
            if (vm.state.PolicyHolder.HomeOccupancyType === 'Renting') {
                vm.ContentChanges(field1, field2);
            }
            else {
                vm.state.PolicyHolder.BuildingCover = true;
                vm.state.PolicyHolder.ContentCover = true;
                vm.state.PropertyDetail.BuildingType = null;
                vm.ResetBuildingTypeSection();
                vm.disableCoverOnOccupancy();
            }
        }

        function BindBuildingType(value) {
            vm.state.PropertyDetail.BuildingType = value;
        }

        function BindBuiltOnType(value) {
            vm.state.PropertyDetail.BuiltOn = value;
        }
        function BindApartmentType(value) {
            vm.state.PropertyDetail.ApartmentType = value;
        }

        function BindSemiDetached(value) {
            vm.state.PropertyDetail.SemiDetachedHomeType = value;
        }

        function BindOtherDwellingType(value) {
            vm.state.PropertyDetail.OtherDwellingTypeHome = value;
        }
        vm.ResetHeritageSection = function () {
            if (!vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsPropertyHeriatgeListed) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.PropertyHeritgeListingDetail = null;
            }
            else if (vm.IsEndorsement && vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsPropertyHeriatgeListed) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.PropertyHeritgeListingDetail = endorsementState.UnderwritingCriteria.AnswerYesToFollowingData.PropertyHeritgeListingDetail;
            }
        };

        vm.ResetHasInsuredInLast3YearsSection = function () {
            if (!vm.state.UnderwritingCriteria.HasInsuredInLast3Years) {
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsEverInsuranceDeclined = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.ReasonEverInsuranceDeclined = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsCriminalConvictionFraudTheftBurglaryArson = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsClaimDeclinedIn3Years = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.ReasonClaimDeclinedIn3Years = null;
                //Added for version 2.0
                if (vm.version >= keyConstService.Version) {
                    vm.state.UnderwritingCriteria.InsuredInLast3YearsData.AnyInsurancePolicyCancelledOrDeclinedInPreviousYears = null;
                    vm.state.UnderwritingCriteria.InsuredInLast3YearsData.NoOfCancellationOrDeclinationOccurredInPreviousYearsForInsured = null;
                    vm.state.UnderwritingCriteria.InsuredInLast3YearsData.CancellationReason = null;
                }
            }
            else {
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsEverInsuranceDeclined = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsCriminalConvictionFraudTheftBurglaryArson = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsClaimDeclinedIn3Years = null;
                if (vm.version >= keyConstService.Version) {
                    vm.state.UnderwritingCriteria.InsuredInLast3YearsData.AnyInsurancePolicyCancelledOrDeclinedInPreviousYears = null;
                    vm.state.UnderwritingCriteria.InsuredInLast3YearsData.NoOfCancellationOrDeclinationOccurredInPreviousYearsForInsured = null;
                    vm.state.UnderwritingCriteria.InsuredInLast3YearsData.CancellationReason = null;
                }
            }
        };

        //new questions for vrsion 2.0
        function ResetInsurancePolicyCancelledSection() {
            vm.state.UnderwritingCriteria.InsuredInLast3YearsData.NoOfCancellationOrDeclinationOccurredInPreviousYearsForInsured = null;
            vm.state.UnderwritingCriteria.InsuredInLast3YearsData.CancellationReason = null;
        }
        //new questions for version 2.0
        function costOfRenovationReset() {
            vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.ValueOfRenovation = null;
            vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate = null;
            vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate = null;
            vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.WorkUndertaken = null;

        }

        //for version2.0 renovation date change
        function OnRenovationDateChange(dateToValidate, isFrom) {

            var mFromDate = moment(vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate, 'DD/MM/YYYY').toDate();
            var mToDate = moment(vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate, 'DD/MM/YYYY').toDate();
            if ((mFromDate >= mToDate) && dateToValidate) {
                toastr.warning("Please enter a valid range.");
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate = null;
                return;
            }
            
            if (!dateToValidate && typeof (isFrom) !== 'undefined') {
                return;
            }
        }

        vm.ResetAnswerYesToDataSection = function () {
            if (!vm.state.UnderwritingCriteria.IsAnswerYesToFollowing) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsUnoccupiedProperty100days = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.UnoccupiedProperty100days = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsHomeUnderConstructionRenovation = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsPoorlyMaintainedProperty = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsPropertyHeriatgeListed = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.PropertyHeritgeListingDetail = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.IsCostofRenovation = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.IsOpeningExternalRoofWalls = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.IsBuildingSecured = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.IsBuildingRainWaterProtected = null;
                if (vm.version >= keyConstService.Version) {
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsPropertyBeingChecked = null;
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.IsContractWorksPolicy = null;
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.ValueOfRenovation = null;
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate = null;
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate = null;
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.WorkUndertaken = null;
                }
            }
            else if (vm.IsEndorsement && vm.state.UnderwritingCriteria.IsAnswerYesToFollowing) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData = angular.copy(endorsementState.UnderwritingCriteria.AnswerYesToFollowingData);
            }
        };

        vm.ResetValuableContent = function () {
            if (!vm.state.ContentsSumInsured.IsValuableContent) {
                vm.state.ContentsSumInsured.ValuableContents = [{ Category: null, Description: null, Value: null, AwayFromHome: false }];
            }
            else if (vm.IsEndorsement && vm.state.ContentsSumInsured.IsValuableContent) {
                vm.state.ContentsSumInsured.ValuableContents = angular.copy(endorsementState.ContentsSumInsured.ValuableContents);
            }
        }

        //Reset questionfor version 2.0
        function resetPolicyHolderCurrentlyHoldInsuranceSection() {
            vm.state.OtherInfo.PeriodOfInsuranceHoldByPolicyholder = null;
        }

        //Reset question for version 2.0 
        function ResetBuildingTypeSection(value, bindvalue) {
            if (value !== bindvalue) {
                vm.state.PropertyDetail.BuiltOn = null;
                vm.state.PropertyDetail.ApartmentType = null;
                vm.state.PropertyDetail.SemiDetachedHomeType = null;
                vm.state.PropertyDetail.IsStrataManagement = null;
                vm.state.PropertyDetail.OtherDwellingTypeHome = null;
            }
        }

        vm.ResetPortableItems = function (fieldSpecified, fieldUnspecified) {
            if (!vm.state.ContentsSumInsured.IsPortableValueCover) {
                vm.state.ContentsSumInsured.IsSpecifiedPortableItems = null;
                vm.state.ContentsSumInsured.IsUnspecifiedPortableItems = null;
                resetUnspecifiedItemsCover(fieldSpecified, fieldUnspecified);
                resetSpecifiedPortableItems(fieldSpecified, fieldUnspecified);
                vm.isUnspecifiedPortableItems = true;
            }
            else if (vm.IsEndorsement && vm.state.ContentsSumInsured.IsPortableValueCover) {
                vm.state.ContentsSumInsured.IsSpecifiedPortableItems = endorsementState.ContentsSumInsured.IsSpecifiedPortableItems;
                vm.state.ContentsSumInsured.IsUnspecifiedPortableItems = endorsementState.ContentsSumInsured.IsUnspecifiedPortableItems;
                vm.state.ContentsSumInsured.UnspecifiedPortableItem = endorsementState.ContentsSumInsured.UnspecifiedPortableItem;
                vm.state.ContentsSumInsured.SpecifiedPortableItems = angular.copy(endorsementState.ContentsSumInsured.SpecifiedPortableItems);
            }
        }

        vm.InvalidZero = function (field, value) {
            var inp = $filter('number')(value);
            if (field) {
                if (value) {
                    if (inp !== '0' && inp !== '') {

                        field.$setValidity('validcurrency', true)
                        BuildingSumInsuredRange(field);
                        if (field.$name === 'ContentSumInsured') {
                            vm.ContentSiFlag = false;
                        }
                        if (field.$name === 'BuildingsSumInsured') {
                            vm.BuildingSiFlag = false;
                        }
                    }
                    else {
                        field.$setValidity('validcurrency', false);
                    }
                }
                else {
                    field.$setValidity('validcurrency', false);
                }
            }
            else if (!field && (value === null || value === undefined || value === 0)) {
                vm.BuildingSiFlag = true;
            }
        }

        vm.RemoveInvalidZero = function (field, value) {
            var inp = $filter('number')(value);
            if (value) {
                if (inp === '0') {
                    field.value = '';
                }
            }
        }

        function declineOnRewireCondition() {
            if (vm.state.CordellResponse.Propertydata.propertyRewired === false && !vm.IsEndorsement) {
                toastr.error(messageConstService.errDeclineOnPropertryRewire);
            }
        }

        function resetUnspecifiedItemsCover(fieldSpecified, fieldUnspecified) {
            if (!vm.state.ContentsSumInsured.IsUnspecifiedPortableItems) {
                vm.state.ContentsSumInsured.UnspecifiedPortableItem = null;
            }
            if (!vm.state.ContentsSumInsured.IsUnspecifiedPortableItems && !vm.state.ContentsSumInsured.IsSpecifiedPortableItems) {
                fieldUnspecified.$setValidity("fieldUnSpecified", false);
                sessionStorageService.set(keyConstService.IsUnspecifiedPortableItems, false);
                vm.isUnspecifiedPortableItems = false;

            }
            else {
                fieldUnspecified.$setValidity("fieldUnSpecified", true);
                fieldSpecified.$setValidity("fieldSpecified", true);
                sessionStorageService.set(keyConstService.IsUnspecifiedPortableItems, true)
                vm.isUnspecifiedPortableItems = true;
            }
            if (vm.IsEndorsement && vm.state.ContentsSumInsured.IsUnspecifiedPortableItems) {
                vm.state.ContentsSumInsured.UnspecifiedPortableItem = endorsementState.ContentsSumInsured.UnspecifiedPortableItem;
            }
        }

        function resetSpecifiedPortableItems(fieldSpecified, fieldUnspecified) {
            if (!vm.state.ContentsSumInsured.IsSpecifiedPortableItems) {
                vm.state.ContentsSumInsured.SpecifiedPortableItems = [{ PortableCategory: null, PortableDescription: null, PortableValue: null }]
            }

            if (!vm.state.ContentsSumInsured.IsUnspecifiedPortableItems && !vm.state.ContentsSumInsured.IsSpecifiedPortableItems) {
                fieldSpecified.$setValidity("fieldSpecified", false);
                vm.isUnspecifiedPortableItems = false;
            }
            else {
                fieldUnspecified.$setValidity("fieldUnSpecified", true);
                fieldSpecified.$setValidity("fieldSpecified", true);
                vm.isUnspecifiedPortableItems = true;
            }
            if (vm.IsEndorsement && vm.state.ContentsSumInsured.IsSpecifiedPortableItems) {
                vm.state.ContentsSumInsured.SpecifiedPortableItems = angular.copy(endorsementState.ContentsSumInsured.SpecifiedPortableItems);
            }
        }

        function resetPropertySection() {
            if (!vm.state.PropertyDetail.AddressText || vm.state.PropertyDetail.IsManualAddress === true) {

                vm.cordellDataBackup = angular.copy(vm.state.CordellResponse.Propertydata);
                vm.ResetCordellData();
                vm.state.CordellResponse.Propertydata.periodName = null;
                vm.state.CordellResponse.Propertydata.yearBuilt = null;
                vm.state.CordellResponse.Propertydata.externalWallMaterial = null;
                vm.state.CordellResponse.Propertydata.roof = null;
                vm.state.CordellResponse.Propertydata.quality = null;
                vm.state.CordellResponse.Propertydata.levels = null
                vm.state.CordellResponse.BuildingSumInsuredEstimate = 0;

                //if (!vm.IsEndorsement && vm.homeData.DDlProcessTypeId !== 4) {
                //    vm.state.CordellResponse.BuildingSumInsured = 0;
                //}
            }
        }

        vm.saveQuote = function () {
            vm.disableButtons = true;
            if (vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate = dateService.getDateDDMMtoMMDD(vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate);
            }

            if (vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate = dateService.getDateDDMMtoMMDD(vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate);
            }

            //// as the property type is int, if the users saves the quote when no data from cordell is returned
            if (vm.version >= keyConstService.Version) {
                if (vm.state.CordellResponse.Propertydata.roomBed === null) {
                    vm.state.CordellResponse.Propertydata.roomBed = 0;
                }
                if (vm.state.CordellResponse.Propertydata.roomBath === null) {
                    vm.state.CordellResponse.Propertydata.roomBath = 0;
                }
            }

            sessionStorageService.remove(keyConstService.getTransactionIdWithoutSaving);
            sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
            sessionStorageService.remove(keyConstService.resetNonRegoData);
            sessionStorageService.set(keyConstService.sessionStorageState, false);
            vm.unspecifiedItemsCover = sessionStorageService.get(keyConstService.IsUnspecifiedPortableItems);
            var transactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
            previousTransactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
            vm.rowVersion = JSON.parse(sessionStorageService.get(keyConstService.rowVersion));
            if (vm.transactionStatus === "Draft") {
                isNewEditTransaction = false;
            }
            else {
                isNewEditTransaction = sessionStorageService.get(keyConstService.IsNewEditTransaction);
            }
            var automaticPayment = -1;
            if (vm.endorsementVM !== null) {
                vm.EffectiveDate = vm.endorsementVM.EndorsementEffectiveDate;
                ExpirationDate = vm.endorsementVM.ExpirationDate;
                vm.endorsementVM.BuildingExcess = vm.state.Excess.BuildingExcess1;
                vm.endorsementVM.ContentExcess = vm.state.Excess.ContentExcess1;
                automaticPayment = vm.brokerManagedPayment;
                sessionStorageService.set(keyConstService.endorsementRequestVM, vm.endorsementVM);
            }
            else {
                var newBusinessData = JSON.parse(sessionStorageService.get(keyConstService.newBusinessCaseData));
                if (newBusinessData) {
                    vm.EffectiveDate = newBusinessData.data.EffectiveDate;
                    ExpirationDate = newBusinessData.data.ExpirationDate;
                    automaticPayment = newBusinessData.data.BrokerManagedPayment;
                }
            }
            if (automaticPayment == -1) {
                automaticPayment = vm.brokerManagedPayment
            }
            vm.state.PaymentFrequency.BrokerManagedPayment = automaticPayment;
            var data = JSON.stringify(vm.state);
            var finalData = { SaveContent: data, EffectiveDate: vm.EffectiveDate, ExpirationDate: ExpirationDate, TransactionId: transactionId, NewEditTransaction: isNewEditTransaction, RowVersion: vm.rowVersion, PaymentFrequency: vm.state.PaymentFrequency.ModeOfPayment, InstallmentDate: vm.homeData.PackageDetail.InstallmentDate, BrokerManagedPayment: automaticPayment };
            var quoteRequest = quotesService.generateRequest(finalData, "Home");
            quotesService.saveQuote(quoteRequest, "Home").then(function (data) {
                if (data !== null && data.data !== null && data.data.error !== null && data.data.error.number === 402) {
                    $timeout(function () {
                        $window.location.href = webUrlConstService.homeIndex;
                    }, 1000);
                    return;
                }
                if (data && data.status === false) {
                    toastr.error(messageConstService.errRecordUpdated);
                    vm.disableButtons = false;
                }
                else if (data && data.status === true) {
                    toastr.success("Saved!");
                    //convert date back to orginal for UI display
                    if (vm.version >= keyConstService.Version) {
                        RenovationDateFormatReset();
                    }
                    //Remove PrimaryClientInsuredId
                    sessionStorageService.remove(keyConstService.PrimaryInsuredId);
                    vm.rowVersion = data.data.quoteTransaction.rowVersion;
                    isNewEditTransaction = false;
                    sessionStorageService.set(keyConstService.IsNewEditTransaction, isNewEditTransaction);
                    sessionStorageService.set(keyConstService.rowVersion, vm.rowVersion);
                    sessionStorageService.set(keyConstService.quoteTransactionId, data.data.quoteTransaction.id);
                    sessionStorageService.set(keyConstService.newBusinessCaseData.status, data.data.quoteTransaction.status);
                    var handledResponse = quotesService.handleResponse(data, "Home");
                    vm.disableButtons = false;
                }
            }, function (e) {
                var myJSON = JSON.stringify(e);
                $log.error('error myJSON', myJSON);
                vm.disableButtons = false;
            });
        };

        function getTermsAndConditons() {
            $mdDialog.show($mdDialog.alert({
                title: 'Terms and Conditions',
                htmlContent: vm.homeData.CordelsTermsAndCondition,
                ok: 'Ok'
            }));

        }

        function finalSaving(finalData) {
            var quoteRequest = quotesService.generateRequest(finalData, "Home");
            quotesService.saveQuote(quoteRequest, "Home").then(function (data) {
                var handledResponse = quotesService.handleResponse(data, "Home");
            }, function (e) {
                var myJSON = JSON.stringify(e);
                $log.error('error myJSON', myJSON);
            });
        }

        //get quote for version 2.0 
        function getQuoteV2() {

            if (vm.state.PropertyDetail.BuildingType !== null) {
                if (vm.state.PropertyDetail.BuildingType === keyConstService.Apartments || vm.state.PropertyDetail.BuildingType === keyConstService.OtherDwellingType) {
                    vm.state.CordellResponse.Propertydata.externalWallMaterial = 'AAC panel';
                    vm.state.CordellResponse.Propertydata.roof = 'Concrete tile';
                }
            }

            //// old questions not in Version 2 should be null
            vm.state.OtherInfo.PreviousInsurer = null;
            vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsEverInsuranceDeclined = null;
            vm.state.UnderwritingCriteria.InsuredInLast3YearsData.ReasonEverInsuranceDeclined = null;

            var handledResponse = vm.getQuote();
            //// resets rennovation start and end date back to the format for it to be visible on UI
            RenovationDateFormatReset();
            if (handledResponse.data.error.number) {
                toastr.error(handledResponse.data.validationMessages);
            }
        }

        function RenovationDateFormatReset() {
            if (vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate = dateService.getDateMMDDtoDDMM(vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate);
            }

            if (vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate = dateService.getDateMMDDtoDDMM(vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate);
            }
        }

        function finalGetQuote(finalData) {
            sessionStorageService.remove(keyConstService.getTransactionIdWithoutSaving);
            sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
            sessionStorageService.remove(keyConstService.resetNonRegoData);
            sessionStorageService.remove(keyConstService.IsUnspecifiedPortableItems);
            sessionStorageService.set(keyConstService.sessionStorageState, false);
            sessionStorageService.set(keyConstService.stampDutyExemption, vm.state.OtherInfo.IsStampDutyExemption);
            vm.disableButtons = true;
            quotesService.generateQuote(quotesService.generateRequest(finalData, "Home"), "Home").then(function (data) {
                var handledResponse = quotesService.handleResponse(data, "Home");
                if (handledResponse.status) {
                    sessionStorageService.remove(keyConstService.IsNewEditTransaction);
                    sessionStorageService.remove(keyConstService.IsCopyQuote);
                    sessionStorageService.remove(keyConstService.IsRenewalPolicy);
                    //Remove PrimaryClientInsuredId
                    sessionStorageService.remove(keyConstService.PrimaryInsuredId);
                    vm.rowVersion = handledResponse.data.rowVersion;
                    sessionStorageService.set(keyConstService.quoteTransactionId, handledResponse.data.transactionId);
                    if (handledResponse.data.error !== null) {
                        if (handledResponse.data.error.number === 401 || handledResponse.data.error.number === 402) {
                            if (handledResponse.data.error.number === 401) {
                                toastr.error(messageConstService.errServiceUnavailable);
                            }
                            $timeout(function () {
                                $window.location.href = webUrlConstService.homeIndex;
                            }, 1000);
                            return;
                        }
                    }
                    if (handledResponse.data.decisionResult) {
                        //
                        if (handledResponse.data.decisionResult.isDeclined || handledResponse.data.decisionResult.isReferral || handledResponse.data.ratingResult) {
                            var quoteTransactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
                            $window.location.href = webUrlConstService.quoteCaseIndex + "?" + sessionStorageService.getEncryption("quoteTransactionId=" + quoteTransactionId);

                        }
                        else {
                            toastr.error(messageConstService.errRatingService);
                        }

                    } else {
                        toastr.error(messageConstService.errDecisionService);
                    }

                }
                else {
                    //error handling for version 2.0 

                    if (handledResponse.errors.length > 0) {
                        if (handledResponse.errors.filter((x) => x.Severity > 10).length > 0) {

                            var severerrors = handledResponse.errors.filter((x) => x.Severity > 10);
                            for (var i = 0; i < severerrors.length; i++) {
                                let servererror = severerrors[0];
                                let msg = servererror.Message;
                                let msgcontent = msg.split(',')[2];
                                toastr.error(msgcontent);
                            }

                            vm.disableButtons = false;
                        }                        
                        else {
                            toastr.error(messageConstService.errServiceUnavailable); 
                        }
                    }
                    else if (handledResponse.data.error.number === 600) {
                        return handledResponse;
                    }
                }
            }, function (e) {
                var myJSON = JSON.stringify(e);
                $log.log('error myJSON', myJSON);
                toastr.error(messageConstService.errMessageWhenDuplicateEntryIssue);
            });
        }

        vm.secondaryListChange = function (DOBFlag, DOBonEdit) {
            for (var i = 0; i < vm.state.PolicyHolder.InsuredNameList.length; i++) {
                if (vm.state.PolicyHolder.InsuredNameList[i].value === vm.state.PolicyHolder.InsuredName && vm.state.PolicyHolder.InsuredName !== 'Other' && vm.state.PolicyHolder.InsuredName !== 'OtherInsured') {
                    var index = vm.state.PolicyHolder.InsuredNameList.indexOf(vm.state.PolicyHolder.InsuredNameList[i]);
                    var temporarylist = angular.copy(vm.state.PolicyHolder.InsuredNameList);
                    // commented as per bug 7095
                    //vm.state.PolicyHolder.OtherInsuredName = null;
                    if (DOBFlag) {
                        if (vm.state.PolicyHolder.InsuredNameList[i].dateOfBirth !== null) {
                            vm.state.PolicyHolder.DateOfBirthApp = vm.state.PolicyHolder.InsuredNameList[i].dateOfBirth;
                            if (JSON.parse(sessionStorageService.get(keyConstService.IsCopyQuote)) === true) {
                                vm.state.PolicyHolder.DateOfBirth = null;
                            }
                        }
                        else {
                            vm.state.PolicyHolder.DateOfBirthApp = "2000-01-01T00:00:00";
                        }
                    }
                    if (!DOBFlag) {
                        vm.state.PolicyHolder.DateOfBirthApp = DOBonEdit;
                    }
                    vm.state.PolicyHolder.InsuredClientId = vm.state.PolicyHolder.InsuredNameList[i].id;
                    vm.state.PolicyHolder.SecondaryInsuredsList = temporarylist;
                    vm.state.PolicyHolder.SecondaryInsuredsList.splice(index, 1);
                    vm.state.PolicyHolder.SecondaryInsuredsList = vm.state.PolicyHolder.SecondaryInsuredsList;

                    //// commented by ankur
                    ////var secondaryInsuredOtherPos = vm.state.PolicyHolder.SecondaryInsuredsList.findIndex(p => p.value === "Other");
                    ////if (secondaryInsuredOtherPos !== -1) {
                    ////    vm.state.PolicyHolder.SecondaryInsuredsList.splice(secondaryInsuredOtherPos, 1);
                    ////}

                    // Changes Related to SME, update Primary Insured Id
                    sessionStorageService.set(keyConstService.PrimaryInsuredId, vm.state.PolicyHolder.InsuredNameList[i].id);
                }
                //else if (vm.state.PolicyHolder.InsuredName === 'Other') {
                //    angular.element('#add-insured').modal('show');
                //}
                ////else if (vm.state.PolicyHolder.InsuredName === 'Other') {
                ////    vm.state.PolicyHolder.InsuredClientId = null;
                ////    temporarylist = angular.copy(vm.state.PolicyHolder.InsuredNameList);
                ////    vm.state.PolicyHolder.SecondaryInsuredsList = temporarylist;
                ////    if (DOBFlag) {
                ////        vm.state.PolicyHolder.DateOfBirthApp = null;
                ////    }
                ////    if (vm.OtherInsuredName !== null) {
                ////        vm.state.PolicyHolder.OtherInsuredName = vm.OtherInsuredName;
                ////        vm.state.PolicyHolder.DateOfBirthApp = vm.DateOfBirthApp;
                ////    }
                ////}
            }
            if (vm.state.PolicyHolder.InsuredName != "OtherInsured") {
                vm.tempPrimaryInsured = vm.state.PolicyHolder.InsuredName;
            } else if (vm.state.PolicyHolder.InsuredName === 'OtherInsured') {
                angular.element('#add-insured').modal('show');
                vm.IsOpenAddInsuredPopup = true;
            }
        }

        function CordellDataState() {
            vm.CordellStateBeforeEstimate = angular.copy(vm.state.CordellResponse.Propertydata);
        }

        function EnableDisableButton(form1) {
            if (vm.state.PolicyHolder.BuildingCover && (vm.state.CordellResponse.BuildingSumInsured == '' || vm.state.CordellResponse.BuildingSumInsured == null || vm.state.CordellResponse.BuildingSumInsured == 0)) {
                form1.$invalid = true;
            }
            if ((vm.selectedAddress === null && !vm.state.PropertyDetail.IsManualAddress) ||
                (form1.$invalid || vm.isNullContentInsured === true) ||
                vm.ExcessValueFlag ||
                vm.ReadOnly ||
                vm.brokerCommissionLimitMessage ||
                vm.BuildingSiFlag ||
                vm.ContentSiFlag ||
                !vm.validDOBOtherInsurer ||
                vm.isUnspecifiedPortableItems === false ||
                !vm.policyHolderNameExists() || !checkAdditionalInsuredInList()) {
                return true;
            } else {
                return false;
            }
        }

        function policyHolderNameExists() {
            return (vm.state.PolicyHolder.InsuredNameList.findIndex(record => record.value === vm.state.PolicyHolder.InsuredName) === -1 ? false : true);
        }



        function RestoreCordellFields() {
            if (vm.CordellStateBeforeEstimate) {
                vm.state.CordellResponse.Propertydata.knowTheArea = vm.CordellStateBeforeEstimate.knowTheArea;
                vm.state.CordellResponse.Propertydata.floorArea = vm.CordellStateBeforeEstimate.floorArea;
                vm.state.CordellResponse.Propertydata.slope = vm.CordellStateBeforeEstimate.slope;
                vm.state.CordellResponse.Propertydata.bushland = vm.CordellStateBeforeEstimate.bushland;
                vm.state.CordellResponse.Propertydata.roomBed = vm.CordellStateBeforeEstimate.roomBed;
                vm.state.CordellResponse.Propertydata.roomBed1Size = vm.CordellStateBeforeEstimate.roomBed1Size,
                    vm.state.CordellResponse.Propertydata.roomBed2Size = vm.CordellStateBeforeEstimate.roomBed2Size,
                    vm.state.CordellResponse.Propertydata.roomBed3Size = vm.CordellStateBeforeEstimate.roomBed3Size,
                    vm.state.CordellResponse.Propertydata.roomBed4Size = vm.CordellStateBeforeEstimate.roomBed4Size,
                    vm.state.CordellResponse.Propertydata.roomBed5Size = vm.CordellStateBeforeEstimate.roomBed5Size,
                    vm.state.CordellResponse.Propertydata.roomBed6Size = vm.CordellStateBeforeEstimate.roomBed6Size,
                    vm.state.CordellResponse.Propertydata.roomBed7Size = vm.CordellStateBeforeEstimate.roomBed7Size,
                    vm.state.CordellResponse.Propertydata.roomBed8Size = vm.CordellStateBeforeEstimate.roomBed8Size,
                    vm.state.CordellResponse.Propertydata.roomBed9Size = vm.CordellStateBeforeEstimate.roomBed9Size,
                    vm.state.CordellResponse.Propertydata.roomBedSizeList = vm.CordellStateBeforeEstimate.roomBedSizeList;
                vm.state.CordellResponse.Propertydata.roomBath = vm.CordellStateBeforeEstimate.roomBath;
                vm.state.CordellResponse.Propertydata.roomBathSizeList = vm.CordellStateBeforeEstimate.roomBathSizeList;
                vm.state.CordellResponse.Propertydata.roomBath1Size = vm.CordellStateBeforeEstimate.roomBath1Size;
                vm.state.CordellResponse.Propertydata.roomBath2Size = vm.CordellStateBeforeEstimate.roomBath2Size;
                vm.state.CordellResponse.Propertydata.roomBath3Size = vm.CordellStateBeforeEstimate.roomBath3Size;
                vm.state.CordellResponse.Propertydata.roomBath4Size = vm.CordellStateBeforeEstimate.roomBath4Size;
                vm.state.CordellResponse.Propertydata.roomBath5Size = vm.CordellStateBeforeEstimate.roomBath5Size;
                vm.state.CordellResponse.Propertydata.roomBath6Size = vm.CordellStateBeforeEstimate.roomBath6Size;
                vm.state.CordellResponse.Propertydata.roomToilet = vm.CordellStateBeforeEstimate.roomToilet;
                vm.state.CordellResponse.Propertydata.garage = vm.CordellStateBeforeEstimate.garage;
                vm.state.CordellResponse.Propertydata.roomKitchen = vm.CordellStateBeforeEstimate.roomKitchen;
                vm.state.CordellResponse.Propertydata.kitchenSizeList = vm.CordellStateBeforeEstimate.kitchenSizeList;
                vm.state.CordellResponse.Propertydata.roomKitchen1Size = vm.CordellStateBeforeEstimate.roomKitchen1Size;
                vm.state.CordellResponse.Propertydata.roomKitchen2Size = vm.CordellStateBeforeEstimate.roomKitchen2Size;
                vm.state.CordellResponse.Propertydata.roomLaundry = vm.CordellStateBeforeEstimate.roomLaundry;
                vm.state.CordellResponse.Propertydata.roomLaundrySizeList = vm.CordellStateBeforeEstimate.roomLaundrySizeList;
                vm.state.CordellResponse.Propertydata.roomLaundry1Size = vm.CordellStateBeforeEstimate.roomLaundry1Size;
                vm.state.CordellResponse.Propertydata.roomLaundry2Size = vm.CordellStateBeforeEstimate.roomLaundry2Size;
                vm.state.CordellResponse.Propertydata.roomEntryFoyerSize = vm.CordellStateBeforeEstimate.roomEntryFoyerSize;
                vm.state.CordellResponse.Propertydata.roomLivingSize = vm.CordellStateBeforeEstimate.roomLivingSize;
                vm.state.CordellResponse.Propertydata.roomDiningSize = vm.CordellStateBeforeEstimate.roomDiningSize;
                vm.state.CordellResponse.Propertydata.roomFamilySize = vm.CordellStateBeforeEstimate.roomFamilySize;
                vm.state.CordellResponse.Propertydata.roomRumpusSize = vm.CordellStateBeforeEstimate.roomRumpusSize;
                vm.state.CordellResponse.Propertydata.roomSunSize = vm.CordellStateBeforeEstimate.roomSunSize;
                vm.state.CordellResponse.Propertydata.roomBilliardSize = vm.CordellStateBeforeEstimate.roomBilliardSize;
                vm.state.CordellResponse.Propertydata.roomHomeTheatreSize = vm.CordellStateBeforeEstimate.roomHomeTheatreSize;
                vm.state.CordellResponse.Propertydata.roomOther = vm.CordellStateBeforeEstimate.roomOther;
                vm.state.CordellResponse.Propertydata.roomOtherSizeList = vm.CordellStateBeforeEstimate.roomOtherSizeList;
                vm.state.CordellResponse.Propertydata.roomOther1Size = vm.CordellStateBeforeEstimate.roomOther1Size;
                vm.state.CordellResponse.Propertydata.roomOther2Size = vm.CordellStateBeforeEstimate.roomOther2Size;
                vm.state.CordellResponse.Propertydata.roomWardrobeBuiltin = vm.CordellStateBeforeEstimate.roomWardrobeBuiltin;
                vm.state.CordellResponse.Propertydata.roomLinenCloset = vm.CordellStateBeforeEstimate.roomLinenCloset;
                vm.state.CordellResponse.Propertydata.roomWardrobeWalkin = vm.CordellStateBeforeEstimate.roomWardrobeWalkin;
                vm.state.CordellResponse.Propertydata.carport = vm.CordellStateBeforeEstimate.carport;
                vm.state.CordellResponse.Propertydata.balconyDeck = vm.CordellStateBeforeEstimate.balconyDeck;
                vm.state.CordellResponse.Propertydata.porchVerandah = vm.CordellStateBeforeEstimate.porchVerandah;
                vm.state.CordellResponse.Propertydata.retainingWalls = vm.CordellStateBeforeEstimate.retainingWalls;
                vm.state.CordellResponse.Propertydata.cabin = vm.CordellStateBeforeEstimate.cabin;
                vm.state.CordellResponse.Propertydata.cabinSizeList = vm.CordellStateBeforeEstimate.cabinSizeList;
                vm.state.CordellResponse.Propertydata.cabin1Size = vm.CordellStateBeforeEstimate.cabin1Size;
                vm.state.CordellResponse.Propertydata.cabin2Size = vm.CordellStateBeforeEstimate.cabin2Size;
                vm.state.CordellResponse.Propertydata.cabin3Size = vm.CordellStateBeforeEstimate.cabin3Size;
                vm.state.CordellResponse.Propertydata.heatingCooling_Included = vm.CordellStateBeforeEstimate.heatingCooling_Included;
                vm.state.CordellResponse.Propertydata.heatingCooling_airConDuctedType = vm.CordellStateBeforeEstimate.heatingCooling_airConDuctedType;
                vm.state.CordellResponse.Propertydata.heatingCooling_airConStandalone = vm.CordellStateBeforeEstimate.heatingCooling_airConStandalone;
                vm.state.CordellResponse.Propertydata.heatingCooling_fireplace = vm.CordellStateBeforeEstimate.heatingCooling_fireplace;
                vm.state.CordellResponse.Propertydata.solar_Included = vm.CordellStateBeforeEstimate.solar_Included;
                vm.state.CordellResponse.Propertydata.solar_HotWater = vm.CordellStateBeforeEstimate.solar_HotWater;
                vm.state.CordellResponse.Propertydata.solar_Electricity = vm.CordellStateBeforeEstimate.solar_Electricity;
                vm.state.CordellResponse.Propertydata.shed_Included = vm.CordellStateBeforeEstimate.shed_Included;
                vm.state.CordellResponse.Propertydata.shed_Small = vm.CordellStateBeforeEstimate.shed_Small;
                vm.state.CordellResponse.Propertydata.shed_Large = vm.CordellStateBeforeEstimate.shed_Large;
                vm.state.CordellResponse.Propertydata.poolSpa_Included = vm.CordellStateBeforeEstimate.poolSpa_Included;
                vm.state.CordellResponse.Propertydata.poolSpa_SpaType = vm.CordellStateBeforeEstimate.poolSpa_SpaType;
                vm.state.CordellResponse.Propertydata.poolSpa_ConcretePoolSize = vm.CordellStateBeforeEstimate.poolSpa_ConcretePoolSize;
                vm.state.CordellResponse.Propertydata.poolSpa_FibreglassPoolSize = vm.CordellStateBeforeEstimate.poolSpa_FibreglassPoolSize;
                vm.state.CordellResponse.Propertydata.poolSpa_VinylPoolSize = vm.CordellStateBeforeEstimate.poolSpa_VinylPoolSize;
                vm.state.CordellResponse.Propertydata.tennisCourt_Included = vm.CordellStateBeforeEstimate.tennisCourt_Included;
                vm.state.CordellResponse.Propertydata.tennisCourt_Number = vm.CordellStateBeforeEstimate.tennisCourt_Number;
                vm.state.CordellResponse.Propertydata.tennisCourt_SurfaceType = vm.CordellStateBeforeEstimate.tennisCourt_SurfaceType;
                vm.state.CordellResponse.Propertydata.tennisCourt_Lighting = vm.CordellStateBeforeEstimate.tennisCourt_Lighting;
                SetCordelFields();
            }
        }

        function claimTypeListSelection() {
            let previousClaimTypeListsection = vm.state.Claims.ClaimTypeList;
            vm.state = getParsedQuestionSetWithoutSaving;

            if (vm.state.Claims.ClaimTypeList.length != previousClaimTypeListsection.length) {
                if (vm.homeData.DDlProcessTypeId == 1 || vm.homeData.DDlProcessTypeId == 0) {
                    vm.state.Claims.ClaimTypeList = previousClaimTypeListsection;
                }
            }

            for (let i = 0; i < vm.state.Claims.ClaimsList.length; i++) {
                let currentitem = vm.state.Claims.ClaimsList[i];
                if (vm.state.Claims.ClaimTypeList.filter(x => x.Value == currentitem.ClaimType).length == 0) {
                    vm.state.Claims.ClaimsList[i].ClaimType = null;
                    vm.state.Claims.ClaimsList[i].CostOfClaim = null;
                }
            }
        }

        vm.tempHomeData = null;
        vm.init = function (homeData) {
            vm.tempHomeData = homeData;
            vm.HomeDropdownListV2 = homeData.HomeDropdownListV2;
            vm.version = homeData.Version;
            var qStartDate = null;
            var qCheckDate = new Date(homeData.DWCAdjustmentDate);
            var specifiedValueReferralnewEffectiveDate = new Date(homeData.SpecifiedValueNewReferralDate);
            if (!homeData.IsEndorsement) {
                if (moment(homeData.PackageDetail.CreatedDate).format("MM/DD/YYYY") >= moment(specifiedValueReferralnewEffectiveDate).format("MM/DD/YYYY")) {
                    vm.showReferralHint = true;
                }
            }
            var isPM = sessionStorageService.get('IsPackageManagerNavigationMode');
            var renewalCounter = sessionStorageService.get('RenewalCounter');
            if (isPM === "true" || renewalCounter !== null) {
                vm.showManagePkg = true;
            }
            vm.PolicyNumber = homeData.PolicyNumber;
            vm.brokerbranchcheck = sessionStorageService.get('IsBranchViewOnly') !== "false";
            sessionStorage.removeItem(keyConstService.Motor);
            sessionStorage.setItem(keyConstService.Home, 'HomeProductController');
            if (sessionStorageService.get(keyConstService.sessionStorageState) === "false") {
                sessionStorageService.remove(keyConstService.getTransactionIdWithoutSaving);
                sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
                sessionStorageService.remove(keyConstService.resetNonRegoData);
            }
            //check if the IsValidQuestionsBack exists already
            var IsValidQuestionsBack = JSON.parse(sessionStorageService.get(keyConstService.IsValidQuestionsBack));
            if (homeData.HomeDropdownListData) {
                vm.maxOccupationTurnover = homeData.HomeDropdownListData.Occupation;
            }
            if (homeData.IsEndorsement) {
                vm.IsEndorsement = homeData.IsEndorsement;
            }
            if (homeData.HomeQuestion && homeData.HomeQuestion.PaymentFrequency.BrokerManagedPayment !== null) {
                vm.brokerManagedPayment = homeData.HomeQuestion.PaymentFrequency.BrokerManagedPayment;
            }
            else {
                vm.brokerManagedPayment = homeData.PackageDetail.BrokerManagedPayment;
            }
            vm.homeData = homeData
            vm.activatePayment = vm.homeData.ActivatePayment;
            if (homeData) {
                if (homeData.IsPolicyBound) {
                    vm.enablePopUp = true;
                    toastr.error(messageConstService.errMessagePolicyBound);

                }
                if (homeData.BuildingSumInsuredAllowedRange) {
                    vm.AllowedBuildingSumInsuredRange = homeData.BuildingSumInsuredAllowedRange;
                }
            }
            vm.endorsementVM = JSON.parse(sessionStorageService.get(keyConstService.endorsementRequestVM));
            if (homeData.QuoteCase !== null || homeData.QuoteTransactionId !== null) {
                vm.CaseNumber = homeData.QuoteCase.CaseNumber;
                vm.TransactionId = homeData.QuoteTransactionId;
            }

            if (vm.IsEndorsement) {
                vm.showBrokerFee = false;
            }
            else {
                vm.showBrokerFee = true;
            }

            if (!homeData.HomeQuestion) {
                vm.ready = true;
                caseId = sessionStorageService.get(keyConstService.caseId);
                sessionStorageService.set(keyConstService.IsNewEditTransaction, isNewEditTransaction);
                vm.CaseNumber = JSON.parse(sessionStorageService.get('caseNumber'));
                transactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
                vm.state = quotesService.loadQuoteData(null, 1, homeData.HomeDropdownListData, vm.version);
                vm.rowVersion = JSON.parse(sessionStorageService.get(keyConstService.rowVersion));
                brokerData = sessionStorageService.get(keyConstService.brokerData);
                var newBusinessCaseData = sessionStorageService.get(keyConstService.newBusinessCaseData);
                var newBusinessCaseDetail = JSON.parse(newBusinessCaseData);
                if (newBusinessCaseDetail) {
                    var startDate = newBusinessCaseDetail.data.EffectiveDate;
                    var productId = newBusinessCaseDetail.data.ProductId;
                }
                homeData.EffectiveDate = newBusinessCaseDetail.data.EffectiveDate;
                qStartDate = new Date(newBusinessCaseDetail.data.EffectiveDate);
                vm.startDateForYear = new Date(newBusinessCaseDetail.data.EffectiveDate);
                vm.isNullContentInsured = false;
                var getQuoteTransactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
                vm.getTransactionIdWithoutSaving = JSON.parse(sessionStorageService.get(keyConstService.getTransactionIdWithoutSaving));
                getQuestionSetWithoutSaving = sessionStorageService.get(keyConstService.getQuestionSetWithoutSaving);
                getParsedQuestionSetWithoutSaving = JSON.parse(getQuestionSetWithoutSaving);
                if (getParsedQuestionSetWithoutSaving) {
                    if (getQuoteTransactionId === vm.getTransactionIdWithoutSaving) {
                        claimTypeListSelection();

                        if (getParsedQuestionSetWithoutSaving.PropertyDetail.AddressLine1) {
                            vm.selectedMannualAddress = getParsedQuestionSetWithoutSaving.PropertyDetail.AddressText;
                        }
                        vm.selectedAddress = getParsedQuestionSetWithoutSaving.PropertyDetail.AddressText;
                        if (getParsedQuestionSetWithoutSaving.PropertyDetail.IsManualAddress === true) {
                            vm.selectedAddress = null;
                            vm.state.PropertyDetail.AddressLine1 = getParsedQuestionSetWithoutSaving.PropertyDetail.AddressLine1;
                            vm.selectedMannualAddress = getParsedQuestionSetWithoutSaving.PropertyDetail.AddressText;
                        }
                        if (getParsedQuestionSetWithoutSaving.PolicyHolder.InsuredName === "Other") {
                            vm.state.PolicyHolder.InsuredName = getParsedQuestionSetWithoutSaving.PolicyHolder.OtherInsuredName
                        }
                        //// building and content cover enable disable on previous next
                        if (getParsedQuestionSetWithoutSaving.PolicyHolder.HomeOccupancyType === "Renting" ||
                            getParsedQuestionSetWithoutSaving.PropertyDetail.BuildingType === keyConstService.Apartments ||
                            getParsedQuestionSetWithoutSaving.PropertyDetail.BuildingType === keyConstService.OtherDwellingType ||
                            (getParsedQuestionSetWithoutSaving.PropertyDetail.BuildingType === keyConstService.SemiDetachedHome && getParsedQuestionSetWithoutSaving.PropertyDetail.IsStrataManagement)) {
                            vm.disableBuilding = true;
                            vm.disableContent = true;
                        }
                        else {
                            vm.disableBuilding = false;
                            vm.disableContent = false;
                        }
                    }
                    // checking for duplicate excess in case of previous/next
                    vm.isDuplicateExcess();
                    //// check if roof and wall is present in list , if not present set to null
                    CheckRoofANdWallValuePresentInDropDown();
                }
                if (getQuoteTransactionId !== vm.getTransactionIdWithoutSaving) {
                    sessionStorageService.remove(keyConstService.IsUnspecifiedPortableItems);
                }
                if (sessionStorageService.get(keyConstService.IsUnspecifiedPortableItems)) {
                    var isUnspecifiedPortable = JSON.parse(sessionStorageService.get(keyConstService.IsUnspecifiedPortableItems));
                    if (isUnspecifiedPortable === false) {
                        vm.isUnspecifiedPortableItems = false;
                    }
                    else {
                        vm.isUnspecifiedPortableItems = true;
                    }
                }
                var brokerCommissionRequest = quotesService.getBrokerCommission({
                    EffectiveDate: startDate,
                    ProductId: productId,
                    ProductName: null,
                })
                    .then(function (result) {
                        vm.data = result.data.brokerBranchCommissionFeeVM;

                        if (vm.data) {
                            for (var i = 0; i < vm.data.length; i++) {
                                if (vm.state.PolicyHolder.BuildingCover && !vm.state.PolicyHolder.ContentCover) {
                                    if (vm.data[i].coverCode === "BUILDING") {
                                        if (!getParsedQuestionSetWithoutSaving) {
                                            vm.state.BrokerCommission.BrokerCommissionPercentage = vm.data[i].brokerCommissionFee;
                                        }
                                        vm.maxbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMax;
                                        vm.minbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMin;
                                    }
                                }
                                if (!vm.state.PolicyHolder.BuildingCover && vm.state.PolicyHolder.ContentCover) {
                                    if (vm.data[i].coverCode === "CONTENT") {
                                        if (!getParsedQuestionSetWithoutSaving) {
                                            vm.state.BrokerCommission.BrokerCommissionPercentage = vm.data[i].brokerCommissionFee;
                                        }
                                        vm.maxbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMax;
                                        vm.minbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMin;
                                    }
                                }
                                if (vm.state.PolicyHolder.BuildingCover && vm.state.PolicyHolder.ContentCover) {
                                    if (vm.data[i].coverCode === "BUILDING,CONTENT") {
                                        if (!getParsedQuestionSetWithoutSaving) {
                                            vm.state.BrokerCommission.BrokerCommissionPercentage = vm.data[i].brokerCommissionFee;
                                        }
                                        vm.maxbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMax;
                                        vm.minbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMin;
                                    }
                                }
                            }
                            vm.checkBrkerCommissionLimit();
                        }
                    })


                brokerdetail = JSON.parse(brokerData);
                if (newBusinessCaseDetail) {
                    newBusinessCaseDetail = JSON.parse(newBusinessCaseData);
                    vm.state.ExistingPackage = newBusinessCaseDetail.data.ExistingPackage;
                }
                if (vm.state.ExistingPackage) {
                    vm.state.OtherInfo.IsAddMorePolicyToPackage = true;
                }

                quotesService.getInsuredNameList(caseId).then(function (ResponseData) {
                    if (ResponseData.data !== null) {
                        vm.state.PolicyHolder.InsuredNameList = ResponseData.data.policyHolder.insuredNameList;
                        vm.state.PolicyHolder.InsuredClientId = ResponseData.data.policyHolder.insuredClientId;
                        vm.ClientDetail = ResponseData.data.clientDetail;
                        vm.addSecondaryClient = ResponseData.data.clientDetail.secondaryInsuredClientVM;
                        vm.otherInsuredAddress = ResponseData.data.clientDetail.addressLogVM;
                        vm.PropertyDetail = angular.copy(ResponseData.data.buildingInfo);
                        if (!vm.getParsedQuestionSetWithoutSaving && getQuoteTransactionId !== vm.getTransactionIdWithoutSaving) {
                            vm.state.PolicyHolder.InsuredName = ResponseData.data.policyHolder.insuredName;
                            vm.state.PropertyDetail.AddressText = ResponseData.data.buildingInfo.addressText;
                            vm.state.PropertyDetail.AddressLine1 = ResponseData.data.buildingInfo.addressLine1;
                            vm.state.PropertyDetail.AddressValue = ResponseData.data.buildingInfo.addressValue;
                            vm.state.PropertyDetail.IsManualAddress = ResponseData.data.buildingInfo.isManualAddress;
                        }
                        var splitSate = vm.state.PropertyDetail.AddressValue != null ? vm.state.PropertyDetail.AddressValue.split('|') : [];
                        vm.AddressState = splitSate[0];
                        if (vm.AddressState === "NSW") {
                            vm.showStampDuty = true;

                        }
                        if ((qStartDate < qCheckDate) && (vm.AddressState === "WA" || vm.AddressState === "ACT" || vm.AddressState === "TAS")) {
                            vm.showDomesticWorkerCompensation = true;
                            vm.state.OtherInfo.IsDomesticWorkerCompensation = vm.state.OtherInfo.IsDomesticWorkerCompensation;

                        }
                        else {
                            vm.showDomesticWorkerCompensation = false;
                            vm.state.OtherInfo.IsDomesticWorkerCompensation = null;
                        }

                        if (getQuoteTransactionId === vm.getTransactionIdWithoutSaving) {
                            vm.address = getParsedQuestionSetWithoutSaving.PropertyDetail.AddressValue;
                            vm.getaddressState = vm.address.split("|");
                            vm.AddressState = vm.getaddressState[0];
                            if ((qStartDate < qCheckDate) && (vm.AddressState === "WA" || vm.AddressState === "ACT" || vm.AddressState === "TAS")) {
                                vm.showDomesticWorkerCompensation = true;
                                vm.state.OtherInfo.IsDomesticWorkerCompensation = vm.state.OtherInfo.IsDomesticWorkerCompensation;

                            }
                            else {
                                vm.showDomesticWorkerCompensation = false;
                                vm.state.OtherInfo.IsDomesticWorkerCompensation = null;
                            }
                        }
                        if (!getParsedQuestionSetWithoutSaving) {
                            vm.state.CordellResponse.Propertydata.postcode = ResponseData.data.buildingInfo.postcode;
                            vm.state.PropertyDetail.AddressLine1 = ResponseData.data.buildingInfo.addressLine1;
                            vm.state.PropertyDetail.IsManualAddress = ResponseData.data.buildingInfo.isManualAddress;
                            if (vm.state.PropertyDetail.IsManualAddress) {
                                vm.selectedMannualAddress = vm.state.PropertyDetail.AddressText;
                                //console.log("selectedMannualAddress", vm.selectedMannualAddress);
                            }

                            else {
                                if (getQuoteTransactionId != vm.getTransactionIdWithoutSaving) {
                                    vm.selectedAddress = { postCode: vm.state.PropertyDetail.Postcode, text: vm.state.PropertyDetail.AddressText, value: vm.state.PropertyDetail.AddressValue };
                                }
                            }
                        }
                    }
                    if (getParsedQuestionSetWithoutSaving && vm.state.PolicyHolder.BuildingCover) {
                        vm.InvalidZero(null, getParsedQuestionSetWithoutSaving.CordellResponse.BuildingSumInsured);
                    }

                    if (vm.state.PolicyHolder.AdditionalPolicyHolderList.length != 0 && vm.state.PolicyHolder.AdditionalPolicyHolderList[0].OtherDateOfBirthApp != null) {
                        for (var i = 0; i < vm.state.PolicyHolder.AdditionalPolicyHolderList.length; i++) {
                            if (vm.state.PolicyHolder.AdditionalPolicyHolderList[i].AdditionalPolicyHolder === "Other") {
                                var dateofBirth = vm.state.PolicyHolder.AdditionalPolicyHolderList[i].OtherDateOfBirthApp;
                                var response = dateService.validateBirthDDMMYYYY(dateofBirth, 115);
                                if (!response.isValid) {
                                    vm.validDOBOtherInsurer = false;
                                    vm.message = response.errorMsg;
                                    break;
                                }
                                else {
                                    vm.validDOBOtherInsurer = true;
                                }
                            }

                            else {
                                continue;
                            }
                        }
                        if (!vm.validDOBOtherInsurer && vm.message === messageConstService.errFutureDateNotAllowed) {
                            toastr.warning(messageConstService.errFutureDatedForAddHolder);
                        }
                        else if (!vm.validDOBOtherInsurer && vm.message === messageConstService.errDateNotAllowed) {
                            toastr.warning(messageConstService.errDateNotAllowed);
                        }
                    }
                    if (getQuoteTransactionId !== vm.getTransactionIdWithoutSaving) {
                        var newDate = new Date(ResponseData.data.policyHolder.dateOfBirthApp);
                        vm.state.PolicyHolder.DateOfBirthApp = newDate;
                    }

                    // retaining claims validation on previous/next
                    vm.checkClaims();

                    //// Default ExcessValue based on Address
                    DefaultExcessOnAddress();

                    for (var i = 0; i < ResponseData.data.policyHolder.secondaryInsuredsList.length; i++) {
                        if (ResponseData.data.policyHolder.secondaryInsuredsList[i].value == vm.state.PolicyHolder.InsuredName && ResponseData.data.policyHolder.secondaryInsuredsList[i].id == vm.state.PolicyHolder.InsuredClientId) {

                            var index = ResponseData.data.policyHolder.secondaryInsuredsList.indexOf(ResponseData.data.policyHolder.secondaryInsuredsList[i]);
                            ResponseData.data.policyHolder.secondaryInsuredsList.splice(index, 1);

                            vm.state.PolicyHolder.SecondaryInsuredsList = ResponseData.data.policyHolder.secondaryInsuredsList;

                            if (getQuoteTransactionId === vm.getTransactionIdWithoutSaving) {
                                vm.getQuestionSetWithoutSavingData = JSON.parse(sessionStorageService.get(keyConstService.getQuestionSetWithoutSaving));
                                if (vm.getQuestionSetWithoutSavingData) {
                                    if (vm.getQuestionSetWithoutSavingData.PolicyHolder.InsuredName === "Other") {
                                        vm.state.PolicyHolder.InsuredName = vm.getQuestionSetWithoutSavingData.PolicyHolder.InsuredName;
                                        vm.state.PolicyHolder.OtherInsuredName = vm.getQuestionSetWithoutSavingData.PolicyHolder.OtherInsuredName;
                                        for (var i = 0; i < vm.getQuestionSetWithoutSavingData.PolicyHolder.SecondaryInsuredsList.length; i++) {
                                            vm.state.PolicyHolder.SecondaryInsuredsList[i] = vm.getQuestionSetWithoutSavingData.PolicyHolder.SecondaryInsuredsList[i];
                                        }
                                    }
                                }
                            }
                            //else {            // commented by Ankur as per US 6829
                            //    if (vm.state.PolicyHolder.InsuredName) {
                            //        vm.state.PolicyHolder.InsuredName = ResponseData.data.policyHolder.insuredName;
                            //    }
                            //}
                        }
                    }
                    if (vm.state.IllionClaimResponseId === null || vm.state.IllionClaimResponseId === undefined) {
                        vm.getAdressEnquiryDetails();
                    }                       
                                       
                });
                vm.doorChecked();
                // removing questionset from session for valid newbusiness quote
                if (!getParsedQuestionSetWithoutSaving) {
                    sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
                }
            }
            /////edit

            else {
                var newBusinessCaseData = sessionStorageService.get(keyConstService.newBusinessCaseData);
                var newBusinessCaseDetail = JSON.parse(newBusinessCaseData);
                qStartDate = newBusinessCaseDetail != null ? new Date(newBusinessCaseDetail.data.EffectiveDate) : new Date(homeData.StartDate);
                vm.startDateForYear = newBusinessCaseDetail != null ? new Date(newBusinessCaseDetail.data.EffectiveDate) : new Date(homeData.StartDate);
                caseNumberForSecondaryInsured = homeData.QuoteCase.Id;
                isUnspecifiedPortable = JSON.parse(sessionStorageService.get(keyConstService.IsUnspecifiedPortableItems));
                vm.brokerFeeGST = homeData.HomeQuestion.PaymentFrequency.BrokerFee;
                vm.addressState = homeData.HomeQuestion.PropertyDetail.AddressValue;
                var splitSate = vm.addressState.split('|');
                vm.storeAddress = splitSate[0];
                vm.AddressState = splitSate[0];
                vm.maxOccupationTurnover = homeData.HomeQuestion.OtherInfo.OccupationNameList;
                homeData.HomeQuestion.OtherInfo.AnnualRevenue = parseInt(homeData.HomeQuestion.OtherInfo.AnnualRevenue);
                vm.IsEndorsementPolicyEffectiveDate = homeData.IsEndorsementPolicyEffectiveDate;
                vm.IsEndorsement = homeData.IsEndorsement;
                vm.isNullContentInsured = false;
                vm.state = homeData.HomeQuestion;
                vm.dataState = homeData;
                vm.addressText = homeData.HomeQuestion.PropertyDetail.AddressText;
                vm.addressValue = homeData.HomeQuestion.PropertyDetail.AddressValue;
                vm.previousAddressLine1ForIllion = vm.state.PropertyDetail.AddressLine1;
                    if (qStartDate >= specifiedValueReferralnewEffectiveDate) {
                        vm.showReferralHint = true;
                    }
                    else {
                        vm.showReferralHint = false;
                }
                var indexOfOther1 = vm.state.PolicyHolder.InsuredNameList.findIndex(p => p.value === "Other");
                if (indexOfOther1 != -1) {
                    vm.state.PolicyHolder.InsuredNameList.splice(indexOfOther1, 1);
                }

                if (vm.state.PolicyHolder.SecondaryInsuredsList !== null) {
                    var indexOfSecOther1 = vm.state.PolicyHolder.SecondaryInsuredsList.findIndex(p => p.value === "Other");
                    if (indexOfSecOther1 != -1) {
                        vm.state.PolicyHolder.SecondaryInsuredsList.splice(indexOfSecOther1, 1);
                    }
                }

                if (vm.state.PolicyHolder.InsuredNameList !== null) {
                    var indexOfOtherInsured = vm.state.PolicyHolder.InsuredNameList.findIndex(p => p.value === "OtherInsured");
                    if (indexOfOtherInsured === -1) {
                        vm.state.PolicyHolder.InsuredNameList.push({ clientType: "Secondary", name: 'Other Insured', value: 'OtherInsured', dateOfBirth: new Date(), Id: -1 });
                    }
                }


                if (vm.state.PolicyHolder.SecondaryInsuredsList !== null) {
                    var indexOfSecondaryOtherInsured = vm.state.PolicyHolder.SecondaryInsuredsList.findIndex(p => p.value === "OtherInsured");
                    if (indexOfSecondaryOtherInsured === -1) {
                        vm.state.PolicyHolder.SecondaryInsuredsList.push({ clientType: "Secondary", name: 'Other Insured', value: 'OtherInsured', dateOfBirth: new Date(), Id: -1 });
                    }
                }

                if (JSON.parse(sessionStorageService.get(keyConstService.IsRenewalPolicy)) === true)
                    homeData.HomeQuestion.CuppingCappingFactor.ExpirationPremium = homeData.HomeQuestion.CuppingCappingFactor.AdjustmentFactor = null;
                if (vm.AddressState) {
                    if ((qStartDate < qCheckDate) && (vm.AddressState.toUpperCase() === "WA" || vm.AddressState.toUpperCase() === "ACT" || vm.AddressState.toUpperCase() === "TAS")) {
                        vm.showDomesticWorkerCompensation = true;
                        vm.state.OtherInfo.IsDomesticWorkerCompensation = vm.state.OtherInfo.IsDomesticWorkerCompensation;

                    }
                    else {
                        vm.showDomesticWorkerCompensation = false;
                        vm.state.OtherInfo.IsDomesticWorkerCompensation = null;
                    }
                }
                if (vm.stampDuty === null) {
                    vm.hideStampDuty = true;
                }
                if (vm.IsEndorsement) {
                    vm.showStampDuty = false;
                    if (homeData.HomeQuestion.OtherInfo.IsStampDutyExemption == true || homeData.HomeQuestion.OtherInfo.IsStampDutyExemption == false) {
                        vm.stampDutyEligibilty = true;
                    }

                    if (homeData.HomeQuestion.OtherInfo.IsStampDutyExemption == null) {
                        vm.sDHide = true;
                    }

                }
                if (homeData.IsReadOnly === true) {
                    if (homeData.HomeQuestion.PropertyDetail.IsManualAddress) {
                        vm.selectedMannualAddress = homeData.HomeQuestion.PropertyDetail.AddressText;
                        vm.state.PropertyDetail.AddressLine1 = homeData.HomeQuestion.PropertyDetail.AddressLine1;
                    }
                    else {
                        vm.selectedAddress = homeData.HomeQuestion.PropertyDetail.AddressText;
                    }

                    if ((qStartDate < qCheckDate) && (vm.AddressState.toUpperCase() === "WA" || vm.AddressState.toUpperCase() === "ACT" || vm.AddressState.toUpperCase() === "TAS")) {
                        vm.showDomesticWorkerCompensation = true;
                        vm.state.OtherInfo.IsDomesticWorkerCompensation = vm.state.OtherInfo.IsDomesticWorkerCompensation;

                    }
                    else {
                        vm.showDomesticWorkerCompensation = false;
                        vm.state.OtherInfo.IsDomesticWorkerCompensation = null;
                    }
                }
                vm.rowVersion = homeData.RowVersion;
                vm.transactionStatus = homeData.Status;
                vm.isSecondaryDisabled = false;
                vm.policyTransactionId = homeData.PolicyTransactionId;
                vm.BuildingSumInsuredValue = homeData.HomeQuestion.CordellResponse.BuildingSumInsured;
                vm.AllowedBuildingSumInsuredRange = homeData.BuildingSumInsuredAllowedRange;
                sessionStorageService.remove(keyConstService.IsNewBusinessReadOnly);
                if (JSON.parse(sessionStorageService.get(keyConstService.IsCopyQuote)) === false) {
                    sessionStorageService.set(keyConstService.IsPackageEditable, vm.dataState.IsPackageEditable);
                }
                else if (JSON.parse(sessionStorageService.get(keyConstService.IsCopyQuote)) === true && newBusinessCaseDetail) {
                    vm.state.ExistingPackage = newBusinessCaseDetail.data.ExistingPackage;
                    caseId = sessionStorageService.get(keyConstService.caseId);
                    quotesService.getInsuredNameList(caseId).then(function (ResponseData) {
                        if (ResponseData.data !== null) {
                            vm.state.PolicyHolder.InsuredNameList = ResponseData.data.policyHolder.insuredNameList;
                            //console.log(ResponseData.data);
                            vm.state.PolicyHolder.InsuredName = ResponseData.data.policyHolder.insuredName;
                            vm.secondaryListChange(true);
                        }
                    });

                    if (vm.state.ExistingPackage) {
                        vm.state.OtherInfo.IsAddMorePolicyToPackage = true;
                    }
                }
                vm.ReadOnly = homeData.IsReadOnly;
                vm.state.ExistingPackage = homeData.QuoteCase.ExistingPackage;
                vm.isNullContentInsured = false;
                var getQuoteTransactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
                vm.getTransactionIdWithoutSaving = JSON.parse(sessionStorageService.get(keyConstService.getTransactionIdWithoutSaving));
                getQuestionSetWithoutSaving = sessionStorageService.get(keyConstService.getQuestionSetWithoutSaving);
                getParsedQuestionSetWithoutSaving = JSON.parse(getQuestionSetWithoutSaving);
                if (getParsedQuestionSetWithoutSaving) {
                    if (getQuoteTransactionId === vm.getTransactionIdWithoutSaving) {

                        claimTypeListSelection();
                        
                        //9Code to enable disable state when policyeffectivedate = endorsementeffectivedate
                        if (homeData.HomeQuestion.PropertyDetail.IsManualAddress == false) {
                            vm.selectedAddress = getParsedQuestionSetWithoutSaving.PropertyDetail.AddressText;
                        }
                        vm.selectedMannualAddress = getParsedQuestionSetWithoutSaving.PropertyDetail.AddressText;
                        vm.address = getParsedQuestionSetWithoutSaving.PropertyDetail.AddressValue;
                        var splitSate = vm.address.split('|');
                        vm.storeAddress = splitSate[0];
                        vm.AddressState = splitSate[0];
                        if ((qStartDate < qCheckDate) && (vm.AddressState.toUpperCase() === "WA" || vm.AddressState.toUpperCase() === "ACT" || vm.AddressState.toUpperCase() === "TAS")) {
                            vm.showDomesticWorkerCompensation = true;
                            vm.state.OtherInfo.IsDomesticWorkerCompensation = getParsedQuestionSetWithoutSaving.OtherInfo.IsDomesticWorkerCompensation;

                        }
                        else {
                            vm.showDomesticWorkerCompensation = false;
                            vm.state.OtherInfo.IsDomesticWorkerCompensation = null;
                        }
                        vm.policyHolderDateOfBirthApp = angular.copy(getParsedQuestionSetWithoutSaving.PolicyHolder.DateOfBirthApp);
                        ////  building and content cover enable disable on previous next
                        if (getParsedQuestionSetWithoutSaving.PolicyHolder.HomeOccupancyType === "Renting" ||
                            getParsedQuestionSetWithoutSaving.PropertyDetail.BuildingType === keyConstService.Apartments ||
                            getParsedQuestionSetWithoutSaving.PropertyDetail.BuildingType === keyConstService.OtherDwellingType ||
                            (getParsedQuestionSetWithoutSaving.PropertyDetail.BuildingType === keyConstService.SemiDetachedHome && getParsedQuestionSetWithoutSaving.PropertyDetail.IsStrataManagement)) {
                            vm.disableBuilding = true;
                            vm.disableContent = true;
                        }
                        else {
                            vm.disableBuilding = false;
                            vm.disableContent = false;
                        }
                    }
                    //// check if roof and wall is present in list , if not present set to null
                    CheckRoofANdWallValuePresentInDropDown();
                }
                if (getParsedQuestionSetWithoutSaving && vm.state.PolicyHolder.BuildingCover) {
                    vm.InvalidZero(null, getParsedQuestionSetWithoutSaving.CordellResponse.BuildingSumInsured);
                }
                if (getQuoteTransactionId !== vm.getTransactionIdWithoutSaving && homeData.Status !== "Draft") {
                    sessionStorageService.remove(keyConstService.IsUnspecifiedPortableItems);
                }
                if (sessionStorageService.get(keyConstService.IsUnspecifiedPortableItems)) {
                    isUnspecifiedPortable = JSON.parse(sessionStorageService.get(keyConstService.IsUnspecifiedPortableItems));
                    if (isUnspecifiedPortable === false) {
                        vm.isUnspecifiedPortableItems = false;
                    }
                    else {
                        vm.isUnspecifiedPortableItems = true;
                    }
                }

                var endorsementDataVM = JSON.parse(sessionStorageService.get(keyConstService.endorsementRequestVM));
                {
                    if (endorsementDataVM) {
                        vm.policyEffectiveDate = moment(endorsementDataVM.StartDate).format('MM/DD/YYYY');
                        vm.endorsementEffectiveDate = endorsementDataVM.EndorsementEffectiveDate;                        
                        if (vm.policyEffectiveDate === vm.endorsementEffectiveDate) {
                            vm.IsEndorsementPolicyEffectiveDate = false;
                            var isEndorsementEdit = JSON.parse(sessionStorageService.get(keyConstService.IsNewEditTransaction));
                            
                            if (isEndorsementEdit) {
                                if (getParsedQuestionSetWithoutSaving) {
                                    vm.state.UnderwritingCriteria.HasInsuredInLast3Years = getParsedQuestionSetWithoutSaving.UnderwritingCriteria.HasInsuredInLast3Years
                                    vm.state.UnderwritingCriteria.InsuredInLast3YearsData = getParsedQuestionSetWithoutSaving.UnderwritingCriteria.InsuredInLast3YearsData;
                                    vm.state.Claims.IsClaimsInLast3Years = getParsedQuestionSetWithoutSaving.Claims.IsClaimsInLast3Years;
                                    vm.state.Claims.ClaimsList = getParsedQuestionSetWithoutSaving.Claims.ClaimsList;
                                }
                            }
                        }
                        else {
                            vm.IsEndorsementPolicyEffectiveDate = true;
                            var newBusinessQuestionsForEndorsement = quotesService.getQuestionSetForPolicy(homeData.PolicyId)
                                .then(function (result) {
                                    var questionsSet = JSON.parse(result.data.requestContent);
                                    vm.state.UnderwritingCriteria.HasInsuredInLast3Years = questionsSet.UnderwritingCriteria.HasInsuredInLast3Years
                                    vm.state.UnderwritingCriteria.InsuredInLast3YearsData = questionsSet.UnderwritingCriteria.InsuredInLast3YearsData;
                                    vm.state.Claims.IsClaimsInLast3Years = questionsSet.Claims.IsClaimsInLast3Years;
                                    vm.state.Claims.ClaimsList = questionsSet.Claims.ClaimsList;
                                });
                        }
                    }
                }
                if (vm.IsEndorsement) {
                    endorsementState = angular.copy(vm.state);
                }
            
                if (vm.state.Claims.IsClaimsInLast3Years) {
                    for (var i = 0; i < vm.state.Claims.ClaimsList.length; i++) {
                        if (vm.state.Claims.ClaimTypeList.filter(x => x.Value == vm.state.Claims.ClaimsList[i].ClaimType).length == 0)
                            vm.state.Claims.ClaimsList[i].ClaimType = vm.state.Claims.ClaimsList[i].CostOfClaim = null;

                        if (vm.state.Claims.ClaimsList[i].ClaimYear == null || vm.state.Claims.ClaimsList[i].ClaimType == null)                            vm.checkNullClaimList = true;

                    }
                }                

                if (vm.ReadOnly === true) {
                    sessionStorageService.set(keyConstService.IsNewBusinessReadOnly, homeData.IsReadOnly);
                }
                var aa = sessionStorageService.get(keyConstService.newBusinessCaseData);
                var startDate = homeData.StartDate;
                if (sessionStorageService.get(keyConstService.newBusinessCaseData) != null) {
                    var newBusinessCaseDetail = JSON.parse(sessionStorageService.get(keyConstService.newBusinessCaseData));
                    vm.EffectiveDate = newBusinessCaseDetail.data.EffectiveDate;
                    ExpirationDate = newBusinessCaseDetail.data.ExpirationDate;
                    startDate = newBusinessCaseDetail.data.EffectiveDate;
                }
                else {
                    vm.EffectiveDate = homeData.EffectiveDate;
                    ExpirationDate = homeData.ExpirationDate;
                }

                if (!sessionStorageService.get(keyConstService.IsNewEditTransaction)) {
                    var isEdit = JSON.parse(sessionStorageService.get(keyConstService.IsNewEditTransaction));
                    if (isEdit !== false && JSON.parse(sessionStorageService.get(keyConstService.IsCopyQuote)) != true) {
                        isNewEditTransaction = true;
                        sessionStorageService.set(keyConstService.IsNewEditTransaction, isNewEditTransaction);
                    }
                }
                
                if (vm.state.PolicyHolder.ContentCover == true) {
                    if (vm.state.ContentsSumInsured.GeneralContentSumInsured == 0) {
                        vm.ContentSiFlag = true;
                    }
                }
                var convertContentSumInsuredToInt = parseInt(homeData.HomeQuestion.ContentsSumInsured.ContentsSumInsured);
                homeData.HomeQuestion.ContentsSumInsured.ContentsSumInsured = convertContentSumInsuredToInt;
                if (homeData.HomeQuestion.ContentsSumInsured.ContentsSumInsured !== 0) {
                    vm.isNullContentInsured = false;
                }
                sessionStorageService.set(keyConstService.rowVersion, homeData.RowVersion);
                sessionStorageService.set(keyConstService.caseId, homeData.QuoteCase.Id);
                caseId = sessionStorageService.get(keyConstService.caseId);

                if (vm.endorsementVM) {
                    sessionStorageService.set(keyConstService.quoteTransactionId, homeData.QuoteTransactionId);
                    if (!(getQuoteTransactionId == vm.getTransactionIdWithoutSaving && getParsedQuestionSetWithoutSaving)) {
                        vm.state.Excess.BuildingExcess1 = vm.endorsementVM.BuildingExcess;
                        vm.state.Excess.BuildingExcess2 = null;
                        vm.state.Excess.BuildingExcess3 = null;
                        vm.state.Excess.ContentExcess2 = null;
                        vm.state.Excess.ContentExcess3 = null;
                        vm.state.Excess.ContentExcess1 = vm.endorsementVM.ContentExcess;
                    }
                }
                else if (vm.homeData.DDlProcessTypeId === 4) {
                    if (vm.homeData.HomeQuestion.CuppingCappingFactor.ExpirationBuildingExcess !== null) {
                        var buildingExcessCount = 0;
                        if (homeData.HomeQuestion.Excess.BuildingExcess1 !== null)
                            buildingExcessCount++;
                        if (homeData.HomeQuestion.Excess.BuildingExcess2 !== null)
                            buildingExcessCount++;
                        if (homeData.HomeQuestion.Excess.BuildingExcess3 !== null)
                            buildingExcessCount++;
                        if (buildingExcessCount === 1) {
                            if (homeData.HomeQuestion.Excess.BuildingExcess1 !== null)
                                vm.state.Excess.BuildingExcess1 = homeData.HomeQuestion.Excess.BuildingExcess1;
                            else if (homeData.HomeQuestion.Excess.BuildingExcess2 !== null)
                                vm.state.Excess.BuildingExcess1 = homeData.HomeQuestion.Excess.BuildingExcess2;
                            else if (homeData.HomeQuestion.Excess.BuildingExcess3 !== null)
                                vm.state.Excess.BuildingExcess1 = homeData.HomeQuestion.Excess.BuildingExcess3;
                            vm.state.Excess.BuildingExcess2 = null;
                            vm.state.Excess.BuildingExcess3 = null;
                        }
                    }
                    if (vm.homeData.HomeQuestion.CuppingCappingFactor.ExpirationContentExcess !== null) {
                        var contentExcessCount = 0;
                        if (homeData.HomeQuestion.Excess.ContentExcess1 !== null)
                            contentExcessCount++;
                        if (homeData.HomeQuestion.Excess.ContentExcess2 !== null)
                            contentExcessCount++;
                        if (homeData.HomeQuestion.Excess.ContentExcess3 !== null)
                            contentExcessCount++;
                        if (contentExcessCount === 1) {
                            if (homeData.HomeQuestion.Excess.ContentExcess1 !== null)
                                vm.state.Excess.ContentExcess1 = homeData.HomeQuestion.Excess.ContentExcess1;
                            else if (homeData.HomeQuestion.Excess.ContentExcess2 !== null)
                                vm.state.Excess.ContentExcess1 = homeData.HomeQuestion.Excess.ContentExcess2;
                            else if (homeData.HomeQuestion.Excess.ContentExcess3 !== null)
                                vm.state.Excess.ContentExcess1 = homeData.HomeQuestion.Excess.ContentExcess3;
                            vm.state.Excess.ContentExcess2 = null;
                            vm.state.Excess.ContentExcess3 = null;
                        }
                    }
                }

                sessionStorageService.set(keyConstService.caseNumber, vm.CaseNumber);
                vm.getNewBusinessCaseData = JSON.parse(sessionStorageService.get(keyConstService.newBusinessCaseData));
                sessionStorageService.set(keyConstService.newBusinessData, vm.getNewBusinessCaseData);
                IsNewBusinessEdit = sessionStorageService.get(keyConstService.IsNewBusinessEdit);

                sessionStorageService.remove(keyConstService.quoteTransactionId);
                sessionStorageService.set(keyConstService.quoteTransactionId, homeData.QuoteTransactionId);
                if (homeData.HomeQuestion.PropertyDetail.AddressText != null && !homeData.HomeQuestion.PropertyDetail.IsManualAddress && getQuoteTransactionId != vm.getTransactionIdWithoutSaving) {
                    vm.selectedAddress = homeData.HomeQuestion.PropertyDetail.AddressText;
                    vm.selectAddress = homeData.HomeQuestion.PropertyDetail.AddressValue;
                    var splitSate = vm.selectAddress.split('|');
                    vm.storeAddress = splitSate[0];
                    vm.AddressState = splitSate[0];
                    if (vm.AddressState === "NSW") {
                        vm.showStampDuty = true;

                    }
                    if ((qStartDate < qCheckDate) && (vm.AddressState.toUpperCase() === "WA" || vm.AddressState.toUpperCase() === "ACT" || vm.AddressState.toUpperCase() === "TAS")) {
                        vm.showDomesticWorkerCompensation = true;
                        vm.state.OtherInfo.IsDomesticWorkerCompensation = vm.state.OtherInfo.IsDomesticWorkerCompensation;

                    }
                    else {
                        vm.showDomesticWorkerCompensation = false;
                        vm.state.OtherInfo.IsDomesticWorkerCompensation = null;
                    }

                }
                else {
                    if (getQuoteTransactionId !== vm.getTransactionIdWithoutSaving) {
                        if (vm.state.PropertyDetail.IsManualAddress == false) {
                            vm.selectedAddress = homeData.HomeQuestion.PropertyDetail.AddressText;
                        }
                        vm.selectedMannualAddress = homeData.HomeQuestion.PropertyDetail.AddressText;
                        vm.selectMannualAddress = homeData.HomeQuestion.PropertyDetail.AddressValue;
                        var splitSate = vm.selectMannualAddress.split('|');
                        vm.AddressState = splitSate[0];
                        if (vm.AddressState === "NSW") {
                            vm.showStampDuty = true;

                        }
                        if ((qStartDate < qCheckDate) && (vm.AddressState.toUpperCase() === "WA" || vm.AddressState.toUpperCase() === "ACT" || vm.AddressState.toUpperCase() === "TAS")) {
                            vm.showDomesticWorkerCompensation = true;
                            vm.state.OtherInfo.IsDomesticWorkerCompensation = vm.state.OtherInfo.IsDomesticWorkerCompensation;

                        }
                        else {
                            vm.showDomesticWorkerCompensation = false;
                            vm.state.OtherInfo.IsDomesticWorkerCompensation = null;
                        }
                    }
                }

                if (vm.IsEndorsement && getQuoteTransactionId !== vm.getTransactionIdWithoutSaving) {
                    if (vm.state.PropertyDetail.IsManualAddress == false) {
                        vm.state.PropertyDetail.AddressLine1 = null;
                        vm.selectedMannualAddress = null;
                        vm.selectedMannualAddress = homeData.HomeQuestion.PropertyDetail.AddressText;
                        vm.selectMannualAddress = homeData.HomeQuestion.PropertyDetail.AddressValue;
                        var splitSate = vm.selectMannualAddress.split('|');
                        vm.AddressState = splitSate[0];
                        if ((qStartDate < qCheckDate) && (vm.AddressState.toUpperCase() === "WA" || vm.AddressState.toUpperCase() === "ACT" || vm.AddressState.toUpperCase() === "TAS")) {
                            vm.showDomesticWorkerCompensation = true;
                            vm.state.OtherInfo.IsDomesticWorkerCompensation = vm.state.OtherInfo.IsDomesticWorkerCompensation;

                        }
                        else {
                            vm.showDomesticWorkerCompensation = false;
                            vm.state.OtherInfo.IsDomesticWorkerCompensation = null;
                        }
                    }
                }

                var occupancyType = homeData.HomeQuestion.PolicyHolder.HomeOccupancyType;
                var isEdit = sessionStorageService.get(keyConstService.IsNewEditTransaction);

                //// enabling disabling building content cover once a saved quote is open
                if (isEdit !== false && (occupancyType === "Renting" ||
                    vm.state.PropertyDetail.BuildingType === keyConstService.Apartments ||
                    vm.state.PropertyDetail.BuildingType === keyConstService.OtherDwellingType ||
                    (vm.state.PropertyDetail.BuildingType === keyConstService.SemiDetachedHome && vm.state.PropertyDetail.IsStrataManagement))){
                    vm.disableBuilding = true;
                    vm.disableContent = true;
                }
                
                var productName = homeData.LOB;
                var brokerCommissionRequestOnEdit = quotesService.getBrokerCommissiononEdit({
                    EffectiveDate: startDate,
                    ProductName: productName,
                    ProductId: null,
                })
                    .then(function (result) {
                        vm.data = result.data.brokerBranchCommissionFeeVM;
                        if (vm.data) {
                            for (var i = 0; i < vm.data.length; i++) {
                                if (vm.state.PolicyHolder.BuildingCover && !vm.state.PolicyHolder.ContentCover) {
                                    if (vm.data[i].coverCode === "BUILDING") {
                                        //vm.state.BrokerCommission.BrokerCommissionPercentage = vm.data[i].brokerCommissionFee;
                                        vm.maxbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMax;
                                        vm.minbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMin;
                                    }
                                }
                                if (!vm.state.PolicyHolder.BuildingCover && vm.state.PolicyHolder.ContentCover) {
                                    if (vm.data[i].coverCode === "CONTENT") {
                                        //vm.state.BrokerCommission.BrokerCommissionPercentage = vm.data[i].brokerCommissionFee;
                                        vm.maxbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMax;
                                        vm.minbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMin;
                                    }
                                }
                                if (vm.state.PolicyHolder.BuildingCover && vm.state.PolicyHolder.ContentCover) {
                                    if (vm.data[i].coverCode === "BUILDING,CONTENT") {
                                        //vm.state.BrokerCommission.BrokerCommissionPercentage = vm.data[i].brokerCommissionFee;
                                        vm.maxbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMax;
                                        vm.minbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMin;
                                    }
                                }
                                if (!vm.ReadOnly && !vm.IsEndorsement) {
                                    vm.checkBrkerCommissionLimit();
                                }
                            }
                            if (getQuoteTransactionId === vm.getTransactionIdWithoutSaving && vm.getTransactionIdWithoutSaving !== null && getQuoteTransactionId !== null) {
                                vm.state.PolicyHolder.DateOfBirthApp = vm.policyHolderDateOfBirthApp;
                            }
                        }
                    })
                SetCordelFields();
                // commented it replace SecondaryInsuredList
                if (JSON.parse(sessionStorageService.get(keyConstService.IsCopyQuote)) !== true) {
                    vm.getSecondaryInsuredList(homeData.HomeQuestion.PolicyHolder.DateOfBirthApp);
                }

                // retaining claims validation on previous/next
                vm.checkClaims();
                // checking for duplicate excess in case of previous/next
                vm.isDuplicateExcess();
                // removing questionset from session for valid newbusiness quote
                if (getParsedQuestionSetWithoutSaving) {
                    sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
                }

                // removing questionset from session for valid newbusiness quote
                if (!getParsedQuestionSetWithoutSaving) {
                    sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
                }

                if (vm.state.PolicyHolder.AdditionalPolicyHolderList.length != 0 && vm.state.PolicyHolder.AdditionalPolicyHolderList[0].OtherDateOfBirthApp != null) {
                    for (var i = 0; i < vm.state.PolicyHolder.AdditionalPolicyHolderList.length; i++) {
                        if (vm.state.PolicyHolder.AdditionalPolicyHolderList[i].AdditionalPolicyHolder === "Other") {
                            var dateofBirth = vm.state.PolicyHolder.AdditionalPolicyHolderList[i].OtherDateOfBirthApp;
                            var response = dateService.validateBirthDDMMYYYY(dateofBirth, 115);
                            if (!response.isValid) {
                                vm.validDOBOtherInsurer = false;
                                vm.message = response.errorMsg;
                                break;
                            }
                            else {
                                vm.validDOBOtherInsurer = true;
                            }
                        }
                        else {
                            continue;
                        }
                    }
                    if (!vm.validDOBOtherInsurer && vm.message === messageConstService.errFutureDateNotAllowed) {
                        toastr.warning(messageConstService.errFutureDatedForAddHolder);
                    }
                    else if (!vm.validDOBOtherInsurer && vm.message === messageConstService.errDateNotAllowed) {
                        toastr.warning(messageConstService.errDateNotAllowed);
                    }
                }

                if (getQuoteTransactionId == null && vm.getTransactionIdWithoutSaving == null) {
                    if (vm.IsEndorsement) {
                        if (homeData.HomeQuestion.PropertyDetail.IsManualAddress) {
                            vm.selectedAddress = null;
                            vm.selectedMannualAddress = homeData.HomeQuestion.PropertyDetail.AddressText;
                            vm.state.PropertyDetail.AddressLine1 = homeData.HomeQuestion.PropertyDetail.AddressLine1;
                        }
                        else {
                            vm.selectedAddress = homeData.HomeQuestion.PropertyDetail.AddressText;
                        }
                    }
                }
                vm.doorChecked();
                var isCopyQuote = JSON.parse(sessionStorageService.get(keyConstService.IsCopyQuote));
                if (!IsNewBusinessEdit && !isCopyQuote) {
                    sessionStorageService.remove(keyConstService.newBusinessCaseData);
                }
                else {
                    if (vm.getNewBusinessCaseData) {
                        vm.homeData.PackageDetail.PaymentFrequency = vm.getNewBusinessCaseData.data.PaymentFrequency;
                        vm.homeData.PackageDetail.InstallmentDate = vm.getNewBusinessCaseData.data.InstallmentDate;
                    }
                }

                //// if call Illion API if copy quote or Edit or endorsement quote when IsIllionCallOnEdit is true
                if ((vm.homeData.DDlProcessTypeId != 4 || vm.IsEndorsement == false) && (vm.homeData.DDlProcessTypeId != 4 && vm.IsEndorsement == false)) {
                     if (JSON.parse(sessionStorageService.get(keyConstService.IsCopyQuote)) || (vm.dataState.IsIllionCallOnEdit && (JSON.parse(sessionStorageService.get(keyConstService.IsNewEditTransaction))))) {
                        vm.state.IllionClaimResponse = null;
                        vm.state.IllionClaimResponseId = null;
                        vm.getAdressEnquiryDetails();
                    }
                }
            }

            vm.state.PaymentFrequency.ModeOfPayment = vm.homeData.PackageDetail.PaymentFrequency;
            vm.state.PaymentFrequency.DayofInstallment = 0;
            if (vm.state.PaymentFrequency.ModeOfPayment === 'Monthly')
                vm.state.PaymentFrequency.DayofInstallment = vm.homeData.PackageDetail.InstallmentDate;

            //  set buildingsiflag = true in case of edit if vm.state.PolicyHolder.BuildingCover and vm.state.CordellResponse. is not null
            if (vm.state.PolicyHolder.BuildingCover && !vm.state.CordellResponse.BuildingSumInsured) {
                vm.BuildingSiFlag = true;
            }
            // updating claims data after changing effective date
            quotesService.updateClaimsInfo(vm.state.Claims);
            // retaining claims validation on previous/next
            vm.checkClaims();

            //disable getquote if insured name is not in list
            //if (vm.state.PolicyHolder.InsuredName !== "Other") {
            //    var existInsuredName = utilityService.valueExistsInArray(vm.state.PolicyHolder.InsuredName, vm.state.PolicyHolder.InsuredNameList);
            //    if (!existInsuredName) {
            //        vm.disableButtons = true;
            //    }
            //}

            // for additional insured
            //checkAdditionalInsuredInList();
            //vm.state.Claims.ClaimYears = quotesService.updateClaimYears(homeData.EffectiveDate);
            getInsuredNameList(true);
            if (vm.version < keyConstService.Version) {
                //// resets rennovation start and end date back to the format for it to be visible on UI
                if (vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate) {
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate = utilityService.ConvertDateTimeForUi(vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate);
                }
                if (vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate) {
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate = utilityService.ConvertDateTimeForUi(vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate);
                }
                // enable building and content cover if occupancy type is not renting and
                // version is less than 2.0
                if (vm.state.PolicyHolder.HomeOccupancyType !== 'Renting') {
                    vm.disableBuilding = false;
                    vm.disableContent = false;
                }
            }
        }; // end of init

        angular.element(document).ready(function () {
            validateConstructionPeriod($scope.subFormContent.OriginalYearBuilt);
            setValidity();
        });

        function setValidity() {
            if ($scope.subFormContent.$invalid) {
                if ($scope.subFormContent.OriginalYearBuilt.$viewValue) {
                    $scope.form1.OriginalYearBuilt.$setValidity("size", false);
                    $scope.form1.OriginalYearBuilt.$touched = true;
                    $scope.form1.$setValidity("size", false);
                }
            }
        }

        function SetCordelFields() {
            if (vm.state.CordellResponse.Propertydata.roomBed > 0) {
                vm.state.CordellResponse.Propertydata.roomBedSizeList = {};
                vm.state.CordellResponse.Propertydata.roomBedSizeList["0"] = vm.state.CordellResponse.Propertydata.roomBed1Size;
                vm.state.CordellResponse.Propertydata.roomBedSizeList["1"] = vm.state.CordellResponse.Propertydata.roomBed2Size;
                vm.state.CordellResponse.Propertydata.roomBedSizeList["2"] = vm.state.CordellResponse.Propertydata.roomBed3Size;
                vm.state.CordellResponse.Propertydata.roomBedSizeList["3"] = vm.state.CordellResponse.Propertydata.roomBed4Size;
                vm.state.CordellResponse.Propertydata.roomBedSizeList["4"] = vm.state.CordellResponse.Propertydata.roomBed5Size;
                vm.state.CordellResponse.Propertydata.roomBedSizeList["5"] = vm.state.CordellResponse.Propertydata.roomBed6Size;
                vm.state.CordellResponse.Propertydata.roomBedSizeList["6"] = vm.state.CordellResponse.Propertydata.roomBed7Size;
                vm.state.CordellResponse.Propertydata.roomBedSizeList["7"] = vm.state.CordellResponse.Propertydata.roomBed8Size;
                vm.state.CordellResponse.Propertydata.roomBedSizeList["8"] = vm.state.CordellResponse.Propertydata.roomBed9Size;
            }

            if (vm.state.CordellResponse.Propertydata.roomBath > 0) {
                vm.state.CordellResponse.Propertydata.roomBathSizeList = {};
                vm.state.CordellResponse.Propertydata.roomBathSizeList["0"] = vm.state.CordellResponse.Propertydata.roomBath1Size;
                vm.state.CordellResponse.Propertydata.roomBathSizeList["1"] = vm.state.CordellResponse.Propertydata.roomBath2Size;
                vm.state.CordellResponse.Propertydata.roomBathSizeList["2"] = vm.state.CordellResponse.Propertydata.roomBath3Size;
                vm.state.CordellResponse.Propertydata.roomBathSizeList["3"] = vm.state.CordellResponse.Propertydata.roomBath4Size;
                vm.state.CordellResponse.Propertydata.roomBathSizeList["4"] = vm.state.CordellResponse.Propertydata.roomBath5Size;
                vm.state.CordellResponse.Propertydata.roomBathSizeList["5"] = vm.state.CordellResponse.Propertydata.roomBath6Size;
            }

            if (vm.state.CordellResponse.Propertydata.roomLaundry > 0) {
                vm.state.CordellResponse.Propertydata.roomLaundrySizeList = {};
                vm.state.CordellResponse.Propertydata.roomLaundrySizeList["0"] = vm.state.CordellResponse.Propertydata.roomLaundry1Size;
                vm.state.CordellResponse.Propertydata.roomLaundrySizeList["1"] = vm.state.CordellResponse.Propertydata.roomLaundry2Size;
            }

            if (vm.state.CordellResponse.Propertydata.roomOther > 0) {
                vm.state.CordellResponse.Propertydata.roomOtherList = {};
                vm.state.CordellResponse.Propertydata.roomOtherList["0"] = vm.state.CordellResponse.Propertydata.roomOther1Size;
                vm.state.CordellResponse.Propertydata.roomOtherList["1"] = vm.state.CordellResponse.Propertydata.roomOther2Size;
            }

            if (vm.state.CordellResponse.Propertydata.roomKitchen > 0) {
                vm.state.CordellResponse.Propertydata.kitchenSizeList = {};
                vm.state.CordellResponse.Propertydata.kitchenSizeList["0"] = vm.state.CordellResponse.Propertydata.roomKitchen1Size;
                vm.state.CordellResponse.Propertydata.kitchenSizeList["1"] = vm.state.CordellResponse.Propertydata.roomKitchen2Size;
            }

            if (vm.state.CordellResponse.Propertydata.cabin > 0) {
                vm.state.CordellResponse.Propertydata.cabinSizeList = {};
                vm.state.CordellResponse.Propertydata.cabinSizeList["0"] = vm.state.CordellResponse.Propertydata.cabin1Size;
                vm.state.CordellResponse.Propertydata.cabinSizeList["1"] = vm.state.CordellResponse.Propertydata.cabin2Size;
                vm.state.CordellResponse.Propertydata.cabinSizeList["2"] = vm.state.CordellResponse.Propertydata.cabin3Size;
            }
        }

        vm.getQuote = function () {
            vm.isDisabled = true;
            vm.getConvertedDate();
            //// resets rennovation start and end date to the format for it to parse in Json
            if (vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate = dateService.getDateDDMMtoMMDD(vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate);
            }

            if (vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate ) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate = dateService.getDateDDMMtoMMDD(vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate);
            }
            if (vm.state.PolicyHolder.BuildingCover == false && vm.state.PolicyHolder.ContentCover == true) {
                vm.state.CordellResponse.BuildingSumInsured = 0;
            }
            if (vm.IsEndorsement) {
                vm.state.PaymentFrequency.BrokerFee = 0;
                vm.state.PaymentFrequency.BrokerFeeGST = 0;
            }
            var transactionId = JSON.parse(sessionStorageService.get(keyConstService.quoteTransactionId));
            if (vm.transactionStatus == "Draft") {
                isNewEditTransaction = false;
            }
            else {
                isNewEditTransaction = sessionStorageService.get(keyConstService.IsNewEditTransaction);
            }
            vm.rowVersion = JSON.parse(sessionStorageService.get(keyConstService.rowVersion));
            var automaticPayment = -1;
            if (vm.endorsementVM != null) {
                vm.EffectiveDate = vm.endorsementVM.EndorsementEffectiveDate;
                ExpirationDate = vm.endorsementVM.ExpirationDate;
                sessionStorageService.remove(keyConstService.endorsementRequestVM);
                sessionStorageService.remove(keyConstService.IsEndorsementEdit);
                automaticPayment = vm.brokerManagedPayment;
            }
            else {
                var newBusinessData = JSON.parse(sessionStorageService.get(keyConstService.newBusinessCaseData));
                if (newBusinessData) {
                    vm.EffectiveDate = newBusinessData.data.EffectiveDate;
                    ExpirationDate = newBusinessData.data.ExpirationDate;
                    automaticPayment = newBusinessData.data.BrokerManagedPayment;
                }
            }
            if (automaticPayment == -1) {
                automaticPayment = vm.brokerManagedPayment
            }
            vm.state.PaymentFrequency.BrokerManagedPayment = automaticPayment;
            sessionStorageService.set(keyConstService.quoteState, vm.state);
            var data = sessionStorageService.get(keyConstService.quoteState);
            var pData = JSON.parse(data);
            if (sessionStorageService.get(keyConstService.IsCopyQuote) === "true")
                isNewEditTransaction = false;
            var finalData = { SaveContent: data, EffectiveDate: vm.EffectiveDate, ExpirationDate: ExpirationDate, TransactionId: transactionId, NewEditTransaction: isNewEditTransaction, RowVersion: vm.rowVersion, PaymentFrequency: vm.state.PaymentFrequency.ModeOfPayment, InstallmentDate: vm.homeData.PackageDetail.InstallmentDate, BrokerManagedPayment: automaticPayment };
            if (vm.version >= keyConstService.Version) {
                var handledResponse = vm.FinalGetQuote(finalData);
                return handledResponse;
            }
            else {
                vm.FinalGetQuote(finalData);
            }
        }
        vm.checkNullValue = function () {
            vm.isNullContentInsured = false;
            if ((vm.state.ContentsSumInsured.GeneralContentsSumInsured === "0" || vm.state.ContentsSumInsured.ContentsSumInsured === "0.00") && vm.state.PolicyHolder.ContentCover === true) {
                vm.isNullContentInsured = true;
            }
        }

        function brokerFeeChange() {
            var regexp = /^[0-9]+(\.[0-9]{1,2})?$/;
            if (!regexp.test(vm.state.PaymentFrequency.BrokerFee)) {
                vm.state.PaymentFrequency.BrokerFee = null;
            }
        }

        vm.isDuplicateExcess = function () {
            if (vm.state.PolicyHolder.BuildingCover && vm.state.PolicyHolder.ContentCover) {
                if (vm.state.Excess.BuildingExcess1 === null && vm.state.Excess.ContentExcess1 === null && (vm.state.Excess.BuildingExcess2 !== null && vm.state.Excess.BuildingExcess2 !== "")
                    && (vm.state.Excess.ContentExcess2 !== null && vm.state.Excess.ContentExcess2 !== "")) {
                    vm.message = "Please select Excess option1.";
                    vm.ExcessValueFlag = true;
                    return;
                }

                if ((vm.state.Excess.BuildingExcess3 !== null && vm.state.Excess.BuildingExcess3 !== "") && (vm.state.Excess.ContentExcess3 !== null && vm.state.Excess.ContentExcess3 !== "") &&
                    (vm.state.Excess.BuildingExcess2 === null || vm.state.Excess.BuildingExcess2 === "") && (vm.state.Excess.ContentExcess2 === null || vm.state.Excess.ContentExcess2 === "")) {
                    vm.message = "Please select Excess Option2.";
                    vm.ExcessValueFlag = true;
                    return;
                }
                else {
                    vm.ExcessValueFlag = false;
                }

                if ((vm.state.Excess.BuildingExcess1 !== null && vm.state.Excess.BuildingExcess1 !== "") && (vm.state.Excess.ContentExcess1 === null || vm.state.Excess.ContentExcess1 === "")) {
                    vm.ExcessValueFlag = true;
                    vm.message = "Please select Content Excess Option1.";
                    return;
                }
                else if ((vm.state.Excess.BuildingExcess1 === null || vm.state.Excess.BuildingExcess1 === "") && (vm.state.Excess.ContentExcess1 !== null && vm.state.Excess.ContentExcess1 !== "")) {
                    vm.ExcessValueFlag = true;
                    vm.message = "Please select Building Excess Option1.";
                    return;
                }

                if ((vm.state.Excess.BuildingExcess2 !== null && vm.state.Excess.BuildingExcess2 !== "") && (vm.state.Excess.ContentExcess2 === null || vm.state.Excess.ContentExcess2 === "")) {
                    vm.ExcessValueFlag = true;
                    vm.message = "Please select Content Excess Option2.";
                    return;
                }
                else if ((vm.state.Excess.BuildingExcess2 === null || vm.state.Excess.BuildingExcess2 === "") && (vm.state.Excess.ContentExcess2 !== null && vm.state.Excess.ContentExcess2 !== "")) {
                    vm.ExcessValueFlag = true;
                    vm.message = "Please select Building Excess Option2.";
                    return;
                }
                else {
                    if ((vm.state.Excess.BuildingExcess2 !== null && vm.state.Excess.BuildingExcess2 !== "") && (vm.state.Excess.ContentExcess2 !== null && vm.state.Excess.ContentExcess2 !== "") &&
                        (vm.state.Excess.BuildingExcess1 === vm.state.Excess.BuildingExcess2) && (vm.state.Excess.ContentExcess1 === vm.state.Excess.ContentExcess2)) {

                        vm.ExcessValueFlag = true;
                        vm.message = "Excess value cannot be same.";
                        return;
                    }
                    else {
                        vm.ExcessValueFlag = false;
                    }

                }

                if ((vm.state.Excess.BuildingExcess3 !== null && vm.state.Excess.BuildingExcess3 !== "") && (vm.state.Excess.ContentExcess3 === null || vm.state.Excess.ContentExcess3 === "")) {
                    vm.ExcessValueFlag = true;
                    vm.message = "Please select Content Excess Option3."
                    return;
                }
                else if ((vm.state.Excess.BuildingExcess3 === null || vm.state.Excess.BuildingExcess3 === "") && (vm.state.Excess.ContentExcess3 !== null && vm.state.Excess.ContentExcess3 !== "")) {
                    vm.ExcessValueFlag = true;
                    vm.message = "Please select Building Excess Option3."
                    return;
                }
                else {
                    if ((vm.state.Excess.BuildingExcess3 !== null && vm.state.Excess.BuildingExcess3 !== "") && (vm.state.Excess.ContentExcess3 !== null && vm.state.Excess.ContentExcess3 !== "")
                        && ((vm.state.Excess.BuildingExcess2 === vm.state.Excess.BuildingExcess3) && (vm.state.Excess.ContentExcess2 === vm.state.Excess.ContentExcess3) ||
                            (vm.state.Excess.BuildingExcess1 === vm.state.Excess.BuildingExcess3) && (vm.state.Excess.ContentExcess1 === vm.state.Excess.ContentExcess3) ||
                            ((vm.state.Excess.BuildingExcess1 === vm.state.Excess.BuildingExcess2) && (vm.state.Excess.ContentExcess1 === vm.state.Excess.ContentExcess2)))) {
                        vm.ExcessValueFlag = true;
                        vm.message = "Excess value cannot be same."
                        return;
                    }
                    else {
                        vm.ExcessValueFlag = false;
                    }
                }

            }
            else if (vm.state.PolicyHolder.BuildingCover) {
                if ((vm.state.Excess.BuildingExcess2 !== null && vm.state.Excess.BuildingExcess2 !== "") && (vm.state.Excess.BuildingExcess2 === vm.state.Excess.BuildingExcess1)) {
                    vm.ExcessValueFlag = true;
                    vm.message = "Excess value cannot be same."
                    return;
                }
                else {
                    if ((vm.state.Excess.BuildingExcess3 !== null && vm.state.Excess.BuildingExcess3 !== "") && ((vm.state.Excess.BuildingExcess2 === vm.state.Excess.BuildingExcess3) || (vm.state.Excess.BuildingExcess1 === vm.state.Excess.BuildingExcess3))) {
                        vm.ExcessValueFlag = true;
                        vm.message = "Excess value cannot be same."
                        return;
                    }
                    else {
                        if ((vm.state.Excess.BuildingExcess2 === null || vm.state.Excess.BuildingExcess2 === "") && (vm.state.Excess.BuildingExcess3 !== null && vm.state.Excess.BuildingExcess3 !== "")) {
                            vm.ExcessValueFlag = true;
                            vm.message = "Please select Excess Option2."
                            return;
                        }
                        else {
                            ////if-else part reoved for sonar qube report bug
                            vm.ExcessValueFlag = false;          
                        }
                    }
                }
            }
            else {
                if ((vm.state.Excess.ContentExcess2 !== null && vm.state.Excess.ContentExcess2 !== "") && (vm.state.Excess.ContentExcess1 === vm.state.Excess.ContentExcess2)) {
                    vm.ExcessValueFlag = true;
                    vm.message = "Excess value cannot be same."
                    return;
                }
                else {
                    if ((vm.state.Excess.ContentExcess3 !== null && vm.state.Excess.ContentExcess3 !== "") && ((vm.state.Excess.ContentExcess2 === vm.state.Excess.ContentExcess3) || (vm.state.Excess.ContentExcess1 === vm.state.Excess.ContentExcess3))) {
                        vm.ExcessValueFlag = true;
                        vm.message = "Excess value cannot be same."
                        return;
                    }
                    else {
                        if ((vm.state.Excess.ContentExcess2 === null || vm.state.Excess.ContentExcess2 === "") && (vm.state.Excess.ContentExcess3 !== null && vm.state.Excess.ContentExcess3 !== "")) {
                            vm.ExcessValueFlag = true;
                            vm.message = "Please select Excess Option2."
                            return;
                        }
                        else {

                            ////if-else part removed for sonar qube report bug
                                vm.ExcessValueFlag = false;
                        }
                    }
                }
            }
        }

        vm.getConvertedDate = function () {
            var dateofBirth = vm.state.PolicyHolder.DateOfBirthApp;
            if (dateofBirth) {
                var response = dateService.validateBirthDDMMYYYY(dateofBirth, 150);

                if (!response.isValid) {
                    vm.state.PolicyHolder.DateOfBirth = '';
                    vm.state.PolicyHolder.DateOfBirthApp = '';
                    toastr.warning(response.errorMsg);
                    return;
                }

                vm.state.PolicyHolder.DateOfBirth = response.date;
            }

        }

        vm.getOtherConvertedDate = function (dob, index, formElement) {
            var dateofBirth = dob;
            if (dateofBirth) {
                var response = dateService.validateBirthDDMMYYYY(dateofBirth, 150);

                if (!response.isValid) {
                    vm.state.PolicyHolder.AdditionalPolicyHolderList[index].OtherDateOfBirth = '';
                    vm.state.PolicyHolder.OtherDateOfBirthApp = '';
                    formElement.$setValidity("OtherDateOfBirth_", false);
                    toastr.warning(response.errorMsg);
                }
                else {
                    formElement.$setValidity("OtherDateOfBirth_", true);
                }

                vm.state.PolicyHolder.AdditionalPolicyHolderList[index].OtherDateOfBirth = response.date;
                vm.checkFutureDate(vm.state.PolicyHolder.AdditionalPolicyHolderList.length);
            }

        }

        vm.getDeclineConvertedDate = function () {
            var dateofBirth = vm.state.DutyOfDisclosure.DeclineDate;
            if (dateofBirth) {
                var response = dateService.validateBirthDDMMYYYY(dateofBirth, 150);

                if (!response.isValid) {
                    vm.state.DutyOfDisclosure.DateOfDecline = '';
                    vm.state.DutyOfDisclosure.DeclineDate = '';
                    toastr.warning(response.errorMsg);
                    return;
                }

                vm.state.DutyOfDisclosure.DateOfDecline = response.date;
            }

        };

        function validateConstructionPeriod(field) {
            if (vm.state.CordellResponse.Propertydata.yearBuilt !== undefined) {
                if (vm.state.CordellResponse.Propertydata.periodName !== null && vm.state.CordellResponse.Propertydata.periodName == 'Modern project home design (1960 to present)' || vm.state.CordellResponse.Propertydata.periodName == 'Modern architect design (1960 to present)') {                    
                    //if (vm.state.CordellResponse.Propertydata.yearBuilt < 1960 || vm.state.CordellResponse.Propertydata.yearBuilt > new Date().getFullYear()) {
                    if (vm.state.CordellResponse.Propertydata.yearBuilt < 1960 || (vm.startDateForYear && vm.state.CordellResponse.Propertydata.yearBuilt > new Date(vm.startDateForYear).getFullYear())) {
                        field.$setValidity("size", false);
                        $scope.subFormContent.$invalid = true;
                        $scope.form1.$setValidity("size", false);
                        setValidity();
                    }
                    else {
                        field.$setValidity("size", true);
                        $scope.subFormContent.$invalid = false;
                        $scope.form1.$setValidity("size", true);
                        setValidity();
                    }
                }
                else {
                    if (field !== undefined) {
                        field.$setValidity("size", true);
                    }
                    $scope.subFormContent.$invalid = false;
                    $scope.form1.$setValidity("size", true);
                    setValidity();
                }
            }
            //Reset Value of PropertyRewired Question
            if (vm.state.CordellResponse.Propertydata.periodName != null && vm.state.CordellResponse.Propertydata.periodName !== 'Victorian (1840 - 1890)' && vm.state.CordellResponse.Propertydata.periodName !== 'Federation (1891 - 1913)') {
                vm.state.CordellResponse.Propertydata.propertyRewired = null;
            }
            else if (vm.state.CordellResponse.Propertydata.periodName != null && (vm.state.CordellResponse.Propertydata.periodName == 'Victorian (1840 - 1890)' || vm.state.CordellResponse.Propertydata.periodName == 'Federation (1891 - 1913)') && vm.IsEndorsement) {
                vm.state.CordellResponse.Propertydata.propertyRewired = angular.copy(endorsementState.CordellResponse.Propertydata.propertyRewired);
            }
        }

        //returns true if the property details are filled
        function validateCalculateSumInsuredButton(form) {
            if (form.autocompleteMannualAddress && form.autocompleteMannualAddress.$invalid) {
                return false;
            }
            if (form.ConstructionStyle.$invalid || form.OriginalYearBuilt.$invalid || form.ExternalWallList.$invalid || form.RoofMaterial.$invalid || form.QualityOfConstruction.$invalid || form.Storeys.$invalid || form.Address1.$invalid || (vm.state.PropertyDetail.IsManualAddress && !vm.selectedMannualAddress)) {
                return false;
            }
            else if (vm.state.CordellResponse.Propertydata.externalWallMaterial === 'RammedEarthStrawMudbrick' || vm.state.CordellResponse.Propertydata.externalWallMaterial === 'SandwichFoamEPS' ||
                vm.state.CordellResponse.Propertydata.externalWallMaterial === 'FibrecementAsbestos' || vm.state.CordellResponse.Propertydata.externalWallMaterial === 'FibrecementNoAsbestos' || vm.state.CordellResponse.Propertydata.externalWallMaterial === 'AluminiumMetal') {
                return false;
            }
            else if (vm.state.CordellResponse.Propertydata.roof === 'FibrecementAsbestos' || vm.state.CordellResponse.Propertydata.roof === 'FibrecementNoAsbestos' || vm.state.CordellResponse.Propertydata.roof === 'SandwichFoamEPS' ||
                vm.state.CordellResponse.Propertydata.roof === 'ColorBond') {
                return false;
            } 
            
            return true;
        }

        function changeInOccupation() {
            //get the occupation and set the message for the revenue.

            occupationService.get(vm.state.OtherInfo.OccupationANZSIC).then(function (response) {
                $log.log('response', response);
                vm.state.OtherInfo.OccupationMinTurnover = response.data.minTurnOver;
                vm.state.OtherInfo.OccupationMaxTurnover = response.data.maxTurnOver;
                vm.state.OtherInfo.OccupationName = response.data.occupationName;
            }, function (error) {
                $log.log('error', error);

            });
        }
        vm.resetBrokerFee = function () {
            if (vm.state.PaymentFrequency.ModeOfPayment === "Annual") {
                vm.state.PaymentFrequency.BrokerFee = 0;
                vm.state.PaymentFrequency.BrokerFeeGST = 0;
            }
        }
        vm.checkBrkerCommissionLimit = function () {
            vm.brokerCommissionLimitMessage = false;
            var regexp = /^[0-9]+(\.[0-9]{1,2})?$/;
            if (!regexp.test(vm.state.BrokerCommission.BrokerCommissionPercentage)) {
                vm.state.BrokerCommission.BrokerCommissionPercentage = null;
                vm.brokerCommissionLimitMessage = true;
            }

            if (vm.state.BrokerCommission.BrokerCommissionPercentage > vm.maxbrokerCommissionPercentage || vm.state.BrokerCommission.BrokerCommissionPercentage < vm.minbrokerCommissionPercentage)
                vm.brokerCommissionLimitMessage = true;
        }

        vm.getArray = function (number) {
            if (number == null)
                return new Array(0);
            else
                return new Array(parseInt(number));
        }

        vm.ResetRoomLaundrySection = function () {
            vm.state.CordellResponse.Propertydata.roomLaundrySizeList = null;
        }

        vm.ResetBathroomSection = function () {
            vm.state.CordellResponse.Propertydata.roomBathSizeList = null;
        }

        vm.ResetBedroomSection = function () {
            vm.state.CordellResponse.Propertydata.roomBedSizeList = null;
        }

        vm.ResetOtherRoomSection = function () {
            vm.state.CordellResponse.Propertydata.roomOtherList = null;
        }

        vm.ResetCabinPoolSection = function () {
            vm.state.CordellResponse.Propertydata.cabinSizeList = null;
        }

        vm.ResetKitchenSection = function () {
            vm.state.CordellResponse.Propertydata.kitchenSizeList = null;
        }

        vm.ResetHeatingCoolingSection = function () {
            if (vm.state.CordellResponse.Propertydata.heatingCooling_Included) {
                if (vm.IsEndorsement) {
                    vm.state.CordellResponse.Propertydata.heatingCooling_airConDuctedType = angular.copy(endorsementState.CordellResponse.Propertydata.heatingCooling_airConDuctedType);
                    vm.state.CordellResponse.Propertydata.heatingCooling_airConStandalone = angular.copy(endorsementState.CordellResponse.Propertydata.heatingCooling_airConStandalone);
                    vm.state.CordellResponse.Propertydata.heatingCooling_fireplace = angular.copy(endorsementState.CordellResponse.Propertydata.heatingCooling_fireplace);
                }
                else {
                    vm.state.CordellResponse.Propertydata.heatingCooling_airConDuctedType = vm.cordellBackupForFloorReset.heatingCooling_airConDuctedType;
                    vm.state.CordellResponse.Propertydata.heatingCooling_airConStandalone = vm.cordellBackupForFloorReset.heatingCooling_airConStandalone;
                    vm.state.CordellResponse.Propertydata.heatingCooling_fireplace = vm.cordellBackupForFloorReset.heatingCooling_fireplace;
                }
            }
            else {
                vm.state.CordellResponse.Propertydata.heatingCooling_airConDuctedType = null;
                vm.state.CordellResponse.Propertydata.heatingCooling_airConStandalone = null;
                vm.state.CordellResponse.Propertydata.heatingCooling_fireplace = null;
            }
        }

        vm.ResetSolarPowerSection = function () {
            if (vm.state.CordellResponse.Propertydata.solar_Included) {
                if (vm.IsEndorsement) {
                    vm.state.CordellResponse.Propertydata.solar_HotWater = angular.copy(endorsementState.CordellResponse.Propertydata.solar_HotWater);
                    vm.state.CordellResponse.Propertydata.solar_Electricity = angular.copy(endorsementState.CordellResponse.Propertydata.solar_Electricity);
                }
                else {
                    vm.state.CordellResponse.Propertydata.solar_HotWater = vm.cordellBackupForFloorReset.solar_HotWater;
                    vm.state.CordellResponse.Propertydata.solar_Electricity = vm.cordellBackupForFloorReset.solar_Electricity;
                }
            }
            else {
                vm.state.CordellResponse.Propertydata.solar_HotWater = null;
                vm.state.CordellResponse.Propertydata.solar_Electricity = null;
            }
        }

        vm.ResetShedsSection = function () {
            if (vm.state.CordellResponse.Propertydata.shed_Included) {
                if (vm.IsEndorsement) {
                    vm.state.CordellResponse.Propertydata.shed_Small = angular.copy(endorsementState.CordellResponse.Propertydata.shed_Small);
                    vm.state.CordellResponse.Propertydata.shed_Large = angular.copy(endorsementState.CordellResponse.Propertydata.shed_Large);
                }
                else {
                    vm.state.CordellResponse.Propertydata.shed_Small = vm.cordellBackupForFloorReset.shed_Small;
                    vm.state.CordellResponse.Propertydata.shed_Large = vm.cordellBackupForFloorReset.shed_Large;
                }
            }
            else {
                vm.state.CordellResponse.Propertydata.shed_Small = 0;
                vm.state.CordellResponse.Propertydata.shed_Large = 0;
            }
        }

        vm.ResetTennisCourtSection = function () {
            if (vm.state.CordellResponse.Propertydata.tennisCourt_Included) {
                if (vm.IsEndorsement) {
                    vm.state.CordellResponse.Propertydata.tennisCourt_Number = angular.copy(endorsementState.CordellResponse.Propertydata.tennisCourt_Number);
                    vm.state.CordellResponse.Propertydata.tennisCourt_SurfaceType = angular.copy(endorsementState.CordellResponse.Propertydata.tennisCourt_SurfaceType);
                    vm.state.CordellResponse.Propertydata.tennisCourt_Lighting = angular.copy(endorsementState.CordellResponse.Propertydata.tennisCourt_Lighting);
                }
                else {
                    vm.state.CordellResponse.Propertydata.tennisCourt_Number = vm.cordellBackupForFloorReset.tennisCourt_Number;
                    vm.state.CordellResponse.Propertydata.tennisCourt_SurfaceType = vm.cordellBackupForFloorReset.tennisCourt_SurfaceType;
                    vm.state.CordellResponse.Propertydata.tennisCourt_Lighting = vm.cordellBackupForFloorReset.tennisCourt_Lighting;
                }
            }
            else {
                vm.state.CordellResponse.Propertydata.tennisCourt_Number = 0;
                vm.state.CordellResponse.Propertydata.tennisCourt_SurfaceType = null;
                vm.state.CordellResponse.Propertydata.tennisCourt_Lighting = null;
            }
        }

        vm.ResetPoolSpaSection = function () {
            if (vm.state.CordellResponse.Propertydata.poolSpa_Included) {
                if (vm.IsEndorsement) {
                    vm.state.CordellResponse.Propertydata.poolSpa_SpaType = angular.copy(endorsementState.CordellResponse.Propertydata.poolSpa_SpaType);
                    vm.state.CordellResponse.Propertydata.poolSpa_ConcretePoolSize = angular.copy(endorsementState.CordellResponse.Propertydata.poolSpa_ConcretePoolSize);
                    vm.state.CordellResponse.Propertydata.poolSpa_FibreglassPoolSize = angular.copy(endorsementState.CordellResponse.Propertydata.poolSpa_FibreglassPoolSize);
                    vm.state.CordellResponse.Propertydata.poolSpa_VinylPoolSize = angular.copy(endorsementState.CordellResponse.Propertydata.poolSpa_VinylPoolSize);
                }
                else {
                    vm.state.CordellResponse.Propertydata.poolSpa_SpaType = vm.cordellBackupForFloorReset.poolSpa_SpaType;
                    vm.state.CordellResponse.Propertydata.poolSpa_ConcretePoolSize = vm.cordellBackupForFloorReset.poolSpa_ConcretePoolSize;
                    vm.state.CordellResponse.Propertydata.poolSpa_FibreglassPoolSize = vm.cordellBackupForFloorReset.poolSpa_FibreglassPoolSize;
                    vm.state.CordellResponse.Propertydata.poolSpa_VinylPoolSize = vm.cordellBackupForFloorReset.poolSpa_VinylPoolSize;
                }
            }
            else {
                vm.state.CordellResponse.Propertydata.poolSpa_SpaType = null;
                vm.state.CordellResponse.Propertydata.poolSpa_ConcretePoolSize = null;
                vm.state.CordellResponse.Propertydata.poolSpa_FibreglassPoolSize = null;
                vm.state.CordellResponse.Propertydata.poolSpa_VinylPoolSize = null;
            }
        };

        function chnageBrokerCommission() {
            getQuoteTransactionId = sessionStorageService.get(keyConstService.getTransactionIdWithoutSaving);
            if (vm.homeData.LOB) {
                var startDate = vm.homeData.StartDate;
                var productName = vm.homeData.LOB;
                var brokerCommissionRequestOnEdit = quotesService.getBrokerCommissiononEdit({
                    EffectiveDate: startDate,
                    ProductName: productName,
                    Productid: null,
                })
                    .then(function (result) {
                        vm.data = result.data.brokerBranchCommissionFeeVM;
                    })
            }
            if (vm.data) {
                if (vm.state.PolicyHolder.ContentCover && !vm.IsEndorsement) {
                    for (var i = 0; i < vm.data.length; i++) {
                        if (vm.data[i].coverCode === "CONTENT") {
                            vm.state.BrokerCommission.BrokerCommissionPercentage = vm.data[i].brokerCommissionFee;
                            vm.maxbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMax;
                            vm.minbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMin;
                            vm.checkBrkerCommissionLimit();
                        }
                    }
                }
            }
        }

        function ResetotherInterestedPartyText() {
            vm.state.OtherInfo.OtherInterestPartyText = null;
        }

        function getSecondaryInsuredList(DOBonEdit) {
            var caseid = caseNumberForSecondaryInsured;
            vm.state.PolicyHolder.InsuredNameList = [];
            vm.state.PolicyHolder.SecondaryInsuredsList = [];
            var secondaryInsuredListOnEdit = clientService.getSecondaryInmsured(
                caseid)
                .then(function (result) {
                    if (result) {
                        vm.data = result.data.policyHolder;
                        for (var i = 0; i < result.data.policyHolder.insuredNameList.length; i++) {

                            vm.state.PolicyHolder.InsuredNameList.push(result.data.policyHolder.insuredNameList[i]);
                            vm.state.PolicyHolder.SecondaryInsuredsList.push(result.data.policyHolder.insuredNameList[i]);
                            vm.secondaryListChange(vm.DOBFlag, DOBonEdit);
                        }

                        // for additional insured
                        //checkAdditionalInsuredInList();
                    }
                });
        }

        function continueOrNavigateBackToPackageManager() {
            vm.packageNumber = sessionStorageService.get('PackageNumberInformation');
            vm.renewalCounter = sessionStorageService.get('RenewalCounter');
            sessionStorageService.remove('IsPackageManagerNavigationMode');
            sessionStorageService.remove('PackageNumberInformation');
            sessionStorageService.remove('RenewalCounter');
            $window.location.href = webUrlConstService.getPackageInfo + sessionStorageService.getEncryption("packageNumber=" + JSON.parse(vm.packageNumber) + "&&renewalCounter=" + vm.renewalCounter);
        }

        function changeOtherInsuredName() {
            if (form1 && form1.OtherInsuredName) {
                if (form1.OtherInsuredName.value.length > 100) {
                    vm.showMessageGrt100OtherInsuredName = true;
                    form1.OtherInsuredName.value = form1.OtherInsuredName.value.substring(0, 100);
                } else {
                    vm.showMessageGrt100OtherInsuredName = false;
                }
            }
        }

        function checkAdditionalInsuredInList() {
            for (var j = 0; j < vm.state.PolicyHolder.AdditionalPolicyHolderList.length; j++) {
                var ele = vm.state.PolicyHolder.AdditionalPolicyHolderList[j];
                //if (ele.AdditionalPolicyHolder !== "Other") {
                var existInsuredName = utilityService.valueExistsInArray(ele.AdditionalPolicyHolder, vm.state.PolicyHolder.SecondaryInsuredsList);
                if (!existInsuredName) {
                    //vm.disableButtons = true;
                    var res = false;
                    //break;
                }
                else {
                    res = true;
                }
                //}
                //else {
                //    vm.otherreadonly = true;
                //}
            }
            return res;
        }

        function DefaultExcessOnAddress() {
            if ((vm.AddressState != null || vm.AddressState != undefined) && vm.AddressState.toUpperCase() === "SA" && !getParsedQuestionSetWithoutSaving) {
                vm.state.Excess.BuildingExcess1 = "500";
                vm.state.Excess.BuildingExcess2 = "750";
                vm.state.Excess.BuildingExcess3 = "1000";
                vm.state.Excess.ContentExcess1 = "500";
                vm.state.Excess.ContentExcess2 = "750";
                vm.state.Excess.ContentExcess3 = "1000";
            }
        }

            //// setting Default Content excess values based on state when content cover is enabled after disabling it
        function DefaultContentExcessOnCoverChange() {
            var addressState = vm.AddressState !== null && vm.AddressState !== undefined ? vm.AddressState.toUpperCase() : null;

            if (vm.homeData.DDlProcessTypeId !== 4 ) {
                if (vm.state.Excess.ContentExcess1 === null || vm.state.Excess.ContentExcess1 === "") {
                    vm.state.Excess.ContentExcess1 = addressState === "SA" ? keyConstService.DefautExcess1Sa : keyConstService.DefautExcess1OtherStates;
                }
                if (!vm.IsEndorsement) {
                    if (vm.state.Excess.ContentExcess2 === null || vm.state.Excess.ContentExcess2 === "") {
                        vm.state.Excess.ContentExcess2 = addressState === "SA" ? keyConstService.DefautExcess2Sa : keyConstService.DefautExcess2OtherStates;
                    }
                    if (vm.state.Excess.ContentExcess3 === null || vm.state.Excess.ContentExcess3 === "") {
                        vm.state.Excess.ContentExcess3 = addressState === "SA" ? keyConstService.DefautExcess3Sa : keyConstService.DefautExcess3OtherStates;;
                    }
                }
            }
            if (vm.endorsementVM && vm.endorsementVM.ContentExcess) {
                vm.state.Excess.ContentExcess1 = vm.endorsementVM.ContentExcess;
            }
            else if (endorsementState && endorsementState.Excess.ContentExcess1) {
                vm.state.Excess.ContentExcess1 = endorsementState.Excess.ContentExcess1;
            }
        }

        function CheckRoofANdWallValuePresentInDropDown() {
            if (vm.version < keyConstService.Version) {
                var resultWallMaterial = utilityService.valueExistsInDropDown(vm.state.CordellResponse.Propertydata.externalWallMaterial, vm.state.CordellDropDownValues.ExternalWallList);
                var resultRoofType = utilityService.valueExistsInDropDown(vm.state.CordellResponse.Propertydata.roof, vm.state.CordellDropDownValues.RoofMaterialList);
                vm.state.CordellResponse.Propertydata.externalWallMaterial = resultWallMaterial === true ? vm.state.CordellResponse.Propertydata.externalWallMaterial : null;
                vm.state.CordellResponse.Propertydata.roof = resultRoofType === true ? vm.state.CordellResponse.Propertydata.roof : null;
            }
            else {
                var resultWallMaterialV2 = utilityService.valueExistsInDropDown(vm.state.CordellResponse.Propertydata.externalWallMaterial, vm.HomeDropdownListV2.ExternalWallTypeList);
                var resultRoofTypeV2 = utilityService.valueExistsInDropDown(vm.state.CordellResponse.Propertydata.roof, vm.HomeDropdownListV2.RoofMaterialList);
                vm.state.CordellResponse.Propertydata.externalWallMaterial = resultWallMaterialV2 === true ? vm.state.CordellResponse.Propertydata.externalWallMaterial : null;
                vm.state.CordellResponse.Propertydata.roof = resultRoofTypeV2 === true ? vm.state.CordellResponse.Propertydata.roof : null;
            }
        }

        function MakeBedRoomBathRoomBlank() {
            if (vm.version >= keyConstService.Version) {
                //// as per requirement
                if (vm.state.CordellResponse.Propertydata.roomBed === 0) {
                    vm.state.CordellResponse.Propertydata.roomBed = null;
                }
                //// as per requirement
                if (vm.state.CordellResponse.Propertydata.roomBath === 0) {
                    vm.state.CordellResponse.Propertydata.roomBath = null;
                }
            }
        }

        function checkManualAddressChange(flag) {
            vm.AddressChange = true;
            if (vm.state.PropertyDetail.AddressText) {
                vm.previousAddressTextForIllion = vm.state.PropertyDetail.AddressText;
            }
            if (flag) {
                vm.previousAddressLine1ForIllion = null;
            }           
        }

        vm.getAdressEnquiryDetails = function () {
            if (vm.homeData.DDlProcessTypeId == 4 || vm.IsEndorsement == true) {
                return;
            }

            if (vm.state.PropertyDetail && vm.state.PropertyDetail.AddressValue) {
                    if (vm.AddressChange && vm.previousAddressTextForIllion && vm.previousAddressTextForIllion === vm.state.PropertyDetail.AddressText) {
                        if (vm.state.PropertyDetail.IsManualAddress) {
                            if (!vm.checkAddressLine1 && vm.state.PropertyDetail.AddressLine1) {
                                if (vm.previousAddressLine1ForIllion) {
                                    if (vm.previousAddressLine1ForIllion == vm.state.PropertyDetail.AddressLine1) {
                                        return;
                                    }
                                }
                                else {
                                    vm.previousAddressLine1ForIllion = vm.state.PropertyDetail.AddressLine1;
                                    return;
                                }
                            }
                        }
                        else {
                            return;
                        }
                    }
                        
                    vm.state.IllionClaimResponse = null;   
                    vm.state.IllionClaimResponseId = null;                                   
                    let addLine1 = null;
                    if (!vm.state.PropertyDetail.IsManualAddress) {
                        let addressTextSplit = vm.state.PropertyDetail.AddressText.split(',');
                        addLine1 = addressTextSplit[0];
                    }
                    else {
                        addLine1 = vm.state.PropertyDetail.AddressLine1;
                        vm.previousAddressLine1ForIllion = addLine1;
                    }
                    if (addLine1 === null || addLine1 === undefined) {
                        vm.checkAddressLine1 = true;
                        return;
                    }
                    vm.checkAddressLine1 = false;
                    let addressSplitSate = vm.state.PropertyDetail.AddressValue.split('|');
                    let addState = addressSplitSate[0];
                    let addPostcode = addressSplitSate[1];
                    let addSuburb = addressSplitSate[2];
                    var illionAddressEnquiryRequestVM = {
                        "AddressLine1": addLine1,
                        "Suburb": addSuburb,
                        "State": addState,
                        "Postcode": addPostcode,                        
                        "AddressText": addLine1 + ", " + addSuburb + " " + addState + " " + addPostcode
                    };
                    utilityService.getAddressEnquiry(illionAddressEnquiryRequestVM).then(function (data) {
                        vm.state.IllionClaimResponseId = data.data;                                               
                    });
                }
        }        
    }
})();;
(function () {
    "use strict";
    angular
        .module("appUI")
        .controller("motorProductCtrl", [
            "$rootScope",
            "$q",
            "$window",
            "$timeout",
            "$log",
            "responsiveService",
            "quotesService",
            "sessionStorageService",
            "dateService",
            "keyConstService",
            "webUrlConstService",
            "nvicMotorService",
            "messageConstService",
            "$http",
            "apiUrlConstService",
            "utilityService",
            "clientService",
            "$scope",
            "moment",
            motorProductCtrl
        ]);

    function motorProductCtrl(
        $rootScope,
        $q,
        $window,
        $timeout,
        $log,
        responsiveService,
        quotesService,
        sessionStorageService,
        dateService,
        keyConstService,
        webUrlConstService,
        nvicMotorService,
        messageConstService,
        $http,
        apiUrlConstService,
        utilityService,
        clientService,
        $scope,
        moment
    ) {
        var vm = this;
        var brokerData;
        var caseId = "0";
        var transactionId = 0;
        var brokerdetail;
        var objEffectiveDate = null;
        var objEffectiveYear = null;
        vm.ExcessOptionArr = [];

        //methods
        vm.init = init;
        vm.back = back;
        vm.discard = discard;
        vm.previousStep = previousStep;
        vm.nextStep = nextStep;
        vm.saveQuote = saveQuote;
        vm.getQuote = getQuote;
        vm.getQuoteV2 = getQuoteV2;
        vm.addClaim = addClaim;
        vm.removeClaim = removeClaim;
        vm.readonly = false;
        vm.AdditionalPolicyHolderListLength = 1;
        vm.removeSpecifiedItems = removeSpecifiedItems;
        vm.addSpecifiedItems = addSpecifiedItems;
        vm.nextPremium = nextPremium;
        vm.regoLookup = regoLookup;
        vm.dateOfBirthFlag = false;
        vm.isDisabled = false;
        vm.validateDOB = validateDOB;
        vm.AdditionalDriversList = [];
        var isNewEditTransaction = false;
        var ExpirationDate = null;
        vm.showBrokerFee = false;
        var endorsementState = null;
        vm.removeModification = removeNonManufactureModification;
        vm.addModification = addNonManufactureModification;
        vm.removeAdditionalPolicyHolder = removeAdditionalPolicyHolder;
        vm.addAdditionalPolicyHolder = addAdditionalPolicyHolder;
        vm.removeAdditionalDriver = removeAdditionalDriver;
        vm.addAdditionalDriver = addAdditionalDriver;
        vm.removeNote = removeNote;
        vm.addNote = addNote;
        vm.changeNotesPrintable = changeNotesPrintable;
        vm.changeInMainDrivesClaimsNumber = changeInMainDrivesClaimsNumber;
        vm.changeInAddiDriverClaimsNumber = changeInAddiDriverClaimsNumber;
        vm.secondaryListChange = secondaryListChange;
        vm.IsAdditionalButtonDisabled = IsAdditionalButtonDisabled;
        vm.addAdditonalCoverages = addAdditonalCoverages;
        vm.stateChange = stateChange;
        vm.rangeYear = rangeYear;
        vm.transactionStatus = null;
        vm.vehicleInsureVehicleForChange = vehicleInsureVehicleForChange;
        vm.isNonManufactureModificationChanged = isNonManufactureModificationChanged;
        vm.motorQuestion;
        vm.isAdditionalPolicyHolderChange = isAdditionalPolicyHolderChange;
        vm.isEverInsuranceDeclinedChange = isEverInsuranceDeclinedChange;
        vm.isClaimDeclinedIn3YearsChange = isClaimDeclinedIn3YearsChange;
        vm.isAdditionalDriverChange = isAdditionalDriverChange;
        vm.changeInMainDrivesLicenseSuspensionCancellationNumber = changeInMainDrivesLicenseSuspensionCancellationNumber;
        vm.changeInAddiDriverLicenseSuspensionCancellationNumber = changeInAddiDriverLicenseSuspensionCancellationNumber;
        vm.execssChange = execssChange;
        vm.querySearch = querySearch;
        vm.mannualSearchQuery = mannualSearchQuery;
        vm.checkValidManualAddress = checkValidManualAddress;
        vm.addressMapped = addressMapped;
        vm.ResetHasInsuredInLast3YearsSection = ResetHasInsuredInLast3YearsSection;
        vm.checkIsSmallBusinessStampDutyEligible = checkIsSmallBusinessStampDutyEligible;
        vm.changeBrokerCommission = changeBrokerCommission;
        vm.validateYear = validateYear;
        vm.resetAddressData = resetAddressData;
        vm.state;
        var quotecaseId;
        vm.resetAllVehicleInfo = resetAllVehicleInfo;
        vm.validAgreedValue = validAgreedValue;
        vm.decimalConfig = {
            sbMin: 0,
            sbMax: keyConstService.AmountMax999999999,
            sbPrecision: 2,
            sbMaxPrecision: 2
        };
        vm.EffectiveDate = null;
        vm.StartDate = null;
        vm.endorsementVM = null;
        vm.IsEndorsement = false;
        vm.IsEndorsementPolicyEffectiveDate = false;
        vm.endorsementPolicyTransactionId = null;
        vm.showDeclineMessageVehicleUsedFor = false;
        vm.nswState = null;
        vm.isManualAddressForNsw = null;
        vm.VehicleUsedFor = null;
        vm.Find = false;
        vm.editStateChange = true;
        vm.resetAllVehicleInfoWhenNoDataFound = resetAllVehicleInfoWhenNoDataFound;
        vm.resetAllVehicleInfoIncludingRegistration = resetAllVehicleInfoIncludingRegistration;
        vm.resetOtherInformationForInterestedParty = resetOtherInformationForInterestedParty;
        vm.resetOtherInformationForPreviousInsurer = resetOtherInformationForPreviousInsurer;
        vm.resetExistingDamageToTheVehicleSection = resetExistingDamageToTheVehicleSection; //reset Question of Version 2.0 WU section
        vm.resetInsurancePolicyCancelledInTheLast3YearsSection = resetInsurancePolicyCancelledInTheLast3YearsSection; //reset Question of Version 2.0 WU section
        vm.resetPolicyHolderCurrentlyHoldInsuranceSection = resetPolicyHolderCurrentlyHoldInsuranceSection; //reset Question of Version 2.0 Other Information section
        vm.getSecondaryInsuredList = getSecondaryInsuredList;
        var caseNumberForSecondaryInsured;
        vm.isManualRego = false;
        vm.MotorMake = null;
        vm.MotorFamily = null;
        vm.NonRego = NonRego;
        vm.MotorYears = null;
        vm.MotorYears = GetManufactureYears;
        vm.VehicleColour = null;
        vm.SelectedVehicleColour = '';
        vm.SelectedMotorYear = '';
        vm.GetMotormake = GetMotormake;
        vm.SelectedMotorMake = '';
        vm.SelectedMotorModel = '';
        vm.GetMotorModel = GetMotorModel;
        vm.GetMotorVehicleList = GetMotorVehicleList;
        vm.GetMotorVehicleStyle = GetMotorVehicleStyle;
        vm.GetMotorVehicleTransmission = GetMotorVehicleTransmission;
        vm.GetMotorVehicleSize = GetMotorVehicleSize;
        vm.MotorStyles = null;
        vm.MotorTransmissions = null;
        vm.MotorSizes = null;
        vm.SelectedMotorStyle = '';
        vm.SelectedMotorTransmission = '';
        vm.SelectedMotorSize = '';
        vm.SelectedMotorListitem = null;
        vm.GetMotorDetails = GetMotorDetails;
        var getQuestionSetWithoutSaving;
        var getTransactionIdWithoutSaving;
        var getParsedQuestionSetWithoutSaving;
        var getQuoteTransactionId;
        var getQuestionSetWithoutSavingData;
        var isManualRegoEnabled;
        vm.coverType = false;
        vm.validDOBOtherInsurer = true;
        vm.NVIcNotFound = false;
        vm.EnableDisableButton = EnableDisableButton;
        vm.policyHolderNameExists = policyHolderNameExists;
        vm.ExcessValueFlag = false;
        vm.brokerFeeChange = brokerFeeChange;
        vm.setDriverDL = true;
        vm.brokerManagedPayment = 0;
        vm.brokerbranchcheck;
        vm.disableButtons = false;
        vm.StartDateCalRoadside = null;
        vm.continueOrNavigateBackToPackageManager = continueOrNavigateBackToPackageManager;
        vm.showMessageGrt100OtherInsuredName = false;
        vm.changeOtherInsuredName = changeOtherInsuredName;
        vm.addOtherInsured = addOtherInsured;
        vm.otherInsuredAddress = null;
        vm.storeOtherInsuredAddress = storeOtherInsuredAddress;
        vm.resetAddress = resetAddress;
        vm.cancelOtherInsured = cancelOtherInsured;
        vm.checkSameAsPrimary = checkSameAsPrimary;
        vm.ClientDetail = {};
        vm.otherreadonly = false;
        vm.OtherSubmitEnabled = OtherSubmitEnabled;
        vm.OtherInsuredName = null;
        vm.DateOfBirthApp = null;
        vm.help_text_for_Endorsement = keyConstService.help_text_for_Endorsement;
        vm.tempPrimaryInsured;
        vm.tempAdditonalPolicyHolders;
        vm.IsOpenAddInsuredPopup = false;
        vm.AdditionalPolicyHolderIndex;
        vm.IsMotorGlassExcessEffective = false;
        vm.tempExcessOption = null;
        vm.tempState = null;
        var qStartDate = null;
        var qEffectiveDate = null;
        vm.isEffectiveDateChange = false;
        vm.isRenewalEffective = false;
        vm.defaultExcessFlag = true;
        vm.qPreviousDate = null;
        vm.illionClaimResponse = null;
        vm.AddressChange = false;
        vm.checkManualAddressChange = checkManualAddressChange;
        vm.previousAddressTextForIllion = null;
        vm.previousAddressLine1ForIllion = null;
        vm.checkAddressLine1 = false;

        function EnableDisableButton(form1) {

            if ((vm.state.OvernightParkedAddress.AddressText=== null && !vm.state.OvernightParkedAddress.IsManualAddress) ||
                form1.$invalid ||
                vm.brokerCommissionLimitMessage ||
                vm.Find == false ||
                vm.setDriverDL == false ||
                !vm.validDOBOtherInsurer ||
                vm.NVIcNotFound == true ||
                vm.ExcessValueFlag == true ||
                !vm.policyHolderNameExists() || !checkAdditionalInsuredInList()) {
                return true;
            } else {
                return false;
            }
        }

        function policyHolderNameExists() {
            return (vm.state.Insured.InsuredNameList !== undefined ? (vm.state.Insured.InsuredNameList.findIndex(record => record.value === vm.state.Insured.InsuredName) === -1 ? false : true) : false);
        }

        function GetVehiclecolour() {
            var colour = JSON.parse(sessionStorageService.get(keyConstService.Colour) === "" ? null : sessionStorageService.get(keyConstService.Colour));
            if (colour) {
                vm.SelectedVehicleColour = colour;
                sessionStorageService.remove(keyConstService.Colour);
            }
        }

        function PolicyHolderHoldInsuranceNullOnCopyQuote() {
            //retriving version of the quote from which copy quote is done and changing value of question PolicyHolderHoldInsurance
            var copyQuoteOldTransactionId = sessionStorageService.get(keyConstService.CopyQuoteOldTransactionId)
            if (copyQuoteOldTransactionId != null) {
                var copyQuoteOldTransactionIdParsed = JSON.parse(copyQuoteOldTransactionId);
            }
            if (copyQuoteOldTransactionIdParsed) {
                quotesService.getUiVersion(copyQuoteOldTransactionIdParsed).then(function (result) {
                    if (result != null && result.status && result.data) {
                        var oldUIVersion = result.data;
                        //Default value changed for the question from false to null for version 2 on copy quote from version 1
                        if (oldUIVersion && oldUIVersion < keyConstService.Version) {
                            if (vm.state.OtherInformation.PolicyHolderHoldInsurance === false) {
                                vm.state.OtherInformation.PolicyHolderHoldInsurance = null;
                            }
                        }
                    }
                }, function (error) {
                    toastr.error(messageConstService.errServiceUnavailable);
                    $log.error('error', error);
                });
            }
        }

        function init(data) {
            var isPM = sessionStorageService.get('IsPackageManagerNavigationMode');
            var renewalCounter = sessionStorageService.get('RenewalCounter');
            if (isPM === "true" || renewalCounter !== null) {
                vm.showManagePkg = true;
            }
            ////Populate VehicleDropdown list 
            GetDDlVehicleColours();
            //// get Excess effective date
            var excessCheckDate = new Date(data.MotorGlassExcessEffectiveDate);

            vm.PolicyNumber = data.PolicyNumber;
            var getEffectiveDate = JSON.parse(sessionStorageService.get(keyConstService.newBusinessCaseData));
            if (getEffectiveDate) {
                vm.StartDateCalRoadside = new Date(getEffectiveDate.data.EffectiveDate);
            }
            else {
                vm.StartDateCalRoadside = data.EffectiveDate;
            }

            vm.brokerbranchcheck = sessionStorageService.get('IsBranchViewOnly') !== "false";
            if (data.QuoteCase) {
                vm.Casenumber = data.QuoteCase.CaseNumber;
            }
            if (data.IsEndorsement) {
                vm.IsEndorsement = data.IsEndorsement;
            }
            if (data.MotorQuestion && data.MotorQuestion.Payment.BrokerManagedPayment !== null) {
                vm.brokerManagedPayment = data.MotorQuestion.Payment.BrokerManagedPayment;
            }
            else {
                vm.brokerManagedPayment = data.PackageDetail.BrokerManagedPayment;
            }

            sessionStorageService.set(keyConstService.effectiveDateInEdit, data.EffectiveDate);
            sessionStorage.removeItem(keyConstService.Home);
            sessionStorage.setItem(keyConstService.Motor, 'MotorProductController');
            if (sessionStorageService.get(keyConstService.sessionStorageState) == "false") {
                sessionStorageService.remove(keyConstService.getTransactionIdWithoutSaving);
                sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
                sessionStorageService.remove(keyConstService.resetNonRegoData);
            }
            var NVICValue = JSON.parse(sessionStorageService.get(keyConstService.NVIcNotFound));
            if (NVICValue === true) {
                vm.NVIcNotFound = true;
                sessionStorageService.set(keyConstService.NVIcNotFound, vm.NVIcNotFound);
            }
            //check if the IsValidQuestionsBack exists already
            var IsValidQuestionsBack = JSON.parse(sessionStorageService.get(keyConstService.IsValidQuestionsBack));
            //if (!IsValidQuestionsBack) {
            //    $window.location.href = webUrlConstService.newBusinessIndex;
            //    sessionStorageService.remove(keyConstService.IsValidQuestionsBack);

            //}
            vm.comprehensiveType = true;
            vm.comprehensivePlusType = true;
            vm.endorsementVM = JSON.parse(sessionStorageService.get(keyConstService.endorsementRequestVM));
            if (vm.IsEndorsement) {
                vm.showBrokerFee = false;
            }
            else {
                vm.showBrokerFee = true;
            }
            if (data) {
                vm.MotorDropDownListV2 = data.MotorDropDownListV2;
                vm.version = data.Version;
                if (data.QuoteCase != null) {
                    //Id kept only for endorsement case.
                    vm.endorsementPolicyTransactionId = data.QuoteCase.PolicyTransactionId;
                }
                vm.vehicleAgeToHideRoadsideAssistance = data.VehicleAgeToHideRoadsideAssistance;
                vm.allowedDriverLicenseYear = data.AllowedDriverLicenseYear;
            }
            vm.initialData = data;
            vm.QuoteTransactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
            if (data.QuoteCase != null || data.QuoteTransactionId !== null) {
                vm.CaseNumber = data.QuoteCase.CaseNumber;
                vm.TransactionId = data.QuoteTransactionId;
            }

            var newBusinessCaseData = sessionStorageService.get(keyConstService.newBusinessCaseData);
            var newBusinessCaseDetail = JSON.parse(newBusinessCaseData);

            if (data.MotorDropdownListData) {
                vm.ready = true;
                GetVehiclecolour();
                caseId = sessionStorageService.get(keyConstService.caseId);
                vm.CaseNumber = JSON.parse(sessionStorageService.get('caseNumber'));
                vm.Casenumber = vm.CaseNumber;
                vm.CaseID = caseId;
                brokerData = sessionStorageService.get(keyConstService.brokerData);
                newBusinessCaseData = sessionStorageService.get(keyConstService.newBusinessCaseData);
                brokerdetail = JSON.parse(brokerData);
                newBusinessCaseDetail = JSON.parse(newBusinessCaseData);


                if (!vm.state) {
                    vm.state = quotesService.loadQuoteData(null, 2, data.MotorDropdownListData);
                    vm.state.currentStep = 1;
                    $log.log("getting state from quoteService. State:", vm.state);
                } else {
                    vm.state = JSON.parse(vm.state);
                    $log.log("getting state from sessionStorage. State:", vm.state);
                }
                if (vm.state !== null && vm.state.OtherInformation !== null) {
                    if (vm.state.OtherInformation.VehicleUsedFor === "RideShare" || vm.state.OtherInformation.VehicleUsedFor === "ForHireOrTaxi") {
                        vm.showDeclineMessageVehicleUsedFor = true;
                    }
                }

                newBusinessCaseData = sessionStorageService.get(keyConstService.newBusinessCaseData);
                newBusinessCaseDetail = JSON.parse(newBusinessCaseData);
                var startDate = newBusinessCaseDetail.data.EffectiveDate;
                ////Check Date for Motor glass Effective Date
                qStartDate = new Date(startDate);
                if (qStartDate >= excessCheckDate) {
                    vm.IsMotorGlassExcessEffective = true;
                }
                var productId = newBusinessCaseDetail.data.ProductId;
                sessionStorageService.set(keyConstService.findRegoData, vm.Find);
                getQuoteTransactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
                vm.getTransactionIdWithoutSaving = JSON.parse(sessionStorageService.get(keyConstService.getTransactionIdWithoutSaving));
                getQuestionSetWithoutSaving = sessionStorageService.get(keyConstService.getQuestionSetWithoutSaving);
                getParsedQuestionSetWithoutSaving = JSON.parse(getQuestionSetWithoutSaving);
                if (sessionStorageService.get(keyConstService.resetNonRegoData)) {
                    vm.qPreviousDate = sessionStorageService.get(keyConstService.OldEffectiveDate);
                    if (vm.qPreviousDate !== null) {
                        vm.qPreviousDate = JSON.parse(vm.qPreviousDate);
                        vm.qPreviousDate = new Date(vm.qPreviousDate.data.EffectiveDate);
                    }
                    if (vm.qPreviousDate >= excessCheckDate) {
                        vm.qPreviousDateFlag = true;
                    }
                }
                if (getParsedQuestionSetWithoutSaving) {
                    if (getQuoteTransactionId === vm.getTransactionIdWithoutSaving && sessionStorageService.get(keyConstService.sessionStorageState)) {
                        vm.state = getParsedQuestionSetWithoutSaving;
                        if (vm.state !== null && vm.state.OtherInformation !== null) {
                            if (vm.state.OtherInformation.VehicleUsedFor === "RideShare" || vm.state.OtherInformation.VehicleUsedFor === "ForHireOrTaxi") {
                                vm.showDeclineMessageVehicleUsedFor = true;
                            }
                        }

                        if (getParsedQuestionSetWithoutSaving.OvernightParkedAddress.IsManualAddress === true) {
                            vm.selectedMannualAddress = getParsedQuestionSetWithoutSaving.OvernightParkedAddress.AddressText;
                        }
                        else if (getParsedQuestionSetWithoutSaving.OvernightParkedAddress.IsManualAddress === false) {
                            vm.selectedAddress = getParsedQuestionSetWithoutSaving.OvernightParkedAddress.AddressText;
                        }
                        vm.isManualRegoEnabled = sessionStorageService.get(keyConstService.isManualRegoEnabled);
                        if (vm.isManualRegoEnabled === "true") {
                            if (!sessionStorageService.get(keyConstService.resetNonRegoData)) {
                                GetValuePopulated(getParsedQuestionSetWithoutSaving.Vehicle);
                            }
                            else {
                                vm.isManualRego = true;
                                vm.SelectedMotorMake = '';
                                vm.SelectedMotorModel = '';
                                vm.SelectedMotorListitem = '';
                                vm.SelectedMotorYear = '';
                                vm.state.Coverages.InsureVehicleForGlassMarketValueBAV = null;
                                vm.state.Coverages.InsureVehicleForGlassMarketValueAAV = null;
                                vm.Motorvehiclelist = null;
                                GetManufactureYears();
                                vm.state.Vehicle.NVICValue = null;
                                vm.state.Vehicle.ManufactureYear = null;
                                vm.state.Vehicle.MotorGlassDetailId = null;
                                vm.state.Vehicle.Make = null;
                                vm.state.Vehicle.Model = null;
                                vm.state.Vehicle.Transmission = null;
                                vm.state.Vehicle.Style = null;
                                vm.state.Vehicle.Size = null;
                                vm.state.Vehicle.Variant = null;
                                vm.state.Vehicle.Series = null;
                                vm.state.Vehicle.Engine = null;
                                vm.state.Vehicle.Cylinders = null;
                                vm.state.Vehicle.VehicleDescription = null;
                                vm.state.Vehicle.BodyType = null;
                                vm.state.Vehicle.IsNonRegoManual = vm.isManualRego;
                                if (vm.IsMotorGlassExcessEffective) {
                                    var qAddressState = vm.state.OvernightParkedAddress.AddressValue.split('|');
                                    vm.tempState = vm.state.Vehicle.State === null || vm.state.Vehicle.State === "" ? qAddressState[0] : vm.state.Vehicle.State;
                                    vm.setDefaultExcessToNull(vm.tempState, null);
                                }
                                toastr.error(messageConstService.errNonRegoDetails);
                            }
                        }
                        else {
                            if (sessionStorageService.get(keyConstService.resetNonRegoData)) {
                                vm.state.Vehicle.ManufactureYear = null;
                                vm.state.Vehicle.Make = null;
                                vm.state.Vehicle.Model = null;
                                vm.state.Vehicle.NVICValue = null;
                                vm.state.Vehicle.VehicleDescription = null;
                                vm.SelectedVehicleColour = null;
                                vm.state.Coverages.InsureVehicleForGlassMarketValueBAV = null;
                                vm.state.Coverages.InsureVehicleForGlassMarketValueAAV = null;
                                vm.Find = false;
                                sessionStorageService.set(keyConstService.findRegoData, vm.Find);
                                if (vm.IsMotorGlassExcessEffective) {
                                    var qAddressState = vm.state.OvernightParkedAddress.AddressValue.split('|');
                                    vm.tempState = vm.state.Vehicle.State === null || vm.state.Vehicle.State === "" ? qAddressState[0] : vm.state.Vehicle.State;
                                    vm.setDefaultExcessToNull(vm.tempState, null);
                                }
                                toastr.error(messageConstService.errNonRegoDetails);
                            }
                        }
                    }
                    // checking for duplicate excess in case of previous/next
                    vm.isDuplicateExcess();
                }


                if (sessionStorageService.get(keyConstService.findRegoData)) {
                    vm.findRegoDetails = JSON.parse(sessionStorageService.get(keyConstService.findRegoData));
                    if (vm.findRegoDetails === false) {
                        vm.Find = false;
                        sessionStorageService.set(keyConstService.findRegoData, vm.Find)
                    }
                    else {
                        vm.Find = true;
                        sessionStorageService.set(keyConstService.findRegoData, vm.Find)
                    }
                }

                if (vm.state.Vehicle.NVICValue && vm.state.Vehicle.NVICValue !== 'NA') {
                    vm.Find = true;
                }
                else {
                    vm.Find = false;
                }

                //if (sessionStorageService.get(keyConstService.setDriverDL)) {
                //    vm.setDriverDL = JSON.parse(sessionStorageService.get(keyConstService.setDriverDL));
                //    if (getParsedQuestionSetWithoutSaving) {
                //        if (getQuoteTransactionId == vm.getTransactionIdWithoutSaving && sessionStorageService.get(keyConstService.sessionStorageState)) {
                //            if (vm.setDriverDL == false) {
                //                toastr.error(messageConstService.errInvalidDLYear);
                //            }
                //        }
                //    }
                //}       

                var brokerCommissionRequest = quotesService.getBrokerCommission({
                    EffectiveDate: startDate,
                    ProductId: productId,
                    ProductName: null,
                })
                    .then(function (result) {
                        vm.data = result.data.brokerBranchCommissionFeeVM;
                        if (vm.data) {
                            for (var i = 0; i < vm.data.length; i++) {
                                if (vm.data[i].coverCode === "COMPREHENSIVE") {
                                    if (!getParsedQuestionSetWithoutSaving) {
                                        vm.state.BrokerCommission.BrokerCommissionPercentage = vm.data[i].brokerCommissionFee;
                                    }
                                    vm.maxbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMax;
                                    vm.minbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMin;
                                    vm.checkBrkerCommissionLimit();
                                }
                            }
                        }
                    })


                vm.state.ExistingPackage = newBusinessCaseDetail.data.ExistingPackage;
                if (vm.state.ExistingPackage) {
                    vm.state.OtherInformation.IsAddMorePolicyToPackage = true;
                }
                quotesService.getInsuredNameList(caseId).then(function (ResponseData) {
                    vm.motorData = ResponseData.data;
                    if (ResponseData.data !== null) {
                        vm.state.Insured.InsuredNameList = ResponseData.data.policyHolder.insuredNameList;
                        vm.state.Insured.InsuredClientId = ResponseData.data.policyHolder.insuredClientId;
                        vm.ClientDetail = ResponseData.data.clientDetail;
                        vm.addSecondaryClient = ResponseData.data.clientDetail.secondaryInsuredClientVM;
                        vm.otherInsuredAddress = ResponseData.data.clientDetail.addressLogVM;
                        vm.PropertyDetail = ResponseData.data.buildingInfo;
                        if (getQuoteTransactionId === vm.getTransactionIdWithoutSaving) {
                            if (vm.state.Insured.InsuredName === "Other") {
                                getQuestionSetWithoutSavingData = JSON.parse(JSON.parse(sessionStorageService.get(getQuestionSetWithoutSaving)));
                                vm.state.Insured.InsuredName = vm.getQuestionSetWithoutSavingData.Insured.InsuredName;
                            }
                        }
                        else {
                            vm.state.Insured.InsuredName = ResponseData.data.policyHolder.insuredName;
                        }
                        vm.state.Drivers.MainDriver.Name = ResponseData.data.policyHolder.insuredName;

                        if (!getParsedQuestionSetWithoutSaving) {
                            if (ResponseData.data.buildingInfo.isManualAddress) {
                                vm.state.OvernightParkedAddress.IsManualAddress = true;
                                vm.selectedMannualAddress = ResponseData.data.buildingInfo.addressText;
                                vm.state.OvernightParkedAddress.AddressText = vm.selectedMannualAddress;
                                vm.state.OvernightParkedAddress.AddressLine1 = ResponseData.data.buildingInfo.addressLine1;
                            }
                            else {
                                vm.state.OvernightParkedAddress.IsManualAddress = false;
                                vm.selectedAddress = ResponseData.data.buildingInfo.addressText;
                                vm.state.OvernightParkedAddress.AddressText = vm.selectedAddress;
                            }
                            vm.state.OvernightParkedAddress.AddressState = ResponseData.data.buildingInfo.addressState;
                            vm.state.OvernightParkedAddress.Postcode = ResponseData.data.buildingInfo.postcode;
                            vm.state.OvernightParkedAddress.AddressValue = ResponseData.data.buildingInfo.addressValue;
                            vm.state.OvernightParkedAddress.Gnaf = ResponseData.data.buildingInfo.gnaf;
                        }

                        if (!getParsedQuestionSetWithoutSaving) {
                            if (ResponseData.data.buildingInfo.addressState) {
                                if (!vm.IsMotorGlassExcessEffective) {
                                    if (!vm.qPreviousDateFlag) {
                                        vm.stateChange(ResponseData.data.buildingInfo.addressState);
                                    }
                                    else {
                                        vm.setDefaultExcessToNull(ResponseData.data.buildingInfo.addressState, null);
                                    }
                                }
                                else {
                                    if (vm.state.Vehicle.MotorGlassDetailId === null || vm.state.Vehicle.MotorGlassDetailId === "") {
                                        vm.setDefaultExcessToNull(ResponseData.data.buildingInfo.addressState, null);
                                    }
                                }
                            }
                            else {
                                var splitState = ResponseData.data.buildingInfo.addressValue.split('|');
                                vm.nswState = splitState[0];
                                vm.AddressState = vm.nswState;
                                vm.isManualAddressForNsw = ResponseData.data.buildingInfo.isManualAddress;
                                if (!vm.IsMotorGlassExcessEffective) {
                                    if (!vm.qPreviousDateFlag) {
                                        vm.stateChange(splitState[0]);
                                    }
                                    else {
                                        vm.setDefaultExcessToNull(splitState[0], null);
                                    }
                                }
                                else {
                                    if (vm.state.Vehicle.MotorGlassDetailId === null || vm.state.Vehicle.MotorGlassDetailId === "") {
                                        vm.setDefaultExcessToNull(splitState[0], null);
                                    }
                                }
                            }
                        }
                        else {

                            if (vm.state.OvernightParkedAddress.AddressValue && vm.state.OvernightParkedAddress.AddressState) {
                                vm.nswState = vm.state.OvernightParkedAddress.AddressState;
                                if (!vm.IsMotorGlassExcessEffective) {
                                    if (!vm.qPreviousDateFlag) {
                                        vm.stateChange(vm.state.OvernightParkedAddress.AddressState);
                                    }
                                    else {
                                        vm.setDefaultExcessToNull(vm.state.OvernightParkedAddress.AddressState, null);
                                    }
                                }
                                else {
                                    if (vm.state.Vehicle.MotorGlassDetailId === null || vm.state.Vehicle.MotorGlassDetailId === "") {
                                        vm.setDefaultExcessToNull(vm.state.OvernightParkedAddress.AddressState, null);
                                    }
                                }
                            }
                            else if (vm.state.OvernightParkedAddress.AddressValue && !vm.state.OvernightParkedAddress.AddressState) {
                                var splitState = vm.state.OvernightParkedAddress.AddressValue.split('|');
                                vm.nswState = splitState[0];
                                if (!vm.IsMotorGlassExcessEffective) {
                                    if (!vm.qPreviousDateFlag) {
                                        vm.stateChange(splitState[0]);
                                    }
                                    else {
                                        vm.setDefaultExcessToNull(splitState[0], null);
                                    }
                                }
                                else {
                                    if (vm.state.Vehicle.MotorGlassDetailId === null || vm.state.Vehicle.MotorGlassDetailId === "") {
                                        vm.setDefaultExcessToNull(splitState[0], null);
                                    }
                                }
                            }
                        }

                        vm.tempPrimaryInsured = vm.state.Insured.InsuredName;
                        vm.tempAdditonalPolicyHolders = angular.copy(vm.state.Insured.AdditionalPolicyHolderList);

                    }

                    if (ResponseData.data.buildingInfo.isManualAddress && getQuoteTransactionId !== vm.getTransactionIdWithoutSaving) {
                        vm.selectedMannualAddress = ResponseData.data.buildingInfo.addressText;
                        vm.state.OvernightParkedAddress.AddressLine1 = ResponseData.data.buildingInfo.addressLine1;
                        vm.state.OvernightParkedAddress.IsManualAddress = true;
                    }

                    //claims in last 3 years validation on previous next

                    var newDate = new Date(ResponseData.data.policyHolder.dateOfBirthApp);
                    if (getQuoteTransactionId === vm.getTransactionIdWithoutSaving) {
                        vm.state.Drivers.MainDriver.DOB = getParsedQuestionSetWithoutSaving.Drivers.MainDriver.DOB;
                    }
                    else {
                        vm.state.Insured.DateOfBirth = dateService.convertDatetoMMDDYYYFormat(ResponseData.data.policyHolder.dateOfBirthApp);
                        vm.state.Insured.DateOfBirthApp = newDate;
                        vm.state.Drivers.MainDriver.DOB = newDate;
                    }
                    for (var i = 0; i < ResponseData.data.policyHolder.secondaryInsuredsList.length; i++) {
                        if (ResponseData.data.policyHolder.secondaryInsuredsList[i].value === vm.state.Insured.InsuredName && ResponseData.data.policyHolder.secondaryInsuredsList[i].id === vm.state.Insured.InsuredClientId) {
                            var index = ResponseData.data.policyHolder.secondaryInsuredsList.indexOf(ResponseData.data.policyHolder.secondaryInsuredsList[i]);
                            ResponseData.data.policyHolder.secondaryInsuredsList.splice(index, 1);
                            vm.state.Insured.SecondaryInsuredsList = ResponseData.data.policyHolder.secondaryInsuredsList;
                        }
                    }
                    if (vm.state.IllionClaimResponseId === null || vm.state.IllionClaimResponseId === undefined) {
                        vm.getAdressEnquiryDetails();
                    }
                    // Commentd by Ankur as per us 6829
                    //var secondaryInsuredOtherPos = vm.state.Insured.SecondaryInsuredsList.findIndex(p => p.value === "Other");
                    //if (secondaryInsuredOtherPos !== -1) {
                    //    vm.state.Insured.SecondaryInsuredsList.splice(secondaryInsuredOtherPos, 1);
                    //}
                });

                vm.state.Broker.BrokerFirstName = brokerdetail.firstName;
                vm.state.Broker.BrokerLastName = brokerdetail.lastName;
                vm.state.Broker.BrokerEmail = brokerdetail.email;
                vm.state.Broker.BrokerPhoneNumber = brokerdetail.phoneNumber;
                vm.state.Broker.BrokerFaxNumber = brokerdetail.fax;
                this.myDate = new Date();
                var Predicate = function (date) {
                    var day = date.getDay();
                    return day === 0 || day === 6;
                };
                vm.changeInMainDrivesClaimsNumber();
                vm.state.Vehicle.VinPlate = "plate";

                //get the current date's year
                vm.currentYear = (new Date()).getFullYear();

                // removing questionset from session for valid newbusiness quote
                if (getParsedQuestionSetWithoutSaving) {
                    sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
                }
                validateIsManfactureYearMore15(vm.state.Vehicle.ManufactureYear, vm.vehicleAgeToHideRoadsideAssistance);
                if (vm.state.Insured.AdditionalPolicyHolderList.length !== 0 && vm.state.Insured.AdditionalPolicyHolderList[0].OtherDateOfBirthApp !== null) {
                    for (var i = 0; i < vm.state.Insured.AdditionalPolicyHolderList.length; i++) {
                        if (vm.state.Insured.AdditionalPolicyHolderList[i].AdditionalPolicyHolder === "Other") {
                            var dateofBirth = vm.state.Insured.AdditionalPolicyHolderList[i].OtherDateOfBirthApp;
                            var response = dateService.validateBirthDDMMYYYY(dateofBirth, 115);
                            if (!response.isValid) {
                                vm.validDOBOtherInsurer = false;
                                vm.message = response.errorMsg;
                                break;
                            }
                            else {
                                vm.validDOBOtherInsurer = true;
                            }
                        }
                        else {
                            continue;
                        }
                    }
                    if (!vm.validDOBOtherInsurer && vm.message === messageConstService.errFutureDateNotAllowed) {
                        toastr.warning(messageConstService.errFutureDatedForAddHolder);
                    }
                    else if (!vm.validDOBOtherInsurer && vm.message === messageConstService.errDateNotAllowed) {
                        toastr.warning(messageConstService.errDateNotAllowed);
                    }
                }

            }

            else {
                //Edit

                vm.dataState = data;
                vm.state = data.MotorQuestion;
                vm.previousAddressLine1ForIllion = vm.state.OvernightParkedAddress.AddressLine1;
                vm.SelectedVehicleColour = vm.state.Vehicle.Colour;
                GetVehiclecolour();
                caseNumberForSecondaryInsured = data.QuoteCase.Id;
                vm.editStateChange = false;
                if (data.QuoteNumber === null && !data.IsEndorsement && vm.state.Vehicle.NVICValue && vm.state.Vehicle.NVICValue.toUpperCase() === 'NA') {
                    vm.editStateChange = true;
                }
                vm.transactionStatus = data.Status;
                //Default value changed for the question from false to null for version 2
                if (vm.state.OtherInformation.PolicyHolderHoldInsurance === false && vm.version < keyConstService.Version) {
                    vm.state.OtherInformation.PolicyHolderHoldInsurance = null;
                }
                if (JSON.parse(sessionStorageService.get(keyConstService.IsCopyQuote)) === false) {
                    sessionStorageService.set(keyConstService.IsPackageEditable, vm.dataState.IsPackageEditable);
                }
                else if (JSON.parse(sessionStorageService.get(keyConstService.IsCopyQuote)) === true){
                    vm.state.Drivers.AdditionalDrivers.forEach(function (ele, index) {
                        ele.IsDisableClaim = false;
                    });
                    vm.state.ExistingPackage = newBusinessCaseDetail.data.ExistingPackage;
                    caseId = sessionStorageService.get(keyConstService.caseId);
                    quotesService.getInsuredNameList(caseId).then(function (ResponseData) {
                        if (ResponseData.data !== null) {
                            vm.state.Insured.InsuredNameList = ResponseData.data.policyHolder.insuredNameList;
                            //console.log(ResponseData.data);
                            vm.state.Insured.InsuredName = ResponseData.data.policyHolder.insuredName;
                            vm.secondaryListChange(true);
                        }
                    });
                    if (vm.state.ExistingPackage) {
                        vm.state.OtherInformation.IsAddMorePolicyToPackage = true;
                    }
                    PolicyHolderHoldInsuranceNullOnCopyQuote();
                }

                vm.IsEndorsementPolicyEffectiveDate = data.IsEndorsementPolicyEffectiveDate;
                //vm.IsEndorsement = data.IsEndorsement;
                vm.EffectiveDate = data.EffectiveDate;
                ExpirationDate = data.ExpirationDate;
                vm.StartDate = data.StartDate;
                vm.VehicleUsedFor = data.MotorQuestion.OtherInformation.VehicleUsedFor;

                if (JSON.parse(sessionStorageService.get(keyConstService.IsRenewalPolicy)) === true)
                    data.MotorQuestion.CuppingCappingFactor.ExpirationPremium = data.MotorQuestion.CuppingCappingFactor.AdjustmentFactor = null;

                if (vm.VehicleUsedFor !== null ) {
                    if (vm.VehicleUsedFor === "RideShare" || vm.VehicleUsedFor === "ForHireOrTaxi") {
                        vm.showDeclineMessageVehicleUsedFor = true;
                    }
                }

                if (sessionStorageService.get(keyConstService.NVIcNotFound) == true) {
                    vm.NVIcNotFound = true;

                }

                sessionStorageService.set(keyConstService.findRegoData, vm.Find)
                if (vm.state.OvernightParkedAddress.IsManualAddress) {

                    vm.selectedMannualAddress = vm.state.OvernightParkedAddress.AddressText;
                }
                else if (vm.state.OvernightParkedAddress.IsManualAddress === false) {
                    vm.selectedAddress = vm.state.OvernightParkedAddress.AddressText;
                }
                if (vm.state.OvernightParkedAddress.AddressValue) {
                    var splitState = vm.state.OvernightParkedAddress.AddressValue.split('|');
                    vm.nswState = splitState[0];
                    vm.AddressState = vm.nswState;
                }
                vm.comprehensiveType = true;
                vm.comprehensivePlusType = true;
                var vehicledetail = sessionStorageService.get(keyConstService.getQuestionSetWithoutSaving);
                if (vehicledetail !== null) {
                    vm.state.Vehicle.ManufactureYear = JSON.parse(vehicledetail).Vehicle.ManufactureYear;
                }
                validateIsManfactureYearMore15(vm.state.Vehicle.ManufactureYear, vm.vehicleAgeToHideRoadsideAssistance);
                if (vm.IsEndorsement) {
                    endorsementState = angular.copy(vm.state);
                    vm.coverType = data.CoverType;
                    if (vm.coverType == "Comprehensive") {
                        vm.comprehensiveType = true;
                        vm.comprehensivePlusType = false;
                    }
                    else {
                        vm.comprehensivePlusType = true;
                        vm.comprehensiveType = false;
                    }
                }

                /*non Rego*/
                if (data.MotorQuestion.Vehicle.IsNonRegoManual && !sessionStorageService.get(keyConstService.getQuestionSetWithoutSaving)) {
                    sessionStorage.setItem(keyConstService.NonRego, data.MotorQuestion.Vehicle);
                    if (!sessionStorageService.get(keyConstService.resetNonRegoData))
                        GetValuePopulated(data.MotorQuestion.Vehicle);
                }

                if (JSON.parse(sessionStorageService.get(keyConstService.IsCopyQuote)) !== true) {
                    vm.getSecondaryInsuredList(data.MotorQuestion.Insured.DateOfBirthApp);
                }

                if (!vm.IsEndorsement) {
                    if (data.MotorQuestion.ExcessOption.Excess1) {
                        vm.ExcessOptionArr.push(parseInt(data.MotorQuestion.ExcessOption.Excess1));
                    }
                    if (data.MotorQuestion.ExcessOption.Excess2) {
                        vm.ExcessOptionArr.push(parseInt(data.MotorQuestion.ExcessOption.Excess2));
                    }
                    if (data.MotorQuestion.ExcessOption.Excess3) {
                        vm.ExcessOptionArr.push(parseInt(data.MotorQuestion.ExcessOption.Excess3));
                    }
                }

                if (vm.endorsementVM) {
                    if (dateService.convertDatetoMMDDYYYFormat(vm.endorsementVM.StartDate) === vm.endorsementVM.EndorsementEffectiveDate) {
                        vm.IsEndorsementPolicyEffectiveDate = false;
                    }
                    else {
                        vm.IsEndorsementPolicyEffectiveDate = true;
                    }
                    if (!(getQuoteTransactionId == vm.getTransactionIdWithoutSaving && getParsedQuestionSetWithoutSaving)) {
                        vm.state.ExcessOption.Excess3 = null;
                        vm.state.ExcessOption.Excess2 = null;
                        vm.state.ExcessOption.Excess1 = vm.endorsementVM.Excess;
                    }

                }

                else if (data.DDlProcessTypeId === 4) {
                    var motorExcess = 0;
                    if (vm.initialData.MotorQuestion.ExcessOption.Excess1 !== null)
                        motorExcess++;
                    if (vm.initialData.MotorQuestion.ExcessOption.Excess2 !== null)
                        motorExcess++;
                    if (vm.initialData.MotorQuestion.ExcessOption.Excess3 !== null)
                        motorExcess++;
                    if (motorExcess === 1) {
                        if (vm.initialData.MotorQuestion.ExcessOption.Excess1 !== null)
                            vm.state.ExcessOption.Excess1 = vm.initialData.MotorQuestion.ExcessOption.Excess1;
                        else if (vm.initialData.MotorQuestion.ExcessOption.Excess2 !== null)
                            vm.state.ExcessOption.Excess1 = vm.initialData.MotorQuestion.ExcessOption.Excess2;
                        else if (vm.initialData.MotorQuestion.ExcessOption.Excess3 !== null)
                            vm.state.ExcessOption.Excess1 = vm.initialData.MotorQuestion.ExcessOption.Excess3;
                        vm.state.ExcessOption.Excess3 = null;
                        vm.state.ExcessOption.Excess2 = null;
                    }
                }
                sessionStorageService.set(keyConstService.quoteTransactionId, data.QuoteTransactionId);
                var convertManufactureyearToInt = parseInt(data.MotorQuestion.Vehicle.ManufactureYear);
                data.MotorQuestion.Vehicle.ManufactureYear = convertManufactureyearToInt;
                var convertInsureVehicleForGlassMarketValueAVToInt = parseInt(data.MotorQuestion.Coverages.InsureVehicleForGlassMarketValueAV);
                data.MotorQuestion.Coverages.InsureVehicleForGlassMarketValueAV = convertInsureVehicleForGlassMarketValueAVToInt;
                var convertInsureVehicleForValueToInt = parseInt(data.MotorQuestion.Coverages.InsureVehicleForValue);
                data.MotorQuestion.Coverages.InsureVehicleForValue = convertInsureVehicleForValueToInt;
                if (vm.isManualRego)
                    vm.state.Coverages.InsureVehicleForValue = convertInsureVehicleForValueToInt;
                vm.ReadOnly = data.IsReadOnly;
                //vm.mannualSearchText = data.MotorQuestion.OvernightParkedAddress.AddressText;
                vm.state.OtherInformation.IsAddMorePolicyToPackage = data.MotorQuestion.OtherInformation.IsAddMorePolicyToPackage;
                vm.policyTransactionId = data.PolicyTransactionId;
                //vm.state.OtherInformation.OtherPreviousInsuredText = data.OtherInformation.OtherPreviousInsuredText;
                quotecaseId = data.QuoteCase.Id;
                if (data.MotorQuestion.Insured.InsuredName === "Other") {
                    vm.state.Insured.OtherInsuredName = data.MotorQuestion.Insured.OtherInsuredName;
                }
                sessionStorageService.set(keyConstService.caseId, data.QuoteCase.Id);
                sessionStorageService.set(keyConstService.caseNumber, vm.CaseNumber);
                vm.QuoteTransactionId = data.QuoteTransactionId;
                caseId = sessionStorageService.get(keyConstService.caseId);
                vm.CaseNumber = JSON.parse(sessionStorageService.get('caseNumber'));
                if (!vm.CaseNumber) {
                    vm.CaseNumber = data.QuoteCase.CaseNumber;
                }
                vm.CaseID = caseId;
                if (!vm.CaseID) {
                    var quoteDetail = sessionStorageService.get('quoteDetail');
                    if (quoteDetail) {
                        var parseQuotedetail = JSON.parse(quoteDetail);
                        caseId = parseQuotedetail.data.quoteTransaction.quoteCaseId;
                    }
                }
                vm.TransactionId = data.QuoteTransactionId;
                vm.currentYear = (new Date()).getFullYear();
                if (!sessionStorageService.get(keyConstService.IsNewEditTransaction)) {
                    var isEdit = sessionStorageService.get(keyConstService.IsNewEditTransaction);
                    if (isEdit !== false && JSON.parse(sessionStorageService.get(keyConstService.IsCopyQuote)) != true) {
                        isNewEditTransaction = true;
                        sessionStorageService.set(keyConstService.IsNewEditTransaction, isNewEditTransaction);
                    }
                }
                vm.ReadOnly = data.IsReadOnly;
                if (vm.ReadOnly == true) {
                    sessionStorageService.set(keyConstService.IsNewBusinessReadOnly, data.IsReadOnly);
                }
                //Commented call again
                //if (caseId) {
                //    quotesService.getInsuredNameList(caseId).then(function (ResponseData) {
                //        if (ResponseData.data !== null) {
                //            vm.state.Insured.InsuredNameList = ResponseData.data.policyHolder.insuredNameList;
                //            vm.ClientDetail = ResponseData.data.clientDetail;
                //            vm.addSecondaryClient = ResponseData.data.clientDetail.secondaryInsuredClientVM;
                //            vm.otherInsuredAddress = ResponseData.data.clientDetail.addressLogVM;
                //            vm.PropertyDetail = ResponseData.data.buildingInfo;
                //            if (data.MotorQuestion.Insured.InsuredName === "Other") {
                //                vm.state.Insured.InsuredName = data.MotorQuestion.Insured.InsuredName;
                //                vm.state.Insured.OtherInsuredName = data.MotorQuestion.Insured.OtherInsuredName;
                //            }
                //            else {
                //                vm.state.Insured.InsuredName = data.MotorQuestion.Insured.InsuredName;
                //            }
                //            vm.state.Insured.SecondaryInsuredsList = ResponseData.data.policyHolder.secondaryInsuredsList;
                //        }
                //    })
                //}
                if (quotecaseId) {
                    quotesService.getInsuredNameList(quotecaseId).then(function (ResponseData) {
                        if (ResponseData.data !== null) {
                            vm.state.Insured.InsuredNameList = ResponseData.data.policyHolder.insuredNameList;
                            vm.state.Insured.SecondaryInsuredsList = ResponseData.data.policyHolder.secondaryInsuredsList;
                            //vm.state.Insured.InsuredClientId = ResponseData.data.policyHolder.insuredClientId;
                            vm.ClientDetail = ResponseData.data.clientDetail;
                            vm.addSecondaryClient = ResponseData.data.clientDetail.secondaryInsuredClientVM;
                            vm.otherInsuredAddress = ResponseData.data.clientDetail.addressLogVM;
                            vm.PropertyDetail = ResponseData.data.buildingInfo;

                            // test Other   --------------------------------------------------------------------------
                            //data.MotorQuestion.Insured.InsuredName = "Other";
                            //vm.state.Insured.OtherInsuredName = "Other Ankur";
                            //vm.state.Insured.DateOfBirthApp = "2000-01-01T00:00:00";

                            //test Other  --------------------------------------------------------------------------
                            //data.MotorQuestion.Insured.AdditionalPolicyHolderList[0].AdditionalPolicyHolder = "Other";
                            //vm.state.Insured.AdditionalPolicyHolderList[0].OtherPolicyHolderName = "Test Other ANkur";
                            //vm.state.Insured.AdditionalPolicyHolderList[0].OtherDateOfBirthApp = "2000-01-01T00:00:00";

                            if (data.MotorQuestion.Insured.InsuredName === "Other") {
                                vm.state.Insured.InsuredName = data.MotorQuestion.Insured.InsuredName;
                                vm.state.Insured.OtherInsuredName = data.MotorQuestion.Insured.OtherInsuredName;
                                var indexOfInsured = vm.state.Insured.InsuredNameList.findIndex(p => p.value === "Other");
                                if (indexOfInsured === -1) {
                                    vm.state.Insured.InsuredNameList.push({ clientType: "Secondary", name: vm.state.Insured.InsuredName, value: vm.state.Insured.InsuredName, dateOfBirth: vm.state.Insured.DateOfBirth, Id: 0 });
                                    vm.state.Insured.SecondaryInsuredsList.push({ clientType: "Secondary", name: vm.state.Insured.InsuredName, value: vm.state.Insured.InsuredName, dateOfBirth: vm.state.Insured.DateOfBirth, Id: 0 });

                                }
                                vm.OtherInsuredName = vm.state.Insured.OtherInsuredName;
                                vm.DateOfBirthApp = vm.state.Insured.DateOfBirthApp;
                                vm.otherreadonly = true;
                            }
                            else if ((data.MotorQuestion.Insured.AdditionalPolicyHolderList.findIndex(p => p.AdditionalPolicyHolder === "Other")) >= 0) {
                                vm.state.Insured.InsuredName = data.MotorQuestion.Insured.InsuredName;
                                vm.state.Insured.OtherInsuredName = data.MotorQuestion.Insured.OtherInsuredName;
                                var indexOfInsured = vm.state.Insured.InsuredNameList.findIndex(p => p.value === "Other");
                                if (indexOfInsured === -1) {
                                    vm.state.Insured.InsuredNameList.push({ clientType: "Secondary", name: "Other", value: "Other", dateOfBirth: null, Id: 0 });
                                    vm.state.Insured.SecondaryInsuredsList.push({ clientType: "Secondary", name: "Other", value: "Other", dateOfBirth: null, Id: 0 });
                                    //// add this line for set the AdditionalPolicyHolderList data.
                                    vm.state.Insured.AdditionalPolicyHolderList = data.MotorQuestion.Insured.AdditionalPolicyHolderList;
                                }
                                vm.OtherInsuredName = vm.state.Insured.OtherInsuredName;
                                vm.DateOfBirthApp = vm.state.Insured.DateOfBirthApp;
                                vm.otherreadonly = true;
                            }
                            else {
                                vm.state.Insured.InsuredName = data.MotorQuestion.Insured.InsuredName;
                            }
                            if (getQuoteTransactionId === vm.getTransactionIdWithoutSaving && vm.InsuredName) {
                                vm.state.Insured.InsuredName = vm.InsuredName;
                            }

                            // If Insured name is not other and additional list is having other but Insuredlist and secondaryInsured list is having remove it array.
                            if (vm.state.Insured.InsuredName !== "Other" && (vm.state.Insured.AdditionalPolicyHolderList.findIndex(p => p.AdditionalPolicyHolder === "Other")) !== -1) {
                                var insuredotherPosition = vm.state.Insured.InsuredNameList.findIndex(p => p.value === "Other");
                                if (insuredotherPosition !== -1) {
                                    vm.state.Insured.InsuredNameList.splice(insuredotherPosition, 1);
                                }
                                //var secondaryInsuredOtherPos = vm.state.Insured.SecondaryInsuredsList.findIndex(p => p.value === "Other");
                                //if (secondaryInsuredOtherPos !== -1) {
                                //    vm.state.Insured.SecondaryInsuredsList.splice(secondaryInsuredOtherPos, 1);
                                //}
                            }

                            if (vm.state.Insured.InsuredName === "Other" && (vm.state.Insured.AdditionalPolicyHolderList.findIndex(p => p.AdditionalPolicyHolder === "Other")) === -1) {
                                //var insuredotherPosition = vm.state.Insured.InsuredNameList.findIndex(p => p.value === "Other");
                                //if (insuredotherPosition !== -1) {
                                //    vm.state.Insured.InsuredNameList.splice(insuredotherPosition, 1);
                                //}
                                var secondaryInsuredOtherPos = vm.state.Insured.SecondaryInsuredsList.findIndex(p => p.value === "Other");
                                if (secondaryInsuredOtherPos !== -1) {
                                    vm.state.Insured.SecondaryInsuredsList.splice(secondaryInsuredOtherPos, 1);
                                }
                            }

                            for (var i = 0; i < ResponseData.data.policyHolder.secondaryInsuredsList.length; i++) {
                                if (vm.state.Insured.InsuredName !== "Other" && ResponseData.data.policyHolder.secondaryInsuredsList[i].value === vm.state.Insured.InsuredName && ResponseData.data.policyHolder.secondaryInsuredsList[i].id === vm.state.Insured.InsuredClientId) {
                                    var index = ResponseData.data.policyHolder.secondaryInsuredsList.indexOf(ResponseData.data.policyHolder.secondaryInsuredsList[i]);
                                    ResponseData.data.policyHolder.secondaryInsuredsList.splice(index, 1);
                                    vm.state.Insured.SecondaryInsuredsList = ResponseData.data.policyHolder.secondaryInsuredsList;
                                }
                            }
                            if (getQuoteTransactionId === vm.getTransactionIdWithoutSaving && vm.getTransactionIdWithoutSaving !== null && getQuoteTransactionId !== null && vm.policyHolderDateOfBirthApp) {
                                vm.state.Insured.DateOfBirthApp = vm.policyHolderDateOfBirthApp;
                            }

                            vm.tempPrimaryInsured = vm.state.Insured.InsuredName;
                            vm.tempAdditonalPolicyHolders = angular.copy(vm.state.Insured.AdditionalPolicyHolderList);
                        }
                    })
                }

                if (sessionStorageService.get(keyConstService.findRegoData)) {
                    vm.findRegoDetails = JSON.parse(sessionStorageService.get(keyConstService.findRegoData));
                    if (vm.findRegoDetails === false) {
                        vm.Find = false;
                        sessionStorageService.set(keyConstService.findRegoData, vm.Find)
                    }
                    else {
                        vm.Find = true;
                        sessionStorageService.set(keyConstService.findRegoData, vm.Find)
                    }
                }
                var startDate = data.StartDate;
                var productName = data.LOB;
                var getQuoteTransactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
                vm.getTransactionIdWithoutSaving = JSON.parse(sessionStorageService.get(keyConstService.getTransactionIdWithoutSaving));
                getQuestionSetWithoutSaving = sessionStorageService.get(keyConstService.getQuestionSetWithoutSaving);
                getParsedQuestionSetWithoutSaving = JSON.parse(getQuestionSetWithoutSaving);
                if (getParsedQuestionSetWithoutSaving && sessionStorageService.get(keyConstService.sessionStorageState) === "true") {
                    if (getQuoteTransactionId === vm.getTransactionIdWithoutSaving) {
                        vm.state = getParsedQuestionSetWithoutSaving;
                        vm.policyHolderDateOfBirthApp = angular.copy(getParsedQuestionSetWithoutSaving.Insured.DateOfBirthApp);
                        vm.InsuredName = angular.copy(getParsedQuestionSetWithoutSaving.Insured.InsuredName);
                        if (vm.state !== null && vm.state.OtherInformation !== null) {
                            if (vm.state.OtherInformation.VehicleUsedFor === "RideShare" || vm.state.OtherInformation.VehicleUsedFor === "ForHireOrTaxi") {
                                vm.showDeclineMessageVehicleUsedFor = true;
                            }
                        }

                        if (getParsedQuestionSetWithoutSaving.OvernightParkedAddress.AddressLine1) {
                            vm.selectedMannualAddress = getParsedQuestionSetWithoutSaving.OvernightParkedAddress.AddressText;
                        }
                        vm.selectedAddress = getParsedQuestionSetWithoutSaving.OvernightParkedAddress.AddressText;
                        if (getParsedQuestionSetWithoutSaving.OvernightParkedAddress.IsManualAddress === true) {
                            vm.selectedAddress = null;
                            vm.state.OvernightParkedAddress.AddressLine1 = getParsedQuestionSetWithoutSaving.OvernightParkedAddress.AddressLine1;
                            vm.selectedMannualAddress = getParsedQuestionSetWithoutSaving.OvernightParkedAddress.AddressText;

                        }
                        vm.isManualRegoEnabled = sessionStorageService.get(keyConstService.isManualRegoEnabled);
                        if (vm.isManualRegoEnabled === "true") {
                            if (!sessionStorageService.get(keyConstService.resetNonRegoData)) {
                                GetValuePopulated(getParsedQuestionSetWithoutSaving.Vehicle);
                            }
                            else {
                                vm.isManualRego = true;
                                vm.SelectedMotorMake = '';
                                vm.SelectedMotorModel = '';
                                vm.SelectedMotorListitem = '';
                                vm.SelectedMotorYear = '';
                                vm.Motorvehiclelist = null;
                                vm.state.Coverages.InsureVehicleForGlassMarketValueBAV = null;
                                vm.state.Coverages.InsureVehicleForGlassMarketValueAAV = null;
                                GetManufactureYears();
                                vm.state.Vehicle.NVICValue = null;
                                vm.state.Vehicle.ManufactureYear = null;
                                vm.state.Vehicle.MotorGlassDetailId = null;
                                vm.state.Vehicle.Make = null;
                                vm.state.Vehicle.Model = null;
                                vm.state.Vehicle.Transmission = null;
                                vm.state.Vehicle.Style = null;
                                vm.state.Vehicle.Size = null;
                                vm.state.Vehicle.Variant = null;
                                vm.state.Vehicle.Series = null;
                                vm.state.Vehicle.Engine = null;
                                vm.state.Vehicle.Cylinders = null;
                                vm.state.Vehicle.VehicleDescription = null;
                                vm.state.Vehicle.BodyType = null;
                                vm.state.Vehicle.IsNonRegoManual = vm.isManualRego;
                                if (vm.dataState.IsReadOnly === false )
                                    toastr.error(messageConstService.errNonRegoDetails);
                            }
                        }
                        else {
                            if (sessionStorageService.get(keyConstService.resetNonRegoData)) {
                                vm.state.Vehicle.ManufactureYear = null;
                                vm.state.Vehicle.Make = null;
                                vm.state.Vehicle.Model = null;
                                vm.state.Vehicle.VehicleDescription = null;
                                vm.state.Vehicle.NVICValue = null;
                                vm.state.Coverages.InsureVehicleForGlassMarketValueBAV = null;
                                vm.state.Coverages.InsureVehicleForGlassMarketValueAAV = null;
                                vm.Find = false;
                                sessionStorageService.set(keyConstService.findRegoData, vm.Find )
                                toastr.error(messageConstService.errNonRegoDetails);
                            }
                        }
                    }
                }

                if (vm.state.Vehicle.NVICValue && vm.state.Vehicle.NVICValue !== 'NA') {
                    vm.Find = true;
                }
                else {
                    vm.Find = false;
                }

                // checking for duplicate excess in case of previous/next
                vm.isDuplicateExcess();

                //if (sessionStorageService.get(keyConstService.setDriverDL)) {
                //    vm.setDriverDL = JSON.parse(sessionStorageService.get(keyConstService.setDriverDL));
                //    if (getParsedQuestionSetWithoutSaving) {
                //        if (getQuoteTransactionId == vm.getTransactionIdWithoutSaving && sessionStorageService.get(keyConstService.sessionStorageState)) {
                //            if (vm.setDriverDL == false) {
                //                toastr.error(messageConstService.errInvalidDLYear);
                //            }
                //        }
                //    }
                //}

                if (vm.state.Insured.AdditionalPolicyHolderList.length != 0 && vm.state.Insured.AdditionalPolicyHolderList[0].OtherDateOfBirthApp != null) {
                    for (var i = 0; i < vm.state.Insured.AdditionalPolicyHolderList.length; i++) {
                        if (vm.state.Insured.AdditionalPolicyHolderList[i].AdditionalPolicyHolder === "Other") {
                            var dateofBirth = vm.state.Insured.AdditionalPolicyHolderList[i].OtherDateOfBirthApp;
                            var response = dateService.validateBirthDDMMYYYY(dateofBirth, 115);
                            if (!response.isValid) {
                                vm.validDOBOtherInsurer = false;
                                vm.message = response.errorMsg;
                                break;
                            }
                            else {
                                vm.validDOBOtherInsurer = true;
                            }
                        }
                        else {
                            continue;
                        }
                    }
                    if (!vm.validDOBOtherInsurer && vm.message === messageConstService.errFutureDateNotAllowed) {
                        toastr.warning(messageConstService.errFutureDatedForAddHolder);
                    }
                    else if (!vm.validDOBOtherInsurer && vm.message === messageConstService.errDateNotAllowed) {
                        toastr.warning(messageConstService.errDateNotAllowed);
                    }
                }

                var endorsementDataVM = JSON.parse(sessionStorageService.get(keyConstService.endorsementRequestVM));
                {
                    if (endorsementDataVM) {
                        vm.AdditionalDriversList = angular.copy(data.MotorQuestion.Drivers.AdditionalDrivers);
                        var policyStartDate = moment(endorsementDataVM.StartDate).format('MM/DD/YYYY');
                        var policyEffectiveDate = moment(endorsementDataVM.PolicyEffectiveDate).format('MM/DD/YYYY');
                        var endorsementEffectiveDate = endorsementDataVM.EndorsementEffectiveDate;
                        if (policyStartDate === endorsementEffectiveDate) {
                            vm.IsEndorsementPolicyEffectiveDate = false;
                            vm.state.Drivers.AdditionalDrivers.forEach(function (ele, index) {
                                ele.IsDisableClaim = false;
                            });
                            var isEndorsementEdit = JSON.parse(sessionStorageService.get(keyConstService.IsNewEditTransaction));
                            if (isEndorsementEdit && getParsedQuestionSetWithoutSaving) {
                                vm.state.UnderwritingCriteria.HasInsuredInLast3Years = getParsedQuestionSetWithoutSaving.UnderwritingCriteria.HasInsuredInLast3Years
                                vm.state.UnderwritingCriteria.InsuredInLast3YearsData = getParsedQuestionSetWithoutSaving.UnderwritingCriteria.InsuredInLast3YearsData;
                                vm.state.Drivers.MainDriver.ClaimNumber = getParsedQuestionSetWithoutSaving.Drivers.MainDriver.ClaimNumber;
                                vm.state.Drivers.MainDriver.Claims = getParsedQuestionSetWithoutSaving.Drivers.MainDriver.Claims;
                                vm.state.Drivers.AdditionalDrivers = getParsedQuestionSetWithoutSaving.Drivers.AdditionalDrivers;
                                vm.state.Coverages.ComprehensiveRoadSide = getParsedQuestionSetWithoutSaving.Coverages.ComprehensiveRoadSide;
                                // Added by Honey on 13-Apr-2020
                            }
                        }
                        else {
                            vm.IsEndorsementPolicyEffectiveDate = true;
                            vm.state.Drivers.AdditionalDrivers.forEach(function (ele, index) {
                                if (ele.CreateDate !== null) {
                                    ele.IsDisableClaim = true;
                                }
                            });
                            var newBusinessQuestionsForEndorsement = quotesService.getQuestionSetForPolicy(data.PolicyId)
                                .then(function (result) {
                                    var questionsSet = JSON.parse(result.data.requestContent);
                                    vm.state.UnderwritingCriteria.HasInsuredInLast3Years = questionsSet.UnderwritingCriteria.HasInsuredInLast3Years
                                    vm.state.UnderwritingCriteria.InsuredInLast3YearsData = questionsSet.UnderwritingCriteria.InsuredInLast3YearsData;
                                    vm.state.Drivers.MainDriver.ClaimNumber = questionsSet.Drivers.MainDriver.ClaimNumber;
                                    vm.state.Drivers.MainDriver.Claims = questionsSet.Drivers.MainDriver.Claims;
                                    vm.state.Drivers.AdditionalDrivers.forEach(function (ele, index) {
                                        if (ele.CreateDate !== null && moment(ele.CreateDate).format('MM/DD/YYYY') == endorsementEffectiveDate) {
                                            ele.IsDisableClaim = false;
                                        }
                                    });
                                    vm.state.Coverages.ComprehensiveRoadSide = questionsSet.Coverages.ComprehensiveRoadSide;
                                    // Added by Honey on 13-Apr-2020
                                });
                        }
                    }
                }

                // removing questionset from session for valid newbusiness quote
                if (getParsedQuestionSetWithoutSaving) {
                    sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
                }
                if (newBusinessCaseDetail != null && newBusinessCaseDetail != undefined) {
                    startDate = newBusinessCaseDetail.data.EffectiveDate;
                }
                var brokerCommissionRequestOnEdit = quotesService.getBrokerCommissiononEdit({
                    EffectiveDate: startDate,
                    ProductName: productName,
                    ProductId: null,
                })
                    .then(function (result) {
                        vm.data = result.data.brokerBranchCommissionFeeVM;
                        if (vm.data) {
                            for (var i = 0; i < vm.data.length; i++) {
                                if (vm.state.Coverages.Coverage == "Comprehensive") {
                                    if (vm.data[i].coverCode === "COMPREHENSIVE") {
                                        vm.maxbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMax;
                                        vm.minbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMin;
                                    }
                                }
                                vm.checkBrkerCommissionLimit();
                            }
                        }
                    })

                // get uiversion
                var editTransaction = false;
                var edit = sessionStorageService.get(keyConstService.IsNewEditTransaction);
                if (edit !== false && JSON.parse(sessionStorageService.get(keyConstService.IsCopyQuote)) != true) {
                    editTransaction = true;
                    if (vm.transactionStatus === "Draft") {
                        editTransaction = false;
                    }
                }

                if (data.DDlProcessTypeId === 1 && (editTransaction === true || getParsedQuestionSetWithoutSaving !== null)) {
                    // get new effective date
                    var newBusinessData = JSON.parse(sessionStorageService.get(keyConstService.newBusinessCaseData));
                    if (newBusinessData) {
                        var newEffectiveDate = newBusinessData.data.EffectiveDate;
                        $http.get(apiUrlConstService.quoteURL + 'GetUIVersion?quotetransactionId=' + data.QuoteTransactionId + '&&policyStartDate=' + newEffectiveDate, { skipInterceptor: true })
                            .then(function (result) {
                                if (result.data.status === true) {
                                    vm.version = result.data.data;
                                }
                                else {
                                    toastr.error(messageConstService.errServiceUnavailable);
                                    $log.error("error data:", result.data);
                                }
                            }, function (error) {
                                toastr.error(messageConstService.errServiceUnavailable);

                                $log.error('error', error);
                            });
                    }
                }

                //// setup default Excess for edit and endorsement and renewal
                var newBusinessData = JSON.parse(sessionStorageService.get(keyConstService.newBusinessCaseData));

                if (newBusinessData) {
                    var newEffectiveDate = newBusinessData.data.EffectiveDate;
                    qStartDate = new Date(newEffectiveDate);
                    qEffectiveDate = new Date(data.EffectiveDate);

                    if (data.DDlProcessTypeId === 4) {
                        if (qStartDate >= excessCheckDate) {
                            vm.IsMotorGlassExcessEffective = true;
                        }
                    }
                    else {
                        if (qStartDate < excessCheckDate && qEffectiveDate >= excessCheckDate) {
                            vm.IsMotorGlassExcessEffective = false;
                            var qAddressState = data.MotorQuestion.OvernightParkedAddress.AddressValue.split('|');
                            vm.tempState = data.MotorQuestion.Vehicle.State === null || data.MotorQuestion.Vehicle.State === "" ? qAddressState[0] : data.MotorQuestion.Vehicle.State;
                            vm.setDefaultExcessToNull(vm.tempState, data.MotorQuestion);
                        }
                        else if (qStartDate > qEffectiveDate || qStartDate < qEffectiveDate) {
                            if (qStartDate >= excessCheckDate) {
                                vm.IsMotorGlassExcessEffective = true;
                            }
                            if (excessCheckDate >= qEffectiveDate && excessCheckDate > qStartDate) {
                                vm.settingExcessAccordingToDefault(null, false, null)
                            }
                            else {
                                vm.isEffectiveDateChange = true;
                                var qAddressState = data.MotorQuestion.OvernightParkedAddress.AddressValue.split('|');
                                vm.tempState = data.MotorQuestion.Vehicle.State === null || data.MotorQuestion.Vehicle.State === "" ? qAddressState[0] : data.MotorQuestion.Vehicle.State;
                                vm.setDefaultExcessToNull(vm.tempState, data.MotorQuestion);
                            }
                        }
                        else {
                            if (qStartDate >= excessCheckDate) {
                                vm.IsMotorGlassExcessEffective = true;
                            }
                            if (vm.IsMotorGlassExcessEffective) {
                                vm.state.ExcessOption.ExcessList = data.DefaultMotorGlassExcessOptionList;
                            }
                        }
                    }
                }
                else {
                    qStartDate = new Date(vm.StartDate);
                    if (qStartDate >= excessCheckDate) {
                        vm.IsMotorGlassExcessEffective = true;
                    }
                    if (vm.IsMotorGlassExcessEffective) {
                        if (data.MotorQuestion.Vehicle.MotorGlassDetailId) {
                            $http.get(apiUrlConstService.getMotorDetailsForId + 'glassMotorId=' + data.MotorQuestion.Vehicle.MotorGlassDetailId, { skipInterceptor: true }).then(function (result) {
                                vm.isRenewalEffective = true;
                                var motorData = result.data.data[0];
                                if (motorData.defaultExcess === null) {
                                    vm.defaultExcessFlag = false;
                                }
                                else {
                                    vm.defaultExcessFlag = true;
                                }
                                vm.settingExcessAccordingToDefault(motorData.defaultExcess, vm.defaultExcessFlag, null);
                            });
                        }
                        else {
                            vm.tempExcessOption = vm.state.ExcessOption.ExcessList;
                            vm.state.ExcessOption.ExcessList = data.DefaultMotorGlassExcessOptionList;
                        }
                    }
                }

                //// if call Illion API if copy quote or Edit or endorsement quote when IsIllionCallOnEdit is true
                if (((vm.dataState && vm.dataState.DDlProcessTypeId != 4) || vm.IsEndorsement == false)
                    && ((vm.dataState && vm.dataState.DDlProcessTypeId != 4) && vm.IsEndorsement == false))
                {
                    if (JSON.parse(sessionStorageService.get(keyConstService.IsCopyQuote)) || (vm.dataState.IsIllionCallOnEdit && (JSON.parse(sessionStorageService.get(keyConstService.IsNewEditTransaction)) || vm.IsEndorsement))) {
                        vm.state.IllionClaimResponse = null;
                        vm.state.IllionClaimResponseId = null;
                        vm.getAdressEnquiryDetails();
                    }
                }
                //// call nvic if copy quote
                if (JSON.parse(sessionStorageService.get(keyConstService.IsCopyQuote))) {
                    if (vm.state.Vehicle.IsNonRegoManual) {
                        GetMotorVehicleList(vm.state.Vehicle.Make, vm.state.Vehicle.ManufactureYear, vm.state.Vehicle.Model, 'Add', vm.state.Vehicle.Style, vm.state.Vehicle.Transmission, vm.state.Vehicle.Size);
                    }
                    else {
                        regoLookup();
                    }                    
                }
            } // end of edit if

            if (newBusinessCaseDetail != undefined) {
                vm.state.Payment.Frequency = newBusinessCaseDetail.data.PaymentFrequency;
                if (vm.state.Payment.Frequency === 'Monthly')
                    vm.state.Payment.DayofInstallment = newBusinessCaseDetail.data.InstallmentDate;
                else
                    vm.state.Payment.DayofInstallment = 0;
            }

            vm.objEffectiveDate = reteiveEffectiveDate(true);
            vm.objEffectiveDate = dateService.convertDatetoMMDDYYYFormat(vm.objEffectiveDate);
            vm.objEffectiveYear = dateService.getYear(vm.objEffectiveDate);
            //Startdateyear is used to correct the rangeyear for claims to solve Bug 2658
            if (vm.StartDate == null) {
                vm.StartDate = vm.objEffectiveDate;
            }
            vm.StartDate = dateService.convertDatetoMMDDYYYFormat(vm.StartDate);
            vm.startDateYear = dateService.getYear(vm.StartDate);
            //commented after confirmation by client
            //vm.checkManufactureYear();
            vm.checkDriverInfo();

            //disable getquote if insured name is not in list
            //if (vm.state.Insured.InsuredName !== "Other") {
            //    var existInsuredName = utilityService.valueExistsInArray(vm.state.Insured.InsuredName, vm.state.Insured.InsuredNameList);
            //    if (!existInsuredName) {
            //        vm.disableButtons = true;
            //    }
            //}

            // for additional insured
            //checkAdditionalInsuredInList();

        }

        function rangeYear(min, max, step) {
            step = step || 1;
            var input = [];
            for (var i = min; i <= max; i += step) {
                input.push(i);
            }
            return input.reverse();
        };


        vm.ResetAdditionalPolicyHolder = function () {
            if (!vm.state.PolicyHolder.IsAdditionalPolicyHolder) {
                vm.state.PolicyHolder.AdditionalPolicyHolderList = [{ AdditionalPolicyHolder: null, OtherPolicyHolderName: null, OtherDateOfBirth: null }];
            }
        };

        vm.checkManufactureYear = function () {
            // commented after confirmation by client.
            //// if select year greater than policy effective year then it show error
            //if (vm.state.Vehicle.ManufactureYear && vm.state.Vehicle.ManufactureYear > vm.objEffectiveYear) {
            //    // for disable quote
            //    vm.SelectedMotorYear = null;
            //    return;
            //}
        };

        //Startdateyear is used to correct the rangeyear for claims to solve Bug 2658
        vm.checkDriverInfo = function () {
            var years = vm.rangeYear(vm.startDateYear - 3, vm.objEffectiveYear);
            // updating claims data after changing effective date
            quotesService.updateMotorClaimsInfo(vm.state.Drivers.MainDriver.Claims, years);
            // commented after confirmation by client
            //if (vm.state.Drivers.MainDriver.YearDL && vm.state.Drivers.MainDriver.YearDL > vm.objEffectiveYear) {
            //    // for disable quote
            //    vm.setDriverDL = false;
            //    return;
            //}

            if (vm.state.Drivers.IsAdditionalDriver && vm.state.Drivers.AdditionalDrivers && vm.state.Drivers.AdditionalDrivers.length > 0) {
                for (var i = 0; i < vm.state.Drivers.AdditionalDrivers.length; i++) {
                    // commented after confirmation by client
                    //if (vm.state.Drivers.AdditionalDrivers[i].YearDL && vm.state.Drivers.AdditionalDrivers[i].YearDL > vm.objEffectiveYear) {
                    //    // for disable quote
                    //    vm.setDriverDL = false;
                    //    return;
                    //}
                    quotesService.updateMotorClaimsInfo(vm.state.Drivers.AdditionalDrivers[i].Claims, years);
                }
            }
        };

        vm.showManualAddressOption = function () {
            vm.state.OvernightParkedAddress.IsManualAddress = true;
            vm.searchText = null;
            vm.resetAddressData();
        };

        vm.resetSearchText = function () {
            vm.state.OvernightParkedAddress.IsManualAddress = false;
            if (vm.state.OvernightParkedAddress.AddressText) {
                vm.previousAddressTextForIllion = vm.state.OvernightParkedAddress.AddressText;
            }            
            vm.AddressChange = true;
            vm.resetAddressData();
        };

        vm.showManualAddressOtherInsured = function () {
            vm.otherInsuredAddress.isManualAddress = true;
            vm.searchText1 = null;
            resetAddress();
        };

        vm.resetSearchTextOtherInsured = function () {
            vm.otherInsuredAddress.isManualAddress = false;
            resetAddress();
        };

        function stateChange(clientState) {
            getQuoteTransactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
            if (clientState && !vm.IsEndorsement && vm.editStateChange && getQuoteTransactionId != vm.getTransactionIdWithoutSaving) {
                if (!vm.isManualRego)
                    vm.state.Vehicle.State = clientState;
                vm.checkIsSmallBusinessStampDutyEligible(true);
                var defaultExcessValues = vm.state.ExcessOption.DefaultExcessValues;
                for (var i = 0; i < defaultExcessValues.length; i++) {
                    if (defaultExcessValues[i].State === clientState) {
                        vm.state.ExcessOption.Excess1 = defaultExcessValues[i].Excess1.toString();
                        vm.state.ExcessOption.Excess2 = defaultExcessValues[i].Excess2.toString();
                        vm.state.ExcessOption.Excess3 = defaultExcessValues[i].Excess3.toString();

                        var arr = [];
                        arr.push(defaultExcessValues[i].Excess1);
                        arr.push(defaultExcessValues[i].Excess2);
                        arr.push(defaultExcessValues[i].Excess3);
                        vm.ExcessOptionArr = arr;

                        return;
                    }
                }
            }
        }
        function IsAdditionalButtonDisabled(name, index, nameObj) {
            if (name && !vm.otherreadonly) {
                vm.isSecondaryDisabled = false;
                if (name !== "Other") {
                    nameObj.OtherDateOfBirth = null;
                    nameObj.OtherDateOfBirthApp = null;
                    nameObj.OtherPolicyHolderName = null;
                }
            }
            var duplicateCount = 0;
            //check if the name already exists twice if yes then remove
            vm.state.Insured.AdditionalPolicyHolderList.forEach(function (ele, index) {
                if (name) {
                    if (ele.AdditionalPolicyHolder !== "Other" && ele.AdditionalPolicyHolder === name) {
                        duplicateCount++;
                    }
                }
            });


            if (duplicateCount > 1) {
                toastr.error("Duplicate additional policyholder not allowed.");
                nameObj.AdditionalPolicyHolder = "";
                return;
            }

            if (vm.otherreadonly && name === "Other" && index === vm.state.Insured.AdditionalPolicyHolderList.length - 1) {
                if (vm.state.Insured.AdditionalPolicyHolderList[index].OtherPolicyHolderName === null) {
                    toastr.error("Other is not allowed");
                    nameObj.AdditionalPolicyHolder = "";
                    return;
                }
            }

            for (var i = 0; i < vm.state.Insured.InsuredNameList.length; i++) {
                if (vm.state.Insured.InsuredNameList[i].value === name) {

                    for (var j = 0; j < vm.state.Insured.AdditionalPolicyHolderList.length; j++) {
                        if (vm.state.Insured.AdditionalPolicyHolderList[j].AdditionalPolicyHolder === name) {
                            vm.state.Insured.AdditionalPolicyHolderList[j].AdditionalDateOfBirth = vm.state.Insured.InsuredNameList[i].dateOfBirth;
                            vm.state.Insured.AdditionalPolicyHolderList[j].AdditionalPolicyHolderType = vm.state.Insured.InsuredNameList[i].clientType;
                        }
                    }
                }
                $log.log(vm.state.Insured.AdditionalPolicyHolderList);
            }

            if (name === 'OtherInsured') {
                vm.AdditionalPolicyHolderIndex = index;
                angular.element('#add-insured').modal('show');
            }
            else if (name != "OtherInsured") {
                vm.tempAdditonalPolicyHolders = angular.copy(vm.state.Insured.AdditionalPolicyHolderList);
            }

            // for additional insured
            //checkAdditionalInsuredInList();
        }
        vm.addSecondaryInsured = function () {
            vm.state.Insured.AdditionalPolicyHolderList.push({ AdditionalPolicyHolder: null, AdditionalDateOfBirth: null, AdditionalPolicyHolderType: null, OtherPolicyHolderName: null, OtherDateOfBirth: null });
            vm.AdditionalPolicyHolderListLength = vm.state.Insured.AdditionalPolicyHolderList.length;
        };

        vm.removeSecondaryInsured = function (item) {
            var index = vm.state.Insured.AdditionalPolicyHolderList.indexOf(item);
            var isvalidDOB = true;
            vm.state.Insured.AdditionalPolicyHolderList.splice(index, 1);
            vm.AdditionalPolicyHolderListLength = vm.state.Insured.AdditionalPolicyHolderList.length;
            for (var i = 0; i < vm.AdditionalPolicyHolderListLength; i++) {
                var dateofBirth = vm.state.Insured.AdditionalPolicyHolderList[i].OtherDateOfBirthApp;
                isvalidDOB = dateService.validateBirthDDMMYYYY(dateofBirth, 150);
            }
            if (isvalidDOB.isValid) {
                vm.validDOBOtherInsurer = true;
            }
            vm.checkFutureDate(vm.AdditionalPolicyHolderListLength);

            // for additional insured
            //checkAdditionalInsuredInList();
        };

        vm.checkFutureDate = function (length) {
            var isvalidDOB = true;
            for (var i = 0; i < length; i++) {
                if (vm.state.Insured.AdditionalPolicyHolderList[i].AdditionalPolicyHolder === "Other") {
                    var dateofBirth = vm.state.Insured.AdditionalPolicyHolderList[i].OtherDateOfBirthApp;
                    isvalidDOB = dateService.validateBirthDDMMYYYY(dateofBirth, 150);

                    if (isvalidDOB.isValid) {
                        vm.validDOBOtherInsurer = true;
                    }
                    else {
                        vm.validDOBOtherInsurer = false;
                        break;
                    }
                }
                else {
                    break;
                }

            }
        }

        function secondaryListChange(DOBFlag, DOBonEdit) {
            for (var i = 0; i < vm.state.Insured.InsuredNameList.length; i++) {
                if (vm.state.Insured.InsuredNameList[i].value === vm.state.Insured.InsuredName && vm.state.Insured.InsuredName !== 'Other' && vm.state.Insured.InsuredName !== 'OtherInsured') {
                    var index = vm.state.Insured.InsuredNameList.indexOf(vm.state.Insured.InsuredNameList[i]);
                    var temporarylist = angular.copy(vm.state.Insured.InsuredNameList);
                    // commented as per bug 7095
                    //vm.state.Insured.OtherInsuredName = null;
                    if (DOBFlag) {
                        if (vm.state.Insured.InsuredNameList[i].dateOfBirth !== null) {
                            vm.state.Insured.DateOfBirthApp = dateService.convertDatetoDDMMYYYFormat(vm.state.Insured.InsuredNameList[i].dateOfBirth);
                            vm.state.Insured.DateOfBirth = dateService.convertDatetoMMDDYYYFormat(vm.state.Insured.InsuredNameList[i].dateOfBirth);
                        }
                        else {
                            vm.state.Insured.DateOfBirthApp = "2000-01-01T00:00:00";
                        }
                    }
                    if (!DOBFlag) {
                        vm.state.Insured.DateOfBirthApp = moment(DOBonEdit, 'DD/MM/YYYY').toDate();

                    }
                    vm.state.Insured.InsuredClientId = vm.state.Insured.InsuredNameList[i].id;
                    vm.state.Insured.SecondaryInsuredsList = temporarylist;
                    vm.state.Insured.SecondaryInsuredsList.splice(index, 1);
                    vm.state.Insured.SecondaryInsuredsList = vm.state.Insured.SecondaryInsuredsList;

                    // Commentd by Ankur as per us 6829
                    //var secondaryInsuredOtherPos = vm.state.Insured.SecondaryInsuredsList.findIndex(p => p.value === "Other");
                    //if (secondaryInsuredOtherPos !== -1) {
                    //    vm.state.Insured.SecondaryInsuredsList.splice(secondaryInsuredOtherPos, 1);
                    //}

                    // Changes Related to SME, update Primary Insured Id
                    sessionStorageService.set(keyConstService.PrimaryInsuredId, vm.state.Insured.InsuredNameList[i].id);
                }
                ////else if (vm.state.Insured.InsuredName === 'Other') {
                ////    vm.state.Insured.InsuredClientId = null;
                ////    var temporarylist = angular.copy(vm.state.Insured.InsuredNameList);
                ////    vm.state.Insured.SecondaryInsuredsList = temporarylist;
                ////    if (DOBFlag) {
                ////        vm.state.Insured.DateOfBirthApp = null;
                ////        //vm.state.Insured.DateOfBirth = null;
                ////    }
                ////    if (vm.OtherInsuredName !== null) {
                ////        vm.state.Insured.OtherInsuredName = vm.OtherInsuredName;
                ////        vm.state.Insured.DateOfBirthApp = vm.DateOfBirthApp;
                ////    }
                ////}
            }

            if (vm.state.Insured.InsuredName != "OtherInsured") {
                vm.tempPrimaryInsured = vm.state.Insured.InsuredName;
            } else if (vm.state.Insured.InsuredName === 'OtherInsured') {
                vm.IsOpenAddInsuredPopup = true;
                angular.element('#add-insured').modal('show');
            }
        }

        function SetNonRegoValue() {
            /* Check the selected value of non rego */
            if (!vm.SelectedMotorStyle) {
                vm.state.Vehicle.Style = null;
            }
            else {
                vm.state.Vehicle.Style = vm.SelectedMotorStyle;
            }

            if (!vm.SelectedMotorTransmission) {
                vm.state.Vehicle.Transmission = null;
            }
            else {
                vm.state.Vehicle.Transmission = vm.SelectedMotorTransmission;
            }

            if (!vm.SelectedMotorSize) {
                vm.state.Vehicle.Size = null;
            }
            else {
                vm.state.Vehicle.Size = vm.SelectedMotorSize;
            }

            if (!vm.SelectedMotorYear) {
                vm.state.Vehicle.ManufactureYear = null;
            }
            else {
                vm.state.Vehicle.ManufactureYear = vm.SelectedMotorYear;
            }

            if (!vm.SelectedMotorMake) {
                vm.state.Vehicle.Make = null;
            } else {
                vm.state.Vehicle.Make = vm.SelectedMotorMake;
            }

            if (!vm.SelectedMotorModel) {
                vm.state.Vehicle.Model = null;
            } else {
                vm.state.Vehicle.Model = vm.SelectedMotorModel;
            }
        }
        function back() {
            var isactivePM = sessionStorageService.get('IsPackageManagerNavigationMode');
            if (isactivePM === "true") {
                sessionStorageService.set(keyConstService.IsPackageManagerNavigationMode, "preTrue");
            }
            vm.disableButtons = true;
            sessionStorageService.remove(keyConstService.resetNonRegoData);
            sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
            sessionStorageService.remove(keyConstService.isManualRegoEnabled);
            vm.SelectedVehicleColour = vm.SelectedVehicleColour === undefined ? null : vm.SelectedVehicleColour;
            vm.state.Vehicle.Colour = vm.SelectedVehicleColour;
            sessionStorageService.set(keyConstService.Colour, vm.SelectedVehicleColour);
            if (vm.isManualRego)
                /* Check the selected value of non rego */
                SetNonRegoValue();

            getQuestionSetWithoutSaving = sessionStorageService.set(keyConstService.getQuestionSetWithoutSaving, vm.state);
            sessionStorageService.set(keyConstService.setDriverDL, vm.setDriverDL);
            isManualRegoEnabled = sessionStorageService.set(keyConstService.isManualRegoEnabled, vm.isManualRego);
            sessionStorageService.set(keyConstService.sessionStorageState, true);
            var quoteTransactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
            getTransactionIdWithoutSaving = sessionStorageService.set(keyConstService.getTransactionIdWithoutSaving, quoteTransactionId);
            var transactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
            if (vm.IsEndorsement) {
                window.location = webUrlConstService.endorsementRequest + sessionStorageService.getEncryption("quoteTransactionId=" + transactionId);
            }
            else {
                if (sessionStorageService.get(keyConstService.IsNewEditTransaction) !== "true") {
                    sessionStorageService.set(keyConstService.IsNewEditTransaction, isNewEditTransaction);
                }
                window.location = webUrlConstService.newBusinessIndex + sessionStorageService.getEncryption("transactionId=" + transactionId);
            }
        }

        function discard() {
            vm.disableButtons = true;
            if (vm.IsEndorsement) {
                quotesService.quoteDiscardRequest(sessionStorageService.get(keyConstService.quoteTransactionId)).then(function (result) {
                    if (result.data) {
                        if (vm.showManagePkg) {
                            vm.packageNumber = sessionStorageService.get('PackageNumberInformation');
                            vm.renewalCounter = sessionStorageService.get('RenewalCounter');
                            sessionStorageService.remove('IsPackageManagerNavigationMode');
                            sessionStorageService.remove('PackageNumberInformation');
                            sessionStorageService.remove('RenewalCounter');
                            $window.location.href = webUrlConstService.getPackageInfo + sessionStorageService.getEncryption("packageNumber=" + JSON.parse(vm.packageNumber) + "&&renewalCounter=" + vm.renewalCounter);
                        }
                        else {
                            $timeout(function () {
                                var Id = vm.dataState.PolicyId;
                                window.location = "/Bind?" + sessionStorageService.getEncryption("id=" + Id);
                            }, 1000);
                        }
                    } else {
                        toastr.error(messageConstService.errServiceUnavailable);
                        vm.disableButtons = false;
                    }
                },
                    function (error) {
                        $log.error('error', error);
                        toastr.error(messageConstService.errServiceUnavailable);
                        vm.disableButtons = false;
                    });
            }
            else {
                $window.location = webUrlConstService.homeIndex;
            }
        }

        function previousStep() {
            if (vm.state.currentStep > 1) {
                vm.state.currentStep = vm.state.currentStep - 1;
            }
            sessionStorageService.set(keyConstService.quoteState, vm.state);
        }

        function nextStep() {
            // Check required

            // For Now Hardcoding Max Steps
            if (vm.state.currentStep < 2) {
                vm.state.currentStep = vm.state.currentStep + 1;
            }

            //Save State later save it with case id
            sessionStorageService.set(keyConstService.quoteState, vm.state);
        }

        function removeClaim(item) {
            var index = vm.state.ClaimHistory.claims.indexOf(item);
            vm.state.ClaimHistory.claims.splice(index, 1);
        }

        function addClaim() {
            vm.state.ClaimHistory.claims.push({ year: null, claimType: null });
        }

        function removeSpecifiedItems(item) {
            var index = vm.state.contents.specifiedItems.indexOf(item);
            vm.state.contents.specifiedItems.splice(index, 1);
        }

        function addSpecifiedItems() {
            vm.state.contents.specifiedItems.push({
                description: null,
                specifiedItems: null,
                sumInsured: 0
            });
        }

        vm.isDuplicateExcess = function () {
            if ((vm.state.ExcessOption.Excess2 !== null && vm.state.ExcessOption.Excess2 !== "") && (vm.state.ExcessOption.Excess1 === vm.state.ExcessOption.Excess2)) {
                vm.ExcessValueFlag = true;
                vm.message = "Excess value cannot be same."
                return;
            }
            else {
                if ((vm.state.ExcessOption.Excess3 !== null && vm.state.ExcessOption.Excess3 !== "") && ((vm.state.ExcessOption.Excess2 === vm.state.ExcessOption.Excess3) || (vm.state.ExcessOption.Excess1 === vm.state.ExcessOption.Excess3))) {
                    vm.ExcessValueFlag = true;
                    vm.message = "Excess value cannot be same."
                    return;
                }
                else {
                    if ((vm.state.ExcessOption.Excess2 === null || vm.state.ExcessOption.Excess2 === "") && (vm.state.ExcessOption.Excess3 !== null && vm.state.ExcessOption.Excess3 !== "")) {
                        vm.ExcessValueFlag = true;
                        vm.message = "Please select Excess Option2."
                        return;
                    }
                    else {
                        vm.ExcessValueFlag = false;
                    }
                }
            }
        };

        function regoLookup(field) {
            var motorData;
            vm.Find = true;
            sessionStorageService.set(keyConstService.findRegoData, vm.Find);
            vm.NVIcNotFound = false;
            sessionStorageService.set(keyConstService.NVIcNotFound, vm.NVIcNotFound);
            if (vm.state.Vehicle.VinPlate === 'plate') {

                var plate = vm.state.Vehicle.RegistrationNumer;
                var jurisdiction = vm.state.Vehicle.State;
                vm.readonly = true;
                var caseNumberForPlate = vm.CaseNumber;
                var policyEffectiveDttm = '';
                var newBusinessData = JSON.parse(sessionStorageService.get(keyConstService.newBusinessCaseData));
                if (newBusinessData) {
                    policyEffectiveDttm = newBusinessData.data.EffectiveDate;
                } else {
                    policyEffectiveDttm = dateService.convertDatetoMMDDYYYFormat(vm.StartDate);
                }

                if (plate && jurisdiction && policyEffectiveDttm) {
                    var response = nvicMotorService.getMotorDetailsForPlate(plate, jurisdiction, policyEffectiveDttm, caseNumberForPlate).then(function (data) {
                        $log.log('motor data', data);
                        if (data.status) {
                            motorData = data.data[0];
                            //showing the first value only till the time how all the vehicle values will be shown
                            vm.state.Vehicle.NVICValue = motorData.nvic;
                            vm.state.Vehicle.ManufactureYear = motorData.year;
                            vm.state.Vehicle.MotorGlassDetailId = motorData.id;
                            vm.state.Vehicle.Make = motorData.make;
                            vm.state.Vehicle.Model = motorData.family;
                            vm.state.Vehicle.Transmission = motorData.transmission;
                            vm.state.Vehicle.Style = motorData.style;
                            vm.state.Vehicle.Size = motorData.size;
                            vm.state.Vehicle.Variant = motorData.variant;
                            vm.state.Vehicle.Series = motorData.series;
                            vm.state.Vehicle.Engine = motorData.engine;
                            vm.state.Vehicle.Cylinders = motorData.cylinder;
                            vm.state.Vehicle.VehicleDescription = motorData.vehicleDescription;
                            vm.state.Vehicle.BodyType = motorData.bodyType;
                            vm.state.Vehicle.Colour = motorData.colour;
                            vm.SelectedVehicleColour = motorData.colour;
                            ////vm.state.Vehicle.Code = motorData.code;
                            vm.state.Vehicle.GlassesCode = motorData.code;
                            ////vm.state.Coverages.InsureVehicleForValue = motorData.marketValue;
                            vm.state.Coverages.InsureVehicleForGlassMarketValueAV = motorData.marketValue;
                            vm.state.Coverages.InsureVehicleForGlassMarketValueAAV = motorData.marketValueAbove;
                            vm.state.Coverages.InsureVehicleForGlassMarketValueBAV = motorData.marketValueBelow;
                            vm.state.Vehicle.IsVehicleRegistered = "1";
                            if (vm.state.Vehicle.ManufactureYear === null && vm.state.Vehicle.Make === null && vm.state.Vehicle.Model === null &&
                                vm.state.Vehicle.Transmission === null && vm.state.Vehicle.BodyType === null && vm.state.Vehicle.Cylinders === null) {
                                toastr.error(messageConstService.errNVICNotFound);

                            }
                            if (vm.state.Vehicle.ManufactureYear) {
                                validateIsManfactureYearMore15(vm.state.Vehicle.ManufactureYear, vm.vehicleAgeToHideRoadsideAssistance);
                            } else {
                                vm.IsManfactureYearMore15 = false;
                                vm.state.Coverages.ComprehensiveRoadSide = false;
                            }
                            //// setting excess value if default excess value is picked from DB
                            if (vm.IsMotorGlassExcessEffective) {
                                if (motorData.defaultExcess === null) {
                                    vm.defaultExcessFlag = false;
                                }
                                else {
                                    vm.defaultExcessFlag = true;
                                }
                                vm.settingExcessAccordingToDefault(motorData.defaultExcess, vm.defaultExcessFlag, vm.PolicyNumber);
                            }
                            vehicleInsureVehicleForChange(field);
                            vm.editStateChange = false;
                        }
                        else {
                            var errMsg = data.errors[0].message;
                            vm.NVIcNotFound = true;
                            sessionStorageService.set(keyConstService.NVIcNotFound, vm.NVIcNotFound);
                            if (errMsg) {
                                $log.error('error', errMsg);
                                toastr.error(messageConstService.errRegoStateNotFound);
                                resetAllVehicleInfoWhenNoDataFound();
                                vehicleInsureVehicleForChange(field);
                                vm.IsManfactureYearMore15 = false;
                            }
                        }


                    }, function (e) {
                        toastr.error(messageConstService.errService3rdAPIUnavailable);
                        $log.error('error', e);
                    });
                }
            }


        }

        function validateIsManfactureYearMore15(manufactureYear, vehicleAgeToHideRoadsideAssistance) {
            var currentYear = new Date(vm.StartDateCalRoadside).getFullYear();
            if (((currentYear - manufactureYear) > vehicleAgeToHideRoadsideAssistance) && manufactureYear) {
                vm.IsManfactureYearMore15 = true;
                vm.state.Coverages.ComprehensiveRoadSide = false;
            }
            else {
                vm.IsManfactureYearMore15 = false;
            }
        }
        vm.VinPlateChange = function () {
            if (vm.state.Vehicle.VinPlate) {
                if (vm.state.Vehicle.VinPlate === 'vin') {
                    vm.state.Vehicle.PlateJurisdiction = "";
                }
                else {
                    vm.state.VehicleDetail.Vin = "";
                }
            }
        };

        vm.save = function (model) {
            $scope.addRelation.submitted = true;

            if ($scope.addRelation.$valid) {
                //ToDo: submit to db
                //$log.log(model);
            } else {
                $log.log("Errors in form save data");
            }
        };

        function saveQuote() {
            vm.disableButtons = true;
            setFalseValueForUWQuestions();
            vm.resetNonRegoDataValue = sessionStorageService.get(keyConstService.resetNonRegoData);
            vm.QuoteTransactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
            vm.state.Vehicle.Colour = vm.SelectedVehicleColour;
            if (vm.SelectedMotorListitem !== null || vm.isManualRego) {
                if (!vm.SelectedMotorListitem) {
                    vm.state.Vehicle.MotorGlassDetailId = vm.SelectedMotorListitem;
                }
                vm.state.Vehicle.IsNonRegoManual = vm.isManualRego;
                SetNonRegoValue();
            }
            else {
                vm.state.Vehicle.IsNonRegoManual = false;
            }
            sessionStorageService.remove(keyConstService.getTransactionIdWithoutSaving);
            sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
            sessionStorageService.remove(keyConstService.effectiveDateInEdit);
            sessionStorageService.remove(keyConstService.Colour);
            if (vm.transactionStatus == "Draft") {
                isNewEditTransaction = false;
            }
            else {
                isNewEditTransaction = sessionStorageService.get(keyConstService.IsNewEditTransaction);
            }
            var automaticPayment = -1;
            if (vm.endorsementVM != null) {
                vm.EffectiveDate = vm.endorsementVM.EndorsementEffectiveDate;
                ExpirationDate = vm.endorsementVM.ExpirationDate;
                automaticPayment = vm.brokerManagedPayment;
            }
            else {
                var newBusinessData = JSON.parse(sessionStorageService.get(keyConstService.newBusinessCaseData));
                if (newBusinessData) {
                    vm.EffectiveDate = newBusinessData.data.EffectiveDate;
                    ExpirationDate = newBusinessData.data.ExpirationDate;
                    automaticPayment = newBusinessData.data.BrokerManagedPayment;
                }
            }
            if (automaticPayment == -1) {
                automaticPayment = vm.brokerManagedPayment
            }
            vm.state.Payment.BrokerManagedPayment = automaticPayment;
            sessionStorageService.set(keyConstService.quoteState, vm.state);
            var data = sessionStorageService.get(keyConstService.quoteState);
            var finalData = { SaveContent: data, EffectiveDate: vm.EffectiveDate, ExpirationDate: ExpirationDate, TransactionId: vm.QuoteTransactionId, NewEditTransaction: isNewEditTransaction, RowVersion: vm.rowVersion, PaymentFrequency: vm.state.Payment.Frequency, InstallmentDate: vm.state.Payment.DayofInstallment, BrokerManagedPayment: automaticPayment  };

            var quoteRequest = quotesService.generateRequest(finalData, "Motor");
            quotesService.saveQuote(quoteRequest, "Motor").then(
                function (data) {
                    //var handledResponse = quotesService.handleResponse(data, "Motor");
                    if (data) {
                        if (data.data !== null && data.data.error !== null && data.data.error.number === 402) {
                            $timeout(function () {
                                $window.location.href = webUrlConstService.homeIndex;
                            }, 1000);
                            return;
                        }
                        if (data.status) {
                            toastr.success("Saved!");
                            //Remove PrimaryClientInsuredId
                            sessionStorageService.remove(keyConstService.PrimaryInsuredId);
                            vm.rowVersion = data.data.quoteTransaction.rowVersion;
                            isNewEditTransaction = false;
                            sessionStorageService.set(keyConstService.IsNewEditTransaction, isNewEditTransaction);
                            sessionStorageService.set(keyConstService.rowVersion, vm.rowVersion);
                            sessionStorageService.set(keyConstService.quoteTransactionId, data.data.quoteTransaction.id);
                            vm.QuoteTransactionId = data.data.quoteTransaction.id;
                            sessionStorageService.set(keyConstService.newBusinessCaseData.status, data.data.quoteTransaction.status);
                            vm.disableButtons = false;
                        }
                    } else {
                        toastr.error("Some went wrong. Please try again!");
                        vm.disableButtons = false;
                    }
                },
                function (e) {
                    $log.log(e);
                    toastr.error("Some went wrong. Please try again!");
                    vm.disableButtons = false;

                }
            );

        }

        //get quote for version 2.0 
        function getQuoteV2()
        {
            // do not remove it because getquote return when handledResponse.data.error.number === 600
            getQuote();
        }

        function setFalseValueForUWQuestions() {
            // set null to false otherwise json will not map to class in service
            if (vm.state) {
                if (vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsExistingDamageToVehicle === null) {
                    vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsExistingDamageToVehicle = false;
                }
                if (vm.state.UnderwritingCriteria.InsuredInLast3YearsData.HailDamage === null) {
                    vm.state.UnderwritingCriteria.InsuredInLast3YearsData.HailDamage = false;
                }
                if (vm.state.UnderwritingCriteria.InsuredInLast3YearsData.OtherDamage === null) {
                    vm.state.UnderwritingCriteria.InsuredInLast3YearsData.OtherDamage = false;
                }
                if (vm.state.UnderwritingCriteria.InsuredInLast3YearsData.AnyInsurancePolicyCancelledInLast3Years === null) {
                    vm.state.UnderwritingCriteria.InsuredInLast3YearsData.AnyInsurancePolicyCancelledInLast3Years = false;
                }
                //Default value changed for the question from null to false for version 2
                if (vm.state.OtherInformation.PolicyHolderHoldInsurance == null) {
                    vm.state.OtherInformation.PolicyHolderHoldInsurance = false;
                }
            }
        }

        function getQuote() {
            // set null to false otherwise json will not map to class in service
            setFalseValueForUWQuestions();
            sessionStorageService.remove(keyConstService.getTransactionIdWithoutSaving);
            sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
            sessionStorageService.remove(keyConstService.resetNonRegoData);
            sessionStorageService.remove(keyConstService.effectiveDateInEdit);
            sessionStorageService.remove(keyConstService.setDriverDL);
            sessionStorageService.remove(keyConstService.findRegoData);
            sessionStorageService.remove(keyConstService.Colour);
            sessionStorageService.set(keyConstService.sessionStorageState, false);
            if (vm.IsEndorsement) {

                vm.state.Payment.BrokerFeeExcludingGST = 0;
                vm.state.Payment.BrokerFeeGST = 0;
            }
            if (vm.SelectedMotorListitem !== null) {
                vm.state.Vehicle.MotorGlassDetailId = vm.SelectedMotorListitem;
                vm.state.Vehicle.IsNonRegoManual = vm.isManualRego;
                /* Check the selected value of non rego */
                SetNonRegoValue();
            }
            else {
                vm.state.Vehicle.IsNonRegoManual = false;
            }

            //// set colour = 'unknown' if null
            vm.state.Vehicle.Colour = vm.SelectedVehicleColour;

            vm.isDisabled = true;
            $log.log("json State:", JSON.stringify(vm.state));
            vm.QuoteTransactionId = JSON.parse(sessionStorageService.get(keyConstService.quoteTransactionId));
            if (vm.transactionStatus == "Draft") {
                isNewEditTransaction = false;
            }
            else {
                isNewEditTransaction = sessionStorageService.get(keyConstService.IsNewEditTransaction);
            }

            vm.rowVersion = JSON.parse(sessionStorageService.get(keyConstService.rowVersion));
            var automaticPayment = -1;
            if (vm.endorsementVM != null) {
                vm.EffectiveDate = vm.endorsementVM.EndorsementEffectiveDate;
                ExpirationDate = vm.endorsementVM.ExpirationDate;
                sessionStorageService.remove(keyConstService.endorsementRequestVM);
                sessionStorageService.remove(keyConstService.IsEndorsementEdit);
                automaticPayment = vm.brokerManagedPayment;
            }
            else {
                var newBusinessData = JSON.parse(sessionStorageService.get(keyConstService.newBusinessCaseData));
                if (newBusinessData) {
                    vm.EffectiveDate = newBusinessData.data.EffectiveDate;
                    ExpirationDate = newBusinessData.data.ExpirationDate;
                    automaticPayment = newBusinessData.data.BrokerManagedPayment;
                }
            }
            if (automaticPayment == -1) {
                automaticPayment = vm.brokerManagedPayment
            }
            vm.state.Payment.BrokerManagedPayment = automaticPayment;
            sessionStorageService.set(keyConstService.quoteState, vm.state);
            var data = sessionStorageService.get(keyConstService.quoteState);
            var pData = JSON.parse(data);
            if (sessionStorageService.get(keyConstService.IsCopyQuote) === "true")
                isNewEditTransaction = false;
            var finalData = { SaveContent: data, EffectiveDate: vm.EffectiveDate, ExpirationDate: ExpirationDate, TransactionId: vm.QuoteTransactionId, NewEditTransaction: isNewEditTransaction, PaymentFrequency: vm.state.Payment.Frequency, InstallmentDate: vm.state.Payment.DayofInstallment, BrokerManagedPayment: automaticPayment  };
            vm.disableButtons = true;
            quotesService
                .generateQuote(
                    quotesService.generateRequest(finalData, "Motor"),
                    "Motor"
                )
                .then(
                    function (data) {
                        var handledResponse = quotesService.handleResponse(data, "Motor");
                        $log.log("handledResponse", handledResponse);
                        if (handledResponse.data && handledResponse.data.transactionId) {
                            sessionStorageService.set(keyConstService.quoteTransactionId, handledResponse.data.transactionId);
                            vm.QuoteTransactionId = sessionStorageService.get(
                                keyConstService.quoteTransactionId
                            );
                            sessionStorageService.remove(keyConstService.IsCopyQuote);
                            sessionStorageService.remove(keyConstService.IsRenewalPolicy);
                        }
                        if (handledResponse.status) {
                            //Remove PrimaryClientInsuredId
                            sessionStorageService.remove(keyConstService.PrimaryInsuredId);
                            if (handledResponse.data.error !== null) {
                                if (handledResponse.data.error.number === 401 || handledResponse.data.error.number === 402 || handledResponse.data.error.number === 400) {
                                    if (handledResponse.data.error.number === 401) {
                                        toastr.error(messageConstService.errServiceUnavailable);
                                    }
                                    if (handledResponse.data.error.number === 400) {
                                        toastr.error(handledResponse.data.error.message);
                                    }
                                    $timeout(function () {
                                        $window.location.href = webUrlConstService.homeIndex;
                                    }, 1000);
                                    return;
                                }
                            }
                            if (handledResponse.data.decisionResult) {
                                //
                                if (
                                    handledResponse.data.decisionResult.isDeclined ||
                                    handledResponse.data.decisionResult.isReferral || handledResponse.data.ratingResult
                                ) {
                                    $window.location.href = webUrlConstService.quoteCaseIndex + "?" + sessionStorageService.getEncryption("quoteTransactionId=" + vm.QuoteTransactionId);
                                } else {
                                    toastr.error(
                                        "Rating Service is currently not available. Please try again or contact system administrator."
                                    );
                                    vm.disableButtons = false;
                                    $log.log("Rating Service is currently not available. Please try again or contact system administrator.");
                                }
                            } else {
                                toastr.error(
                                    "Service is currently not available. Please try again or contact system administrator."
                                );
                                vm.disableButtons = false;
                            }
                        } else {
                            //error handling for version 2.0
                            if (handledResponse.errors.length > 0) {
                                if (handledResponse.errors.filter((x) => x.Severity > 10).length > 0) {

                                    var severerrors = handledResponse.errors.filter((x) => x.Severity > 10);

                                    for (var i = 0; i < severerrors.length; i++) {
                                        let servererror = severerrors[0];
                                        let msg = servererror.Message;
                                        let msgcontent = msg.split(',')[2];
                                        toastr.error(msgcontent);
                                    }

                                    vm.disableButtons = false;
                                }
                                else {
                                    toastr.error(messageConstService.errServiceUnavailable);
                                }
                            }
                            else if (handledResponse.data.error.number === 600) {
                                toastr.error(handledResponse.data.validationMessages);
                            }
                        }
                    },
                    function (e) {
                        $log.error("error", e);
                        var myJSON = JSON.stringify(e);
                        $log.log('error myJSON', myJSON);
                        toastr.error(messageConstService.errMessageWhenDuplicateEntryIssue);
                    }
                );
        }

        function validAgreedValue(field) {
            if (parseInt(vm.state.Coverages.InsureVehicleForValue) > parseInt(vm.state.Coverages.InsureVehicleForGlassMarketValueAAV) || parseInt(vm.state.Coverages.InsureVehicleForValue) < parseInt(vm.state.Coverages.InsureVehicleForGlassMarketValueBAV)) {
                field.$setValidity('InsureVehicleForValue', false);
            }
            else {
                field.$setValidity('InsureVehicleForValue', true);
            }
        }

        //vm.getConvertedDate = function () {
        //    var dateofBirth = vm.state.PolicyHolder.DateOfBirthApp;
        //    if (dateofBirth) {
        //        var response = dateService.validateBirthDDMMYYYY(dateofBirth, 150);

        //if (!response.isValid) {
        //    vm.state.PolicyHolder.DateOfBirth = '';
        //    vm.state.PolicyHolder.DateOfBirthApp = '';
        //    toastr.warning(response.errorMsg);
        //    return;
        //}

        //vm.state.PolicyHolder.DateOfBirth = response.date;
        //    }

        //}

        vm.getConvertedDate = function (dob, index, formElement) {
            var dateofBirth = dob;
            if (dateofBirth) {
                var response = dateService.validateBirthDDMMYYYY(dateofBirth, 150);
                if (!response.isValid) {
                    if (index !== null) {
                        vm.state.Insured.AdditionalPolicyHolderList[index].OtherDateOfBirth = '';
                        vm.state.Insured.OtherDateOfBirthApp = '';
                        toastr.warning(response.errorMsg);
                        formElement.$setValidity("OtherDateOfBirth_", false)
                        return;
                    }
                    else {
                        vm.state.Insured.DateOfBirth = '';
                        vm.state.Insured.DateOfBirthApp = '';
                        toastr.warning(response.errorMsg);
                        formElement.$setValidity("OtherDateOfBirth_", true)
                        return;
                    }

                }
                else {
                    if (index !== null) {
                        vm.state.Insured.AdditionalPolicyHolderList[index].OtherDateOfBirth = response.date;
                    }
                    else {
                        vm.state.Insured.DateOfBirth = response.date;
                    }
                }
            }
        }


        vm.getOtherConvertedDate = function (dob, index, formElement) {
            var dateofBirth = dob;
            if (dateofBirth) {
                var response = dateService.validateBirthDDMMYYYY(dateofBirth, 150);

                if (!response.isValid) {
                    vm.state.Insured.AdditionalPolicyHolderList[index].OtherDateOfBirth = '';
                    vm.state.Insured.OtherDateOfBirthApp = '';
                    formElement.$setValidity("OtherDateOfBirth_", false);
                    toastr.warning(response.errorMsg);
                }
                else {
                    formElement.$setValidity("OtherDateOfBirth_", true);
                }

                vm.state.Insured.AdditionalPolicyHolderList[index].OtherDateOfBirth = response.date;
                vm.checkFutureDate(vm.state.Insured.AdditionalPolicyHolderList.length);
            }

        }

        function validateDOB(formDOB, formElement, DOB, YearDL) {
            if (DOB) {
                var response = dateService.validateBirthDDMMYYYY(DOB, 150);
                //$log.log("vm.state.Drivers.MainDriver.DOB", vm.state.Drivers.MainDriver.DOB);
                if (!response.isValid) {
                    formDOB.$setValidity("dateofBirth", false);
                    formDOB.errorMessage = "dateofBirth future date not allowed.";

                    toastr.warning(response.errorMsg);
                    return;
                }
                formDOB.$setValidity("dateofBirth", true);
                validateYear(formElement, DOB, YearDL);

            }
        }

        function validateYear(formElement, DOB, YearDL) {
            if (DOB && YearDL) {
                //commented after confirmation by client
                //var getEffectiveDate = reteiveEffectiveDate(true);
                //getEffectiveDate = dateService.convertDatetoMMDDYYYFormat(getEffectiveDate);
                //var year = dateService.getYear(getEffectiveDate);
                //// if select year greater than policy effective year then it show error
                //if (YearDL > year) {
                //    toastr.error(messageConstService.errSelectedYeargrtEffDte);
                //    // for disable quote
                //    vm.setDriverDL = false;
                //    return;
                //}
                var validDateResponse = dateService.validateDate(DOB);
                if (validDateResponse.isValid) {
                    // in case of endorsement effective date
                    var getEffectiveDate = reteiveEffectiveDate(false);
                    var getDate = moment(getEffectiveDate).format('MM/DD/YYYY');
                    var getEffyear = getDate.split('/');
                    var effyear = getEffyear[2];
                    var effMonth = getEffyear[0];
                    var effDate = getEffyear[1];
                    var validDateResponse = dateService.validateDate(DOB);
                    var selectedDate = moment(validDateResponse.date);
                    var getSelectedyear = validDateResponse.date.split('/');
                    var selectedyear = getSelectedyear[2];
                    var selectedMonth = getSelectedyear[0];
                    var selectedDate = getSelectedyear[1];
                    vm.allowedDriverLicenseYear = 17;
                    if ((effyear - selectedyear) >= vm.allowedDriverLicenseYear) {
                        if (formElement) {
                            formElement.$setValidity("driverYearDL", true);
                        }

                        if ((effyear - selectedyear) == vm.allowedDriverLicenseYear && (effMonth == selectedMonth)) {
                            if (selectedDate <= effDate) {
                                vm.setDriverDL = true;
                            }

                            else {
                                if (formElement) {
                                    formElement.$setValidity("driverYearDL", false);
                                    formElement.errorMessage = messageConstService.errInvalidDLYear;
                                }
                                vm.setDriverDL = false;
                                toastr.error(messageConstService.errInvalidDLYear);
                                return;
                            }
                        }
                        else if (effyear - selectedyear > vm.allowedDriverLicenseYear) {

                            vm.setDriverDL = true;
                        }
                        else if ((effyear - selectedyear) == vm.allowedDriverLicenseYear && (effMonth != selectedMonth)) {
                            if (selectedMonth <= effMonth) {
                                vm.setDriverDL = true;
                            }
                            else {
                                if (formElement) {
                                    formElement.$setValidity("driverYearDL", false);
                                    formElement.errorMessage = messageConstService.errInvalidDLYear;
                                }
                                vm.setDriverDL = false;
                                toastr.error(messageConstService.errInvalidDLYear);
                                return;
                            }
                        }
                        var differenceYear = YearDL - selectedyear;
                        if (differenceYear < vm.allowedDriverLicenseYear) {
                            if (formElement) {
                                formElement.$setValidity("driverYearDL", false);
                                formElement.errorMessage = messageConstService.errInvalidDLYear;
                            }
                            vm.setDriverDL = false;
                            toastr.error(messageConstService.errInvalidDLYear);
                            return;
                        }
                        else {
                            vm.setDriverDL = true;
                        }
                    }
                    else {
                        if (formElement) {
                            formElement.$setValidity("driverYearDL", false);
                            formElement.errorMessage = messageConstService.errInvalidDLYear;
                        }
                        vm.setDriverDL = false;
                        toastr.error(messageConstService.errInvalidDLYear);
                        return;
                    }
                }
            }
            if (!YearDL && getQuestionSetWithoutSaving) {
                if (formElement) {
                    formElement.$setValidity("driverYearDL", false);
                    formElement.errorMessage = messageConstService.errInvalidDLYear;
                    toastr.error(messageConstService.errInvalidDLYear);
                }
            }
        }

        function addAdditonalCoverages(additonalCoverage) {
            ////if already exists then remove else add
            var addtionalCoverages = vm.state.Coverages.AddtionalCoverages;
            var isExists = false;
            for (var i = 0; i < addtionalCoverages.length; i++) {
                if (addtionalCoverages[i] === additonalCoverage) {
                    isExists = true;

                }
            }

            if (isExists) {
                addtionalCoverages.splice(addtionalCoverages.indexOf(additonalCoverage), 1)

            } else {
                addtionalCoverages.push(additonalCoverage);
            }
        }

        function removeNonManufactureModification(item) {
            //find the index from the modifications
            vm.state.Coverages.NonManufactureModifications.splice(vm.state.Coverages.NonManufactureModifications.indexOf(item), 1);
        }

        function isNonManufactureModificationChanged() {
            if (!vm.state.Coverages.IsNonManufactureModification) {
                ////remove all.
                vm.state.Coverages.NonManufactureModifications = [{ ModificationCategory: null, Description: null, Value: null }];
            }

            if (vm.IsEndorsement && vm.state.Coverages.IsNonManufactureModification)
            {
                vm.state.Coverages.NonManufactureModifications = angular.copy(endorsementState.Coverages.NonManufactureModifications);
            }
        }

        function addNonManufactureModification() {
            //add new in the modification
            var mod = { ModificationCategory: null, Description: null, Value: null };
            vm.state.Coverages.NonManufactureModifications.push(mod);
        }

        function removeAdditionalPolicyHolder(item) {
            vm.state.Insured.AdditionalPolicyHolders.splice(vm.state.Insured.AdditionalPolicyHolders.indexOf(item), 1);
        }

        function addAdditionalPolicyHolder() {
            var mod = { Name: null, DateOfBirth: null };
            vm.state.Insured.AdditionalPolicyHolders.push(mod);
        }

        function removeAdditionalDriver(item) {
            vm.state.Drivers.AdditionalDrivers.splice(vm.state.Drivers.AdditionalDrivers.indexOf(item), 1);
            for (var i = 0; i < vm.state.Drivers.AdditionalDrivers.length; i++){
                validateYear(null,vm.state.Drivers.AdditionalDrivers[i].DOB, vm.state.Drivers.AdditionalDrivers[i].YearDL)
            }
        }

        function addAdditionalDriver() {
            if (vm.state.Drivers.AdditionalDrivers.length < 7) {
                var additonalDriver = {
                    Name: null,
                    DOB: null,
                    Gender: null,
                    YearDL: null,
                    ClaimNumber: "0",
                    Claims: [],
                    LicenceSuspensionsOrCancellationsInLast3Years: "0",
                    LicenceSuspensionsOrCancellationsInLast3YearsReasonArray: [],
                    IsDisableClaim: false,
                    CreateDate: null
                };
                vm.state.Drivers.AdditionalDrivers.push(additonalDriver);
            }


        }

        function removeNote(item) {
            vm.state.Notes.splice(vm.state.Notes.indexOf(item), 1);
        }

        /**
         * add the new note and hide the if more than one
         * @param {any} currentNote
         */
        function addNote(currentNote) {
            var newNote = {
                Note: null,
                IsPrintable: (!currentNote.IsPrintable)
            };
            if (vm.state.Notes.length < 2) {
                vm.state.Notes.push(newNote);
            };
        }

        /**
         * / change the printable status of other
         * @param {any} note
         */
        function changeNotesPrintable(currentNote) {
            if (vm.state.Notes.length > 1) {
                var currentIndex = vm.state.Notes.indexOf(currentNote);
                var index = 1 - currentIndex;
                vm.state.Notes[index].IsPrintable = (!currentNote.IsPrintable);
            }

        }


        function changeInMainDrivesClaimsNumber() {
            //changes the claims of main driver as per the mainDriverClaimsNumber.
            var numberOfClaims = vm.state.Drivers.MainDriver.ClaimNumber;
            var currentClaims = vm.state.Drivers.MainDriver.Claims;
            var claimsToAdd = numberOfClaims - currentClaims.length;
            if (claimsToAdd > 0) {
                for (var i = 0; i < claimsToAdd; i++) {
                    vm.state.Drivers.MainDriver.Claims.push({
                        ClaimType: null,
                        ClaimYear: null
                    });
                }
            }
            if (claimsToAdd < 0) {
                //remove from last
                for (var i = 0; i > claimsToAdd; i--) {
                    vm.state.Drivers.MainDriver.Claims.pop();
                }
            }
        }

        function changeInAddiDriverLicenseSuspensionCancellationNumber(index) {
            var additionalDriver = vm.state.Drivers.AdditionalDrivers[index];
            var count = additionalDriver.LicenceSuspensionsOrCancellationsInLast3Years;
            var currentLicenceSuspensionsOrCancellationsInLast3YearsReasonArray = additionalDriver.LicenceSuspensionsOrCancellationsInLast3YearsReasonArray;
            var ToAdd = count - currentLicenceSuspensionsOrCancellationsInLast3YearsReasonArray.length;
            if (ToAdd > 0) {
                for (var i = 0; i < ToAdd; i++) {
                    additionalDriver.LicenceSuspensionsOrCancellationsInLast3YearsReasonArray.push({
                        LicenceSuspensionsOrCancellationsInLast3YearsReason: null,
                        LicenceSuspensionsOrCancellationsInLast3YearsReasonOtherText: null
                    });
                }
            }
            if (ToAdd < 0) {
                //remove from last
                for (var i = 0; i > ToAdd; i--) {
                    additionalDriver.LicenceSuspensionsOrCancellationsInLast3YearsReasonArray.pop();
                }
            }
        }

        function changeInAddiDrivesLicenseSuspensionCancellationNumber(index) {
            var additionalDriver = vm.state.Drivers.AdditionalDrivers[index];

            var count = additionalDriver.ClaimNumber;
            var currentClaims = additionalDriver.Claims;
            var claimsToAdd = numberOfClaims - currentClaims.length;
            if (claimsToAdd > 0) {
                for (var i = 0; i < claimsToAdd; i++) {
                    additionalDriver.Claims.push({
                        ClaimType: null,
                        ClaimYear: null
                    });
                }
            }
            if (claimsToAdd < 0) {
                //remove from last
                for (var i = 0; i > claimsToAdd; i--) {
                    additionalDriver.Claims.pop();
                }
            }
        }

        function changeInMainDrivesClaimsNumber() {
            var numberOfClaims = vm.state.Drivers.MainDriver.ClaimNumber;
            var currentClaims = vm.state.Drivers.MainDriver.Claims;
            var claimsToAdd = numberOfClaims - currentClaims.length;
            if (claimsToAdd > 0) {
                for (var i = 0; i < claimsToAdd; i++) {
                    vm.state.Drivers.MainDriver.Claims.push({
                        ClaimType: null,
                        ClaimYear: null
                    });
                }
            }
            if (claimsToAdd < 0) {
                //remove from last
                for (var i = 0; i > claimsToAdd; i--) {
                    vm.state.Drivers.MainDriver.Claims.pop();
                }
            }
        }

        function changeInAddiDriverClaimsNumber(index) {
            var additionalDriver = vm.state.Drivers.AdditionalDrivers[index];

            var numberOfClaims = additionalDriver.ClaimNumber;
            var currentClaims = additionalDriver.Claims;
            var claimsToAdd = numberOfClaims - currentClaims.length;
            if (claimsToAdd > 0) {
                for (var i = 0; i < claimsToAdd; i++) {
                    additionalDriver.Claims.push({
                        ClaimType: null,
                        ClaimYear: null
                    });
                }
            }
            if (claimsToAdd < 0) {
                //remove from last
                for (var i = 0; i > claimsToAdd; i--) {
                    additionalDriver.Claims.pop();
                }
            }
        }
        function changeInMainDrivesLicenseSuspensionCancellationNumber() {
            var count = vm.state.Drivers.MainDriver.LicenceSuspensionsOrCancellationsInLast3Years;
            var currentLicenceSuspensionsOrCancellationsInLast3YearsReasonArray = vm.state.Drivers.MainDriver.LicenceSuspensionsOrCancellationsInLast3YearsReasonArray;
            var ToAdd = count - currentLicenceSuspensionsOrCancellationsInLast3YearsReasonArray.length;
            if (ToAdd > 0) {
                for (var i = 0; i < ToAdd; i++) {
                    vm.state.Drivers.MainDriver.LicenceSuspensionsOrCancellationsInLast3YearsReasonArray.push({
                        LicenceSuspensionsOrCancellationsInLast3YearsReason: null,
                        LicenceSuspensionsOrCancellationsInLast3YearsReasonOtherText: null
                    });
                }
            }
            if (ToAdd < 0) {
                //remove from last
                for (var i = 0; i > ToAdd; i--) {
                    vm.state.Drivers.MainDriver.LicenceSuspensionsOrCancellationsInLast3YearsReasonArray.pop();
                }
            }
        }
        function vehicleInsureVehicleForChange(field) {

            if (vm.state.Coverages.InsureVehicleFor === vm.state.Coverages.InsureVehicleForList[1].Value) {
                vm.state.Coverages.InsureVehicleForValue = vm.state.Coverages.InsureVehicleForGlassMarketValueAV;
            }
            if (vm.state.Coverages.InsureVehicleFor === "Agreed") {
                vm.state.Coverages.InsureVehicleForValue = 0;
            }
        }

        function isAdditionalPolicyHolderChange() {
            if (!vm.state.Insured.IsAdditionalPolicyHolder) {
                vm.state.Insured.AdditionalPolicyHolderList = [{ AdditionalPolicyHolder: null, AdditionalDateOfBirth: null, AdditionalPolicyHolderType: null, OtherPolicyHolderName: null, OtherDateOfBirth: null }];
                vm.validDOBOtherInsurer = true;
            }

            if (vm.IsEndorsement && vm.state.Insured.IsAdditionalPolicyHolder)
            {
                vm.state.Insured.AdditionalPolicyHolderList = angular.copy(endorsementState.Insured.AdditionalPolicyHolderList);
            }
        }

        function isEverInsuranceDeclinedChange() {
            if (!vm.state.AcceptanceCriteria.IsEverInsuranceDeclined) {
                vm.state.AcceptanceCriteria.ReasonEverInsuranceDeclined = "";
            }
        }

        function isClaimDeclinedIn3YearsChange() {
            if (!vm.state.AcceptanceCriteria.IsClaimDeclinedIn3Years) {
                vm.state.AcceptanceCriteria.ReasonClaimDeclinedIn3Years = "";
            }

        }

        function isAdditionalDriverChange() {
            if (vm.state.Drivers.IsAdditionalDriver == false) {
                vm.setDriverDL = true;
            }
            if (!vm.state.Drivers.IsAdditionalDriver) {
                vm.state.Drivers.AdditionalDrivers = [{
                    Name: null,
                    DOB: null,
                    Gender: null,
                    YearDL: null,
                    ClaimNumber: "0",
                    Claims: [],
                    LicenceSuspensionsOrCancellationsInLast3Years: "0",
                    LicenceSuspensionsOrCancellationsInLast3YearsReasonArray: [],
                    IsDisableClaim: false,
                    CreateDate: null
                }];
            }

            if (vm.IsEndorsement && vm.state.Drivers.IsAdditionalDriver) {
                vm.state.Drivers.AdditionalDrivers = angular.copy(endorsementState.Drivers.AdditionalDrivers);
                var endorsementDataVM = JSON.parse(sessionStorageService.get(keyConstService.endorsementRequestVM));
                if (endorsementDataVM)
                {
                    var endorsementEffectiveDate = endorsementDataVM.EndorsementEffectiveDate;
                    vm.state.Drivers.AdditionalDrivers.forEach(function (ele, index) {
                        if (moment(ele.CreateDate).format('MM/DD/YYYY') == endorsementEffectiveDate) {
                            ele.IsDisableClaim = false;
                        }
                    });
                }
            }
        }

        function execssChange(item, form, excessIndex) {
            var excess = parseInt(item);
            if (vm.endorsementVM) {
                vm.endorsementVM.Excess = item;
                sessionStorageService.set(keyConstService.endorsementRequestVM, vm.endorsementVM);
            }
            var index = vm.ExcessOptionArr.indexOf(excess);
            if (index >= 0) {
                vm.ExcessOptionArr[excessIndex] = excess;
                if (excessIndex === 0) {
                    form.ExcessOption1.$setValidity("excess", false);
                    form.ExcessOption1.errorMessage = "Duplicate excess not allowed.";
                    vm.ExcessValueFlag = true;
                }
                else if (excessIndex === 1) {
                    form.ExcessOption2.$setValidity("excess", false);
                    form.ExcessOption2.errorMessage = "Duplicate excess not allowed.";
                    vm.ExcessValueFlag = true;
                }
                else if (excessIndex === 2) {
                    form.ExcessOption3.$setValidity("excess", false);
                    form.ExcessOption3.errorMessage = "Duplicate excess not allowed.";
                    vm.ExcessValueFlag = true;
                }

                toastr.error("Duplicate excess not allowed.");
                return;
            }
            vm.ExcessOptionArr[excessIndex] = excess;
            //form.$setValidity("excess", true);

            if (vm.ExcessOptionArr[0] !== vm.ExcessOptionArr[1] && vm.ExcessOptionArr[1] !== vm.ExcessOptionArr[2] && vm.ExcessOptionArr[2] !== vm.ExcessOptionArr[0]) {
                form.ExcessOption1.$setValidity("excess", true);
                form.ExcessOption2.$setValidity("excess", true);
                form.ExcessOption3.$setValidity("excess", true);
                vm.ExcessValueFlag = false;
            }
        }



        function addressMapped(address) {
            if (!address) {
                vm.state.OvernightParkedAddress.AddressText = null;

            }

            if (address && address.value == 'N/A') {
                address = null;
                vm.selectedAddress = null;
                vm.showManualAddressOption();
            }

            if (address && address.value == 'N/A') {
                address = null;
                vm.selectedAddress = null;
                vm.showManualAddressOption();
            }

            if (address) {
                if (!address.text) {
                    vm.state.OvernightParkedAddress.AddressText = address;
                }
                if (address.text) {
                    vm.state.OvernightParkedAddress.AddressText = address.text;
                    if (address.value) {
                        vm.state.OvernightParkedAddress.AddressValue = address.value;
                        var splitSate = address.value.split('|');
                        vm.nswState = splitSate[0];
                        vm.checkIsSmallBusinessStampDutyEligible();
                        vm.AddressState = splitSate[0];
                        if (vm.AddressState) {
                            vm.stateChange(vm.AddressState)
                        }
                        else {
                            $log.log("AddressState not found!");
                        }

                    }
                }
                if (vm.AddressChange) {
                    vm.getAdressEnquiryDetails();
                }
            }
        }

        function ResetHasInsuredInLast3YearsSection() {
            if (!vm.state.UnderwritingCriteria.HasInsuredInLast3Years) {
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsEverInsuranceDeclined = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.ReasonEverInsuranceDeclined = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsCriminalConvictionFraudTheftBurglaryArson = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsClaimDeclinedIn3Years = false;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.ReasonClaimDeclinedIn3Years = null;
                //New Question Added For Version 2.0
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsExistingDamageToVehicle = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.HailDamage = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.OtherDamage = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.AnyInsurancePolicyCancelledInLast3Years = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.CancellationReason = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.NoOfCancellationOccurredInLast3YearsForInsured = null;
            }
            else {
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsEverInsuranceDeclined = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsCriminalConvictionFraudTheftBurglaryArson = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsClaimDeclinedIn3Years = null;
                vm.state.OtherInformation.IsEligibleForNSWSmallBusinessSDExemption = vm.state.OtherInformation.IsEligibleForNSWSmallBusinessSDExemption
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsExistingDamageToVehicle = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.HailDamage = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.OtherDamage = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.AnyInsurancePolicyCancelledInLast3Years = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.CancellationReason = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.NoOfCancellationOccurredInLast3YearsForInsured = null;
            }
        }

        //reset New Question of Version 2.0 Underwriting Section
        function resetExistingDamageToTheVehicleSection() {
            vm.state.UnderwritingCriteria.InsuredInLast3YearsData.HailDamage = null;
            vm.state.UnderwritingCriteria.InsuredInLast3YearsData.OtherDamage = null;
        }

        //reset  New Question of Version 2.0 Underwriting Section
        function resetInsurancePolicyCancelledInTheLast3YearsSection() {
            vm.state.UnderwritingCriteria.InsuredInLast3YearsData.CancellationReason = null;
            vm.state.UnderwritingCriteria.InsuredInLast3YearsData.NoOfCancellationOccurredInLast3YearsForInsured = null;
        }

        //reset New Question of Version 2.0 Other Information
        function resetPolicyHolderCurrentlyHoldInsuranceSection() {
            vm.state.OtherInformation.PeriodOfInsuranceHoldByPolicyholder = null;
        }

        function checkIsSmallBusinessStampDutyEligible(resetVehicle) {
            vm.state.OtherInformation.IsSmallBusinessStampDutyEligibleShowHide = false;
            vm.showDeclineMessageVehicleUsedFor = false;
            if (resetVehicle && !vm.isManualRego) {
                resetAllVehicleInfoIncludingRegistration();
            }

            if (vm.state.OtherInformation.VehicleUsedFor === "RideShare" || vm.state.OtherInformation.VehicleUsedFor == "ForHireOrTaxi") {
                vm.showDeclineMessageVehicleUsedFor = true;
            }
            if (vm.nswState === "NSW" && vm.state.OtherInformation.VehicleUsedFor === "PrimarlyBusinessUse") {
                vm.state.OtherInformation.IsSmallBusinessStampDutyEligibleShowHide = true;
                vm.state.OtherInformation.IsEligibleForNSWSmallBusinessSDExemption = false;

            }
            else {
                vm.state.OtherInformation.IsSmallBusinessStampDutyEligibleShowHide = false;
                vm.state.OtherInformation.IsEligibleForNSWSmallBusinessSDExemption = null;
            }
        }

        function resetAllVehicleInfo() {
            vm.Find = false;
            sessionStorageService.set(keyConstService.findRegoData, vm.Find)
            if (vm.isManualRego) {
                vm.Find = true;
                sessionStorageService.set(keyConstService.findRegoData, vm.Find)
            }
            vm.state.Vehicle.Make = null;
            vm.state.Vehicle.Model = null;
            vm.state.Vehicle.Cylinders = null;
            vm.state.Vehicle.Transmission = null;
            vm.state.Vehicle.BodyType = null;
            vm.state.Vehicle.ManufactureYear = null;
            vm.state.Vehicle.Style = null;
            vm.state.Vehicle.Size = null;
            vm.state.Vehicle.Variant = null;
            vm.state.Vehicle.Series = null;
            vm.state.Vehicle.Engine = null;
            vm.state.Vehicle.Cylinders = null;
            vm.state.Vehicle.VehicleDescription = null;
            vm.state.Vehicle.IsVehicleRegistered = null;
            vm.state.Vehicle.NVICValue = "NA";
        }

        function changeBrokerCommission() {
            vm.brokerCommissionLimitMessage = false;
            if (vm.data) {
                if (vm.state.Coverages.Coverage == "Comprehensive") {
                    for (var i = 0; i < vm.data.length; i++) {
                        if (vm.data[i].coverCode === "COMPREHENSIVE") {
                            vm.state.BrokerCommission.BrokerCommissionPercentage = vm.data[i].brokerCommissionFee;
                            vm.maxbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMax;
                            vm.minbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMin;
                        }
                    }
                }
                if (vm.state.Coverages.Coverage === "ThirdPartyProperty") {
                    for (var i = 0; i < vm.data.length; i++) {
                        if (vm.data[i].coverCode === "THIRDPARTYPROPERTY") {
                            vm.state.BrokerCommission.BrokerCommissionPercentage = vm.data[i].brokerCommissionFee;
                            vm.maxbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMax;
                            vm.minbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMin;
                        }
                    }
                }
            }
        }

        function resetAllVehicleInfoIncludingRegistration() {
            vm.state.Vehicle.Make = null;
            vm.state.Vehicle.Model = null;
            vm.state.Vehicle.Cylinders = null;
            vm.state.Vehicle.Transmission = null;
            vm.state.Vehicle.BodyType = null;
            vm.state.Vehicle.ManufactureYear = null;
            vm.state.Vehicle.Style = null;
            vm.state.Vehicle.Size = null;
            vm.state.Vehicle.Variant = null;
            vm.state.Vehicle.Series = null;
            vm.state.Vehicle.Engine = null;
            vm.state.Vehicle.Cylinders = null;
            vm.state.Vehicle.VehicleDescription = null;
            vm.state.Vehicle.IsVehicleRegistered = null;
            vm.state.Vehicle.NVICValue = "NA";
            vm.state.Vehicle.RegistrationNumer = null;
        }

        vm.checkBrkerCommissionLimit = function () {
            vm.brokerCommissionLimitMessage = false;
            var regexp = /^[0-9]+(\.[0-9]{1,2})?$/;
            if (!regexp.test(vm.state.BrokerCommission.BrokerCommissionPercentage)) {
                vm.state.BrokerCommission.BrokerCommissionPercentage = null;
                vm.brokerCommissionLimitMessage = true;
            }

            if (vm.state.BrokerCommission.BrokerCommissionPercentage > vm.maxbrokerCommissionPercentage || vm.state.BrokerCommission.BrokerCommissionPercentage < vm.minbrokerCommissionPercentage)
                vm.brokerCommissionLimitMessage = true;
        }

        function resetAddressData() {
            vm.nswState = null;
            vm.checkIsSmallBusinessStampDutyEligible();
            if (vm.state.OvernightParkedAddress.IsManualAddress) {
                vm.previousAddress = vm.state.OvernightParkedAddress.Address;
                vm.previousSelectedAddress = vm.selectedAddress;
                vm.state.OvernightParkedAddress.Address = null;
                vm.selectedAddress = null;
                vm.selectedMannualAddress = null;
                vm.mannualSearchText = null;
                vm.state.OvernightParkedAddress.AddressValue = null;
            } else {
                //restore the address
                vm.selectedAddress = vm.previousSelectedAddress;
                vm.state.OvernightParkedAddress.AddressLine1 = null;
                vm.state.OvernightParkedAddress.AddressText = null;
            }

        }

        function querySearch(query) {
            return $http.get(apiUrlConstService.addressURL + 'IntechAddressListAsync?address=' + query, { skipInterceptor: true })
                .then(function (result) {
                    let obj = {
                        text: messageConstService.manualAddressList,
                        value: 'N/A',
                        postCode: null
                    };

                    let resultantdata = result.data.data;
                    if (resultantdata.length > 0) {
                        resultantdata.push(obj);
                    }

                    return resultantdata;
                });
        }


        function mannualSearchQuery(query) {
            return $http.get(apiUrlConstService.addressURL + 'MannualAddressList?searchAddress=' + query, { skipInterceptor: true })
                .then(function (result) {
                    return result.data.data;
                });
        }

        function checkValidManualAddress(field) {
            if (vm.mannualSearchText) {
                if (!vm.selectedMannualAddress) {
                    field.$setValidity('invalid', false);
                }
                else {
                    field.$setValidity('invalid', true);
                }
            }
        }

        function nextPremium() {
            vm.getTransactionIdWithoutSaving = null;
            sessionStorageService.remove(keyConstService.getTransactionIdWithoutSaving);
            if (vm.policyTransactionId) {
                $window.location.href = webUrlConstService.bindIndex + sessionStorageService.getEncryption('id=' + vm.policyTransactionId);
            }
            else {
                window.location = webUrlConstService.quoteCasePremiumURL + sessionStorageService.getEncryption('quoteTransactionId=' + vm.TransactionId);
            }
        }

        vm.ResetDeclineSection = function () {
            if (!vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsEverInsuranceDeclined) {
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.ReasonEverInsuranceDeclined = null;
            }
            if (!vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsClaimDeclinedIn3Years) {
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.ReasonClaimDeclinedIn3Years = null;
            }
        };

        function resetOtherInformationForInterestedParty() {

            vm.state.OtherInformation.OtherInterestPartyText = null;
        }

        function resetOtherInformationForPreviousInsurer() {
            vm.state.OtherInformation.OtherPreviousInsuredText = null;
        }

        function NonRego(e) {
            if (e.target.checked) {
                vm.isManualRego = true;
                vm.state.Vehicle.IsNonRegoManual = true;
                vm.Find = true;
                sessionStorageService.set(keyConstService.findRegoData, vm.Find);
                vm.NVIcNotFound = false;
                sessionStorageService.set(keyConstService.NVIcNotFound, vm.NVIcNotFound);
                vm.state.Vehicle.Colour = null;
                vm.SelectedVehicleColour = null;
                vm.state.Vehicle.State = '';
                //if (sessionStorage.getItem(keyConstService.NonRego)) {

                //}
                GetManufactureYears();
                GetDDlVehicleColours();
            }
            else {
                vm.Find = false;
                sessionStorageService.set(keyConstService.findRegoData, vm.Find)
                vm.isManualRego = false;
                vm.SelectedMotorListitem = null;
                vm.SelectedMotorYear = null;
                vm.SelectedMotorMake = null;
                vm.SelectedMotorListitem = null;
                vm.MotorMake = null;
                vm.Motormodel = null;
                vm.Motorvehiclelist = null;
                vm.state.Vehicle.Colour = null;
                vm.SelectedVehicleColour = null;
                vm.state.Vehicle.ManufactureYear = null;
                vm.state.Vehicle.Make = null;
                vm.state.Vehicle.Model = null;
                vm.state.Vehicle.VehicleDescription = null;
                vm.state.Vehicle.IsNonRegoManual = false;
            }
        }

        function GetManufactureYears() {
            return $http.get(apiUrlConstService.getMotorVehicleManuYears, { skipInterceptor: true })
                .then(function (result) {
                    vm.MotorYears = result.data.data;
                });
        }

        function GetDDlVehicleColours() {
            return $http.get(apiUrlConstService.getDDlVehicleColours + 'valueToShow=UI drop down', { skipInterceptor: true })
                .then(function (result) {
                    vm.VehicleColour = result.data.data;
                });
        }

        function GetMotormake(year, callType) {
            //commented after confirmation by client
            //var getEffectiveDate = reteiveEffectiveDate(true);
            //getEffectiveDate = dateService.convertDatetoMMDDYYYFormat(getEffectiveDate);
            //var effYear = dateService.getYear(getEffectiveDate);
            //// if select year greater than policy effective year then it show error
            //if (year > effYear) {
            //    toastr.error(messageConstService.errSelectedYeargrtEffDte);
            //    // for disable quote
            //    vm.SelectedMotorYear = null;
            //    return;
            //}
            //console.log(year);
            return $http.get(apiUrlConstService.getMotorVehiclemake + 'year=' + year, { skipInterceptor: true })
                .then(function (result) {
                    vm.MotorMake = result.data.data;
                    if (callType == 'New') {
                        resetnonrego();
                    }
                });
        }
        function GetMotorVehicleStyle(year, make, model, callType) {
            if (!make && !year && !model) {
                return;
            }
            vm.MotorStyles = null;
            vm.SelectedMotorStyle = '';
            vm.SelectedMotorSize = '';
            vm.MotorSizes = null;
            vm.SelectedMotorTransmission = '';
            vm.MotorTransmissions = null;
            return $http.get(apiUrlConstService.getMotorVehicleStyle + 'year=' + year + '&make=' + make + '&family=' + model, { skipInterceptor: true })
                .then(function (result) {
                    vm.MotorStyles = result.data.data;
                    if (callType == 'Add') {
                        GetMotorVehicleList(make, year, model, callType, '', '', '');
                    }
                });

        }

        function GetMotorVehicleTransmission(year, make, model, style, callType) {
            if (!make && !year && !model) {
                return;
            }
            return $http.get(apiUrlConstService.getMotorVehicleTransmission + 'year=' + year + '&make=' + make + '&family=' + model + '&style=' + style, { skipInterceptor: true })
                .then(function (result) {
                    vm.MotorTransmissions = result.data.data;
                    //vm.SelectedMotorSize = '';
                    //vm.MotorSizes = null;
                    if (!style) { style = ''; }
                    if (callType == 'Add') {
                        GetMotorVehicleList(make, year, model, callType, style, '', '');
                    }
                });
        }
        function GetMotorVehicleSize(year, make, model, style, transmission, callType) {
            if (!make && !year && !model) {
                return;
            }
            return $http.get(apiUrlConstService.getMotorVehicleSize + 'year=' + year + '&make=' + make + '&family=' + model + '&style=' + style + '&transmission=' + transmission, { skipInterceptor: true })
                .then(function (result) {
                    vm.MotorSizes = result.data.data;
                    if (!transmission) { transmission = ''; }
                    if (callType == 'Add') {
                        GetMotorVehicleList(make, year, model, callType, style, transmission, '');
                    }
                });
        }
        function resetAllVehicleInfoWhenNoDataFound() {
            vm.state.Vehicle.Make = null;
            vm.state.Vehicle.Model = null;
            vm.state.Vehicle.Cylinders = null;
            vm.state.Vehicle.Transmission = null;
            vm.state.Vehicle.BodyType = null;
            vm.state.Vehicle.ManufactureYear = null;
            vm.state.Vehicle.Style = null;
            vm.state.Vehicle.Size = null;
            vm.state.Vehicle.Variant = null;
            vm.state.Vehicle.Series = null;
            vm.state.Vehicle.Engine = null;
            vm.state.Vehicle.Cylinders = null;
            vm.state.Vehicle.VehicleDescription = null;
            vm.state.Vehicle.IsVehicleRegistered = null;
            vm.state.Vehicle.NVICValue = "NA";
        }
        function resetnonrego() {
            vm.SelectedMotorTransmission = '';
            vm.SelectedMotorModel = '';
            vm.SelectedMotorMake = '';
            vm.SelectedMotorStyle = '';
            vm.SelectedMotorSize = '';
            vm.Motormodel = null;
            vm.Motorvehiclelist = null;
            vm.MotorStyles = null;
            vm.MotorTransmissions = null;
            vm.MotorSizes = null;
        }
        function getSecondaryInsuredList(DBonEdit) {
            var caseid = caseNumberForSecondaryInsured;
            vm.state.Insured.InsuredNameList = [];
            vm.state.Insured.SecondaryInsuredsList = [];
            var secondaryInsuredListOnEdit = clientService.getSecondaryInmsured(
                caseid)
                .then(function (result) {
                    if (result) {
                        vm.data = result.data.policyHolder;
                        for (var i = 0; i < result.data.policyHolder.insuredNameList.length; i++) {

                            vm.state.Insured.InsuredNameList.push(result.data.policyHolder.insuredNameList[i]);
                            vm.state.Insured.SecondaryInsuredsList.push(result.data.policyHolder.insuredNameList[i]);
                            vm.secondaryListChange(vm.dateOfBirthFlag, DBonEdit);
                        }

                        // for additional insured
                        //checkAdditionalInsuredInList();
                    }
                })
        }

        function GetMotorVehicleList(make, year, model, callType, style, transmission, size) {
            if (!make && !year && !model && !style && !transmission && !size) {
                return;
            }
            if (!style) { style = ''; }
            if (!transmission) { transmission = ''; }
            if (!size) { size = ''; }
            var tempDate = '';
            var newBusinessData = JSON.parse(sessionStorageService.get(keyConstService.newBusinessCaseData));
            if (newBusinessData) {
                tempDate = newBusinessData.data.EffectiveDate;
            } else {
                tempDate = dateService.convertDatetoMMDDYYYFormat(vm.StartDate);
            }

            return $http.get(apiUrlConstService.getMotorVehicledesList + 'year=' + year + '&make=' + make + '&family=' + model + '&policyEffectiveDttm=' + tempDate + '&style=' + style + '&transmission=' + transmission + '&size=' + size, { skipInterceptor: true })
                .then(function (result) {
                    vm.Motorvehiclelist = JSON.parse(result.data.data);
                    if (callType === 'Add') {
                        vm.SelectedMotorListitem = vm.Motorvehiclelist[0].Id;
                        GetMotorDetails(vm.SelectedMotorListitem);
                    }
                });
        }

        function GetMotorDetails(glassmotorId, field) {
            return $http.get(apiUrlConstService.getMotorDetailsForId + 'glassMotorId=' + glassmotorId, { skipInterceptor: true }).then(function (data) {
                var motorData = data.data.data[0];
                //showing the first value only till the time how all the vehicle values will be shown                
                vm.state.Vehicle.NVICValue = motorData.nvic;
                vm.state.Vehicle.ManufactureYear = motorData.year;
                vm.state.Vehicle.MotorGlassDetailId = motorData.id;
                vm.state.Vehicle.Make = motorData.make;
                vm.state.Vehicle.Model = motorData.family;
                vm.state.Vehicle.Transmission = motorData.transmission;
                vm.state.Vehicle.Style = motorData.style;
                vm.state.Vehicle.Size = motorData.size;
                vm.state.Vehicle.Variant = motorData.variant;
                vm.state.Vehicle.Series = motorData.series;
                vm.state.Vehicle.Engine = motorData.engine;
                vm.state.Vehicle.Cylinders = motorData.cylinder;
                vm.state.Vehicle.VehicleDescription = motorData.vehicleDescription;
                vm.state.Vehicle.BodyType = motorData.bodyType;
                vm.state.Vehicle.IsNonRegoManual = vm.isManualRego;
                vm.state.Coverages.InsureVehicleForValue = motorData.marketValue;
                vm.state.Coverages.InsureVehicleForGlassMarketValueAV = motorData.marketValue;
                vm.state.Coverages.InsureVehicleForGlassMarketValueAAV = motorData.marketValueAbove;
                vm.state.Coverages.InsureVehicleForGlassMarketValueBAV = motorData.marketValueBelow;
                vm.state.Vehicle.Colour = motorData.colour;
                ////vm.state.Vehicle.Code = motorData.code;
                vm.state.Vehicle.GlassesCode = motorData.code;
                vm.state.Vehicle.IsVehicleRegistered = "1";
                //// setting excess value if default excess value is picked from DB
                if (vm.IsMotorGlassExcessEffective) {
                    if (motorData.defaultExcess === null) {
                        vm.defaultExcessFlag = false;
                    }
                    else {
                        vm.defaultExcessFlag = true;
                    }
                    vm.settingExcessAccordingToDefault(motorData.defaultExcess, vm.defaultExcessFlag, vm.PolicyNumber);
                }
                if (vm.state.Vehicle.ManufactureYear === null && vm.state.Vehicle.Make === null && vm.state.Vehicle.Model === null &&
                    vm.state.Vehicle.Transmission === null && vm.state.Vehicle.BodyType === null && vm.state.Vehicle.Cylinders === null) {
                    toastr.error(messageConstService.errNVICNotFound);
                }
                if (vm.state.Vehicle.ManufactureYear) {
                    validateIsManfactureYearMore15(vm.state.Vehicle.ManufactureYear, vm.vehicleAgeToHideRoadsideAssistance);
                } else {
                    vm.IsManfactureYearMore15 = true;
                    vm.state.Coverages.ComprehensiveRoadSide = false;
                }
                vehicleInsureVehicleForChange(field);
                if (vm.state.Vehicle.NVICValue) {
                    vm.Find = true;
                }
            });
        }

        function GetValuePopulated(data) {
            vm.isManualRego = data.IsNonRegoManual;

            /* Bind Year */
            GetManufactureYears();
            vm.SelectedMotorYear = parseInt(data.ManufactureYear);
            if (isNaN(vm.SelectedMotorYear)) {
                vm.SelectedMotorYear = null;
            }

            /* Bind Make */
            GetMotormake(vm.SelectedMotorYear, 'Edit');
            vm.SelectedMotorMake = data.Make;

            /* Bind Model */
            GetMotorModel(vm.SelectedMotorMake, vm.SelectedMotorYear);
            vm.SelectedMotorModel = data.Model;

            /* Bind Style */
            GetMotorVehicleStyle(vm.SelectedMotorYear, vm.SelectedMotorMake, vm.SelectedMotorModel, 'Edit');
            vm.SelectedMotorStyle = data.Style;

            /* Bind Transmission */
            GetMotorVehicleTransmission(vm.SelectedMotorYear, vm.SelectedMotorMake, vm.SelectedMotorModel, vm.SelectedMotorStyle, 'Edit');
            vm.SelectedMotorTransmission = data.Transmission;


            /* Bind Size */
            GetMotorVehicleSize(vm.SelectedMotorYear, vm.SelectedMotorMake, vm.SelectedMotorModel, vm.SelectedMotorStyle, vm.SelectedMotorTransmission, 'Edit');
            vm.SelectedMotorSize = data.Size;

            /* Bind Vehicle Description */
            vm.SelectedMotorListitem = data.MotorGlassDetailId;
            GetMotorVehicleList(vm.SelectedMotorMake, vm.SelectedMotorYear, vm.SelectedMotorModel, 'Edit', vm.SelectedMotorStyle, vm.SelectedMotorTransmission, vm.SelectedMotorSize);

            vm.state.Vehicle.NVICValue = data.NVICValue;
            vm.state.Vehicle.ManufactureYear = data.ManufactureYear;
            vm.state.Vehicle.MotorGlassDetailId = data.MotorGlassDetailId;
            vm.state.Vehicle.Make = data.Make;
            vm.state.Vehicle.Model = data.Model;
            vm.state.Vehicle.Transmission = data.Transmission;
            vm.state.Vehicle.Style = data.Style;
            vm.state.Vehicle.Size = data.Size;
            vm.state.Vehicle.Variant = data.Variant;
            vm.state.Vehicle.Series = data.Series;
            vm.state.Vehicle.Engine = data.Engine;
            vm.state.Vehicle.Cylinders = data.Cylinders;
            vm.state.Vehicle.VehicleDescription = data.VehicleDescription;
            vm.state.Vehicle.BodyType = data.BodyType;
            vm.state.Vehicle.IsNonRegoManual = vm.isManualRego;
            vm.state.Vehicle.Colour = data.Colour;
            vm.Find = true;

        }
        function GetMotorModel(make, year) {
            var tempDate = '';
            var newBusinessData = JSON.parse(sessionStorageService.get(keyConstService.newBusinessCaseData));
            if (newBusinessData) {
                tempDate = newBusinessData.data.EffectiveDate;
            } else {
                tempDate = dateService.convertDatetoMMDDYYYFormat(vm.StartDate);
            }
            return $http.get(apiUrlConstService.getMotorVehiclemodel + 'year=' + year + '&make=' + make + '&policyEffectiveDttm=' + tempDate, { skipInterceptor: true })
                .then(function (result) {
                    vm.Motormodel = result.data.data;
                });

        }
        vm.checkRadioButton = function (count) {
            if (count === 0) {
                return 'checked';
            } else {
                return '';
            }

        };

        function brokerFeeChange() {
            var regexp = /^[0-9]+(\.[0-9]{1,2})?$/;
            if (!regexp.test(vm.state.Payment.BrokerFeeExcludingGST)) {
                vm.state.Payment.BrokerFeeExcludingGST = null;
            }
        }

        function reteiveEffectiveDate(requirePolicyEffectivedate) {
            var effectiveDate;
            var getEffDate = JSON.parse(sessionStorageService.get(keyConstService.newBusinessCaseData));
            if (getEffDate) {
                effectiveDate = getEffDate.data.EffectiveDate;
            }
            else if (getEffDate === null && !vm.IsEndorsement) {
                effectiveDate = vm.EffectiveDate;
            }
            else if (vm.IsEndorsement) {
                var endorsementEffDate = JSON.parse(sessionStorageService.get(keyConstService.endorsementRequestVM));
                if (endorsementEffDate) {
                    effectiveDate = endorsementEffDate.EndorsementEffectiveDate;
                    if (requirePolicyEffectivedate) {
                        effectiveDate = endorsementEffDate.PolicyEffectiveDate;
                    }
                }
                if (!effectiveDate) {
                    effectiveDate = vm.dataState.EffectiveDate;
                }
            }
            return effectiveDate;
        }


        angular.element(document).ready(function () {
            validateYear($scope.frmMotor.MainDriverYearDL, vm.state.Drivers.MainDriver.DOB, vm.state.Drivers.MainDriver.YearDL);
            if (vm.state.Drivers.IsAdditionalDriver) {
                for (var i = 0; i < vm.state.Drivers.AdditionalDrivers.length; i++) {
                    if ($scope.frmMotor.hasOwnProperty("addiDriverName_".concat(i))) {
                        vm.getAddDriverYearDL = $scope.frmMotor["addiDriverYearDL_".concat(i)];
                    }
                    validateYear(vm.getAddDriverYearDL, vm.state.Drivers.AdditionalDrivers[i].DOB, vm.state.Drivers.AdditionalDrivers[i].YearDL);
                }
            }
        });

        function continueOrNavigateBackToPackageManager() {
            var packageNumber = sessionStorageService.get('PackageNumberInformation');
            var renewalCounter = sessionStorageService.get('RenewalCounter');
            sessionStorageService.remove('IsPackageManagerNavigationMode');
            sessionStorageService.remove('PackageNumberInformation');
            sessionStorageService.remove('RenewalCounter');
            $window.location.href = webUrlConstService.getPackageInfo + sessionStorageService.getEncryption("packageNumber=" + JSON.parse(packageNumber) + "&&renewalCounter=" + renewalCounter);
        }

        function changeOtherInsuredName() {
            if (frmMotor && frmMotor.OtherInsuredName) {
                if (frmMotor.OtherInsuredName.value.length > 100) {
                    vm.showMessageGrt100OtherInsuredName = true;
                    frmMotor.OtherInsuredName.value = frmMotor.OtherInsuredName.value.substring(0, 100);
                } else {
                    vm.showMessageGrt100OtherInsuredName = false;
                }
            }
        }

        function checkAdditionalInsuredInList() {
            for (var j = 0; j < vm.state.Insured.AdditionalPolicyHolderList.length; j++) {
                var ele = vm.state.Insured.AdditionalPolicyHolderList[j];
                //if (ele.AdditionalPolicyHolder !== "Other") {
                var existInsuredName = utilityService.valueExistsInArray(ele.AdditionalPolicyHolder, vm.state.Insured.SecondaryInsuredsList);
                if (!existInsuredName) {
                    var res = false;
                    //break;
                }
                else {
                    res = true;
                }
                //}
                //else {
                //    vm.otherreadonly = true;
                //}
            }
            return res;
        }
        function addOtherInsured() {
            vm.ClientDetail.SecondaryInsuredClientVM = vm.addSecondaryClient;
            vm.ClientDetail.SecondaryInsuredClientVM[0].AddressLogVM = vm.otherInsuredAddress;

            var client = {
                ClientViewModel: vm.ClientDetail.clientViewModel !== null ? vm.ClientDetail.clientViewModel : null,
                SecondaryInsuredClientVM: vm.ClientDetail.SecondaryInsuredClientVM
            };

            var request = clientService.updateClientData({
                client: client
            });
            request.then(function success(response) {
                if (vm.ClientDetail.SecondaryInsuredClientVM[0].ClientType == 'Individual') {
                    if (vm.IsOpenAddInsuredPopup) {
                        vm.state.Insured.InsuredName = vm.ClientDetail.SecondaryInsuredClientVM[0].FirstName + " " + vm.ClientDetail.SecondaryInsuredClientVM[0].LastName;
                        vm.state.Insured.DateOfBirthApp = vm.ClientDetail.SecondaryInsuredClientVM[0].DateOfBirthStringAsDDMMYYYY;
                        vm.IsOpenAddInsuredPopup = false;
                    } else {
                        vm.state.Insured.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].AdditionalPolicyHolder = vm.ClientDetail.SecondaryInsuredClientVM[0].FirstName + " " + vm.ClientDetail.SecondaryInsuredClientVM[0].LastName;
                        vm.state.Insured.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].DateOfBirthApp = "2000-01-01T00:00:00";
                        vm.state.Insured.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].AdditionalPolicyHolderType = "Secondary";
                    }
                } else {
                    if (vm.IsOpenAddInsuredPopup) {
                        vm.state.Insured.InsuredName = vm.ClientDetail.SecondaryInsuredClientVM[0].OrganisationName;
                        vm.state.Insured.DateOfBirthApp = "2000-01-01T00:00:00";
                        vm.IsOpenAddInsuredPopup = false;
                    } else {
                        vm.state.Insured.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].AdditionalPolicyHolder = vm.ClientDetail.SecondaryInsuredClientVM[0].OrganisationName;
                        vm.state.Insured.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].DateOfBirthApp = "2000-01-01T00:00:00";
                        vm.state.Insured.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].AdditionalPolicyHolderType = "Secondary";
                    }
                }
                return getInsuredNameList(false);
            });
        }

        function getInsuredNameList(isEdit) {
            caseId = sessionStorageService.get(keyConstService.caseId);
            quotesService.getInsuredNameList(caseId).then(function (ResponseData) {
                vm.motorData = ResponseData.data;
                if (ResponseData.data !== null) {
                    if (!isEdit) {
                        vm.state.Insured.InsuredNameList = ResponseData.data.policyHolder.insuredNameList;
                        vm.state.Insured.SecondaryInsuredsList = ResponseData.data.policyHolder.secondaryInsuredsList;
                        //vm.state.Insured.InsuredClientId = ResponseData.data.policyHolder.insuredClientId;
                        vm.ClientDetail = ResponseData.data.clientDetail;
                        vm.addSecondaryClient = ResponseData.data.clientDetail.secondaryInsuredClientVM;
                        vm.otherInsuredAddress = ResponseData.data.clientDetail.addressLogVM;
                        vm.PropertyDetail = ResponseData.data.buildingInfo;
                        if (getQuoteTransactionId === vm.getTransactionIdWithoutSaving) {
                            if (vm.state.Insured.InsuredName === "Other") {
                                getQuestionSetWithoutSavingData = JSON.parse(JSON.parse(sessionStorageService.get(getQuestionSetWithoutSaving)));
                                vm.state.Insured.InsuredName = vm.getQuestionSetWithoutSavingData.Insured.InsuredName;
                            }
                        }
                        //else {
                        if (vm.state.Insured.InsuredName === "Other")
                        {
                            var indexOfInsured = vm.state.Insured.InsuredNameList.findIndex(p => p.value === "Other");
                            if (indexOfInsured === -1) {
                                vm.state.Insured.InsuredNameList.push({ clientType: "Secondary", name: vm.state.Insured.InsuredName, value: vm.state.Insured.InsuredName, dateOfBirth: vm.state.Insured.DateOfBirth, Id: 0 });
                                //vm.state.Insured.SecondaryInsuredsList.push({ clientType: "Secondary", name: vm.state.Insured.InsuredName, value: vm.state.Insured.InsuredName, dateOfBirth: vm.state.Insured.DateOfBirth, Id: 0 });
                            }
                            vm.OtherInsuredName = vm.state.Insured.OtherInsuredName;
                            vm.DateOfBirthApp = vm.state.Insured.DateOfBirthApp;
                            vm.otherreadonly = true;
                        } else {
                            var indexOfInsured = vm.state.Insured.InsuredNameList.findIndex(p => p.value === "Other");
                            if (indexOfInsured >= 0) {
                                vm.state.Insured.InsuredNameList.splice(indexOfInsured, 1);
                            }
                        }

                        if ((vm.state.Insured.AdditionalPolicyHolderList.findIndex(p => p.AdditionalPolicyHolder === "Other")) >= 0) {
                            //var indexOfInsured = vm.state.Insured.InsuredNameList.findIndex(p => p.value === "Other");
                            //if (indexOfInsured === -1) {
                            //    vm.state.Insured.InsuredNameList.push({ clientType: "Secondary", name: "Other", value: "Other", dateOfBirth: null, Id: 0 });
                            //    vm.state.Insured.SecondaryInsuredsList.push({ clientType: "Secondary", name: "Other", value: "Other", dateOfBirth: null, Id: 0 });
                            //}
                            var indexOfInsured = vm.state.Insured.SecondaryInsuredsList.findIndex(p => p.value === "Other");
                            if (indexOfInsured === -1) {
                                vm.state.Insured.SecondaryInsuredsList.push({ clientType: "Secondary", name: "Other", value: "Other", dateOfBirth: null, Id: 0 });
                            }
                            vm.otherreadonly = true;
                        } else {
                            var indexOfInsured = vm.state.Insured.SecondaryInsuredsList.findIndex(p => p.value === "Other");
                            if (indexOfInsured >= 0) {
                                vm.state.Insured.SecondaryInsuredsList.splice(indexOfInsured, 1);
                            }
                        }

                        if (vm.state.Insured.InsuredName !== "Other" && (vm.state.Insured.AdditionalPolicyHolderList.findIndex(p => p.AdditionalPolicyHolder === "Other")) == -1) {
                            if (vm.state.Insured.InsuredClientId !== null && vm.state.Insured.OtherInsuredName === null) {
                                vm.state.Insured.InsuredName = vm.state.Insured.InsuredName;
                            }
                            //else {
                            //    vm.state.Insured.InsuredName = ResponseData.data.policyHolder.insuredName;
                            //}
                        }

                        // If Insured name is not other and additional list is having other but Insuredlist and secondaryInsured list is having remove it array.
                        if (vm.state.Insured.InsuredName !== "Other" && (vm.state.Insured.AdditionalPolicyHolderList.findIndex(p => p.AdditionalPolicyHolder === "Other")) === -1) {
                            var insuredotherPosition = vm.state.Insured.InsuredNameList.findIndex(p => p.value === "Other");
                            if (insuredotherPosition !== -1) {
                                vm.state.Insured.InsuredNameList.splice(insuredotherPosition, 1);
                            }
                            var secondaryInsuredOtherPos = vm.state.Insured.SecondaryInsuredsList.findIndex(p => p.value === "Other");
                            if (secondaryInsuredOtherPos !== -1) {
                                vm.state.Insured.SecondaryInsuredsList.splice(secondaryInsuredOtherPos, 1);
                            }
                        }

                        // comment these line, because if page values is not updated then their no need to reset MainDriver.Name, this should be same as user sets.
                        //vm.state.Drivers.MainDriver.Name = ResponseData.data.policyHolder.insuredName;
                        if (getParsedQuestionSetWithoutSaving !== undefined && getParsedQuestionSetWithoutSaving !== null && !getParsedQuestionSetWithoutSaving) {
                            if (ResponseData.data.buildingInfo.isManualAddress) {
                                vm.state.OvernightParkedAddress.IsManualAddress = true;
                                vm.selectedMannualAddress = ResponseData.data.buildingInfo.addressText;
                                vm.state.OvernightParkedAddress.AddressLine1 = ResponseData.data.buildingInfo.addressLine1;
                            }
                            else {
                                vm.state.OvernightParkedAddress.IsManualAddress = false;
                                vm.selectedAddress = ResponseData.data.buildingInfo.addressText;
                            }
                            vm.state.OvernightParkedAddress.AddressState = ResponseData.data.buildingInfo.addressState;
                            vm.state.OvernightParkedAddress.Postcode = ResponseData.data.buildingInfo.postcode;
                            vm.state.OvernightParkedAddress.AddressValue = ResponseData.data.buildingInfo.addressValue;
                            vm.state.OvernightParkedAddress.Gnaf = ResponseData.data.buildingInfo.gnaf;
                        }

                        if (getParsedQuestionSetWithoutSaving !== undefined && getParsedQuestionSetWithoutSaving !== null && !getParsedQuestionSetWithoutSaving) {
                            if (ResponseData.data.buildingInfo.addressState) {
                                vm.stateChange(ResponseData.data.buildingInfo.addressState);
                            }
                            else {
                                var splitState = ResponseData.data.buildingInfo.addressValue.split('|');
                                vm.nswState = splitState[0];
                                vm.AddressState = vm.nswState;
                                vm.isManualAddressForNsw = ResponseData.data.buildingInfo.isManualAddress;
                                vm.stateChange(splitState[0]);
                            }
                        }
                        else {
                            if (vm.state.OvernightParkedAddress.AddressValue && vm.state.OvernightParkedAddress.AddressState) {
                                vm.nswState = vm.state.OvernightParkedAddress.AddressState;
                                vm.stateChange(vm.state.OvernightParkedAddress.AddressState);
                            }
                            else if (vm.state.OvernightParkedAddress.AddressValue && !vm.state.OvernightParkedAddress.AddressState) {
                                var splitState = vm.state.OvernightParkedAddress.AddressValue.split('|');
                                vm.nswState = splitState[0];
                                vm.stateChange(splitState[0]);
                            }
                        }
                    }
                    else {
                        vm.ClientDetail = ResponseData.data.clientDetail;
                        vm.addSecondaryClient = ResponseData.data.clientDetail.secondaryInsuredClientVM;
                        vm.otherInsuredAddress = ResponseData.data.clientDetail.addressLogVM;

                        if (ResponseData.data.buildingInfo.isManualAddress === false) {
                            vm.selectedAddress = vm.state.OvernightParkedAddress.AddressText;
                        }

                    }

                    vm.tempPrimaryInsured = vm.state.Insured.InsuredName;
                    vm.tempAdditonalPolicyHolders = angular.copy(vm.state.Insured.AdditionalPolicyHolderList);
                    //console.log(" -- vm.tempAdditonalPolicyHolders      :  " + vm.tempAdditonalPolicyHolders)
                }

                if (!isEdit) {
                    //if (ResponseData.data.buildingInfo.isManualAddress && getQuoteTransactionId !== vm.getTransactionIdWithoutSaving) {
                    //    vm.selectedMannualAddress = ResponseData.data.buildingInfo.addressText;
                    //    vm.state.OvernightParkedAddress.AddressLine1 = ResponseData.data.buildingInfo.addressLine1;
                    //    vm.state.OvernightParkedAddress.IsManualAddress = true;
                    //}

                    //claims in last 3 years validation on previous next

                    // comment this because it is not used
                    //var newDate = new Date(ResponseData.data.policyHolder.dateOfBirthApp);
                    if (getQuoteTransactionId === vm.getTransactionIdWithoutSaving) {
                        vm.state.Drivers.MainDriver.DOB = getParsedQuestionSetWithoutSaving.Drivers.MainDriver.DOB;
                    }
                    else {
                        vm.state.Insured.DateOfBirth = dateService.convertDatetoMMDDYYYFormat(ResponseData.data.policyHolder.dateOfBirthApp);
                        // comment these two lines, because if page values is not updated then their no need to reset DOB for Insured & Driver, those should be same as user sets.  
                        //vm.state.Insured.DateOfBirthApp = newDate;
                        //vm.state.Drivers.MainDriver.DOB = newDate;
                    }

                    if (vm.state.Insured.InsuredName != "Other") {
                        var objSelectedInsured = vm.state.Insured.InsuredNameList.filter(function (e) { return e.value === vm.state.Insured.InsuredName })
                        vm.state.Insured.InsuredClientId = objSelectedInsured[0].id;
                    } else {
                        vm.state.Insured.InsuredClientId = -2;
                    }

                    for (var i = 0; i < ResponseData.data.policyHolder.secondaryInsuredsList.length; i++) {
                        if (ResponseData.data.policyHolder.secondaryInsuredsList[i].value === vm.state.Insured.InsuredName && ResponseData.data.policyHolder.secondaryInsuredsList[i].id === vm.state.Insured.InsuredClientId) {
                            var index = ResponseData.data.policyHolder.secondaryInsuredsList.indexOf(ResponseData.data.policyHolder.secondaryInsuredsList[i]);
                            ResponseData.data.policyHolder.secondaryInsuredsList.splice(index, 1);
                            vm.state.Insured.SecondaryInsuredsList = ResponseData.data.policyHolder.secondaryInsuredsList;
                        }

                        // Commentd by Ankur as per us 6829
                        ////else {
                        ////    if (vm.state.Insured.InsuredName) {
                        ////        vm.state.Insured.InsuredName = ResponseData.data.policyHolder.insuredName;
                        ////    }
                        ////}
                    }
                }
            });

            if (!isEdit) {
                resetAddress();
            }
        }

        function storeOtherInsuredAddress(address) {
            if (address && address.value == 'N/A') {
                address = null;
                vm.selectedAddress1 = null;
                vm.showManualAddressOtherInsured();
            }

            if (address !== null && address !== undefined) {
                if (address.value) {
                    vm.addSecondaryClient[0].IsStampDutyExempted = false;
                    var splitSate = address.value.split('|');
                    var AddressState = splitSate[0];
                    vm.addSecondaryClient[0].IsStampDutyExempted = false;
                    if (AddressState === "NSW") {
                        vm.addSecondaryClient[0].showStampDuty = true;
                    }
                    else {
                        vm.addSecondaryClient[0].showStampDuty = false;
                    }

                    if (vm.addSecondaryClient[0].IsSameAsPrimaryAddress && vm.otherInsuredAddress && vm.PropertyDetail.addressText !== address.text) {
                        vm.addSecondaryClient[0].IsSameAsPrimaryAddress = false;
                    }

                    if (vm.otherInsuredAddress) {
                        vm.otherInsuredAddress.Address = address.text;
                        vm.otherInsuredAddress.DelimeterAddress = address.value;
                        vm.otherInsuredAddress.PostCode = address.postCode === null ? null : address.postCode;
                        if (address.isManualAddress) {
                            vm.selectedOtherMannualItem = vm.selectedOtherMannualAddress.text;
                            vm.otherInsuredAddress.AddressLine1 = vm.selectedOtherMannualAddress.addressLine1;
                        }
                    }
                    else {
                        vm.otherInsuredAddress = {
                            Address: address.text,
                            DelimeterAddress: address.value,
                            PostCode: address.postCode === null ? null : address.postCode
                        };
                    }
                }
            }
        }

        function checkSameAsPrimary() {
            if (vm.addSecondaryClient[0].IsSameAsPrimaryAddress) {

                if (!vm.PropertyDetail.isManualAddress) {
                    vm.selectedAddress1 = { postCode: vm.PropertyDetail.postcode, text: vm.PropertyDetail.addressText, value: vm.PropertyDetail.addressValue };
                    storeOtherInsuredAddress(vm.selectedAddress1);
                }
                else {
                    vm.selectedOtherMannualAddress = { postCode: vm.PropertyDetail.postcode, text: vm.PropertyDetail.addressText, addressLine1: vm.PropertyDetail.addressLine1, value: vm.PropertyDetail.addressValue, isManualAddress: vm.PropertyDetail.isManualAddress };
                    storeOtherInsuredAddress(vm.selectedOtherMannualAddress);
                }
                if (vm.otherInsuredAddress === null) vm.otherInsuredAddress = {}
                vm.otherInsuredAddress.isManualAddress = vm.PropertyDetail.isManualAddress;
                if (vm.otherInsuredAddress.isManualAddress === false) {
                    vm.otherInsuredAddress.AddressLine1 = null;
                    vm.mannualOtherSearchText = null;
                    vm.selectedOtherMannualItem = null;
                }
            }
        }

        function resetAddress() {
            vm.selectedAddress1 = null;
            vm.otherInsuredAddress.Address = null;
            vm.otherInsuredAddress.DelimeterAddress = null;
            vm.otherInsuredAddress.PostCode = null;
            vm.showStampDuty = false;
            if (vm.addSecondaryClient.length > 0) {
                vm.addSecondaryClient[0].IsStampDutyExempted = false;
                vm.addSecondaryClient[0].IsSameAsPrimaryAddress = false;
            }

            if (vm.otherInsuredAddress.isManualAddress === false) {
                vm.otherInsuredAddress.AddressLine1 = null;
                vm.mannualOtherSearchText = null;
                vm.selectedOtherMannualItem = null;
            }
        }

        function cancelOtherInsured(type) {
            if (vm.addSecondaryClient.length > 0) {
                vm.addSecondaryClient[0].FirstName = null;
                vm.addSecondaryClient[0].LastName = null;
                vm.addSecondaryClient[0].DateOfBirthStringAsDDMMYYYY = null;
                vm.addSecondaryClient[0].OrganisationName = null;
                vm.addSecondaryClient[0].TradingName = null;
                vm.searchText1 = null;
                if (type === 'cancelButton') {
                    vm.addSecondaryClient[0].ClientType = null;
                }
            }

            if (type.$name === 'otherInsuredForm' && vm.otherInsuredAddress.isManualAddress === false) {
                type.otherAutocompleteAddress.$invalid = true;
                type.otherAutocompleteAddress.$touched = false;
            }

            if (type === 'cancelButton') {
                if (vm.IsOpenAddInsuredPopup) {
                    vm.state.Insured.InsuredName = vm.tempPrimaryInsured;
                    vm.IsOpenAddInsuredPopup = false;
                } else if (vm.tempAdditonalPolicyHolders != null) {
                    vm.state.Insured.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].AdditionalPolicyHolder = vm.tempAdditonalPolicyHolders[vm.AdditionalPolicyHolderIndex] == undefined ? null : vm.tempAdditonalPolicyHolders[vm.AdditionalPolicyHolderIndex].AdditionalPolicyHolder;
                    vm.state.Insured.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].AdditionalPolicyHolderType = "Secondary";
                } else {
                    vm.state.Insured.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].AdditionalPolicyHolder = null;
                }
            }

            // Commentd by Ankur as per us 6829
            //vm.tempPrimaryInsured = vm.state.Insured.InsuredNameList.filter(function (e) { return e.clientType === 'Primary' })
            //vm.state.Insured.InsuredName = vm.tempPrimaryInsured[0].name;
            vm.otherInsuredAddress.isManualAddress = false;
            resetAddress();
        }

        function OtherSubmitEnabled(otherInsuredForm) {
            if (otherInsuredForm.$invalid || (vm.selectedAddress1 === null && !vm.otherInsuredAddress.isManualAddress)) {
                return true;
            }
            else {
                return false;
            }
        }

        vm.checkValidOtherManualAddress = function (field) {
            if (vm.mannualOtherSearchText) {
                if (!vm.selectedOtherMannualItem) {
                    field.$setValidity('invalid', false);
                }
                else {
                    field.$setValidity('invalid', true);
                }
            }
        }

        //// setting default excess value to null
        vm.setDefaultExcessToNull = function (clientState, data) {
            if (vm.IsMotorGlassExcessEffective && !vm.isEffectiveDateChange) {

                if (!vm.isManualRego)
                    vm.state.Vehicle.State = clientState;
                vm.checkIsSmallBusinessStampDutyEligible(true);
                vm.state.ExcessOption.Excess1 = null;
                vm.state.ExcessOption.Excess2 = null;
                vm.state.ExcessOption.Excess3 = null;
                vm.tempExcessOption = vm.state.ExcessOption.ExcessList;
                vm.tempState = clientState;
                vm.state.ExcessOption.ExcessList = null;

            }
            else if (vm.IsMotorGlassExcessEffective && vm.isEffectiveDateChange) {
                vm.state.ExcessOption.Excess1 = null;
                vm.state.ExcessOption.Excess2 = null;
                vm.state.ExcessOption.Excess3 = null;
                vm.tempExcessOption = vm.state.ExcessOption.ExcessList;
                vm.state.ExcessOption.ExcessList = null;
            }
            else if (vm.qPreviousDateFlag || !vm.IsMotorGlassExcessEffective) {
                vm.settingExcessAccordingToDefault(null, false, null)
                var defaultExcessValues = vm.state.ExcessOption.DefaultExcessValues;
                for (var i = 0; i < defaultExcessValues.length; i++) {
                    if (defaultExcessValues[i].State === clientState) {
                        vm.state.ExcessOption.Excess1 = defaultExcessValues[i].Excess1.toString();
                        vm.state.ExcessOption.Excess2 = defaultExcessValues[i].Excess2.toString();
                        vm.state.ExcessOption.Excess3 = defaultExcessValues[i].Excess3.toString();
                        var arr = [];
                        arr.push(defaultExcessValues[i].Excess1);
                        arr.push(defaultExcessValues[i].Excess2);
                        arr.push(defaultExcessValues[i].Excess3);
                        vm.ExcessOptionArr = arr;
                    }
                }
            }
        }

        //// setting Excess according to default excess
        vm.settingExcessAccordingToDefault = function (defaultExcess, defaultExcessFlag, policyNumber) {
            if (defaultExcess === null) {
                defaultExcess = 0;
            }
            var response = nvicMotorService.getExcessListAccordingtoDefaultExcess(defaultExcess, defaultExcessFlag, policyNumber).then(function (data) {
                var result = JSON.parse(data.data);
                if (defaultExcessFlag === true) {
                    if (vm.IsEndorsement && !vm.isRenewalEffective) {
                        vm.state.ExcessOption.Excess1 = result.Result.Excess1.toString();
                        vm.state.ExcessOption.Excess2 = null;
                        vm.state.ExcessOption.Excess3 = null;
                        vm.state.ExcessOption.ExcessList = result.Result.ExcessOptionList;
                    }
                    else if (vm.isRenewalEffective) {
                        vm.state.ExcessOption.ExcessList = result.Result.ExcessOptionList;
                        vm.isRenewalEffective = false;
                    }
                    else {
                        vm.state.ExcessOption.Excess1 = result.Result.Excess1.toString();
                        vm.state.ExcessOption.Excess2 = result.Result.Excess2 != 0 ? result.Result.Excess2.toString() : null;
                        vm.state.ExcessOption.Excess3 = result.Result.Excess3 != 0 ? result.Result.Excess3.toString() : null;
                        vm.state.ExcessOption.ExcessList = result.Result.ExcessOptionList;

                        var arr = [];
                        arr.push(result.Result.Excess1);
                        arr.push(result.Result.Excess2);
                        arr.push(result.Result.Excess3);
                        vm.ExcessOptionArr = arr;
                    }
                }
                else {
                    vm.state.ExcessOption.ExcessList = result.Result.ExcessOptionList;
                    if (vm.isRenewalEffective) {
                        vm.isRenewalEffective = false;
                    }
                    else if (!vm.IsEndorsement) {
                        var defaultExcessValues = vm.state.ExcessOption.DefaultExcessValues;
                        var qAddressState = vm.state.OvernightParkedAddress.AddressValue.split('|');
                        vm.tempState = vm.state.Vehicle.State === null || vm.state.Vehicle.State === "" ? qAddressState[0] : vm.state.Vehicle.State;
                        for (var i = 0; i < defaultExcessValues.length; i++) {
                            if (defaultExcessValues[i].State === vm.tempState) {
                                vm.state.ExcessOption.Excess1 = defaultExcessValues[i].Excess1.toString();
                                vm.state.ExcessOption.Excess2 = defaultExcessValues[i].Excess2.toString();
                                vm.state.ExcessOption.Excess3 = defaultExcessValues[i].Excess3.toString();
                                var arr = [];
                                arr.push(defaultExcessValues[i].Excess1);
                                arr.push(defaultExcessValues[i].Excess2);
                                arr.push(defaultExcessValues[i].Excess3);
                                vm.ExcessOptionArr = arr;
                            }
                        }
                    }
                    else if (vm.IsEndorsement) {
                        vm.state.ExcessOption.Excess1 = result.Result.Excess1.toString();
                    }
                }


            });
        }
        function checkManualAddressChange(flag) {
            vm.AddressChange = true;
            if (vm.state.OvernightParkedAddress.AddressText) {
                vm.previousAddressTextForIllion = vm.state.OvernightParkedAddress.AddressText;
            }
            
            if (flag) {
                vm.previousAddressLine1ForIllion = null;
            }
        }

        vm.getAdressEnquiryDetails = function () {
            if ((vm.dataState && vm.dataState.DDlProcessTypeId == 4) || vm.IsEndorsement == true) {
                return;
            }

            if (vm.state.OvernightParkedAddress && vm.state.OvernightParkedAddress.AddressValue) {
                if (vm.AddressChange && vm.previousAddressTextForIllion && vm.previousAddressTextForIllion === vm.state.OvernightParkedAddress.AddressText) {
                    if (vm.state.OvernightParkedAddress.IsManualAddress) {
                        if (!vm.checkAddressLine1 && vm.state.OvernightParkedAddress.AddressLine1) {
                            if (vm.previousAddressLine1ForIllion) {
                                if (vm.previousAddressLine1ForIllion == vm.state.OvernightParkedAddress.AddressLine1) {
                                    return;
                                }
                            }
                            else {
                                vm.previousAddressLine1ForIllion = vm.state.OvernightParkedAddress.AddressLine1;
                                return;
                            }
                        }                        
                    }
                    else {
                        return;
                    }
                }
                vm.state.IllionClaimResponse = null;
                vm.state.IllionClaimResponseId = null;
                let addLine1 = null;
                if (!vm.state.OvernightParkedAddress.IsManualAddress) {
                    let addressTextSplit = vm.state.OvernightParkedAddress.AddressText.split(',');
                    addLine1 = addressTextSplit[0];
                }
                else {
                    addLine1 = vm.state.OvernightParkedAddress.AddressLine1;
                    vm.previousAddressLine1ForIllion = addLine1;
                }
                if (addLine1 === null || addLine1 === undefined) {
                    vm.checkAddressLine1 = true;
                    return;
                }

                vm.checkAddressLine1 = false;
                let addressSplitSate = vm.state.OvernightParkedAddress.AddressValue.split('|');
                let addState = addressSplitSate[0];
                let addPostcode = addressSplitSate[1];
                let addSuburb = addressSplitSate[2];
                var illionAddressEnquiryRequestVM = {
                    "AddressLine1": addLine1,
                    "Suburb": addSuburb,
                    "State": addState,
                    "Postcode": addPostcode,
                    "AddressText": addLine1 + "," + addSuburb + " " + addState + " " + addPostcode
                };
                utilityService.getAddressEnquiry(illionAddressEnquiryRequestVM).then(function (data) {
                    vm.state.IllionClaimResponseId = data.data;
                });
            }
        }

    }
})();
;
(function () {
    'use strict';

    var appUI = angular.module('appUI');



    appUI.controller('landlordProtectionCtrl', ['$rootScope', '$q', '$window', '$filter', 'responsiveService', 'quotesService', 'sessionStorageService', 'apiUrlConstService', 'webUrlConstService', 'dateService', 'disclaimerService', '$http', '$log', 'messageConstService', 'keyConstService', 'occupationService', '$scope', '$mdDialog', '$timeout', 'clientService', 'utilityService', landlordProtectionCtrl]);
    function landlordProtectionCtrl($rootScope, $q, $window, $filter, responsiveService, quotesService, sessionStorageService, apiUrlConstService, webUrlConstService, dateService, disclaimerService, $http, $log, messageConstService, keyConstService, occupationService, $scope, $mdDialog, $timeout, clientService, utilityService) {
        var vm = this;
        var caseId = null;
        var isNewEditTransaction = false;
        var transactionId = 0;
        var brokerData;
        var getQuestionSetWithoutSaving;
        var getTransactionIdWithoutSaving;
        var getParsedQuestionSetWithoutSaving;
        var getQuoteTransactionId;
        var brokerdetail;
        var previousTransactionId = null;
        var ExpirationDate = null;
        var IsNewBusinessEdit = null;
        var caseNumberForSecondaryInsured;
        var endorsementState = null;
        vm.invalidSuminsuredAmount = null;
        vm.minContentsSumInsured = null;
        vm.DefaultSumInsured = null;
        vm.checkSumInsuredValue = null;
        vm.invalidRentalAmount = false;
        vm.checkNullClaimList = false;
        vm.nextPremium = nextPremium;
        vm.addressMapped = addressMapped;
        vm.ReadOnly = null;
        vm.getSecondaryInsuredList = getSecondaryInsuredList;
        vm.isClaimsInLast3YearsChanged = isClaimsInLast3YearsChanged;
        vm.finalGetQuote = finalGetQuote;
        vm.validDOBOtherInsurer = true;
        vm.removeNote = removeNote;
        vm.addNote = addNote;
        vm.propertyDecline = propertyDecline;
        vm.changeNotesPrintable = changeNotesPrintable;
        vm.resetAddressData = resetAddressData;
        vm.checkClaims = null;
        vm.EnableDisableButton = EnableDisableButton;
        vm.policyHolderNameExists = policyHolderNameExists;
        vm.brokerFeeChange = brokerFeeChange;
        vm.brokerManagedPayment = 0;
        vm.brokerbranchcheck;
        vm.disableButtons = false;
        vm.showMessageGrt100OtherInsuredName = false;
        vm.changeOtherInsuredName = changeOtherInsuredName;
        vm.continueOrNavigateBackToPackageManager = continueOrNavigateBackToPackageManager;
        vm.addOtherInsured = addOtherInsured;
        vm.otherInsuredAddress = null;
        vm.storeOtherInsuredAddress = storeOtherInsuredAddress;
        vm.resetAddress = resetAddress;
        vm.cancelOtherInsured = cancelOtherInsured;
        vm.checkSameAsPrimary = checkSameAsPrimary;
        vm.ClientDetail = {};
        vm.otherreadonly = false;
        vm.OtherSubmitEnabled = OtherSubmitEnabled;
        vm.showDomesticWorkerCompensation = false;
        vm.OtherInsuredName = null;
        vm.DateOfBirthApp = null;
        vm.help_text_for_Endorsement = keyConstService.help_text_for_Endorsement;
        vm.tempPrimaryInsured;
        vm.tempAdditonalPolicyHolders;
        vm.AdditionalPolicyHolderIndex;
        vm.IsOpenAddInsuredPopup = false;
        vm.onClickAddressNotFound = onClickAddressNotFound;                                                   // function for On click of adress not found
        vm.resetAddressNotFound = resetAddressNotFound;                                                        // function to reset on change Addres 
        vm.onClickAddressNotFoundOtherInsured = onClickAddressNotFoundOtherInsured;                           // function for On click of adress not found OtherInsured
        vm.resetAddressNotFoundOtherInsured = resetAddressNotFoundOtherInsured;                                // function to reset on change Addres OtherInsured
        vm.illionClaimResponse = null;
        vm.checkManualAddressChange = checkManualAddressChange;
        vm.previousAddressTextForIllion = null;
        vm.previousAddressLine1ForIllion = null;
        vm.checkAddressLine1 = false;

        function EnableDisableButton(form1) {
            if ((vm.selectedAddress === null && !vm.state.PropertyDetail.IsManualAddress) ||
                (form1.$invalid) ||
                vm.ReadOnly ||
                vm.invalidRentalAmount ||
                vm.invalidSuminsuredAmount ||
                vm.brokerCommissionLimitMessage ||
                !vm.validDOBOtherInsurer ||
                !vm.policyHolderNameExists() || !checkAdditionalInsuredInList()) {
                return true;
            } else {
                return false;
            }
        }

        function policyHolderNameExists() {
            return (vm.state.PolicyHolder.InsuredNameList.findIndex(record => record.value === vm.state.PolicyHolder.InsuredName) === -1 ? false : true);
        }

        vm.tempLandlordProtectionData = null;
        vm.init = function (landlordProtectionData) {
            vm.tempLandlordProtectionData = landlordProtectionData;
            var qStartDate = null;
            var qCheckDate = new Date(landlordProtectionData.DWCAdjustmentDate);
            var isPM = sessionStorageService.get('IsPackageManagerNavigationMode');
            var renewalCounter = sessionStorageService.get('RenewalCounter');
            if (isPM === "true" || renewalCounter !== null) {
                vm.showManagePkg = true;
            }
            vm.hideDomesticWorkerCompensation = false;
            vm.brokerbranchcheck = sessionStorageService.get('IsBranchViewOnly') !== "false";
            vm.PolicyNumber = landlordProtectionData.PolicyNumber;
            var IsValidQuestionsBack = JSON.parse(sessionStorageService.get(keyConstService.IsValidQuestionsBack));
            if (landlordProtectionData.IsEndorsement) {
                vm.IsEndorsement = landlordProtectionData.IsEndorsement;
            }
            if (landlordProtectionData.LandlordProtectionQuestion && landlordProtectionData.LandlordProtectionQuestion.PaymentFrequency.BrokerManagedPayment !== null) {
                vm.brokerManagedPayment = landlordProtectionData.LandlordProtectionQuestion.PaymentFrequency.BrokerManagedPayment;
            }
            else {
                vm.brokerManagedPayment = landlordProtectionData.PackageDetail.BrokerManagedPayment;
            }

            vm.maxRentalAmount = keyConstService.WeeklyRentalMaxAmount;
            vm.minRentalAmount = keyConstService.WeeklyRentalMinAmount;
            vm.minContentsSumInsured = keyConstService.MinLandlordProtectionSI;
            vm.DefaultSumInsured = keyConstService.DefaultLandlordProtectionSI;
            vm.landlordProtectionData = landlordProtectionData
            vm.activatePayment = vm.landlordProtectionData.ActivatePayment;
            if (landlordProtectionData) {
                if (landlordProtectionData.IsPolicyBound) {
                    vm.enablePopUp = true;
                    toastr.error(messageConstService.errMessagePolicyBound);

                }
            }
            vm.endorsementVM = JSON.parse(sessionStorageService.get(keyConstService.endorsementRequestVM));
            if (landlordProtectionData.QuoteCase != null || landlordProtectionData.QuoteTransactionId != null) {
                vm.CaseNumber = landlordProtectionData.QuoteCase.CaseNumber;
                vm.TransactionId = landlordProtectionData.QuoteTransactionId;
            }

            if (vm.IsEndorsement) {
                vm.showBrokerFee = false;
            }
            else {
                vm.showBrokerFee = true;
            }
            if (!landlordProtectionData.LandlordProtectionQuestion) {
                vm.ready = true;
                caseId = sessionStorageService.get(keyConstService.caseId);
                sessionStorageService.set(keyConstService.IsNewEditTransaction, isNewEditTransaction);
                vm.CaseNumber = JSON.parse(sessionStorageService.get('caseNumber'));
                transactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
                vm.state = quotesService.loadQuoteData(null, 3, landlordProtectionData.LandlordProtectionListData);
                vm.rowVersion = JSON.parse(sessionStorageService.get(keyConstService.rowVersion));
                brokerData = sessionStorageService.get(keyConstService.brokerData);
                var newBusinessCaseData = sessionStorageService.get(keyConstService.newBusinessCaseData);
                var newBusinessCaseDetail = JSON.parse(newBusinessCaseData);
                var startDate = newBusinessCaseDetail.data.EffectiveDate;
                var productId = newBusinessCaseDetail.data.ProductId;
                qStartDate = new Date(newBusinessCaseDetail.data.EffectiveDate);
                vm.state.ContentsSumInsured.GeneralContentSumInsured = vm.DefaultSumInsured;
                var getQuoteTransactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
                if ((sessionStorageService.get(keyConstService.getTransactionIdWithoutSaving))) {
                    vm.getTransactionIdWithoutSaving = JSON.parse(sessionStorageService.get(keyConstService.getTransactionIdWithoutSaving));
                }
                getQuestionSetWithoutSaving = sessionStorageService.get(keyConstService.getQuestionSetWithoutSaving);
                getParsedQuestionSetWithoutSaving = JSON.parse(getQuestionSetWithoutSaving);
                if (getParsedQuestionSetWithoutSaving) {
                    if (getQuoteTransactionId == vm.getTransactionIdWithoutSaving) {
                        vm.state = getParsedQuestionSetWithoutSaving;
                        vm.state.PaymentFrequency.ModeOfPayment = newBusinessCaseDetail.data.ModeOfPayment;
                        vm.state.PaymentFrequency.InstallmentDate = newBusinessCaseDetail.data.InstallmentDate;
                        if (getParsedQuestionSetWithoutSaving.PropertyDetail.IsManualAddress) {
                            vm.selectedMannualAddress = getParsedQuestionSetWithoutSaving.PropertyDetail.AddressText;
                        }
                        else {
                            vm.selectedAddress = angular.copy(getParsedQuestionSetWithoutSaving.PropertyDetail.AddressText);
                        }
                        vm.addressValue = getParsedQuestionSetWithoutSaving.PropertyDetail.AddressValue;
                        if (vm.addressValue !== null) {
                            var splitSate = vm.addressValue.split('|');
                            vm.storeAddress = splitSate[0];
                            vm.getAddressState = splitSate[0];
                            vm.getAddressState = vm.storeAddress;
                            if ((qStartDate < qCheckDate) && (vm.getAddressState.toUpperCase() === "WA" || vm.getAddressState.toUpperCase() === "ACT" || vm.getAddressState.toUpperCase() === "TAS")) {
                                vm.showDomesticWorkerCompensation = true;
                                vm.state.OptionalCover.IsDomesticWorkerCompensation = getParsedQuestionSetWithoutSaving.OptionalCover.IsDomesticWorkerCompensation ;

                            }
                            else {
                                vm.showDomesticWorkerCompensation = false;
                                vm.state.OptionalCover.IsDomesticWorkerCompensation  = null;
                            }

                        }
                    }
                }

                var brokerCommissionRequest = quotesService.getBrokerCommission({
                    EffectiveDate: startDate,
                    ProductId: productId,
                    ProductName: null,
                })
                    .then(function (result) {
                        vm.data = result.data.brokerBranchCommissionFeeVM;
                        if (vm.data) {
                            for (var i = 0; i < vm.data.length; i++) {
                                if (vm.data[i].coverCode === "CONTENT") {
                                    if (!getParsedQuestionSetWithoutSaving) {
                                        vm.state.BrokerCommission.BrokerCommissionPercentage = vm.data[i].brokerCommissionFee;
                                    }
                                    vm.maxbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMax;
                                    vm.minbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMin;
                                    vm.checkBrkerCommissionLimit();
                                }
                            }
                        }
                    })

                brokerdetail = JSON.parse(brokerData);
                var newBusinessCaseDetail = JSON.parse(newBusinessCaseData);
                vm.state.ExistingPackage = newBusinessCaseDetail.data.ExistingPackage;
                if (vm.state.ExistingPackage) {
                    vm.state.OtherInfo.IsAddMorePolicyToPackage = true;
                }

                if (vm.state.PolicyHolder.AdditionalPolicyHolderList.length != 0 && vm.state.PolicyHolder.AdditionalPolicyHolderList[0].OtherDateOfBirthApp != null) {
                    for (var i = 0; i < vm.state.PolicyHolder.AdditionalPolicyHolderList.length; i++) {
                        if (vm.state.PolicyHolder.AdditionalPolicyHolderList[i].AdditionalPolicyHolder === "Other") {
                            var dateofBirth = vm.state.PolicyHolder.AdditionalPolicyHolderList[i].OtherDateOfBirthApp;
                            var response = dateService.validateBirthDDMMYYYY(dateofBirth, 115);
                            if (!response.isValid) {
                                vm.validDOBOtherInsurer = false;
                                vm.message = response.errorMsg;
                                break;
                            }
                            else {
                                vm.validDOBOtherInsurer = true;
                            }
                        }
                        else {
                            continue;
                        }
                    }
                    if (!vm.validDOBOtherInsurer && vm.message === messageConstService.errFutureDateNotAllowed) {
                        toastr.warning(messageConstService.errFutureDatedForAddHolder);
                    }
                    else if (!vm.validDOBOtherInsurer && vm.message === messageConstService.errDateNotAllowed) {
                        toastr.warning(messageConstService.errDateNotAllowed);
                    }
                }
                quotesService.getInsuredNameList(caseId).then(function (ResponseData) {
                    if (ResponseData.data !== null) {
                        vm.state.PolicyHolder.InsuredNameList = ResponseData.data.policyHolder.insuredNameList;
                        vm.state.PolicyHolder.InsuredClientId = ResponseData.data.policyHolder.insuredClientId;
                        vm.ClientDetail = ResponseData.data.clientDetail;
                        vm.addSecondaryClient = ResponseData.data.clientDetail.secondaryInsuredClientVM;
                        vm.otherInsuredAddress = ResponseData.data.clientDetail.addressLogVM;
                        vm.state.PolicyHolder.InsuredName = ResponseData.data.policyHolder.insuredName;
                        vm.PropertyDetail = angular.copy(ResponseData.data.buildingInfo);
                        if (!vm.selectedAddress) {
                            ResponseData.data.buildingInfo.addressText = null;
                            ResponseData.data.buildingInfo.addressValue = null;
                        }

                        if (vm.selectedAddress && getQuoteTransactionId !== vm.getTransactionIdWithoutSaving) {
                            vm.state.PropertyDetail.AddressText = ResponseData.data.buildingInfo.addressText;
                            vm.state.PropertyDetail.AddressValue = ResponseData.data.buildingInfo.addressValue;
                            var splitSate = ResponseData.data.buildingInfo.addressValue != null ? ResponseData.data.buildingInfo.addressValue.split('|'): [];
                            vm.AddressState = splitSate[0];
                            if ((qStartDate < qCheckDate) && (vm.AddressState === "WA" || vm.AddressState === "ACT" || vm.AddressState === "TAS")) {
                                vm.showDomesticWorkerCompensation = true;
                                vm.state.OptionalCover.IsDomesticWorkerCompensation = vm.state.OptionalCover.IsDomesticWorkerCompensation ;

                            }
                            else {
                                vm.showDomesticWorkerCompensation = false;
                                vm.state.OptionalCover.IsDomesticWorkerCompensation  = null;
                            }


                            if (getQuoteTransactionId === vm.getTransactionIdWithoutSaving) {
                                if ((qStartDate < qCheckDate) && (vm.AddressState === "WA" || vm.AddressState === "ACT" || vm.AddressState === "TAS")) {
                                    vm.showDomesticWorkerCompensation = true;
                                    vm.state.OptionalCover.IsDomesticWorkerCompensation = vm.state.OptionalCover.IsDomesticWorkerCompensation ;

                                }
                                else {
                                    vm.showDomesticWorkerCompensation = false;
                                    vm.state.OptionalCover.IsDomesticWorkerCompensation = null;
                                }
                            }

                        }
                        vm.checkRentalAmount();
                        vm.checkSumInsuredValue();
                        vm.checkClaims();


                        if (getQuoteTransactionId !== vm.getTransactionIdWithoutSaving) {
                            var newDate = new Date(ResponseData.data.policyHolder.dateOfBirthApp);
                            vm.state.PolicyHolder.DateOfBirthApp = newDate;
                        }
                        for (var i = 0; i < ResponseData.data.policyHolder.secondaryInsuredsList.length; i++) {
                            if (ResponseData.data.policyHolder.secondaryInsuredsList[i].value === vm.state.PolicyHolder.InsuredName && ResponseData.data.policyHolder.secondaryInsuredsList[i].id === vm.state.PolicyHolder.InsuredClientId) {
                                var index = ResponseData.data.policyHolder.secondaryInsuredsList.indexOf(ResponseData.data.policyHolder.secondaryInsuredsList[i]);
                                ResponseData.data.policyHolder.secondaryInsuredsList.splice(index, 1);
                                vm.state.PolicyHolder.SecondaryInsuredsList = ResponseData.data.policyHolder.secondaryInsuredsList;

                                if (getQuoteTransactionId === vm.getTransactionIdWithoutSaving) {
                                    vm.getQuestionSetWithoutSavingData = JSON.parse(sessionStorageService.get(keyConstService.getQuestionSetWithoutSaving));
                                    if (vm.getQuestionSetWithoutSavingData) {
                                        if (vm.getQuestionSetWithoutSavingData.PolicyHolder.InsuredName === "Other") {
                                            vm.state.PolicyHolder.InsuredName = vm.getQuestionSetWithoutSavingData.PolicyHolder.InsuredName;
                                            vm.state.PolicyHolder.OtherInsuredName = vm.getQuestionSetWithoutSavingData.PolicyHolder.OtherInsuredName;
                                            for (var i = 0; i < vm.getQuestionSetWithoutSavingData.PolicyHolder.SecondaryInsuredsList.length; i++) {
                                                vm.state.PolicyHolder.SecondaryInsuredsList[i] = vm.getQuestionSetWithoutSavingData.PolicyHolder.SecondaryInsuredsList[i];
                                            }
                                        }
                                    }
                                }
                                else {
                                    if (vm.state.PolicyHolder.InsuredName) {
                                        vm.state.PolicyHolder.InsuredName = ResponseData.data.policyHolder.insuredName;
                                    }
                                }
                            }
                        }

                        vm.tempPrimaryInsured = ResponseData.data.policyHolder.insuredName;
                        vm.tempAdditonalPolicyHolders = angular.copy(ResponseData.data.policyHolder.additionalPolicyHolderList);

                        // Commentd by Ankur as per us 6829
                        //var secondaryInsuredOtherPos = vm.state.PolicyHolder.SecondaryInsuredsList.findIndex(p => p.value === "Other");
                        //if (secondaryInsuredOtherPos !== -1) {
                        //    vm.state.PolicyHolder.SecondaryInsuredsList.splice(secondaryInsuredOtherPos, 1);
                        //}
                    }
                });

                // removing questionset from session for valid newbusiness quote
                if (!getParsedQuestionSetWithoutSaving) {
                    sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
                }
            }
            //edit,endorsement,view
            else {
                var newBusinessCaseData = sessionStorageService.get(keyConstService.newBusinessCaseData);
                var newBusinessCaseDetail = JSON.parse(newBusinessCaseData);
                qStartDate = newBusinessCaseDetail != null ? new Date(newBusinessCaseDetail.data.EffectiveDate) : new Date(landlordProtectionData.StartDate);
                caseNumberForSecondaryInsured = landlordProtectionData.QuoteCase.Id;
                vm.brokerFeeGST = landlordProtectionData.LandlordProtectionQuestion.PaymentFrequency.BrokerFee;
                vm.addressState = landlordProtectionData.LandlordProtectionQuestion.PropertyDetail.AddressValue;
                if (vm.addressState !== null) {
                    var splitSate = vm.addressState.split('|');
                    vm.storeAddress = splitSate[0];
                    vm.AddressState = splitSate[0];

                }

                if (JSON.parse(sessionStorageService.get(keyConstService.IsRenewalPolicy)) === true)
                    landlordProtectionData.LandlordProtectionQuestion.CuppingCappingFactor.ExpirationPremium = landlordProtectionData.LandlordProtectionQuestion.CuppingCappingFactor.AdjustmentFactor = null;

                vm.IsEndorsementPolicyEffectiveDate = landlordProtectionData.IsEndorsementPolicyEffectiveDate;
                vm.IsEndorsement = landlordProtectionData.IsEndorsement;
                vm.state = landlordProtectionData.LandlordProtectionQuestion;
                vm.previousAddressLine1ForIllion = vm.state.PropertyDetail.AddressLine1;                
                var indexOfOther1 = vm.state.PolicyHolder.InsuredNameList.findIndex(p => p.value === "Other");
                if (indexOfOther1 != -1) {
                    vm.state.PolicyHolder.InsuredNameList.splice(indexOfOther1, 1);
                }

                if (vm.state.PolicyHolder.SecondaryInsuredsList !== null) {
                    var indexOfSecOther1 = vm.state.PolicyHolder.SecondaryInsuredsList.findIndex(p => p.value === "Other");
                    if (indexOfSecOther1 != -1) {
                        vm.state.PolicyHolder.SecondaryInsuredsList.splice(indexOfSecOther1, 1);
                    }
                }

                if (vm.state.PolicyHolder.InsuredNameList !== null) {
                    var indexOfOtherInsured = vm.state.PolicyHolder.InsuredNameList.findIndex(p => p.value === "OtherInsured");
                    if (indexOfOtherInsured === -1) {
                        vm.state.PolicyHolder.InsuredNameList.push({ clientType: "Secondary", name: 'Other Insured', value: 'OtherInsured', dateOfBirth: new Date(), Id: -1 });
                    }
                }

                if (vm.state.PolicyHolder.SecondaryInsuredsList !== null) {
                    var indexOfSecondaryOtherInsured = vm.state.PolicyHolder.SecondaryInsuredsList.findIndex(p => p.value === "OtherInsured");
                    if (indexOfSecondaryOtherInsured === -1) {
                        vm.state.PolicyHolder.SecondaryInsuredsList.push({ clientType: "Secondary", name: 'Other Insured', value: 'OtherInsured', dateOfBirth: new Date(), Id: -1 });
                    }
                }


                if (vm.addressState !== null) {
                    if ((qStartDate < qCheckDate) && (vm.AddressState.toUpperCase() === "WA" || vm.AddressState.toUpperCase() === "ACT" || vm.AddressState.toUpperCase() === "TAS")) {
                        vm.showDomesticWorkerCompensation = true;
                        vm.state.OptionalCover.IsDomesticWorkerCompensation = landlordProtectionData.LandlordProtectionQuestion.OptionalCover.IsDomesticWorkerCompensation;

                    }
                    else {
                        vm.showDomesticWorkerCompensation = false;
                        vm.state.OptionalCover.IsDomesticWorkerCompensation = null;
                    }
                }
                vm.dataState = landlordProtectionData;
                vm.rowVersion = landlordProtectionData.RowVersion;
                vm.transactionStatus = landlordProtectionData.Status;
                vm.isSecondaryDisabled = false;
                vm.policyTransactionId = landlordProtectionData.PolicyTransactionId;
                sessionStorageService.remove(keyConstService.IsNewBusinessReadOnly);
                if (JSON.parse(sessionStorageService.get(keyConstService.IsCopyQuote)) === false) {
                    sessionStorageService.set(keyConstService.IsPackageEditable, vm.dataState.IsPackageEditable);
                }
                else if (JSON.parse(sessionStorageService.get(keyConstService.IsCopyQuote)) === true && newBusinessCaseDetail) {
                    vm.state.ExistingPackage = newBusinessCaseDetail.data.ExistingPackage;
                    caseId = sessionStorageService.get(keyConstService.caseId);
                    quotesService.getInsuredNameList(caseId).then(function (ResponseData) {
                        if (ResponseData.data !== null) {
                            vm.state.PolicyHolder.InsuredNameList = ResponseData.data.policyHolder.insuredNameList;
                            //console.log(ResponseData.data);
                            vm.state.PolicyHolder.InsuredName = ResponseData.data.policyHolder.insuredName;
                            vm.secondaryListChange(true);
                        }
                    });
                    if (vm.state.ExistingPackage) {
                        vm.state.OtherInfo.IsAddMorePolicyToPackage = true;
                    }
                }
                vm.ReadOnly = landlordProtectionData.IsReadOnly;
                var getQuoteTransactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
                if (sessionStorageService.get(keyConstService.getTransactionIdWithoutSaving)) {
                    vm.getTransactionIdWithoutSaving = JSON.parse(sessionStorageService.get(keyConstService.getTransactionIdWithoutSaving));
                }
                getQuestionSetWithoutSaving = sessionStorageService.get(keyConstService.getQuestionSetWithoutSaving);
                getParsedQuestionSetWithoutSaving = JSON.parse(getQuestionSetWithoutSaving);
                var newBusinessdata = JSON.parse(sessionStorageService.get(keyConstService.newBusinessCaseData));
                if (getParsedQuestionSetWithoutSaving) {
                    if (getQuoteTransactionId == vm.getTransactionIdWithoutSaving) {
                        vm.state = getParsedQuestionSetWithoutSaving;
                        vm.policyHolderDateOfBirthApp = angular.copy(getParsedQuestionSetWithoutSaving.PolicyHolder.DateOfBirthApp);
                        if (newBusinessdata) {
                            vm.state.PaymentFrequency.ModeOfPayment = newBusinessdata.data.PaymentFrequency;
                            vm.state.PaymentFrequency.DayofInstallment = vm.state.PaymentFrequency.ModeOfPayment.toUpperCase() === 'MONTHLY' ? newBusinessdata.data.InstallmentDate : 0;
                        }
                        splitSate = vm.state.PropertyDetail.AddressValue.split('|');
                        vm.storeAddress = splitSate[0];
                        vm.getAddressState = splitSate[0];
                        if ((qStartDate < qCheckDate) && (vm.getAddressState === "WA" || vm.getAddressState === "ACT" || vm.getAddressState === "TAS")) {
                            vm.showDomesticWorkerCompensation = true;
                            vm.state.OptionalCover.IsDomesticWorkerCompensation = vm.state.OptionalCover.IsDomesticWorkerCompensation ;

                        }
                        else {
                            vm.showDomesticWorkerCompensation = false;
                            vm.state.OptionalCover.IsDomesticWorkerCompensation  = null;
                        }

                        //Code to enable disable state when policyeffectivedate = endorsementeffectivedate
                        if (getParsedQuestionSetWithoutSaving.PropertyDetail.IsManualAddress) {
                            vm.state.PropertyDetail.AddressLine1 = getParsedQuestionSetWithoutSaving.PropertyDetail.AddressLine1;
                            vm.selectedMannualAddress = getParsedQuestionSetWithoutSaving.PropertyDetail.AddressText;

                        }
                        else if (!getParsedQuestionSetWithoutSaving.PropertyDetail.IsManualAddress && getParsedQuestionSetWithoutSaving.PropertyDetail.AddressText !=null) {
                            vm.state.PropertyDetail.AddressText = getParsedQuestionSetWithoutSaving.PropertyDetail.AddressText;
                            vm.selectedAddress = { postCode: getParsedQuestionSetWithoutSaving.PropertyDetail.Postcode, text: getParsedQuestionSetWithoutSaving.PropertyDetail.AddressText, value: getParsedQuestionSetWithoutSaving.PropertyDetail.AddressValue };
                        }
                    }
                }
                else {

                    if (landlordProtectionData.LandlordProtectionQuestion.PropertyDetail.IsManualAddress) {
                        vm.selectedMannualAddress = landlordProtectionData.LandlordProtectionQuestion.PropertyDetail.AddressText;
                        vm.state.PropertyDetail.AddressLine1 = landlordProtectionData.LandlordProtectionQuestion.PropertyDetail.AddressLine1;
                    }
                    else {
                        vm.selectedAddress = landlordProtectionData.LandlordProtectionQuestion.PropertyDetail.AddressText;
                    }
                }
                //message retainment on previous next
                vm.checkSumInsuredValue();
                vm.checkRentalAmount();
                vm.checkClaims();
                var endorsementDataVM = JSON.parse(sessionStorageService.get(keyConstService.endorsementRequestVM));
                {
                    if (endorsementDataVM) {
                        vm.policyEffectiveDate = moment(endorsementDataVM.StartDate).format('MM/DD/YYYY');
                        vm.endorsementEffectiveDate = endorsementDataVM.EndorsementEffectiveDate;
                        if (vm.policyEffectiveDate === vm.endorsementEffectiveDate) {
                            vm.addressValue = JSON.parse(sessionStorageService.get(keyConstService.AddressValue));
                            if (vm.addressValue && getQuoteTransactionId !== vm.getTransactionIdWithoutSaving && getQuoteTransactionId !== undefined && vm.getTransactionIdWithoutSaving) {
                                var splitSate = vm.addressValue.split('|');
                                vm.storeAddress = splitSate[0];
                                vm.AddressState = splitSate[0];

                            }
                            vm.IsEndorsementPolicyEffectiveDate = false;
                            var isEndorsementEdit = JSON.parse(sessionStorageService.get(keyConstService.IsNewEditTransaction));
                            if (isEndorsementEdit) {
                                if (getParsedQuestionSetWithoutSaving) {
                                    vm.state.UnderwritingCriteria.HasInsuredInLast3Years = getParsedQuestionSetWithoutSaving.UnderwritingCriteria.HasInsuredInLast3Years
                                    vm.state.UnderwritingCriteria.InsuredInLast3YearsData = getParsedQuestionSetWithoutSaving.UnderwritingCriteria.InsuredInLast3YearsData;
                                    vm.state.Claims.IsClaimsInLast3Years = getParsedQuestionSetWithoutSaving.Claims.IsClaimsInLast3Years;
                                    vm.state.Claims.ClaimsList = getParsedQuestionSetWithoutSaving.Claims.ClaimsList;
                                }
                            }
                        }
                        else {
                            vm.IsEndorsementPolicyEffectiveDate = true;
                            var newBusinessQuestionsForEndorsement = quotesService.getQuestionSetForPolicy(landlordProtectionData.PolicyId)
                                .then(function (result) {
                                    var questionsSet = JSON.parse(result.data.requestContent);
                                    vm.state.UnderwritingCriteria.HasInsuredInLast3Years = questionsSet.UnderwritingCriteria.HasInsuredInLast3Years
                                    vm.state.UnderwritingCriteria.InsuredInLast3YearsData = questionsSet.UnderwritingCriteria.InsuredInLast3YearsData;
                                    vm.state.Claims.IsClaimsInLast3Years = questionsSet.Claims.IsClaimsInLast3Years;
                                    vm.state.Claims.ClaimsList = questionsSet.Claims.ClaimsList;
                                });
                        }
                    }
                }

                if (vm.IsEndorsement) {
                    endorsementState = angular.copy(vm.state);
                }
                if (vm.state.Claims.IsClaimsInLast3Years) {
                    for (var i = 0; i < vm.state.Claims.ClaimsList.length; i++) {
                        if (vm.state.Claims.ClaimsList[i].ClaimYear == null || vm.state.Claims.ClaimsList[i].ClaimType == null)
                            vm.checkNullClaimList = true;
                    }
                }
                if (vm.ReadOnly == true) {
                    sessionStorageService.set(keyConstService.IsNewBusinessReadOnly, landlordProtectionData.IsReadOnly);
                }
                var startDate = landlordProtectionData.StartDate;
                if (sessionStorageService.get(keyConstService.newBusinessCaseData) != null) {
                    var newBusinessCaseDetail = JSON.parse(sessionStorageService.get(keyConstService.newBusinessCaseData));
                    vm.EffectiveDate = newBusinessCaseDetail.data.EffectiveDate;
                    ExpirationDate = newBusinessCaseDetail.data.ExpirationDate;
                    startDate = newBusinessCaseDetail.data.EffectiveDate;
                }
                else {
                    vm.EffectiveDate = landlordProtectionData.EffectiveDate;
                    ExpirationDate = landlordProtectionData.ExpirationDate;
                }

                if (!sessionStorageService.get(keyConstService.IsNewEditTransaction)) {
                    var isEdit = JSON.parse(sessionStorageService.get(keyConstService.IsNewEditTransaction));
                    if (isEdit !== false && JSON.parse(sessionStorageService.get(keyConstService.IsCopyQuote)) != true) {
                        isNewEditTransaction = true;
                        sessionStorageService.set(keyConstService.IsNewEditTransaction, isNewEditTransaction);
                    }
                }
                var convertContentSumInsuredToInt = parseInt(landlordProtectionData.LandlordProtectionQuestion.ContentsSumInsured.ContentsSumInsured);
                landlordProtectionData.LandlordProtectionQuestion.ContentsSumInsured.ContentsSumInsured = convertContentSumInsuredToInt;
                sessionStorageService.set(keyConstService.rowVersion, landlordProtectionData.RowVersion);
                sessionStorageService.set(keyConstService.caseId, landlordProtectionData.QuoteCase.Id);
                caseId = sessionStorageService.get(keyConstService.caseId);

                sessionStorageService.set(keyConstService.caseNumber, vm.CaseNumber);
                vm.getNewBusinessCaseData = JSON.parse(sessionStorageService.get(keyConstService.newBusinessCaseData));
                sessionStorageService.set(keyConstService.newBusinessData, vm.getNewBusinessCaseData);
                IsNewBusinessEdit = sessionStorageService.get(keyConstService.IsNewBusinessEdit);
                sessionStorageService.remove(keyConstService.quoteTransactionId);
                sessionStorageService.set(keyConstService.quoteTransactionId, landlordProtectionData.QuoteTransactionId);

                if (landlordProtectionData.LandlordProtectionQuestion.PropertyDetail.AddressText != null && !landlordProtectionData.LandlordProtectionQuestion.PropertyDetail.IsManualAddress && getQuoteTransactionId !== vm.getTransactionIdWithoutSaving) {
                    vm.selectedAddress = landlordProtectionData.LandlordProtectionQuestion.PropertyDetail.AddressText;
                    vm.selectAddress = landlordProtectionData.LandlordProtectionQuestion.PropertyDetail.AddressValue;
                    if (vm.selectAddress !== null) {
                        var splitSate = vm.selectAddress.split('|');
                        vm.storeAddress = splitSate[0];
                        vm.AddressState = splitSate[0];
                        if ((qStartDate < qCheckDate) && (vm.AddressState === "WA" || vm.AddressState === "ACT" || vm.AddressState === "TAS")) {
                            vm.showDomesticWorkerCompensation = true;
                            vm.state.OptionalCover.IsDomesticWorkerCompensation = vm.state.OptionalCover.IsDomesticWorkerCompensation;

                        }
                        else {
                            vm.showDomesticWorkerCompensation = false;
                            vm.state.OptionalCover.IsDomesticWorkerCompensation = null;
                        }

                        if (vm.AddressState === "NSW") {
                            vm.showStampDuty = true;

                        }


                    }
                }
                else if (landlordProtectionData.LandlordProtectionQuestion.PropertyDetail.AddressText != null && landlordProtectionData.LandlordProtectionQuestion.PropertyDetail.IsManualAddress ) {
                    vm.selectedMannualAddress = landlordProtectionData.LandlordProtectionQuestion.PropertyDetail.AddressText;
                    vm.selectMannualAddress = landlordProtectionData.LandlordProtectionQuestion.PropertyDetail.AddressValue;
                    if (vm.selectMannualAddress !== null) {
                        var splitSate = vm.selectMannualAddress.split('|');
                        vm.AddressState = splitSate[0];
                        if ((qStartDate < qCheckDate) && (vm.AddressState.toUpperCase() === "WA" || vm.AddressState.toUpperCase() === "ACT" || vm.AddressState.toUpperCase() === "TAS")) {
                            vm.showDomesticWorkerCompensation = true;
                            vm.state.OptionalCover.IsDomesticWorkerCompensation = vm.state.OptionalCover.IsDomesticWorkerCompensation;

                        }
                        else {
                            vm.showDomesticWorkerCompensation = false;
                            vm.state.OptionalCover.IsDomesticWorkerCompensation = null;
                        }
                        if (vm.AddressState === "NSW") {
                            vm.showStampDuty = true;

                        }
                    }
                }



                if (vm.IsEndorsement) {
                    if (vm.state.PropertyDetail.IsManualAddress == false) {
                        vm.state.PropertyDetail.AddressLine1 = null;
                        vm.selectedMannualAddress = null;
                    }
                }

                if (vm.IsEndorsement) {
                    if (vm.state.PropertyDetail.IsManualAddress == false) {
                        vm.state.PropertyDetail.AddressLine1 = null;
                        vm.selectedMannualAddress = null;
                    }
                }

                if (vm.endorsementVM) {
                    sessionStorageService.set(keyConstService.quoteTransactionId, landlordProtectionData.QuoteTransactionId);
                    if (!(getQuoteTransactionId == vm.getTransactionIdWithoutSaving && getParsedQuestionSetWithoutSaving)) {
                        vm.state.Excess.ContentExcess2 = null;
                        vm.state.Excess.ContentExcess3 = null;
                        vm.state.Excess.ContentExcess1 = vm.endorsementVM.ContentExcess;
                    }
                }

                var occupancyType = landlordProtectionData.LandlordProtectionQuestion.PolicyHolder.LandlordOccupancyType;
                var isEdit = sessionStorageService.get(keyConstService.IsNewEditTransaction);
                var productName = landlordProtectionData.LOB;
                var brokerCommissionRequestOnEdit = quotesService.getBrokerCommissiononEdit({
                    EffectiveDate: startDate,
                    ProductName: productName,
                    ProductId: null,
                })
                    .then(function (result) {
                        vm.data = result.data.brokerBranchCommissionFeeVM;
                        if (vm.data) {
                            for (var i = 0; i < vm.data.length; i++) {
                                if (vm.data[i].coverCode === "CONTENT") {
                                    vm.maxbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMax;
                                    vm.minbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMin;
                                }
                                if (!vm.ReadOnly && !vm.IsEndorsement) {
                                    vm.checkBrkerCommissionLimit();
                                }
                            }
                            if (getQuoteTransactionId === vm.getTransactionIdWithoutSaving && vm.getTransactionIdWithoutSaving !== null && getQuoteTransactionId !== null) {
                                vm.state.PolicyHolder.DateOfBirthApp = vm.policyHolderDateOfBirthApp;
                            }
                        }
                    })

                // commented 
                if (JSON.parse(sessionStorageService.get(keyConstService.IsCopyQuote)) !== true) {
                    vm.getSecondaryInsuredList(landlordProtectionData.LandlordProtectionQuestion.PolicyHolder.DateOfBirthApp);
                }

                // removing questionset from session for valid newbusiness quote
                if (!getParsedQuestionSetWithoutSaving) {
                    sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
                }

                //// if call Illion API if copy quote or Edit or endorsement quote when IsIllionCallOnEdit is true
                if (vm.tempLandlordProtectionData.DDlProcessTypeId != 4 || vm.IsEndorsement == false && (vm.tempLandlordProtectionData.DDlProcessTypeId != 4 && vm.IsEndorsement == false)) {
                    if (JSON.parse(sessionStorageService.get(keyConstService.IsCopyQuote)) || (landlordProtectionData.IsIllionCallOnEdit && (JSON.parse(sessionStorageService.get(keyConstService.IsNewEditTransaction))))) {
                        vm.state.IllionClaimResponse = null;
                        vm.state.IllionClaimResponseId = null;
                        vm.getAdressEnquiryDetails();
                    }
                }
                

                if (vm.state.PolicyHolder.AdditionalPolicyHolderList.length != 0 && vm.state.PolicyHolder.AdditionalPolicyHolderList[0].OtherDateOfBirthApp != null) {
                    for (var i = 0; i < vm.state.PolicyHolder.AdditionalPolicyHolderList.length; i++) {
                        if (vm.state.PolicyHolder.AdditionalPolicyHolderList[i].AdditionalPolicyHolder === "Other") {
                            var dateofBirth = vm.state.PolicyHolder.AdditionalPolicyHolderList[i].OtherDateOfBirthApp;
                            var response = dateService.validateBirthDDMMYYYY(dateofBirth, 115);
                            if (!response.isValid) {
                                vm.validDOBOtherInsurer = false;
                                vm.message = response.errorMsg;
                                break;
                            }
                            else {
                                vm.validDOBOtherInsurer = true;
                            }
                        }
                        else {
                            continue;
                        }
                    }
                    if (!vm.validDOBOtherInsurer && vm.message === messageConstService.errFutureDateNotAllowed) {
                        toastr.warning(messageConstService.errFutureDatedForAddHolder);
                    }
                    else if (!vm.validDOBOtherInsurer && vm.message === messageConstService.errDateNotAllowed) {
                        toastr.warning(messageConstService.errDateNotAllowed);
                    }
                }
                var isCopyQuote = JSON.parse(sessionStorageService.get(keyConstService.IsCopyQuote));
                if (!IsNewBusinessEdit && !isCopyQuote) {
                    sessionStorageService.remove(keyConstService.newBusinessCaseData);
                }
                else {
                    vm.landlordProtectionData.PackageDetail.PaymentFrequency = vm.getNewBusinessCaseData.data.PaymentFrequency;
                    vm.landlordProtectionData.PackageDetail.InstallmentDate = vm.getNewBusinessCaseData.data.InstallmentDate;
                }
                getInsuredNameList(true);
            }

            vm.state.PaymentFrequency.ModeOfPayment = vm.landlordProtectionData.PackageDetail.PaymentFrequency;
            vm.state.PaymentFrequency.DayofInstallment = 0;
            if (vm.state.PaymentFrequency.ModeOfPayment === 'Monthly') {
                vm.state.PaymentFrequency.DayofInstallment = vm.landlordProtectionData.PackageDetail.InstallmentDate;
            }

            // updating claims data after changing effective date
            quotesService.updateClaimsInfo(vm.state.Claims);
            // retaining claims validation on previous/next
            vm.checkClaims();

            //disable getquote if insured name is not in list
            if (vm.state.PolicyHolder.InsuredName !== "Other") {
                var existInsuredName = utilityService.valueExistsInArray(vm.state.PolicyHolder.InsuredName, vm.state.PolicyHolder.InsuredNameList);
                if (!existInsuredName) {
                    vm.disableButtons = true;
                }
            }

            // for additional insured
            //checkAdditionalInsuredInList();

        };
        //end of init
        vm.Back = function () {
            var isactivePM = sessionStorageService.get('IsPackageManagerNavigationMode');
            if (isactivePM === "true") {
                sessionStorageService.set(keyConstService.IsPackageManagerNavigationMode, "preTrue");
            }
            vm.disableButtons = true;
            if (vm.IsEndorsement) {
                if (vm.state.PropertyDetail.IsManualAddress === false) {
                    vm.selectedMannualAddress = null;
                    vm.state.PropertyDetail.AddressLine1 = null;
                }
                sessionStorageService.set(keyConstService.AddressValue, vm.state.PropertyDetail.AddressValue)
            }
            sessionStorageService.remove(keyConstService.resetNonRegoData);
            sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
            sessionStorageService.remove(keyConstService.isManualRegoEnabled);
            getQuestionSetWithoutSaving = sessionStorageService.set(keyConstService.getQuestionSetWithoutSaving, vm.state);
            var quoteTransactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
            sessionStorageService.get(keyConstService.newBusinessCaseData);
            sessionStorageService.set(keyConstService.sessionStorageState, true);
            getTransactionIdWithoutSaving = sessionStorageService.set(keyConstService.getTransactionIdWithoutSaving, quoteTransactionId);
            var transactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
            sessionStorageService.set(keyConstService.IllionAddressEnquiry, true);

            if (vm.IsEndorsement) {
                window.location = webUrlConstService.endorsementRequest + sessionStorageService.getEncryption("quoteTransactionId=" + transactionId);
            }
            else {
                if (sessionStorageService.get(keyConstService.IsNewEditTransaction) !== "true") {
                    sessionStorageService.set(keyConstService.IsNewEditTransaction, isNewEditTransaction);
                }
                window.location = webUrlConstService.newBusinessIndex + sessionStorageService.getEncryption("transactionId=" + transactionId);
            }
        };

        vm.Cancel = function () {
            vm.disableButtons = true;
            if (vm.IsEndorsement) {
                quotesService.quoteDiscardRequest(sessionStorageService.get(keyConstService.quoteTransactionId)).then(function (result) {
                    if (result.data) {
                        if (vm.showManagePkg) {
                            vm.packageNumber = sessionStorageService.get('PackageNumberInformation');
                            vm.renewalCounter = sessionStorageService.get('RenewalCounter');
                            sessionStorageService.remove('IsPackageManagerNavigationMode');
                            sessionStorageService.remove('PackageNumberInformation');
                            sessionStorageService.remove('RenewalCounter');
                            $window.location.href = webUrlConstService.getPackageInfo + sessionStorageService.getEncryption("packageNumber=" + JSON.parse(vm.packageNumber) + "&&renewalCounter=" + vm.renewalCounter);
                        }
                        else {
                            $timeout(function () {
                                var Id = vm.dataState.PolicyId;
                                window.location = "/Bind?" + sessionStorageService.getEncryption("id=" + Id);
                            }, 1000);
                        }
                    } else {
                        toastr.error(messageConstService.errServiceUnavailable);
                        vm.disableButtons = false;
                    }
                },
                    function (error) {
                        $log.error('error', error);
                        toastr.error(messageConstService.errServiceUnavailable);
                        vm.disableButtons = false;
                    });
            }
            else {
                $window.location = webUrlConstService.homeIndex;
            }
        };

        // function for On click of address not found
        function onClickAddressNotFound() {
            vm.state.PropertyDetail.IsManualAddress = true;
            vm.searchText = null;
            resetAddressData();
        }
        //function to reset values on address input change
        function resetAddressNotFound() {
            vm.state.PropertyDetail.IsManualAddress = false;
            if (vm.state.PropertyDetail.AddressText) {
                vm.previousAddressTextForIllion = vm.state.PropertyDetail.AddressText;
            }            
            vm.resetAddressData();
        }
        //function for On click of address not found other insured
        function onClickAddressNotFoundOtherInsured() {
            vm.otherInsuredAddress.isManualAddress = true;
            vm.searchText1 = null;
            resetAddress();
        }
        //function to reset values on address input change other insured
        function resetAddressNotFoundOtherInsured() {
            vm.otherInsuredAddress.isManualAddress = false;
            resetAddress();
        }

        function resetAddressData() {
            vm.showDomesticWorkerCompensation = false;
            vm.state.OptionalCover.IsDomesticWorkerCompensation = null;
            if (!vm.IsEndorsement) {
                if (vm.state.PropertyDetail.IsManualAddress) {
                    vm.previousAddress = [{
                        postcode: vm.state.PropertyDetail.Postcode,
                        text: vm.state.PropertyDetail.AddressText,
                        value: vm.state.PropertyDetail.AddressValue,
                    }];

                    vm.previousSelectedAddress = vm.state.PropertyDetail.AddressText;
                    vm.state.PropertyDetail.Address = null;
                    vm.selectedMannualAddress = null;
                    vm.mannualSearchText = null;
                    vm.state.PropertyDetail.AddressLine1 = null;
                    vm.state.PropertyDetail.AddressText = null;
                    vm.state.PropertyDetail.AddressValue = null;
                } else {
                    //restore the address
                    vm.state.PropertyDetail.AddressText = vm.previousSelectedAddress;
                    if (vm.previousAddress && vm.previousAddress[0].text) {
                        vm.selectedAddress = vm.previousAddress[0];
                    }
                }
            }
            else {
                if (endorsementState.PropertyDetail.IsManualAddress) {
                    if (!vm.state.PropertyDetail.IsManualAddress) {
                        vm.previousAddressLine1 = vm.state.PropertyDetail.AddressLine1;
                        vm.manualAddressText = vm.state.PropertyDetail.AddressText;
                        vm.state.PropertyDetail.AddressLine1 = null;
                        vm.state.PropertyDetail.AddressText = null;
                        vm.selectedMannualAddress = null;
                        vm.selectedAddress = null;
                    }
                    else {
                        vm.state.PropertyDetail.AddressLine1 = vm.previousAddressLine1;
                        vm.state.PropertyDetail.AddressText = vm.manualAddressText;
                        vm.selectedMannualAddress = vm.manualAddressText;
                    }
                }
                else {
                    if (!vm.state.PropertyDetail.IsManualAddress) {
                        vm.selectedAddress = vm.previousSelectedAddress;
                        vm.state.PropertyDetail.AddressValue = vm.previousAddressValue;
                    }
                    else {
                        vm.previousAddress = vm.state.PropertyDetail.AddressText;
                        vm.previousAddressValue = vm.state.PropertyDetail.AddressValue;
                        vm.previousSelectedAddress = vm.selectedAddress;
                        vm.state.PropertyDetail.AddressText = null;
                        vm.state.PropertyDetail.AddressLine1 = null;
                        vm.selectedAddress = null;
                        vm.selectedMannualAddress = null;
                    }
                }
            }

        }

        vm.saveQuote = function () {
            vm.disableButtons = true;
            sessionStorageService.remove(keyConstService.getTransactionIdWithoutSaving);
            sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
            sessionStorageService.remove(keyConstService.resetNonRegoData);
            sessionStorageService.remove(keyConstService.IllionAddressEnquiry);
            sessionStorageService.set(keyConstService.sessionStorageState, false);
            var transactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
            previousTransactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
            vm.rowVersion = JSON.parse(sessionStorageService.get(keyConstService.rowVersion));
            var automaticPayment = -1;
            if (vm.transactionStatus == "Draft") {
                isNewEditTransaction = false;
            }
            else {
                isNewEditTransaction = sessionStorageService.get(keyConstService.IsNewEditTransaction);
            }
            if (vm.endorsementVM != null) {
                vm.EffectiveDate = vm.endorsementVM.EndorsementEffectiveDate;
                ExpirationDate = vm.endorsementVM.ExpirationDate;
                vm.endorsementVM.BuildingExcess = vm.state.Excess.BuildingExcess1;
                vm.endorsementVM.ContentExcess = vm.state.Excess.ContentExcess1;

                sessionStorageService.set(keyConstService.endorsementRequestVM, vm.endorsementVM);
            }
            else {
                var newBusinessData = JSON.parse(sessionStorageService.get(keyConstService.newBusinessCaseData));
                if (newBusinessData) {
                    vm.EffectiveDate = newBusinessData.data.EffectiveDate;
                    ExpirationDate = newBusinessData.data.ExpirationDate;
                    automaticPayment = newBusinessData.data.BrokerManagedPayment;
                }
            }
            if (automaticPayment == -1) {
                automaticPayment = vm.brokerManagedPayment
            }
            vm.state.PaymentFrequency.BrokerManagedPayment = automaticPayment;
            var data = JSON.stringify(vm.state);
            var finalData = { SaveContent: data, EffectiveDate: vm.EffectiveDate, ExpirationDate: ExpirationDate, TransactionId: transactionId, NewEditTransaction: isNewEditTransaction, RowVersion: vm.rowVersion, PaymentFrequency: vm.state.PaymentFrequency.ModeOfPayment, InstallmentDate: vm.state.PaymentFrequency.DayofInstallment, BrokerManagedPayment: automaticPayment };
            var quoteRequest = quotesService.generateRequest(finalData, "LandlordProtection");
            quotesService.saveQuote(quoteRequest, "LandlordProtection").then(function (data) {
                if (data !== null && data.data !== null && data.data.error !== null && data.data.error.number === 402) {
                    $timeout(function () {
                        $window.location.href = webUrlConstService.homeIndex;
                    }, 1000);
                    return;
                }
                if (data && data.status === false) {
                    toastr.error(messageConstService.errRecordUpdated);
                    vm.disableButtons = false;
                }
                else if (data && data.status === true) {
                    toastr.success("Saved!");
                    //Remove PrimaryClientInsuredId
                    sessionStorageService.remove(keyConstService.PrimaryInsuredId);
                    vm.rowVersion = data.data.quoteTransaction.rowVersion;
                    isNewEditTransaction = false;
                    sessionStorageService.set(keyConstService.IsNewEditTransaction, isNewEditTransaction);
                    sessionStorageService.set(keyConstService.rowVersion, vm.rowVersion);
                    sessionStorageService.set(keyConstService.quoteTransactionId, data.data.quoteTransaction.id);
                    sessionStorageService.set(keyConstService.newBusinessCaseData.status, data.data.quoteTransaction.status);
                    var handledResponse = quotesService.handleResponse(data, "LandlordProtection");
                    vm.disableButtons = false;
                }
            }, function (e) {
                var myJSON = JSON.stringify(e);
                $log.error('error myJSON', myJSON);
                vm.disableButtons = false;
            });
        }

        function nextPremium() {
            if (vm.policyTransactionId) {
                $window.location.href = webUrlConstService.bindIndex + sessionStorageService.getEncryption('id=' + vm.policyTransactionId);
            }
            else {
                window.location = webUrlConstService.quoteCasePremiumURL + sessionStorageService.getEncryption('quoteTransactionId=' + vm.TransactionId);
            }
        }

        function finalSaving(finalData) {
            var quoteRequest = quotesService.generateRequest(finalData, "LandlordProtection");
            quotesService.saveQuote(quoteRequest, "LandlordProtection").then(function (data) {
                var handledResponse = quotesService.handleResponse(data, "LandlordProtection");
            }, function (e) {
                var myJSON = JSON.stringify(e);
                $log.error('error myJSON', myJSON);
            });
        }

        vm.addSecondaryInsured = function () {
            vm.state.PolicyHolder.AdditionalPolicyHolderList.push({ AdditionalPolicyHolder: null, AdditionalDateOfBirth: null, AdditionalPolicyHolderType: null, OtherPolicyHolderName: null, OtherDateOfBirth: null });
            vm.AdditionalPolicyHolderListLength = vm.state.PolicyHolder.AdditionalPolicyHolderList.length;
        };

        vm.removeSecondaryInsured = function (item) {
            var index = vm.state.PolicyHolder.AdditionalPolicyHolderList.indexOf(item);
            vm.state.PolicyHolder.AdditionalPolicyHolderList.splice(index, 1);
            vm.AdditionalPolicyHolderListLength = vm.state.PolicyHolder.AdditionalPolicyHolderList.length;
            vm.checkFutureDate(vm.AdditionalPolicyHolderListLength);
            // for additional insured
            //checkAdditionalInsuredInList();
        };

        vm.checkFutureDate = function(length) {
            var isvalidDOB = true;
            for (var i = 0; i < length; i++) {
                if (vm.state.PolicyHolder.AdditionalPolicyHolderList[i].AdditionalPolicyHolder === "Other") {
                    var dateofBirth = vm.state.PolicyHolder.AdditionalPolicyHolderList[i].OtherDateOfBirthApp;
                    isvalidDOB = dateService.validateBirthDDMMYYYY(dateofBirth, 150);

                    if (isvalidDOB.isValid) {
                        vm.validDOBOtherInsurer = true;
                    }
                    else {
                        vm.validDOBOtherInsurer = false;
                        break;
                    }
                }
                else {
                    break;
                }

            }
        }

        vm.secondaryListChange = function (DOBFlag, DOBonEdit) {
            for (var i = 0; i < vm.state.PolicyHolder.InsuredNameList.length; i++) {
                if (vm.state.PolicyHolder.InsuredNameList[i].value === vm.state.PolicyHolder.InsuredName && vm.state.PolicyHolder.InsuredName !== 'Other' && vm.state.PolicyHolder.InsuredName !== 'OtherInsured') {
                    var index = vm.state.PolicyHolder.InsuredNameList.indexOf(vm.state.PolicyHolder.InsuredNameList[i]);
                    var temporarylist = angular.copy(vm.state.PolicyHolder.InsuredNameList);
                    // commented as per bug 7095
                    //vm.state.PolicyHolder.OtherInsuredName = null;
                    if (DOBFlag) {
                        if (vm.state.PolicyHolder.InsuredNameList[i].dateOfBirth !== null) {
                            vm.state.PolicyHolder.DateOfBirthApp = dateService.convertDatetoDDMMYYYFormat(vm.state.PolicyHolder.InsuredNameList[i].dateOfBirth);
                            if (JSON.parse(sessionStorageService.get(keyConstService.IsCopyQuote)) === true) {
                                vm.state.PolicyHolder.DateOfBirth = null;
                            }
                        }
                        else {
                            vm.state.PolicyHolder.InsuredNameList[i].dateOfBirth = "2000-01-01T00:00:00";
                        }
                    }
                    if (!DOBFlag) {
                        vm.state.PolicyHolder.DateOfBirthApp = DOBonEdit;
                    }
                    vm.state.PolicyHolder.SecondaryInsuredsList = temporarylist;
                    vm.state.PolicyHolder.InsuredClientId = vm.state.PolicyHolder.InsuredNameList[i].id;
                    vm.state.PolicyHolder.SecondaryInsuredsList.splice(index, 1);
                    vm.state.PolicyHolder.SecondaryInsuredsList = vm.state.PolicyHolder.SecondaryInsuredsList;

                    // Commentd by Ankur as per us 6829
                    //var secondaryInsuredOtherPos = vm.state.PolicyHolder.SecondaryInsuredsList.findIndex(p => p.value === "Other");
                    //if (secondaryInsuredOtherPos !== -1) {
                    //        vm.state.PolicyHolder.SecondaryInsuredsList.splice(secondaryInsuredOtherPos, 1);
                    //}

                    // Changes Related to SME, update Primary Insured Id
                    sessionStorageService.set(keyConstService.PrimaryInsuredId, vm.state.PolicyHolder.InsuredNameList[i].id);
                }
                //else if (vm.state.PolicyHolder.InsuredName === 'Other') {
                //    angular.element('#add-insured').modal('show');
                //}
                ////else if (vm.state.PolicyHolder.InsuredName === 'Other') {
                ////    vm.state.PolicyHolder.InsuredClientId = null;
                ////    vm.state.PolicyHolder.OtherInsureName = vm.OtherInsuredName;
                ////    var temporarylist = angular.copy(vm.state.PolicyHolder.InsuredNameList);
                ////    vm.state.PolicyHolder.SecondaryInsuredsList = temporarylist;
                ////    if (DOBFlag) {
                ////        vm.state.PolicyHolder.DateOfBirthApp = null;
                ////    }
                ////    if (vm.OtherInsuredName !== null) {
                ////        vm.state.PolicyHolder.OtherInsuredName = vm.OtherInsuredName;
                ////        vm.state.PolicyHolder.DateOfBirthApp = vm.DateOfBirthApp;
                ////    }
                ////}
            }
            if (vm.state.PolicyHolder.InsuredName != "OtherInsured") {
                vm.tempPrimaryInsured = vm.state.PolicyHolder.InsuredName;
            } else if (vm.state.PolicyHolder.InsuredName === 'OtherInsured') {
                angular.element('#add-insured').modal('show');
                vm.IsOpenAddInsuredPopup = true;
            }
        }

        vm.getOtherConvertedDate = function (dob, index, formElement) {
            var dateofBirth = dob;
            if (dateofBirth) {
                var response = dateService.validateBirthDDMMYYYY(dateofBirth, 150);

                if (!response.isValid) {
                    vm.state.PolicyHolder.AdditionalPolicyHolderList[index].OtherDateOfBirth = '';
                    vm.state.PolicyHolder.OtherDateOfBirthApp = '';
                    formElement.$setValidity("OtherDateOfBirth_", false);
                    toastr.warning(response.errorMsg);
                }
                else {
                    formElement.$setValidity("OtherDateOfBirth_", true);
                }
                vm.checkFutureDate(vm.state.PolicyHolder.AdditionalPolicyHolderList.length);
                vm.state.PolicyHolder.AdditionalPolicyHolderList[index].OtherDateOfBirth = response.date;
            }

        }

        vm.addClaims = function () {
            if (vm.state.Claims.ClaimsList.length <= 6) {
                vm.state.Claims.ClaimsList.push({ ClaimYear: null, ClaimType: null, CostOfClaim: 0 });
            }
            else {
                vm.DisableAddClaim = true;
            }

            if (vm.state.Claims.ClaimsList.length > 1) {
                for (var i = 0; i < vm.state.Claims.ClaimsList.length; i++) {
                    if (vm.state.Claims.ClaimsList[i].ClaimYear == null) {
                        vm.checkNullClaimList = true;
                    }
                    else if (vm.state.Claims.ClaimsList[i].ClaimType == null) {
                        vm.checkNullClaimList = true;
                    }
                }
            }
        }

        vm.removeClaims = function (item) {
            var index = vm.state.Claims.ClaimsList.indexOf(item);
            vm.state.Claims.ClaimsList.splice(index, 1);
            vm.DisableAddClaim = false;
            if (vm.state.Claims.ClaimsList.length <= 1) {
                if (vm.state.Claims.ClaimsList[0].ClaimYear == null) {
                    vm.checkNullClaimList = true;
                    vm.state.Claims.ClaimsList = [{ ClaimYear: null, ClaimType: null, CostOfClaim: 0 }];
                }
            }
        }

        vm.checkClaims = function () {
            if (vm.state.Claims.ClaimsList.length >= 1 && vm.state.Claims.IsClaimsInLast3Years) {
                for (var i = 0; i < vm.state.Claims.ClaimsList.length; i++) {
                    if (!vm.state.Claims.ClaimsList[i].ClaimYear) {
                        vm.checkNullClaimList = true;
                    }
                    else if (!vm.state.Claims.ClaimsList[i].ClaimType) {
                        vm.checkNullClaimList = true;
                    }
                }
            }
        }

        function isClaimsInLast3YearsChanged() {
            if (!vm.state.Claims.IsClaimsInLast3Years) {
                vm.state.Claims.ClaimsList = [{ ClaimYear: null, ClaimType: null, CostOfClaim: 0 }];
                vm.checkNullClaimList = false;
            }
            else if (vm.IsEndorsement && vm.state.Claims.IsClaimsInLast3Years) {
                vm.state.Claims.ClaimsList = angular.copy(endorsementState.Claims.ClaimsList);
                vm.checkNullClaimList = true;
            }
            else
                vm.checkNullClaimList = true;

        }

        vm.checkRentalAmount = function () {
            vm.invalidRentalAmount = false;
            if (vm.state.PolicyHolder.LandlordOccupancyType === "Permanent") {
                if ((vm.state.PolicyHolder.WeeklyRentalAmount < vm.minRentalAmount || vm.state.PolicyHolder.WeeklyRentalAmount > vm.maxRentalAmount) && vm.state.PolicyHolder.WeeklyRentalAmount !== null  ) {
                    vm.invalidRentalAmount = true;
                }
            }
        }

        vm.checkBrkerCommissionLimit = function () {
            vm.brokerCommissionLimitMessage = false;
            var regexp = /^[0-9]+(\.[0-9]{1,2})?$/;
            if (!regexp.test(vm.state.BrokerCommission.BrokerCommissionPercentage)) {
                vm.state.BrokerCommission.BrokerCommissionPercentage = null;
                vm.brokerCommissionLimitMessage = true;
            }

            if (vm.state.BrokerCommission.BrokerCommissionPercentage > vm.maxbrokerCommissionPercentage || vm.state.BrokerCommission.BrokerCommissionPercentage < vm.minbrokerCommissionPercentage)
                vm.brokerCommissionLimitMessage = true;
        }

        vm.ResetAdditionalPolicyHolder = function () {
            if (!vm.state.PolicyHolder.IsAdditionalPolicyHolder) {
                vm.state.PolicyHolder.AdditionalPolicyHolderList = [{ AdditionalPolicyHolder: null, OtherPolicyHolderName: null, OtherDateOfBirth: null }];
                vm.validDOBOtherInsurer = true;
            }
            else if (vm.IsEndorsement && vm.state.PolicyHolder.IsAdditionalPolicyHolder && endorsementState != null) {
                vm.state.PolicyHolder.AdditionalPolicyHolderList = angular.copy(endorsementState.PolicyHolder.AdditionalPolicyHolderList);
            }
        }

        vm.IsAdditionalButtonDisabled = function (name, index, nameObj) {
            if (name && !vm.otherreadonly) {
                vm.isSecondaryDisabled = false;
                if (name !== "Other") {
                    nameObj.OtherDateOfBirth = null;
                    nameObj.OtherDateOfBirthApp = null;
                    nameObj.OtherPolicyHolderName = null;
                }
            }

            var duplicateCount = 0;
            //check if the name already exists twice if yes then remove
            vm.state.PolicyHolder.AdditionalPolicyHolderList.forEach(function (ele, index) {
                if (ele.AdditionalPolicyHolder !== "Other" && ele.AdditionalPolicyHolder === name) {
                    duplicateCount++;
                }
            });


            if (duplicateCount > 1) {
                toastr.error(messageConstService.errDuplicatePolicyHolder);
                nameObj.AdditionalPolicyHolder = "";
                return;
            }

            if (vm.otherreadonly && name === "Other" && index === vm.state.PolicyHolder.AdditionalPolicyHolderList.length - 1) {
                if (vm.state.PolicyHolder.AdditionalPolicyHolderList[index].OtherPolicyHolderName === null) {
                    toastr.error("Other is not allowed");
                    nameObj.AdditionalPolicyHolder = "";
                    return;
                }
            }

            for (var i = 0; i < vm.state.PolicyHolder.InsuredNameList.length; i++) {
                if (vm.state.PolicyHolder.InsuredNameList[i].value === name) {

                    for (var j = 0; j < vm.state.PolicyHolder.AdditionalPolicyHolderList.length; j++) {
                        if (vm.state.PolicyHolder.AdditionalPolicyHolderList[j].AdditionalPolicyHolder === name) {
                            vm.state.PolicyHolder.AdditionalPolicyHolderList[j].AdditionalDateOfBirth = vm.state.PolicyHolder.InsuredNameList[i].dateOfBirth;
                            vm.state.PolicyHolder.AdditionalPolicyHolderList[j].AdditionalPolicyHolderType = vm.state.PolicyHolder.InsuredNameList[i].clientType;
                        }
                    }
                }
            }

            //checkAdditionalInsuredInList();

            if (name === 'OtherInsured') {
                vm.AdditionalPolicyHolderIndex = index;
                angular.element('#add-insured').modal('show');
            }
            else if (name != "OtherInsured") {
                vm.tempAdditonalPolicyHolders = angular.copy(vm.state.PolicyHolder.AdditionalPolicyHolderList);
            }
        }

        vm.ResetHasInsuredInLast3YearsSection = function () {
            if (!vm.state.UnderwritingCriteria.HasInsuredInLast3Years) {
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsEverInsuranceDeclined = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.ReasonEverInsuranceDeclined = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsCriminalConvictionFraudTheftBurglaryArson = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsClaimDeclinedIn3Years = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.ReasonClaimDeclinedIn3Years = null;
            }
            else {
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsEverInsuranceDeclined = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsCriminalConvictionFraudTheftBurglaryArson = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsClaimDeclinedIn3Years = null;

            }
        }

        vm.ResetDeclineSection = function () {
            if (!vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsEverInsuranceDeclined) {
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.ReasonEverInsuranceDeclined = null;
            }
            if (!vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsClaimDeclinedIn3Years) {
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.ReasonClaimDeclinedIn3Years = null;
            }
        }

        vm.checkSumInsuredValue = function () {
            vm.invalidSuminsuredAmount = false;
            if (vm.state.ContentsSumInsured.GeneralContentSumInsured < vm.minContentsSumInsured) {
                vm.invalidSuminsuredAmount = true;
            }
        }

        vm.InvalidZero = function (field, value) {
            var inp = $filter('number')(value);
            if (value) {
                if (inp != '0' && inp != '') {
                    field.$setValidity('validcurrency', true)
                }
                else {
                    field.$setValidity('validcurrency', false);
                }
            }
            else {
                field.$setValidity('validcurrency', false);
            }
        }

        vm.querySearch = function (query) {
            return $http.get(apiUrlConstService.addressURL + 'IntechAddressListAsync?address=' + query, { skipInterceptor: true })
                .then(function (result) {
                    let obj = {
                        text: messageConstService.manualAddressList,
                        value: 'N/A',
                        postCode: null
                    };

                    let resultantdata = result.data.data;
                    if (resultantdata.length > 0) {
                        resultantdata.push(obj);
                    }
                    return resultantdata;
                });
        }

        vm.mannualSearchQuery = function (query) {
            return $http.get(apiUrlConstService.addressURL + 'MannualAddressList?searchAddress=' + query, { skipInterceptor: true })
                .then(function (result) {
                    return result.data.data;
                });
        }

        function addressMapped(address) {
            if (!address) {
                vm.state.PropertyDetail.AddressText = null;
                //vm.ResetBuildingSection();
                //vm.ResetPropertySection();
            }

            if (address && address.value == 'N/A') {
                address = null;
                vm.selectedAddress = null;
                onClickAddressNotFound()
            }

            if (address) {
                var newBusinessCaseData = sessionStorageService.get(keyConstService.newBusinessCaseData);
                var newBusinessCaseDetail = JSON.parse(newBusinessCaseData);
                var qStartDate = newBusinessCaseDetail != null ? new Date(newBusinessCaseDetail.data.EffectiveDate) : new Date(vm.tempLandlordProtectionData.StartDate);
                var qCheckDate = new Date(vm.tempLandlordProtectionData.DWCAdjustmentDate);
                if (!address.text) {
                    vm.state.PropertyDetail.AddressText = address;
                }
                if (address.text) {
                    vm.state.PropertyDetail.AddressText = address.text;
                    if (address.value) {
                        vm.state.PropertyDetail.AddressValue = address.value;
                        vm.state.PropertyDetail.postcode = address.postCode === null ? null : address.postCode;
                        var splitSate = address.value.split('|');
                        vm.AddressState = splitSate[0];
                        if ((qStartDate < qCheckDate) && (vm.AddressState === "WA" || vm.AddressState === "ACT" || vm.AddressState === "TAS")) {
                            vm.showDomesticWorkerCompensation = true;
                            vm.state.OptionalCover.IsDomesticWorkerCompensation = vm.state.OptionalCover.IsDomesticWorkerCompensation ;

                        }
                        else {
                            vm.showDomesticWorkerCompensation = false;
                            vm.state.OptionalCover.IsDomesticWorkerCompensation  = null;
                        }

                    }
                }
                var illionCall = JSON.parse(sessionStorageService.get(keyConstService.IllionAddressEnquiry));
                sessionStorageService.remove(keyConstService.IllionAddressEnquiry);
                if (illionCall === null || illionCall === undefined || !illionCall) {
                    vm.getAdressEnquiryDetails();
                }
            }
        }
        
        function removeNote(item) {
            vm.state.Notes.splice(vm.state.Notes.indexOf(item), 1);
        }

        function addNote(currentNote) {
            var newNote = {
                Note: null,
                IsPrintable: !currentNote.IsPrintable
            };
            if (vm.state.Notes.length < 2) {
                vm.state.Notes.push(newNote);
            }
        }

        vm.removeClaims = function (item) {
            var index = vm.state.Claims.ClaimsList.indexOf(item);
            vm.state.Claims.ClaimsList.splice(index, 1);
            vm.DisableAddClaim = false;
            if (vm.state.Claims.ClaimsList.length <= 1) {
                if (vm.state.Claims.ClaimsList[0].ClaimYear == null) {
                    vm.checkNullClaimList = true;
                    vm.state.Claims.ClaimsList = [{ ClaimYear: null, ClaimType: null, CostOfClaim: 0 }];
                }
            }
        }

        vm.addClaims = function () {
            if (vm.state.Claims.ClaimsList.length <= 6) {
                vm.state.Claims.ClaimsList.push({ ClaimYear: null, ClaimType: null, CostOfClaim: 0 });
            }
            else {
                vm.DisableAddClaim = true;
            }

            if (vm.state.Claims.ClaimsList.length > 1) {
                for (var i = 0; i < vm.state.Claims.ClaimsList.length; i++) {
                    if (vm.state.Claims.ClaimsList[i].ClaimYear == null) {
                        vm.checkNullClaimList = true;
                    }
                    else if (vm.state.Claims.ClaimsList[i].ClaimType == null) {
                        vm.checkNullClaimList = true;
                    }
                }
            }
        }

        vm.IsAdditionalClaimDisabled = function (item, index) {

            if (item !== null) {
                vm.DisableAddClaim = false;
            }

            if (vm.state.Claims.ClaimsList.length <= 1) {
                if (!item) {
                    vm.checkNullClaimList = true;
                    vm.state.Claims.ClaimsList = [{ ClaimYear: null, ClaimType: null, CostOfClaim: 0 }];
                }
            }

            if (item === 'Theft' || item === 'BushfireOrflood') {
                vm.state.Claims.ClaimsList[index].CostOfClaim = 0;
            }
            if (isNewEditTransaction) {
                if (item !== 'Theft' || item !== 'BushfireOrflood') {
                    vm.state.Claims.ClaimsList[index].CostOfClaim = 0;
                }
            }

            vm.checkClaims();
        };

        vm.CoverChange = function () {
            if (vm.state.PolicyHolder.LandlordOccupancyType == "Holiday") {
                vm.invalidRentalAmount = false;
                vm.state.PolicyHolder.WeeklyRentalAmount = null;
                vm.state.PolicyHolder.IsBehindRent = null;
            }
        }

        function getSecondaryInsuredList(DOBonEdit) {
            var caseid = caseNumberForSecondaryInsured;
            vm.state.PolicyHolder.InsuredNameList = [];
            vm.state.PolicyHolder.SecondaryInsuredsList = [];
            var secondaryInsuredListOnEdit = clientService.getSecondaryInmsured(
                caseid)
                .then(function (result) {
                    if (result) {
                        vm.data = result.data.policyHolder;
                        for (var i = 0; i < result.data.policyHolder.insuredNameList.length; i++) {

                            vm.state.PolicyHolder.InsuredNameList.push(result.data.policyHolder.insuredNameList[i]);
                            vm.state.PolicyHolder.SecondaryInsuredsList.push(result.data.policyHolder.insuredNameList[i]);
                            vm.secondaryListChange(vm.DOBFlag, DOBonEdit);
                        }

                        // for additional insured
                        //checkAdditionalInsuredInList();
                    }
                })
        }

        function brokerFeeChange() {
            var regexp = /^[0-9]+(\.[0-9]{1,2})?$/;
            if (!regexp.test(vm.state.PaymentFrequency.BrokerFee)) {
                vm.state.PaymentFrequency.BrokerFee = null;
            }
        }

        vm.ResetUnOccupiedProperty = function () {
            if (!vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsUnoccupiedProperty100days) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.UnoccupiedProperty100days = null;
            }
            else if (vm.IsEndorsement && vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsUnoccupiedProperty100days) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.UnoccupiedProperty100days = endorsementState.UnderwritingCriteria.AnswerYesToFollowingData.UnoccupiedProperty100days;
            }
        }

        vm.ResetAnswerYesToDataSection = function () {
            if (!vm.state.UnderwritingCriteria.IsAnswerYesToFollowing) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsUnoccupiedProperty100days = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.UnoccupiedProperty100days = null;
            }
            else if (vm.IsEndorsement && vm.state.UnderwritingCriteria.IsAnswerYesToFollowing) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData = angular.copy(endorsementState.UnderwritingCriteria.AnswerYesToFollowingData);
            }
        }


        vm.getConvertedDate = function () {
            var dateofBirth = vm.state.PolicyHolder.DateOfBirthApp;
            if (dateofBirth) {
                var response = dateService.validateBirthDDMMYYYY(dateofBirth, 150);

                if (!response.isValid) {
                    vm.state.PolicyHolder.DateOfBirth = '';
                    vm.state.PolicyHolder.DateOfBirthApp = '';
                    toastr.warning(response.errorMsg);
                    return;
                }

                vm.state.PolicyHolder.DateOfBirth = response.date;
            }

        }

        vm.getQuote = function () {
            vm.isDisabled = true;
            vm.getConvertedDate();
            if (vm.IsEndorsement) {
                vm.state.PaymentFrequency.BrokerFee = 0;
                vm.state.PaymentFrequency.BrokerFeeGST = 0;
            }          
            var transactionId = JSON.parse(sessionStorageService.get(keyConstService.quoteTransactionId));
            if (vm.transactionStatus == "Draft") {
                isNewEditTransaction = false;
            }
            else {
                isNewEditTransaction = sessionStorageService.get(keyConstService.IsNewEditTransaction);
            }
            vm.rowVersion = JSON.parse(sessionStorageService.get(keyConstService.rowVersion));
            var automaticPayment = -1;
            if (vm.endorsementVM != null) {
                vm.EffectiveDate = vm.endorsementVM.EndorsementEffectiveDate;
                ExpirationDate = vm.endorsementVM.ExpirationDate;
                sessionStorageService.remove(keyConstService.endorsementRequestVM);
                sessionStorageService.remove(keyConstService.IsEndorsementEdit);

            }
            else {
                var newBusinessData = JSON.parse(sessionStorageService.get(keyConstService.newBusinessCaseData));
                if (newBusinessData) {
                    vm.EffectiveDate = newBusinessData.data.EffectiveDate;
                    ExpirationDate = newBusinessData.data.ExpirationDate;
                    automaticPayment = newBusinessData.data.BrokerManagedPayment;
                }
            }
            if (automaticPayment == -1) {
                automaticPayment = vm.brokerManagedPayment;
            }
            vm.state.PaymentFrequency.BrokerManagedPayment = automaticPayment;
            sessionStorageService.set(keyConstService.quoteState, vm.state);
            var data = sessionStorageService.get(keyConstService.quoteState);
            var pData = JSON.parse(data);
            if (sessionStorageService.get(keyConstService.IsCopyQuote) === "true")
                isNewEditTransaction = false;
            var finalData = { SaveContent: data, EffectiveDate: vm.EffectiveDate, ExpirationDate: ExpirationDate, TransactionId: transactionId, NewEditTransaction: isNewEditTransaction, RowVersion: vm.rowVersion, PaymentFrequency: vm.state.PaymentFrequency.ModeOfPayment, InstallmentDate: vm.state.PaymentFrequency.DayofInstallment, BrokerManagedPayment: automaticPayment };
            vm.finalGetQuote(finalData);
        }

        function finalGetQuote(finalData) {
            vm.disableButtons = true;
            sessionStorageService.remove(keyConstService.getTransactionIdWithoutSaving);
            sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
            sessionStorageService.remove(keyConstService.resetNonRegoData);
            sessionStorageService.remove(keyConstService.IllionAddressEnquiry);
            sessionStorageService.set(keyConstService.sessionStorageState, false);
            sessionStorageService.set(keyConstService.stampDutyExemption, vm.state.OtherInfo.IsStampDutyExemption);
            quotesService.generateQuote(quotesService.generateRequest(finalData, "LandlordProtection"), "LandlordProtection").then(function (data) {
                var handledResponse = quotesService.handleResponse(data, "LandlordProtection");
                if (handledResponse.status) {
                    sessionStorageService.remove(keyConstService.IsNewEditTransaction);
                    sessionStorageService.remove(keyConstService.IsCopyQuote);
                    sessionStorageService.remove(keyConstService.IsRenewalPolicy);
                    vm.rowVersion = handledResponse.data.rowVersion;
                    sessionStorageService.set(keyConstService.quoteTransactionId, handledResponse.data.transactionId);
                    //Remove PrimaryClientInsuredId
                    sessionStorageService.remove(keyConstService.PrimaryInsuredId);
                    if (handledResponse.data.error !== null) {
                        if (handledResponse.data.error.number === 401 || handledResponse.data.error.number === 402) {
                            if (handledResponse.data.error.number === 401) {
                                toastr.error(messageConstService.errServiceUnavailable);
                            }
                            $timeout(function () {
                                $window.location.href = webUrlConstService.homeIndex;
                            }, 1000);
                            return;
                        }
                    }
                    if (handledResponse.data.decisionResult) {
                        //
                        if (handledResponse.data.decisionResult.isDeclined || handledResponse.data.decisionResult.isReferral || handledResponse.data.ratingResult) {
                            var quoteTransactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
                            $window.location.href = webUrlConstService.quoteCaseIndex + '?' + sessionStorageService.getEncryption("quoteTransactionId=" + quoteTransactionId);

                        }
                        else {
                            toastr.error(messageConstService.errRatingService);
                        }

                    } else {
                        toastr.error(messageConstService.errDecisionService);
                    }

                }
                else {

                    if (handledResponse.errors.length > 0) {
                        if (handledResponse.errors.filter((x) => x.Severity > 10).length > 0) {

                            var severerrors = handledResponse.errors.filter((x) => x.Severity > 10);
                            
                            for (var i = 0; i < severerrors.length; i++) {
                                let servererror = severerrors[0];
                                let msg = servererror.Message;
                                let msgcontent = msg.split(',')[2];
                                toastr.error(msgcontent);    
                            }

                            vm.disableButtons = false;
                        }
                        else {
                            toastr.error(messageConstService.errServiceUnavailable);                            
                        }
                    }
                }

            }, function (e) {
                var myJSON = JSON.stringify(e);
                $log.log('error myJSON', myJSON);
                toastr.error(messageConstService.errMessageWhenDuplicateEntryIssue);
            });
        }

        vm.decimalConfig = {
            sbMin: 0,
            sbMax: keyConstService.AmountMax999999999,
            sbPrecision: 2,
            sbMaxPrecision: 2
        };

        function propertyDecline() {
            if (vm.state.UnderwritingCriteria.IsPropertyUsedForFollowing === true) {
                toastr.error(messageConstService.errPropertyUsed)
            }
        }

        function changeNotesPrintable(currentNote) {
            if (vm.state.Notes.length > 1) {
                var currentIndex = vm.state.Notes.indexOf(currentNote);
                var index = 1 - currentIndex;
                vm.state.Notes[index].IsPrintable = (!currentNote.IsPrintable);
            }
        }

        function continueOrNavigateBackToPackageManager() {
            var packageNumber = sessionStorageService.get('PackageNumberInformation');
            var renewalCounter = sessionStorageService.get('RenewalCounter');
            sessionStorageService.remove('IsPackageManagerNavigationMode');
            sessionStorageService.remove('PackageNumberInformation');
            sessionStorageService.remove('RenewalCounter');
            $window.location.href = webUrlConstService.getPackageInfo + sessionStorageService.getEncryption("packageNumber=" + JSON.parse(packageNumber) + "&&renewalCounter=" + renewalCounter);
        }

        function changeOtherInsuredName() {
            if (form1 && form1.OtherInsuredName) {
                if (form1.OtherInsuredName.value.length > 100) {
                    vm.showMessageGrt100OtherInsuredName = true;
                    form1.OtherInsuredName.value = form1.OtherInsuredName.value.substring(0, 100);
                } else {
                    vm.showMessageGrt100OtherInsuredName = false;
                }
            }
        }

        function checkAdditionalInsuredInList() {
            for (var j = 0; j < vm.state.PolicyHolder.AdditionalPolicyHolderList.length; j++) {
                var ele = vm.state.PolicyHolder.AdditionalPolicyHolderList[j];
                //if (ele.AdditionalPolicyHolder !== "Other") {
                    var existInsuredName = utilityService.valueExistsInArray(ele.AdditionalPolicyHolder, vm.state.PolicyHolder.SecondaryInsuredsList);
                    if (!existInsuredName) {
                        var res = false;
                        //break;
                    }
                    else {
                        res = true;
                        //vm.disableButtons = false;
                    }
                //}
                //else {
                //    vm.otherreadonly = true;
                //}
            }
            return res;
        }


        function addOtherInsured() {
            vm.ClientDetail.SecondaryInsuredClientVM = vm.addSecondaryClient;
            vm.ClientDetail.SecondaryInsuredClientVM[0].AddressLogVM = vm.otherInsuredAddress;

            var client = {
                ClientViewModel: vm.ClientDetail.clientViewModel !== null ? vm.ClientDetail.clientViewModel : null,
                SecondaryInsuredClientVM: vm.ClientDetail.SecondaryInsuredClientVM
            };

            var request = clientService.updateClientData({
                client: client
            });
            request.then(function success(response) {
                if (vm.ClientDetail.SecondaryInsuredClientVM[0].ClientType == 'Individual') {
                    if (vm.IsOpenAddInsuredPopup) {
                        vm.state.PolicyHolder.InsuredName = vm.ClientDetail.SecondaryInsuredClientVM[0].FirstName + " " + vm.ClientDetail.SecondaryInsuredClientVM[0].LastName;
                        vm.state.PolicyHolder.DateOfBirthApp = vm.ClientDetail.SecondaryInsuredClientVM[0].DateOfBirthStringAsDDMMYYYY;
                        vm.IsOpenAddInsuredPopup = false;
                    } else {
                        vm.state.PolicyHolder.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].AdditionalPolicyHolder = vm.ClientDetail.SecondaryInsuredClientVM[0].FirstName + " " + vm.ClientDetail.SecondaryInsuredClientVM[0].LastName;
                        vm.state.PolicyHolder.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].DateOfBirthApp = "2000-01-01T00:00:00";
                        vm.state.PolicyHolder.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].AdditionalPolicyHolderType = "Secondary";
                    }
                } else {
                    if (vm.IsOpenAddInsuredPopup) {
                        vm.state.PolicyHolder.InsuredName = vm.ClientDetail.SecondaryInsuredClientVM[0].OrganisationName;
                        vm.state.PolicyHolder.DateOfBirthApp = "2000-01-01T00:00:00";
                        vm.IsOpenAddInsuredPopup = false;
                    } else {
                        vm.state.PolicyHolder.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].AdditionalPolicyHolder = vm.ClientDetail.SecondaryInsuredClientVM[0].OrganisationName;
                        vm.state.PolicyHolder.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].DateOfBirthApp = "2000-01-01T00:00:00";
                        vm.state.PolicyHolder.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].AdditionalPolicyHolderType = "Secondary";
                    }
                }
                return getInsuredNameList(false);
            });
        }

        function getInsuredNameList(isEdit) {
            var qCheckDate = new Date(vm.tempLandlordProtectionData.DWCAdjustmentDate);
            var newBusinessCaseData = sessionStorageService.get(keyConstService.newBusinessCaseData);
            var newBusinessCaseDetail = JSON.parse(newBusinessCaseData);
            var qStartDate = newBusinessCaseDetail != null ? new Date(newBusinessCaseDetail.data.EffectiveDate) : new Date(vm.tempLandlordProtectionData.StartDate);
            caseId = sessionStorageService.get(keyConstService.caseId);
            quotesService.getInsuredNameList(caseId).then(function (ResponseData) {
                if (ResponseData.data !== null) {
                    if (!isEdit) {
                        vm.state.PolicyHolder.InsuredNameList = ResponseData.data.policyHolder.insuredNameList;
                        vm.state.PolicyHolder.SecondaryInsuredsList = ResponseData.data.policyHolder.secondaryInsuredsList;
                        //vm.state.PolicyHolder.InsuredClientId = ResponseData.data.policyHolder.insuredClientId;
                        vm.ClientDetail = ResponseData.data.clientDetail;
                        vm.addSecondaryClient = ResponseData.data.clientDetail.secondaryInsuredClientVM;
                        vm.otherInsuredAddress = ResponseData.data.clientDetail.addressLogVM;
                        vm.PropertyDetail = angular.copy(ResponseData.data.buildingInfo);
                        //vm.state.PolicyHolder.InsuredName = ResponseData.data.policyHolder.insuredName;
                        if (!vm.selectedAddress) {
                            ResponseData.data.buildingInfo.addressText = null;
                            ResponseData.data.buildingInfo.addressValue = null;
                        }
                        if (vm.selectedAddress) {
                            // Commented as per bug 7567
                            //vm.state.PropertyDetail.AddressText = ResponseData.data.buildingInfo.addressText;
                            //vm.state.PropertyDetail.AddressValue = ResponseData.data.buildingInfo.addressValue;
                            //var splitSate = ResponseData.data.buildingInfo.addressValue.split('|');
                            //vm.AddressState = splitSate[0];
                            //if ((qStartDate < qCheckDate) && (vm.AddressState === "WA" || vm.AddressState === "ACT" || vm.AddressState === "TAS") && vm.selectedAddress) {
                            //    vm.showDomesticWorkerCompensation = true;
                            //}
                            //else {
                            //    vm.showDomesticWorkerCompensation = false;
                            //}

                            //  7533
                            //if (getQuoteTransactionId === vm.getTransactionIdWithoutSaving) {
                            //    if ((qStartDate < qCheckDate) && (vm.getAddressState === "WA" || vm.getAddressState === "ACT" || vm.getAddressState === "TAS")) {
                            //        vm.showDomesticWorkerCompensation = true;

                            //    }
                            //    else {
                            //        vm.showDomesticWorkerCompensation = false;
                            //        vm.state.OtherInfo.IsDomesticWorkerCompensation = null;
                            //    }
                            //}

                            //  7533
                            //if (vm.IsEndorsement && vm.policyEffectiveDate != undefined && vm.endorsementEffectiveDate != undefined) {
                            //    if (vm.policyEffectiveDate === vm.endorsementEffectiveDate) {
                            //        vm.showDomesticWorkerCompensation = true;
                            //    }
                            //}
                        }

                        vm.checkRentalAmount();
                        vm.checkSumInsuredValue();
                        vm.checkClaims();

                        if (getQuoteTransactionId !== vm.getTransactionIdWithoutSaving) {
                            var newDate = new Date(ResponseData.data.policyHolder.dateOfBirthApp);
                            vm.state.PolicyHolder.DateOfBirthApp = newDate;
                        }
                        //else {
                        if (vm.state.PolicyHolder.InsuredName === "Other") {
                            var indexOfInsured = vm.state.PolicyHolder.InsuredNameList.findIndex(p => p.value === "Other");
                            if (indexOfInsured === -1) {
                                vm.state.PolicyHolder.InsuredNameList.push({ clientType: "Secondary", name: vm.state.PolicyHolder.InsuredName, value: vm.state.PolicyHolder.InsuredName, dateOfBirth: vm.state.PolicyHolder.DateOfBirth, Id: 0 });
                                //vm.state.PolicyHolder.SecondaryInsuredsList.push({ clientType: "Secondary", name: vm.state.PolicyHolder.InsuredName, value: vm.state.PolicyHolder.InsuredName, dateOfBirth: vm.state.PolicyHolder.DateOfBirth, Id: 0 });
                            }
                            vm.OtherInsuredName = vm.state.PolicyHolder.OtherInsuredName;
                            vm.DateOfBirthApp = vm.state.PolicyHolder.DateOfBirthApp;
                            vm.otherreadonly = true;
                        } else {
                            var indexOfInsured = vm.state.PolicyHolder.InsuredNameList.findIndex(p => p.value === "Other");
                            if (indexOfInsured >= 0) {
                                vm.state.PolicyHolder.InsuredNameList.splice(indexOfInsured, 1);
                            }
                        }

                        if ((vm.state.PolicyHolder.AdditionalPolicyHolderList.findIndex(p => p.AdditionalPolicyHolder === "Other")) >= 0) {
                            //var indexOfInsured = vm.state.PolicyHolder.InsuredNameList.findIndex(p => p.value === "Other");
                            //if (indexOfInsured === -1) {
                            //    vm.state.PolicyHolder.InsuredNameList.push({ clientType: "Secondary", name: "Other", value: "Other", dateOfBirth: null, Id: 0 });
                            //    vm.state.PolicyHolder.SecondaryInsuredsList.push({ clientType: "Secondary", name: "Other", value: "Other", dateOfBirth: null, Id: 0 });
                            //}
                            var indexOfInsured = vm.state.PolicyHolder.SecondaryInsuredsList.findIndex(p => p.value === "Other");
                            if (indexOfInsured === -1) {
                                vm.state.PolicyHolder.SecondaryInsuredsList.push({ clientType: "Secondary", name: "Other", value: "Other", dateOfBirth: null, Id: 0 });
                            }
                            vm.otherreadonly = true;
                        } else {
                            var indexOfInsured = vm.state.PolicyHolder.SecondaryInsuredsList.findIndex(p => p.value === "Other");
                            if (indexOfInsured >= 0) {
                                vm.state.PolicyHolder.SecondaryInsuredsList.splice(indexOfInsured, 1);
                            }
                        }

                        if (vm.state.PolicyHolder.InsuredName !== "Other" && (vm.state.PolicyHolder.AdditionalPolicyHolderList.findIndex(p => p.AdditionalPolicyHolder === "Other")) == -1) {
                            if (vm.state.PolicyHolder.InsuredClientId !== null && vm.state.PolicyHolder.OtherInsuredName === null) {
                                vm.state.PolicyHolder.InsuredName = vm.state.PolicyHolder.InsuredName;
                            }
                            //else {
                            //    vm.state.PolicyHolder.InsuredName = ResponseData.data.policyHolder.insuredName;
                            //}
                        }
                        
                        // If Insured name is not other and additional list is having other but Insuredlist and secondaryInsured list is having remove it array.
                        if (vm.state.PolicyHolder.InsuredName !== "Other" && (vm.state.PolicyHolder.AdditionalPolicyHolderList.findIndex(p => p.AdditionalPolicyHolder === "Other")) === -1) {
                            var insuredotherPosition = vm.state.PolicyHolder.InsuredNameList.findIndex(p => p.value === "Other");
                            if (insuredotherPosition !== -1) {
                                vm.state.PolicyHolder.InsuredNameList.splice(insuredotherPosition, 1);
                            }

                            //// commented by ankur
                            ////var secondaryInsuredOtherPos = vm.state.PolicyHolder.SecondaryInsuredsList.findIndex(p => p.value === "Other");
                            ////if (secondaryInsuredOtherPos !== -1) {
                            ////    vm.state.PolicyHolder.SecondaryInsuredsList.splice(secondaryInsuredOtherPos, 1);
                            ////}
                        }

                        if (vm.state.PolicyHolder.InsuredName != "Other") {
                            var objSelectedInsured = vm.state.PolicyHolder.InsuredNameList.filter(function (e) { return e.value === vm.state.PolicyHolder.InsuredName })
                            vm.state.PolicyHolder.InsuredClientId = objSelectedInsured.length > 0 ? objSelectedInsured[0].id : 0;
                        } else {
                            vm.state.PolicyHolder.InsuredClientId = -2;
                        }

                        for (var i = 0; i < ResponseData.data.policyHolder.secondaryInsuredsList.length; i++) {
                            if (ResponseData.data.policyHolder.secondaryInsuredsList[i].value === vm.state.PolicyHolder.InsuredName && ResponseData.data.policyHolder.secondaryInsuredsList[i].id === vm.state.PolicyHolder.InsuredClientId) {
                                var index = ResponseData.data.policyHolder.secondaryInsuredsList.indexOf(ResponseData.data.policyHolder.secondaryInsuredsList[i]);
                                ResponseData.data.policyHolder.secondaryInsuredsList.splice(index, 1);
                                vm.state.PolicyHolder.SecondaryInsuredsList = ResponseData.data.policyHolder.secondaryInsuredsList;

                                if (getQuoteTransactionId === vm.getTransactionIdWithoutSaving) {
                                    vm.getQuestionSetWithoutSavingData = JSON.parse(sessionStorageService.get(keyConstService.getQuestionSetWithoutSaving));
                                    if (vm.getQuestionSetWithoutSavingData) {
                                        if (vm.getQuestionSetWithoutSavingData.PolicyHolder.InsuredName === "Other") {
                                            vm.state.PolicyHolder.InsuredName = vm.getQuestionSetWithoutSavingData.PolicyHolder.InsuredName;
                                            vm.state.PolicyHolder.OtherInsuredName = vm.getQuestionSetWithoutSavingData.PolicyHolder.OtherInsuredName;
                                            for (var i = 0; i < vm.getQuestionSetWithoutSavingData.PolicyHolder.SecondaryInsuredsList.length; i++) {
                                                vm.state.PolicyHolder.SecondaryInsuredsList[i] = vm.getQuestionSetWithoutSavingData.PolicyHolder.SecondaryInsuredsList[i];
                                            }
                                        }
                                    }
                                }
                            }
                            //else {
                            //    if (vm.state.PolicyHolder.InsuredName) {
                            //        vm.state.PolicyHolder.InsuredName = ResponseData.data.policyHolder.insuredName;
                            //}
                            //}
                        }

                    }
                    else {
                        // test Other   --------------------------------------------------------------------------
                        //vm.state.PolicyHolder.InsuredName = "Other";
                        //vm.state.PolicyHolder.OtherInsuredName = "Other Ankur";
                        //vm.state.PolicyHolder.DateOfBirthApp = "2000-01-01T00:00:00";

                        vm.ClientDetail = ResponseData.data.clientDetail;
                        vm.addSecondaryClient = ResponseData.data.clientDetail.secondaryInsuredClientVM;
                        vm.otherInsuredAddress = ResponseData.data.clientDetail.addressLogVM;
                        vm.PropertyDetail = angular.copy(ResponseData.data.buildingInfo);
                        if (vm.state.PolicyHolder.InsuredName === "Other") {
                            var indexOfInsured = vm.state.PolicyHolder.InsuredNameList.findIndex(p => p.value === "Other");
                            if (indexOfInsured === -1) {
                                vm.state.PolicyHolder.InsuredNameList.push({ clientType: "Secondary", name: vm.state.PolicyHolder.InsuredName, value: vm.state.PolicyHolder.InsuredName, dateOfBirth: vm.state.PolicyHolder.DateOfBirth, Id: 0 });
                                vm.state.PolicyHolder.SecondaryInsuredsList.push({ clientType: "Secondary", name: vm.state.PolicyHolder.InsuredName, value: vm.state.PolicyHolder.InsuredName, dateOfBirth: vm.state.PolicyHolder.DateOfBirth, Id: 0 });
                            }
                            vm.OtherInsuredName = vm.state.PolicyHolder.OtherInsuredName;
                            vm.DateOfBirthApp = vm.state.PolicyHolder.DateOfBirthApp;
                            vm.otherreadonly = true;
                        }

                        if (vm.state.PropertyDetail.IsManualAddress === false) {
                            vm.selectedAddress = vm.state.PropertyDetail.AddressText;
                        }
                        //test Other  --------------------------------------------------------------------------
                        //vm.state.PolicyHolder.AdditionalPolicyHolderList[0].AdditionalPolicyHolder = "Other";
                        //vm.state.PolicyHolder.AdditionalPolicyHolderList[0].OtherPolicyHolderName = "Test Other ANkur";
                        //vm.state.PolicyHolder.AdditionalPolicyHolderList[0].OtherDateOfBirthApp = "2000-01-01T00:00:00";

                        if ((vm.state.PolicyHolder.AdditionalPolicyHolderList.findIndex(p => p.AdditionalPolicyHolder === "Other")) >= 0) {
                            var indexOfInsured = vm.state.PolicyHolder.InsuredNameList.findIndex(p => p.value === "Other");
                            if (indexOfInsured === -1) {
                                vm.state.PolicyHolder.InsuredNameList.push({ clientType: "Secondary", name: "Other", value: "Other", dateOfBirth: null, Id: 0 });
                                vm.state.PolicyHolder.SecondaryInsuredsList.push({ clientType: "Secondary", name: "Other", value: "Other", dateOfBirth: null, Id: 0 });

                            }
                            vm.otherreadonly = true;
                        }
                    }

                    // If Insured name is not other and additional list is having other but Insuredlist and secondaryInsured list is having remove it array.
                    if (vm.state.PolicyHolder.InsuredName !== "Other" && (vm.state.PolicyHolder.AdditionalPolicyHolderList.findIndex(p => p.AdditionalPolicyHolder === "Other")) !== -1) {
                        var insuredotherPosition = vm.state.PolicyHolder.InsuredNameList.findIndex(p => p.value === "Other");
                        if (insuredotherPosition !== -1) {
                            vm.state.PolicyHolder.InsuredNameList.splice(insuredotherPosition, 1);
                        }
                        //var secondaryInsuredOtherPos = vm.state.PolicyHolder.SecondaryInsuredsList.findIndex(p => p.value === "Other");
                        //if (secondaryInsuredOtherPos !== -1) {
                        //    vm.state.PolicyHolder.SecondaryInsuredsList.splice(secondaryInsuredOtherPos, 1);
                        //}
                    }
                    if (vm.state.PolicyHolder.InsuredName === "Other" && (vm.state.PolicyHolder.AdditionalPolicyHolderList.findIndex(p => p.AdditionalPolicyHolder === "Other")) === -1) {
                        var secondaryInsuredOtherPos = vm.state.PolicyHolder.SecondaryInsuredsList.findIndex(p => p.value === "Other");
                        if (secondaryInsuredOtherPos !== -1) {
                            vm.state.PolicyHolder.SecondaryInsuredsList.splice(secondaryInsuredOtherPos, 1);
                        }
                    }

                    vm.tempPrimaryInsured = vm.state.PolicyHolder.InsuredName;
                    vm.tempAdditonalPolicyHolders = angular.copy(vm.state.PolicyHolder.AdditionalPolicyHolderList);
                }
            });
            if (!isEdit) {
                resetAddress();
            }

        }

        function storeOtherInsuredAddress(address) {     
            if (address && address.value == 'N/A') {
                address = null;
                vm.selectedAddress1 = null;
                onClickAddressNotFoundOtherInsured();
            }

            if (address !== null && address !== undefined) {
                if (address.value) {
                    vm.addSecondaryClient[0].IsStampDutyExempted = false;
                    var splitSate = address.value.split('|');
                    var AddressState = splitSate[0];
                    vm.addSecondaryClient[0].IsStampDutyExempted = false;
                    if (AddressState === "NSW") {
                        vm.addSecondaryClient[0].showStampDuty = true;
                    }
                    else {
                        vm.addSecondaryClient[0].showStampDuty = false;
                    }

                    if (vm.addSecondaryClient[0].IsSameAsPrimaryAddress && vm.otherInsuredAddress && vm.PropertyDetail.addressText !== address.text) {
                        vm.addSecondaryClient[0].IsSameAsPrimaryAddress = false;
                    }

                    if (vm.otherInsuredAddress) {
                        vm.otherInsuredAddress.Address = address.text;
                        vm.otherInsuredAddress.DelimeterAddress = address.value;
                        vm.otherInsuredAddress.PostCode = address.postCode === null ? null : address.postCode;
                        if (address.isManualAddress) {
                            vm.selectedOtherMannualItem = vm.selectedOtherMannualAddress.text;
                            vm.otherInsuredAddress.AddressLine1 = vm.selectedOtherMannualAddress.addressLine1;
                        }
                    }
                    else {
                        vm.otherInsuredAddress = {
                            Address: address.text,
                            DelimeterAddress: address.value,
                            PostCode: address.postCode === null ? null : address.postCode
                        };
                    }
                }
            }
        }

        function checkSameAsPrimary() {
            if (vm.addSecondaryClient[0].IsSameAsPrimaryAddress) {

                if (!vm.PropertyDetail.isManualAddress) {
                    vm.selectedAddress1 = { postCode: vm.PropertyDetail.postcode, text: vm.PropertyDetail.addressText, value: vm.PropertyDetail.addressValue };
                    storeOtherInsuredAddress(vm.selectedAddress1);
                }
                else {
                    vm.selectedOtherMannualAddress = { postCode: vm.PropertyDetail.postcode, text: vm.PropertyDetail.addressText, addressLine1: vm.PropertyDetail.addressLine1, value: vm.PropertyDetail.addressValue, isManualAddress: vm.PropertyDetail.isManualAddress };
                    storeOtherInsuredAddress(vm.selectedOtherMannualAddress);
                }
                vm.otherInsuredAddress.isManualAddress = vm.PropertyDetail.isManualAddress;
                if (vm.otherInsuredAddress.isManualAddress === false) {
                    vm.otherInsuredAddress.AddressLine1 = null;
                    vm.mannualOtherSearchText = null;
                    vm.selectedOtherMannualItem = null;
                }
            }
        }


        function resetAddress() {
                vm.selectedAddress1 = null;
                vm.otherInsuredAddress.Address = null;
                vm.otherInsuredAddress.DelimeterAddress = null;
                vm.otherInsuredAddress.PostCode = null;
            vm.showStampDuty = false;
            if (vm.addSecondaryClient.length > 0) {
                vm.addSecondaryClient[0].IsStampDutyExempted = false;
                vm.addSecondaryClient[0].IsSameAsPrimaryAddress = false;
                }
                //vm.searchText1 = null;
            if (vm.otherInsuredAddress.isManualAddress === false) {
                vm.otherInsuredAddress.AddressLine1 = null;
                vm.mannualOtherSearchText = null;
                vm.selectedOtherMannualItem = null;
            }
        }

        function cancelOtherInsured(type) {
            if (vm.addSecondaryClient.length > 0) {
                vm.addSecondaryClient[0].FirstName = null;
                vm.addSecondaryClient[0].LastName = null;
                vm.addSecondaryClient[0].DateOfBirthStringAsDDMMYYYY = null;
                vm.addSecondaryClient[0].OrganisationName = null;
                vm.addSecondaryClient[0].TradingName = null;
                vm.searchText1 = null;
                if (type === 'cancelButton') {
                    vm.addSecondaryClient[0].ClientType = null;
                }
            }
            if (type.$name === 'otherInsuredForm' && vm.otherInsuredAddress.isManualAddress === false) {
                type.otherAutocompleteAddress.$invalid = true;
                type.otherAutocompleteAddress.$touched = false;
            }

            if (type === 'cancelButton') {
                if (vm.IsOpenAddInsuredPopup) {
                    vm.state.PolicyHolder.InsuredName = vm.tempPrimaryInsured;
                    vm.IsOpenAddInsuredPopup = false;
                } else if (vm.tempAdditonalPolicyHolders != null) {
                    vm.state.PolicyHolder.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].AdditionalPolicyHolder = vm.tempAdditonalPolicyHolders[vm.AdditionalPolicyHolderIndex] == undefined ? null : vm.tempAdditonalPolicyHolders[vm.AdditionalPolicyHolderIndex].AdditionalPolicyHolder;
                    vm.state.PolicyHolder.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].AdditionalPolicyHolderType = "Secondary";
                } else {
                    vm.state.PolicyHolder.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].AdditionalPolicyHolder = null;
                }
            }

            //vm.tempPrimaryInsured = vm.state.PolicyHolder.InsuredNameList.filter(function (e) { return e.clientType === 'Primary' })
            //vm.state.PolicyHolder.InsuredName = vm.tempPrimaryInsured[0].name;
            vm.otherInsuredAddress.isManualAddress = false;
            resetAddress();
        }

        function OtherSubmitEnabled(otherInsuredForm) {
            if (otherInsuredForm.$invalid || (vm.selectedAddress1 === null && !vm.otherInsuredAddress.isManualAddress)) {
                return true;
            }
            else {
                return false;
            }
        }

        vm.checkValidOtherManualAddress = function (field) {
            if (vm.mannualOtherSearchText) {
                if (!vm.selectedOtherMannualItem) {
                    field.$setValidity('invalid', false);
                }
                else {
                    field.$setValidity('invalid', true);
                }
            }
        }


        //Check Is Address is valid or not
        vm.checkValidManualAddress = function (field) {
            if (vm.mannualSearchText) {
                if (!vm.selectedMannualAddress) {
                    field.$setValidity('invalid', false);
                }
                else {
                    field.$setValidity('invalid', true);
                }
            }
        }

        function checkManualAddressChange(flag) {            
            if (vm.state.PropertyDetail.AddressText) {
                vm.previousAddressTextForIllion = vm.state.PropertyDetail.AddressText;
            } 
            if (flag) {
                vm.previousAddressLine1ForIllion = null;
            }            
        }

        vm.getAdressEnquiryDetails = function () {
            if (vm.IsEndorsement || (vm.tempLandlordProtectionData && vm.tempLandlordProtectionData.DDlProcessTypeId == 4)) {
                return;
            }

            if (vm.state.PropertyDetail && vm.state.PropertyDetail.AddressValue) {                
                if (vm.previousAddressTextForIllion && vm.previousAddressTextForIllion === vm.state.PropertyDetail.AddressText) {
                    if (vm.state.PropertyDetail.IsManualAddress) {
                        if (!vm.checkAddressLine1 && vm.state.PropertyDetail.AddressLine1) {
                            if (vm.previousAddressLine1ForIllion) {
                                if (vm.previousAddressLine1ForIllion == vm.state.PropertyDetail.AddressLine1) {
                                    return;
                                }
                            }
                            else {
                                vm.previousAddressLine1ForIllion = vm.state.PropertyDetail.AddressLine1;
                                return;
                            }
                        }                        
                    }
                    else {
                        return;
                    }
                }
                let addLine1 = null;
                if (!vm.state.PropertyDetail.IsManualAddress) {
                    let addressTextSplit = vm.state.PropertyDetail.AddressText.split(',');
                    addLine1 = addressTextSplit[0];
                }
                else {                    
                    addLine1 = vm.state.PropertyDetail.AddressLine1;
                    vm.previousAddressLine1ForIllion = addLine1;
                }
                if (addLine1 === null || addLine1 === undefined) {
                    vm.checkAddressLine1 = true;
                    return;
                }    
                vm.checkAddressLine1 = false;
                vm.state.IllionClaimResponse = null;
                vm.state.IllionClaimResponseId = null;
                let addressSplitSate = vm.state.PropertyDetail.AddressValue.split('|');
                let addState = addressSplitSate[0];
                let addPostcode = addressSplitSate[1];
                let addSuburb = addressSplitSate[2];
                var illionAddressEnquiryRequestVM = {
                    "AddressLine1": addLine1,
                    "Suburb": addSuburb,
                    "State": addState,
                    "Postcode": addPostcode,
                    "AddressText": addLine1 + "," + addSuburb + " " + addState + " " + addPostcode
                };
                utilityService.getAddressEnquiry(illionAddressEnquiryRequestVM).then(function (data) {
                    vm.state.IllionClaimResponseId = data.data;
                });
            }
        }
    }

})();;
(function () {
    'use strict';

    var appUI = angular.module('appUI');



    appUI.controller('landlordStandardCtrl', ['$rootScope', '$q', '$window', '$filter', 'responsiveService', 'quotesService', 'sessionStorageService', 'apiUrlConstService', 'webUrlConstService', 'dateService', 'disclaimerService', '$http', '$log', 'messageConstService', 'keyConstService', 'occupationService', '$scope', '$mdDialog', '$timeout', 'clientService', 'utilityService', landlordStandardCtrl]);
    function landlordStandardCtrl($rootScope, $q, $window, $filter, responsiveService, quotesService, sessionStorageService, apiUrlConstService, webUrlConstService, dateService, disclaimerService, $http, $log, messageConstService, keyConstService, occupationService, $scope, $mdDialog, $timeout, clientService, utilityService) {
        var vm = this;
        var caseId = null;
        var isNewEditTransaction = false;
        var transactionId = 0;
        var brokerData;
        var getQuestionSetWithoutSaving;
        var getTransactionIdWithoutSaving;
        var getParsedQuestionSetWithoutSaving;
        var getQuoteTransactionId;
        var brokerdetail;
        vm.invalidSuminsuredAmount = false;
        vm.minContentsSumInsured = null;
        vm.DefaultSumInsured = null;
        vm.checkSumInsuredValue = null;
        vm.invalidRentalAmount = false;
        vm.addressMapped = addressMapped;
        vm.propertyDecline = propertyDecline;
        vm.findAddress = findAddress;
        vm.BuildingSumInsuredRange = BuildingSumInsuredRange;
        vm.addNote = addNote;
        vm.removeNote = removeNote;
        vm.chnageBrokerCommission = chnageBrokerCommission;
        vm.ContentChanges = ContentChanges;
        vm.changeNotesPrintable = changeNotesPrintable;
        vm.doorChecked = doorChecked;
        vm.DoorSecurities = DoorSecurities; 
        vm.resetAlarmSecurity = resetAlarmSecurity;
        vm.addDoorSecurity = addDoorSecurity;
        vm.isClaimsInLast3YearsChanged = isClaimsInLast3YearsChanged;
        vm.resetAddressData = resetAddressData;
        vm.RestoreCordellData = RestoreCordellData;
        vm.ResetCordellData = ResetCordellData;
        vm.resetCordellRestData = resetCordellRestData; 
        vm.setNonFloorAreaDetail = setNonFloorAreaDetail;
        vm.nextPremium = nextPremium;
        vm.isAdditionalPolicyHolderChange = isAdditionalPolicyHolderChange;
        vm.AnnualRevenueRange = AnnualRevenueRange;
        vm.sumInsuredEstimate = sumInsuredEstimate;
        vm.toggleSelectionDoorSecurity = toggleSelectionDoorSecurity;
        vm.ResetSumInsuredValue = resetSumInsuredValue;
        vm.declineOnRewireCondition = declineOnRewireCondition;
        vm.resetUnspecifiedItemsCover = resetUnspecifiedItemsCover;
        vm.resetSpecifiedPortableItems = resetSpecifiedPortableItems;
        vm.resetPropertySection = resetPropertySection;
        vm.getTermsAndConditons = getTermsAndConditons;
        vm.finalSaving = finalSaving;
        vm.finalGetQuote = finalGetQuote;
        vm.CordellDataState = CordellDataState;
        vm.RestoreCordellFields = RestoreCordellFields;
        vm.SetCordelFields = SetCordelFields;
        vm.validateConstructionPeriod = validateConstructionPeriod;
        vm.validateCalculateSumInsuredButton = validateCalculateSumInsuredButton;
        vm.ResetotherInterestedPartyText = ResetotherInterestedPartyText;
        vm.changeInOccupation = changeInOccupation;
        vm.getSecondaryInsuredList = getSecondaryInsuredList;
        vm.checkDefaultBuildingSumInsured = checkDefaultBuildingSumInsured;
        vm.showDefaultBuildingSumInsuredRange = false;
        vm.checkDefaultContentSumInsured = checkDefaultContentSumInsured;
        vm.showDefaultContentSumInsuredRange = false;
        vm.DefaultSumInsured = null;
        vm.checkWeeklyRentalAmount = checkWeeklyRentalAmount;
        vm.checkWeeklyRentalAmountLimit = false;
        var previousTransactionId = null;
        var ExpirationDate = null;
        var caseNumberForSecondaryInsured;
        var IsNewBusinessEdit = null;
        vm.defaultValueForSpecialContent = defaultValueForSpecialContent;
        vm.showDeafultSpeacilContent = false
        var endorsementState = null;
        vm.disablePaymentFrequency = false;
        vm.Back = Back;
        vm.resetLossOfRent = resetLossOfRent;
        vm.resetRentDefault = resetRentDefault;
        vm.resetSecurityDetails = resetSecurityDetails;
        vm.validDOBOtherInsurer = true;
        vm.valueOfCover = null;
        vm.checkedDoorList = [];
        vm.NoneOfTheAboveIndex = 0;
        vm.checkClaims = null;
        vm.EnableDisableButton = EnableDisableButton;
        vm.policyHolderNameExists = policyHolderNameExists;
        vm.setSpecialContentValidity = true;
        vm.selectedAddressValue = null;
        vm.brokerFeeChange = brokerFeeChange;
        vm.brokerbranchcheck;
        vm.brokerManagedPayment = 0;
        vm.disableButtons = false;
        vm.continueOrNavigateBackToPackageManager = continueOrNavigateBackToPackageManager;
        vm.showMessageGrt100OtherInsuredName = false;
        vm.changeOtherInsuredName = changeOtherInsuredName;
        vm.addOtherInsured = addOtherInsured;
        vm.otherInsuredAddress = null;
        vm.storeOtherInsuredAddress = storeOtherInsuredAddress;
        vm.resetAddress = resetAddress;
        vm.cancelOtherInsured = cancelOtherInsured;
        vm.checkSameAsPrimary = checkSameAsPrimary;
        vm.ClientDetail = {};
        vm.otherreadonly = false;
        vm.OtherSubmitEnabled = OtherSubmitEnabled;
        vm.showDomesticWorkerCompensation = false;
        vm.OtherInsuredName = null;
        vm.DateOfBirthApp = null;
        vm.help_text_for_Endorsement = keyConstService.help_text_for_Endorsement;
        vm.primaryClientAddressState = null;
        vm.tempPrimaryInsured;
        vm.tempAdditonalPolicyHolders;
        vm.AdditionalPolicyHolderIndex;
        vm.IsOpenAddInsuredPopup = false;
        vm.getQuoteV2 = getQuoteV2;
        vm.disablecover = disablecover;
        vm.BindBuildingType = BindBuildingType;
        vm.BindBuiltOnType = BindBuiltOnType;
        vm.BindApartmentType = BindApartmentType;
        vm.BindSemiDetached = BindSemiDetached;
        vm.BindOtherDwellingType = BindOtherDwellingType;
        vm.resetValuesOnBuildingCoverFalse = resetValuesOnBuildingCoverFalse;
        vm.ResetBuildingSumInsureforV2 = ResetBuildingSumInsureforV2;
        vm.OnRenovationDateChange = OnRenovationDateChange;
        var endorsementPropertyData = null;
        vm.onClickAddressNotFound = onClickAddressNotFound;                                                   // function for On click of adress not found
        vm.resetAddressNotFound = resetAddressNotFound;                                                        // function to reset on change Addres 
        vm.onClickAddressNotFoundOtherInsured = onClickAddressNotFoundOtherInsured;                           // function for On click of adress not found OtherInsured
        vm.resetAddressNotFoundOtherInsured = resetAddressNotFoundOtherInsured;                                // function to reset on change Addres OtherInsured
        vm.IsRentDefaultChanges = false;
        vm.propertyDeclineForTotalUnits = propertyDeclineForTotalUnits;
        vm.illionClaimResponse = null;
        vm.checkManualAddressChange = checkManualAddressChange;
        vm.previousAddressTextForIllion = null;
        vm.previousAddressLine1ForIllion = null;
        vm.endorsementData = null;
        vm.rentDefaultEndorsementConditions = rentDefaultEndorsementConditions;
        vm.IsAddressavailable = false;
        vm.LastBoundRentDefaultAnswers = null;
        vm.checkAddressLine1 = false;
        vm.OnRentDefaulChildQuestionChange = OnRentDefaulChildQuestionChange;
        vm.ShowRentDefaultDeclineText = false;
        vm.startDateForYear = null;

        function EnableDisableButton(form1) {
            if (vm.state.PolicyHolder.BuildingCover && (vm.state.CordellResponse.BuildingSumInsured == '' || vm.state.CordellResponse.BuildingSumInsured == null || vm.state.CordellResponse.BuildingSumInsured == 0)) {
                form1.$invalid = true;
            }
            if ((vm.selectedAddress === null && !vm.state.PropertyDetail.IsManualAddress == true) ||
                (form1.$invalid || vm.isNullContentInsured == true) ||
                vm.ExcessValueFlag ||
                vm.ReadOnly ||
                vm.brokerCommissionLimitMessage ||
                vm.BuildingSiFlag ||
                vm.ContentSiFlag ||
                vm.checkWeeklyRentalAmountLimit == true ||
                vm.showDefaultBuildingSumInsuredRange == true ||
                vm.invalidSuminsuredAmount == true ||
                !vm.validDOBOtherInsurer ||
                vm.setSpecialContentValidity == false ||
                !vm.policyHolderNameExists() || !checkAdditionalInsuredInList()) {
                return true;
            } else {
                return false;
            }
        }

        function policyHolderNameExists() {
            return (vm.state.PolicyHolder.InsuredNameList.findIndex(record => record.value === vm.state.PolicyHolder.InsuredName) === -1 ? false : true);
        }

        function initializeDoorSecurityCheckBox(mode) {
            vm.checkedDoorList = [];
            for (var index = 0; index < vm.state.SecurityDetails.DoorSecuritiesList.length; index++) {
                vm.checkedDoorList.push(false);
            }
            if (mode === 0)
                vm.state.SecurityDetails.DoorSecurities = [];
            if (vm.state.SecurityDetails.DoorSecurities.length === 0) {
                vm.state.SecurityDetails.DoorSecurities.push("NoneOfTheAbove");
                vm.checkedDoorList[vm.NoneOfTheAboveIndex] = true;
            }
        }

        function doorChecked() {
            var index = 0, counter = 0;
            $.each(vm.state.SecurityDetails.DoorSecuritiesList, function (key, value) {
                if (value.Value === "NoneOfTheAbove")
                    vm.NoneOfTheAboveIndex = counter;
                else
                    counter++;
            });

            initializeDoorSecurityCheckBox(1);

            if (vm.state.SecurityDetails.DoorSecurities.length !== 0) {
                for (index = 0; index < vm.state.SecurityDetails.DoorSecuritiesList.length; index++) {
                    var item = vm.state.SecurityDetails.DoorSecuritiesList[index].Value;
                    if (vm.state.SecurityDetails.DoorSecurities.indexOf(item) > -1)
                        vm.checkedDoorList[index] = true;
                }
            }
        }

        function DoorSecurities() {
            if (vm.state.ContentsSumInsured.GeneralContentSumInsured > keyConstService.LLContentSumInsuredLimit) {
                doorChecked();
            }
            if (vm.state.ContentsSumInsured.GeneralContentSumInsured < keyConstService.LLContentSumInsuredLimit) {
                vm.invalidSuminsuredAmount = true;
                vm.state.SecurityDetails.WindowSecurities = null;
                vm.state.SecurityDetails.AlarmType = null;
                vm.state.SecurityDetails.IsAlarmSecurity = null;
                vm.state.SecurityDetails.DoorSecurities = [];
            }
        }

        function toggleSelectionDoorSecurity(doorSecurity, indexValue) {
            var index = vm.state.SecurityDetails.DoorSecurities.indexOf(doorSecurity);
            if (index < 0) {
                if (doorSecurity !== 'NoneOfTheAbove') {
                    vm.state.SecurityDetails.DoorSecurities = vm.state.SecurityDetails.DoorSecurities.filter(function (e) { return e !== 'NoneOfTheAbove' })
                    vm.checkedDoorList[vm.NoneOfTheAboveIndex] = false;
                }
                else {
                    initializeDoorSecurityCheckBox(0);
                }
                if (doorSecurity !== 'NoneOfTheAbove') {
                    vm.state.SecurityDetails.DoorSecurities.push(doorSecurity);
                }
                vm.checkedDoorList[indexValue] = true;
            }
            else {
                if (doorSecurity === 'NoneOfTheAbove' && vm.state.SecurityDetails.DoorSecurities.length === 1) {
                    vm.checkedDoorList[indexValue] = true;
                }
                else if (doorSecurity === 'NoneOfTheAbove') {
                    initializeDoorSecurityCheckBox(0);
                }
                else {
                    vm.state.SecurityDetails.DoorSecurities.splice(index, 1);
                    if (vm.state.SecurityDetails.DoorSecurities.length === 0)
                        initializeDoorSecurityCheckBox();
                    vm.checkedDoorList[indexValue] = false;
                }
            }
            $log.log('vm.state.SecurityDetails.DoorSecurities', vm.state.SecurityDetails.DoorSecurities);
        }

        vm.tempLandlordStandardData = null;
        vm.init = function (landlordStandardData) {  
            vm.tempLandlordStandardData = landlordStandardData;
            vm.LandlordStandardDropDownListV2 = landlordStandardData.LandlordStandardDropDownListV2;
            vm.version = landlordStandardData.Version;
            var qStartDate = null;
            var qCheckDate = new Date(landlordStandardData.DWCAdjustmentDate);
            var isPM = sessionStorageService.get('IsPackageManagerNavigationMode');
            var renewalCounter = sessionStorageService.get('RenewalCounter');
            if (isPM === "true" || renewalCounter !== null) {
                vm.showManagePkg = true;
            }
            vm.hideDomesticWorkerCompensation = false;
            vm.brokerbranchcheck = sessionStorageService.get('IsBranchViewOnly') !== "false";
            vm.landlordStandardData = landlordStandardData;
            vm.PolicyNumber = landlordStandardData.PolicyNumber;
            sessionStorage.removeItem(keyConstService.Motor);
            sessionStorage.setItem(keyConstService.Home, 'HomeProductController');
            if (sessionStorageService.get(keyConstService.sessionStorageState) === "false") {
                sessionStorageService.remove(keyConstService.getTransactionIdWithoutSaving);
                sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
                sessionStorageService.remove(keyConstService.resetNonRegoData);
            }
            var IsValidQuestionsBack = JSON.parse(sessionStorageService.get(keyConstService.IsValidQuestionsBack));
            if (landlordStandardData.LandlordStandardListData) {
                vm.maxOccupationTurnover = landlordStandardData.LandlordStandardListData.Occupation;
            }
            if (landlordStandardData.IsEndorsement) {
                vm.IsEndorsement = landlordStandardData.IsEndorsement;
            }
            if (landlordStandardData.LandlordStandardQuestion && landlordStandardData.LandlordStandardQuestion.PaymentFrequency.BrokerManagedPayment !== null) {
                vm.brokerManagedPayment = landlordStandardData.LandlordStandardQuestion.PaymentFrequency.BrokerManagedPayment;
            }
            else {
                vm.brokerManagedPayment = landlordStandardData.PackageDetail.BrokerManagedPayment;
            }

            vm.landlordStandardData = landlordStandardData
            vm.activatePayment = vm.landlordStandardData.ActivatePayment;
            if (landlordStandardData) {
                if (landlordStandardData.IsPolicyBound) {
                    vm.enablePopUp = true;
                    toastr.error(messageConstService.errMessagePolicyBound);

                }
                if (landlordStandardData.BuildingSumInsuredAllowedRange) {
                    vm.AllowedBuildingSumInsuredRange = landlordStandardData.BuildingSumInsuredAllowedRange;
                }
            }
            vm.DefaultSumInsured = keyConstService.DefaultLandlordStandardSI;
            vm.minContentsSumInsured = keyConstService.MinLandlordStandardSI;

            vm.endorsementVM = JSON.parse(sessionStorageService.get(keyConstService.endorsementRequestVM));
            if (landlordStandardData.QuoteCase != null || landlordStandardData.QuoteTransactionId != null) {
                vm.CaseNumber = landlordStandardData.QuoteCase.CaseNumber;
                vm.TransactionId = landlordStandardData.QuoteTransactionId;
            }

            if (vm.IsEndorsement) {
                vm.showBrokerFee = false;
            }
            else {
                vm.showBrokerFee = true;
            }

            if (!landlordStandardData.LandlordStandardQuestion) {
                vm.ready = true;
                caseId = sessionStorageService.get(keyConstService.caseId);
                sessionStorageService.set(keyConstService.IsNewEditTransaction, isNewEditTransaction);
                vm.CaseNumber = JSON.parse(sessionStorageService.get('caseNumber'));
                transactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
               
                vm.rowVersion = JSON.parse(sessionStorageService.get(keyConstService.rowVersion));
                brokerData = sessionStorageService.get(keyConstService.brokerData);
                var newBusinessCaseData = sessionStorageService.get(keyConstService.newBusinessCaseData);
                var newBusinessCaseDetail = JSON.parse(newBusinessCaseData);

                var startDate = newBusinessCaseDetail.data.EffectiveDate;
                var productId = newBusinessCaseDetail.data.ProductId;
                qStartDate = new Date(newBusinessCaseDetail.data.EffectiveDate);
                vm.startDateForYear = new Date(newBusinessCaseDetail.data.EffectiveDate);
                var rentDefaultNewVersionDate = new Date(landlordStandardData.RentDefaultNewVersionDate);
                if (qStartDate >= rentDefaultNewVersionDate) {
                    vm.IsRentDefaultChanges = true;
                }
                vm.state = quotesService.loadQuoteData(null, 4, landlordStandardData.LandlordStandardListData, vm.version, vm.IsRentDefaultChanges);
                vm.isNullContentInsured = false;
                vm.state.ContentsSumInsured.GeneralContentSumInsured = vm.DefaultSumInsured;
                vm.state.CordellResponse.BuildingSumInsuredEstimate = 0;
                var getQuoteTransactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
                vm.getTransactionIdWithoutSaving = JSON.parse(sessionStorageService.get(keyConstService.getTransactionIdWithoutSaving));
                vm.getID = getQuoteTransactionId;
                getQuestionSetWithoutSaving = sessionStorageService.get(keyConstService.getQuestionSetWithoutSaving);
                getParsedQuestionSetWithoutSaving = JSON.parse(getQuestionSetWithoutSaving);
                vm.retainValueforQuestion = getParsedQuestionSetWithoutSaving;
               
                if (getParsedQuestionSetWithoutSaving) {
                    if (getQuoteTransactionId == vm.getTransactionIdWithoutSaving) {

                        claimTypeListSelection();

                        vm.state.PaymentFrequency.ModeOfPayment = newBusinessCaseDetail.data.ModeOfPayment ? newBusinessCaseDetail.data.ModeOfPayment : newBusinessCaseDetail.data.PaymentFrequency;
                        vm.state.PaymentFrequency.InstallmentDate = newBusinessCaseDetail.data.InstallmentDate;
                        vm.selectedMannualAddress = getParsedQuestionSetWithoutSaving.PropertyDetail.AddressText;
                        if (getParsedQuestionSetWithoutSaving.PropertyDetail.IsManualAddress === false) {
                            vm.selectedAddress = getParsedQuestionSetWithoutSaving.PropertyDetail.AddressText;
                        }

                        if (getParsedQuestionSetWithoutSaving.PropertyDetail.IsManualAddress == true) {
                            vm.selectedAddress = null;
                            vm.state.PropertyDetail.AddressLine1 = getParsedQuestionSetWithoutSaving.PropertyDetail.AddressLine1;
                            vm.selectedMannualAddress = getParsedQuestionSetWithoutSaving.PropertyDetail.AddressText;

                        }

                        var splitSate = getParsedQuestionSetWithoutSaving.PropertyDetail.AddressValue !== null ? getParsedQuestionSetWithoutSaving.PropertyDetail.AddressValue.split('|') : [];
                        vm.storeAddress = splitSate[0];
                        vm.getAddressState = splitSate[0];
                        if (vm.getAddressState) {
                            if ((qStartDate < qCheckDate) && (vm.getAddressState === "WA" || vm.getAddressState === "ACT" || vm.getAddressState === "TAS")) {
                                vm.showDomesticWorkerCompensation = true;
                                vm.state.OptionalCover.IsDomesticWorkerCompensation = vm.state.OptionalCover.IsDomesticWorkerCompensation ;

                            }
                            else {
                                vm.showDomesticWorkerCompensation = false;
                                vm.state.OptionalCover.IsDomesticWorkerCompensation  = null;
                            }
                        }
                        if (vm.state.ContentsSumInsured.IsValuableContent) {
                            for (var i = 0; i < getParsedQuestionSetWithoutSaving.ContentsSumInsured.ValuableContents.length; i++) {
                                defaultValueForSpecialContent(null, getParsedQuestionSetWithoutSaving.ContentsSumInsured.ValuableContents[i].Value, i);
                            }
                        }

                        //// building and content cover enable disable on previous next
                        if (getParsedQuestionSetWithoutSaving.PropertyDetail.BuildingType === keyConstService.Apartments ||
                            getParsedQuestionSetWithoutSaving.PropertyDetail.BuildingType === keyConstService.OtherDwellingType ||
                            (getParsedQuestionSetWithoutSaving.PropertyDetail.BuildingType === keyConstService.SemiDetachedHome && getParsedQuestionSetWithoutSaving.PropertyDetail.IsStrataManagement) ||
                            (getParsedQuestionSetWithoutSaving.PropertyDetail.BuildingType === keyConstService.MultipleUnits && getParsedQuestionSetWithoutSaving.PropertyDetail.IsStrataManagement === true) ||
                            (getParsedQuestionSetWithoutSaving.PropertyDetail.BuildingType === keyConstService.MultipleUnits && getParsedQuestionSetWithoutSaving.PropertyDetail.AllOwnedByInsured === false)) {
                            vm.disableBuilding = true;
                            vm.disableContent = true;
                        }
                    }
                    // checking for duplicate excess in case of previous/next
                    vm.isDuplicateExcess();

                    //// check if roof and wall is present in list , if not present set to null
                    CheckRoofANdWallValuePresentInDropDown();

                }

                var brokerCommissionRequest = quotesService.getBrokerCommission({
                    EffectiveDate: startDate,
                    ProductId: productId,
                    ProductName: null,
                })
                    .then(function (result) {
                        vm.data = result.data.brokerBranchCommissionFeeVM;

                        if (vm.data) {
                            for (var i = 0; i < vm.data.length; i++) {
                                if (vm.state.PolicyHolder.BuildingCover && !vm.state.PolicyHolder.ContentCover) {
                                    if (vm.data[i].coverCode === "BUILDING") {
                                        if (!getParsedQuestionSetWithoutSaving) {
                                            vm.state.BrokerCommission.BrokerCommissionPercentage = vm.data[i].brokerCommissionFee;
                                        }
                                        vm.maxbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMax;
                                        vm.minbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMin;
                                    }
                                }
                                if (!vm.state.PolicyHolder.BuildingCover && vm.state.PolicyHolder.ContentCover) {
                                    if (vm.data[i].coverCode === "CONTENT") {
                                        if (!getParsedQuestionSetWithoutSaving) {
                                            vm.state.BrokerCommission.BrokerCommissionPercentage = vm.data[i].brokerCommissionFee;
                                        }
                                        vm.maxbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMax;
                                        vm.minbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMin;
                                    }
                                }
                                if (vm.state.PolicyHolder.BuildingCover && vm.state.PolicyHolder.ContentCover) {
                                    if (vm.data[i].coverCode === "BUILDING,CONTENT") {
                                        if (!getParsedQuestionSetWithoutSaving) {
                                            vm.state.BrokerCommission.BrokerCommissionPercentage = vm.data[i].brokerCommissionFee;
                                        }
                                        vm.maxbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMax;
                                        vm.minbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMin;
                                    }
                                }
                            }
                            vm.checkBrkerCommissionLimit();
                        }
                    })
                if (vm.state.ContentsSumInsured.IsValuableContent && sessionStorageService.get(keyConstService.specialContentvalidity))
                {
                    vm.parseSpecialContentvalidity = JSON.parse(sessionStorageService.get(keyConstService.specialContentvalidity))
                    for (i = 0; i < vm.parseSpecialContentvalidity.length; i++) {
                        if (vm.parseSpecialContentvalidity[i].IsValid === true) {
                            vm.setSpecialContentValidity = false;
                        }
                    }
                }

                brokerdetail = JSON.parse(brokerData);
                var newBusinessCaseDetail = JSON.parse(newBusinessCaseData);
                vm.state.ExistingPackage = newBusinessCaseDetail.data.ExistingPackage;
                if (vm.state.ExistingPackage) {
                    vm.state.OtherInfo.IsAddMorePolicyToPackage = true;
                }
                quotesService.getInsuredNameList(caseId).then(function (ResponseData) {
                    if (ResponseData.data !== null) {
                        vm.state.PolicyHolder.InsuredNameList = ResponseData.data.policyHolder.insuredNameList;
                        vm.state.PolicyHolder.InsuredClientId = ResponseData.data.policyHolder.insuredClientId;
                        vm.state.PolicyHolder.InsuredName = ResponseData.data.policyHolder.insuredName;
                        vm.ClientDetail = ResponseData.data.clientDetail;
                        vm.otherInsuredAddress = ResponseData.data.clientDetail.addressLogVM;
                        vm.addSecondaryClient = ResponseData.data.clientDetail.secondaryInsuredClientVM;
                        vm.PropertyDetail = angular.copy(ResponseData.data.buildingInfo);

                        var clientSplitSate = ResponseData.data.buildingInfo.addressValue != null ? ResponseData.data.buildingInfo.addressValue.split('|') : [];
                        vm.primaryClientAddressState = clientSplitSate[0];

                        if (!vm.selectedAddress) {
                            ResponseData.data.buildingInfo.addressText = null;
                            ResponseData.data.buildingInfo.addressValue = null;
                        }
                        var splitSate = ResponseData.data.buildingInfo.addressValue != null ? ResponseData.data.buildingInfo.addressValue.split('|'):[];
                        vm.AddressState = splitSate[0];
                        if (vm.AddressState === "NSW") {
                            vm.showStampDuty = true;

                        }
                        if (getQuoteTransactionId !== vm.getTransactionIdWithoutSaving) {
                            if ((qStartDate < qCheckDate) && (vm.AddressState != undefined) && (vm.AddressState.toUpperCase() === "WA" || vm.AddressState.toUpperCase() === "ACT" || vm.AddressState.toUpperCase() === "TAS")) {
                                vm.showDomesticWorkerCompensation = true;
                                vm.state.OptionalCover.IsDomesticWorkerCompensation = vm.state.OptionalCover.IsDomesticWorkerCompensation ;

                            }
                            else {
                                vm.showDomesticWorkerCompensation = false;
                                vm.state.OptionalCover.IsDomesticWorkerCompensation  = null;
                            }
                        }

                        vm.state.CordellResponse.Propertydata.postcode = ResponseData.data.buildingInfo.postcode;

                    }

                    if (vm.state.PolicyHolder.AdditionalPolicyHolderList.length != 0 && vm.state.PolicyHolder.AdditionalPolicyHolderList[0].OtherDateOfBirthApp != null) {
                        for (var i = 0; i < vm.state.PolicyHolder.AdditionalPolicyHolderList.length; i++) {
                            if (vm.state.PolicyHolder.AdditionalPolicyHolderList[i].AdditionalDateOfBirth === "Other") {
                                var dateofBirth = vm.state.PolicyHolder.AdditionalPolicyHolderList[i].OtherDateOfBirthApp;
                                var response = dateService.validateBirthDDMMYYYY(dateofBirth, 115);
                                if (!response.isValid) {
                                    vm.validDOBOtherInsurer = false;
                                    vm.message = response.errorMsg;
                                    break;
                                }
                                else {
                                    vm.validDOBOtherInsurer = true;
                                }
                            }
                            else {
                                break;
                            }
                        }
                        if (!vm.validDOBOtherInsurer && vm.message === messageConstService.errFutureDateNotAllowed) {
                            toastr.warning(messageConstService.errFutureDatedForAddHolder);
                        }
                        else if (!vm.validDOBOtherInsurer && vm.message === messageConstService.errDateNotAllowed) {
                            toastr.warning(messageConstService.errDateNotAllowed);
                        }
                    }


                    if (vm.state.ContentsSumInsured.IsValuableContent || vm.state.ContentsSumInsured.GeneralContentSumInsured > keyConstService.LLContentSumInsuredLimit)
                        doorChecked();

                    //// setting excessValue Based on primary client's addressSate
                    DefaultExcessOnAddress();

                    //retaining Claims state on previous/next
                    vm.checkClaims();
                    vm.checkWeeklyRentalAmount(vm.state.OptionalCover.WeeklyRentalAmount);
                    checkDefaultBuildingSumInsured(vm.state.CordellResponse.BuildingSumInsured);
                    BuildingSumInsuredRange(vm.state.CordellResponse.BuildingSumInsured);
                    if (vm.state.PolicyHolder.ContentCover) {
                        vm.checkSumInsuredValue();
                    }

                    if (getQuoteTransactionId !== vm.getTransactionIdWithoutSaving) {
                        var newDate = new Date(ResponseData.data.policyHolder.dateOfBirthApp);
                        vm.state.PolicyHolder.DateOfBirthApp = newDate;
                    }
                    for (var i = 0; i < ResponseData.data.policyHolder.secondaryInsuredsList.length; i++) {
                        if (ResponseData.data.policyHolder.secondaryInsuredsList[i].value === vm.state.PolicyHolder.InsuredName && ResponseData.data.policyHolder.secondaryInsuredsList[i].id === vm.state.PolicyHolder.InsuredClientId) {
                            var index = ResponseData.data.policyHolder.secondaryInsuredsList.indexOf(ResponseData.data.policyHolder.secondaryInsuredsList[i]);
                            ResponseData.data.policyHolder.secondaryInsuredsList.splice(index, 1);
                            vm.state.PolicyHolder.SecondaryInsuredsList = ResponseData.data.policyHolder.secondaryInsuredsList;

                            if (getQuoteTransactionId === vm.getTransactionIdWithoutSaving) {
                                vm.getQuestionSetWithoutSavingData = JSON.parse(sessionStorageService.get(keyConstService.getQuestionSetWithoutSaving));
                                if (vm.getQuestionSetWithoutSavingData.PolicyHolder.InsuredName === "Other") {
                                    vm.state.PolicyHolder.InsuredName = vm.getQuestionSetWithoutSavingData.PolicyHolder.InsuredName;
                                    vm.state.PolicyHolder.OtherInsuredName = vm.getQuestionSetWithoutSavingData.PolicyHolder.OtherInsuredName;
                                    for (var i = 0; i < vm.getQuestionSetWithoutSavingData.PolicyHolder.SecondaryInsuredsList.length; i++) {
                                        vm.state.PolicyHolder.SecondaryInsuredsList[i] = vm.getQuestionSetWithoutSavingData.PolicyHolder.SecondaryInsuredsList[i];
                                    }
                                }
                            }

                            // Commentd by Ankur as per us 6829
                            //else {
                            //    if (vm.state.PolicyHolder.InsuredName) {
                            //        vm.state.PolicyHolder.InsuredName = ResponseData.data.policyHolder.insuredName;
                            //    }
                            //}
                        }
                    }

                    vm.tempPrimaryInsured = ResponseData.data.policyHolder.insuredName;
                    vm.tempAdditonalPolicyHolders = angular.copy(ResponseData.data.policyHolder.additionalPolicyHolderList);

                    // Commentd by Ankur as per us 6829
                    //var secondaryInsuredOtherPos = vm.state.PolicyHolder.SecondaryInsuredsList.findIndex(p => p.value === "Other");
                    //if (secondaryInsuredOtherPos !== -1) {
                    //    vm.state.PolicyHolder.SecondaryInsuredsList.splice(secondaryInsuredOtherPos, 1);
                    //}
                });

                if (vm.IsRentDefaultChanges) {
                    vm.OnRentDefaulChildQuestionChange();
                }

                // removing questionset from session for valid newbusiness quote
                if (!getParsedQuestionSetWithoutSaving) {
                    sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
                }
            }

            else {
                var newBusinessCaseData = sessionStorageService.get(keyConstService.newBusinessCaseData);
                var newBusinessCaseDetail = JSON.parse(newBusinessCaseData);
                qStartDate = newBusinessCaseDetail != null ? new Date(newBusinessCaseDetail.data.EffectiveDate) : new Date(landlordStandardData.StartDate);
                vm.startDateForYear = newBusinessCaseDetail != null ? new Date(newBusinessCaseDetail.data.EffectiveDate) : new Date(landlordStandardData.StartDate);
                caseNumberForSecondaryInsured = landlordStandardData.QuoteCase.Id;
                vm.brokerFeeGST = landlordStandardData.LandlordStandardQuestion.PaymentFrequency.BrokerFee;
                vm.addressState = landlordStandardData.LandlordStandardQuestion.PropertyDetail.AddressValue;
                var rentDefaultNewVersionDate = new Date(landlordStandardData.RentDefaultNewVersionDate);
                if (landlordStandardData.LandlordStandardQuestion.PropertyDetail.IsManualAddress === false) {
                vm.selectedAddress = landlordStandardData.LandlordStandardQuestion.PropertyDetail.AddressText;
                }
                if (qStartDate >= rentDefaultNewVersionDate) {
                    vm.IsRentDefaultChanges = true;
                }              
                if (vm.addressState) {
                    var splitSate = vm.addressState.split('|');
                    vm.storeAddress = splitSate[0];
                    vm.AddressState = splitSate[0];
                }

                if (JSON.parse(sessionStorageService.get(keyConstService.IsRenewalPolicy)) === true)
                    landlordStandardData.LandlordStandardQuestion.CuppingCappingFactor.ExpirationPremium = landlordStandardData.LandlordStandardQuestion.CuppingCappingFactor.AdjustmentFactor = null;

                vm.maxOccupationTurnover = landlordStandardData.LandlordStandardQuestion.OtherInfo.OccupationNameList;
                landlordStandardData.LandlordStandardQuestion.OtherInfo.AnnualRevenue = parseInt(landlordStandardData.LandlordStandardQuestion.OtherInfo.AnnualRevenue);
                vm.IsEndorsementPolicyEffectiveDate = landlordStandardData.IsEndorsementPolicyEffectiveDate;
                vm.IsEndorsement = landlordStandardData.IsEndorsement;
                vm.isNullContentInsured = false;
                vm.state = landlordStandardData.LandlordStandardQuestion;
                vm.LastBoundRentDefaultAnswers = landlordStandardData.LastBoundRentDefaultAnswers;

                if (vm.state.PolicyHolder.InsuredNameList !==  null) {
                    var indexOfOther1 = vm.state.PolicyHolder.InsuredNameList.findIndex(p => p.value === "Other");
                    if (indexOfOther1 != -1) {
                        vm.state.PolicyHolder.InsuredNameList.splice(indexOfOther1, 1);
                    }
                }
                
                if (vm.state.PolicyHolder.SecondaryInsuredsList !== null) {
                    var indexOfSecOther1 = vm.state.PolicyHolder.SecondaryInsuredsList.findIndex(p => p.value === "Other");
                    if (indexOfSecOther1 != -1) {
                        vm.state.PolicyHolder.SecondaryInsuredsList.splice(indexOfSecOther1, 1);
                    }
                }
                
                if (vm.state.PolicyHolder.InsuredNameList !== null) {
                    var indexOfOtherInsured = vm.state.PolicyHolder.InsuredNameList.findIndex(p => p.value === "OtherInsured");
                    if (indexOfOtherInsured === -1) {
                        vm.state.PolicyHolder.InsuredNameList.push({ clientType: "Secondary", name: 'Other Insured', value: 'OtherInsured', dateOfBirth: new Date(), Id: -1 });
                    }
                }
                
                if (vm.state.PolicyHolder.SecondaryInsuredsList !== null) {
                    var indexOfSecondaryOtherInsured = vm.state.PolicyHolder.SecondaryInsuredsList.findIndex(p => p.value === "OtherInsured");
                    if (indexOfSecondaryOtherInsured === -1) {
                        vm.state.PolicyHolder.SecondaryInsuredsList.push({ clientType: "Secondary", name: 'Other Insured', value: 'OtherInsured', dateOfBirth: new Date(), Id: -1 });
                    }
                }
                

                if (vm.AddressState) {
                    if ((qStartDate < qCheckDate) && (vm.AddressState.toUpperCase() === "WA" || vm.AddressState.toUpperCase() === "ACT" || vm.AddressState.toUpperCase() === "TAS")) {
                    vm.showDomesticWorkerCompensation = true;
                    vm.state.OptionalCover.IsDomesticWorkerCompensation = landlordStandardData.LandlordStandardQuestion.OptionalCover.IsDomesticWorkerCompensation;

                    }
                }
                else {
                vm.showDomesticWorkerCompensation = false;
                vm.state.OptionalCover.IsDomesticWorkerCompensation = null;
                }
                vm.dataState = landlordStandardData;
                vm.valueOfCover = angular.copy(landlordStandardData.LandlordStandardQuestion.PolicyHolder.BuildingCover);
                vm.stampDuty = landlordStandardData.LandlordStandardQuestion.OtherInfo.IsStampDutyExemption;

                if (vm.stampDuty === null) {
                    vm.hideStampDuty = true;
                }


                if (vm.IsEndorsement) {
                    vm.showStampDuty = false;
                    if (landlordStandardData.LandlordStandardQuestion.OtherInfo.IsStampDutyExemption == true || landlordStandardData.LandlordStandardQuestion.OtherInfo.IsStampDutyExemption == false) {
                        vm.stampDutyEligibilty = true;
                    }

                    if (landlordStandardData.LandlordStandardQuestion.OtherInfo.IsStampDutyExemption == null) {
                        vm.sDHide = true;
                    }
                    //// for rent default
                    vm.endorsementData = angular.copy(vm.state);
                }

                vm.rowVersion = landlordStandardData.RowVersion;
                vm.transactionStatus = landlordStandardData.Status;
                vm.isSecondaryDisabled = false;
                vm.policyTransactionId = landlordStandardData.PolicyTransactionId;
                vm.BuildingSumInsuredValue = landlordStandardData.LandlordStandardQuestion.CordellResponse.BuildingSumInsured;
                vm.AllowedBuildingSumInsuredRange = landlordStandardData.BuildingSumInsuredAllowedRange;
                sessionStorageService.remove(keyConstService.IsNewBusinessReadOnly);
                if (JSON.parse(sessionStorageService.get(keyConstService.IsCopyQuote)) === false) {
                    sessionStorageService.set(keyConstService.IsPackageEditable, vm.dataState.IsPackageEditable);
                }
                else if (JSON.parse(sessionStorageService.get(keyConstService.IsCopyQuote)) === true && newBusinessCaseDetail) {
                    vm.state.ExistingPackage = newBusinessCaseDetail.data.ExistingPackage;
                    caseId = sessionStorageService.get(keyConstService.caseId);
                    quotesService.getInsuredNameList(caseId).then(function (ResponseData) {
                        if (ResponseData.data !== null) {
                            vm.state.PolicyHolder.InsuredNameList = ResponseData.data.policyHolder.insuredNameList;
                            vm.state.PolicyHolder.InsuredName = ResponseData.data.policyHolder.insuredName;
                            vm.secondaryListChange(true);
                        }
                    });
                    if (vm.state.ExistingPackage) {
                        vm.state.OtherInfo.IsAddMorePolicyToPackage = true;
                    }
                }
                vm.ReadOnly = landlordStandardData.IsReadOnly;
                vm.previousContentSumInsured = vm.state.ContentsSumInsured.GeneralContentSumInsured;
                vm.state.ExistingPackage = landlordStandardData.QuoteCase.ExistingPackage;
                vm.isNullContentInsured = false;
                var getQuoteTransactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
                vm.getID = getQuoteTransactionId;
                vm.getTransactionIdWithoutSaving = JSON.parse(sessionStorageService.get(keyConstService.getTransactionIdWithoutSaving));
                getQuestionSetWithoutSaving = sessionStorageService.get(keyConstService.getQuestionSetWithoutSaving);
                getParsedQuestionSetWithoutSaving = JSON.parse(getQuestionSetWithoutSaving);
                vm.retainValueforQuestion = getParsedQuestionSetWithoutSaving;
                var newBusinessdata = JSON.parse(sessionStorageService.get(keyConstService.newBusinessCaseData));
                if (getParsedQuestionSetWithoutSaving) {
                    if (getQuoteTransactionId == vm.getTransactionIdWithoutSaving) {

                        claimTypeListSelection();

                        vm.policyHolderDateOfBirthApp = angular.copy(getParsedQuestionSetWithoutSaving.PolicyHolder.DateOfBirthApp);
                        if (newBusinessdata) {
                            vm.state.PaymentFrequency.ModeOfPayment = newBusinessdata.data.ModeOfPayment ? newBusinessdata.data.ModeOfPayment : newBusinessdata.data.PaymentFrequency;
                            vm.state.PaymentFrequency.DayofInstallment = vm.state.PaymentFrequency.ModeOfPayment.toUpperCase() === 'MONTHLY' ? newBusinessdata.data.InstallmentDate : 0;
                        }
                        vm.selectedMannualAddress = getParsedQuestionSetWithoutSaving.PropertyDetail.AddressText;                       
                        if (getParsedQuestionSetWithoutSaving.PropertyDetail.IsManualAddress == true) {
                            vm.selectedAddress = null;
                            vm.state.PropertyDetail.AddressLine1 = getParsedQuestionSetWithoutSaving.PropertyDetail.AddressLine1;
                            vm.selectedMannualAddress = getParsedQuestionSetWithoutSaving.PropertyDetail.AddressText;
                        }
                        else {
                            vm.selectedAddress = getParsedQuestionSetWithoutSaving.PropertyDetail.AddressText;
                        }

                        var splitSate = getParsedQuestionSetWithoutSaving.PropertyDetail.AddressValue.split('|');
                        vm.storeAddress = splitSate[0];
                        vm.getAddressState = splitSate[0];
                        if (vm.getAddressState) {
                            if ((qStartDate < qCheckDate) && (vm.getAddressState.toUpperCase() === "WA" || vm.getAddressState.toUpperCase() === "ACT" || vm.getAddressState.toUpperCase() === "TAS")) {
                                vm.showDomesticWorkerCompensation = true;
                                vm.state.OptionalCover.IsDomesticWorkerCompensation = getParsedQuestionSetWithoutSaving.OptionalCover.IsDomesticWorkerCompensation;
                            }
                            else {
                                vm.showDomesticWorkerCompensation = false;
                                vm.state.OptionalCover.IsDomesticWorkerCompensation = null;
                            }
                        }

                        //// building and content cover enable disable on previous next
                        if (getParsedQuestionSetWithoutSaving.PropertyDetail.BuildingType === keyConstService.Apartments ||
                            getParsedQuestionSetWithoutSaving.PropertyDetail.BuildingType === keyConstService.OtherDwellingType ||
                            (getParsedQuestionSetWithoutSaving.PropertyDetail.BuildingType === keyConstService.SemiDetachedHome && getParsedQuestionSetWithoutSaving.PropertyDetail.IsStrataManagement) ||
                            (getParsedQuestionSetWithoutSaving.PropertyDetail.BuildingType === keyConstService.MultipleUnits && getParsedQuestionSetWithoutSaving.PropertyDetail.IsStrataManagement === true) ||
                            (getParsedQuestionSetWithoutSaving.PropertyDetail.BuildingType === keyConstService.MultipleUnits && getParsedQuestionSetWithoutSaving.PropertyDetail.AllOwnedByInsured === false)) {
                            vm.disableBuilding = true;
                            vm.disableContent = true;
                        }

                        //// check if roof and wall is present in list , if not present set to null
                        CheckRoofANdWallValuePresentInDropDown();
                    }
                    if (vm.state.ContentsSumInsured.IsValuableContent) {
                        for (var i = 0; i < getParsedQuestionSetWithoutSaving.ContentsSumInsured.ValuableContents.length; i++) {
                            defaultValueForSpecialContent(null, getParsedQuestionSetWithoutSaving.ContentsSumInsured.ValuableContents[i].Value, i);
                        }
                    }

                    }
                else {
                    if (landlordStandardData.LandlordStandardQuestion.PropertyDetail.IsManualAddress) {
                        vm.selectedMannualAddress = landlordStandardData.LandlordStandardQuestion.PropertyDetail.AddressText;
                        vm.state.PropertyDetail.AddressLine1 = landlordStandardData.LandlordStandardQuestion.PropertyDetail.AddressLine1;
                    }
                    else {
                        vm.selectedAddress = landlordStandardData.LandlordStandardQuestion.PropertyDetail.AddressText;
                    }
                }

                var endorsementDataVM = JSON.parse(sessionStorageService.get(keyConstService.endorsementRequestVM));
                {
                    if (endorsementDataVM) {
                        vm.policyEffectiveDate = moment(endorsementDataVM.StartDate).format('MM/DD/YYYY');
                        vm.endorsementEffectiveDate = endorsementDataVM.EndorsementEffectiveDate;
                        if (vm.policyEffectiveDate === vm.endorsementEffectiveDate) {
                            vm.addressValue = JSON.parse(sessionStorageService.get(keyConstService.AddressValue));
                            if (vm.addressValue && getQuoteTransactionId !== vm.getTransactionIdWithoutSaving && getQuoteTransactionId !== undefined && vm.getTransactionIdWithoutSaving) {
                                var splitSate = vm.addressValue.split('|');
                                vm.storeAddress = splitSate[0];
                                vm.AddressState = splitSate[0];
                               
                            }
 
                            vm.IsEndorsementPolicyEffectiveDate = false;
                            var isEndorsementEdit = JSON.parse(sessionStorageService.get(keyConstService.IsNewEditTransaction));
                            if (isEndorsementEdit) {
                                if (getParsedQuestionSetWithoutSaving) {
                                    vm.state.UnderwritingCriteria.HasInsuredInLast3Years = getParsedQuestionSetWithoutSaving.UnderwritingCriteria.HasInsuredInLast3Years
                                    vm.state.UnderwritingCriteria.InsuredInLast3YearsData = getParsedQuestionSetWithoutSaving.UnderwritingCriteria.InsuredInLast3YearsData;
                                    vm.state.Claims.IsClaimsInLast3Years = getParsedQuestionSetWithoutSaving.Claims.IsClaimsInLast3Years;
                                    vm.state.Claims.ClaimsList = getParsedQuestionSetWithoutSaving.Claims.ClaimsList;
                                }
                            }
                        }
                        else {
                            vm.IsEndorsementPolicyEffectiveDate = true;
                            var newBusinessQuestionsForEndorsement = quotesService.getQuestionSetForPolicy(landlordStandardData.PolicyId)
                                .then(function (result) {
                                    var questionsSet = JSON.parse(result.data.requestContent);
                                    vm.state.UnderwritingCriteria.HasInsuredInLast3Years = questionsSet.UnderwritingCriteria.HasInsuredInLast3Years
                                    vm.state.UnderwritingCriteria.InsuredInLast3YearsData = questionsSet.UnderwritingCriteria.InsuredInLast3YearsData;
                                    vm.state.Claims.IsClaimsInLast3Years = questionsSet.Claims.IsClaimsInLast3Years;
                                    vm.state.Claims.ClaimsList = questionsSet.Claims.ClaimsList;
                                });
                        }
                    }
                }
       
                if (!vm.IsEndorsement && getQuoteTransactionId !== vm.getTransactionIdWithoutSaving) {
                    if (vm.AddressState) {
                        if ((qStartDate < qCheckDate) && (vm.AddressState.toUpperCase() === "WA" || vm.AddressState.toUpperCase() === "ACT" || vm.AddressState.toUpperCase() === "TAS")) {
                            vm.showDomesticWorkerCompensation = true;
                            vm.state.OptionalCover.IsDomesticWorkerCompensation = vm.state.OptionalCover.IsDomesticWorkerCompensation;

                        }
                        else {
                            vm.showDomesticWorkerCompensation = false;
                            vm.state.OptionalCover.IsDomesticWorkerCompensation = null;
                        }
                    }

                }
                if (vm.IsEndorsement && getQuoteTransactionId !== vm.getTransactionIdWithoutSaving) {
                    endorsementState = angular.copy(vm.state);
                    if (vm.AddressState) {
                        if ((qStartDate < qCheckDate) && (vm.AddressState.toUpperCase() === "WA" || vm.AddressState.toUpperCase() === "ACT" || vm.AddressState.toUpperCase() === "TAS")) {
                            vm.showDomesticWorkerCompensation = true;
                            vm.state.OptionalCover.IsDomesticWorkerCompensation = vm.state.OptionalCover.IsDomesticWorkerCompensation ;

                        }
                        else {
                            vm.showDomesticWorkerCompensation = false;
                            vm.state.OptionalCover.IsDomesticWorkerCompensation  = null;
                        }
                    }
                }
                if (vm.IsRentDefaultChanges) {
                    vm.rentDefaultEndorsementConditions();
                    vm.OnRentDefaulChildQuestionChange();
                }

                if (vm.state.Claims.IsClaimsInLast3Years) {
                    for (var i = 0; i < vm.state.Claims.ClaimsList.length; i++) {

                        if (vm.state.Claims.ClaimTypeList.filter(x => x.Value == vm.state.Claims.ClaimsList[i].ClaimType).length == 0)
                            vm.state.Claims.ClaimsList[i].ClaimType = vm.state.Claims.ClaimsList[i].CostOfClaim = null;


                        if (vm.state.Claims.ClaimsList[i].ClaimYear == null || vm.state.Claims.ClaimsList[i].ClaimType == null)
                            vm.checkNullClaimList = true;
                    }
                }
                if (vm.ReadOnly == true) {
                    sessionStorageService.set(keyConstService.IsNewBusinessReadOnly, landlordStandardData.IsReadOnly);
                }
                var startDate = landlordStandardData.StartDate;
                if (sessionStorageService.get(keyConstService.newBusinessCaseData) != null) {
                    var newBusinessCaseDetail = JSON.parse(sessionStorageService.get(keyConstService.newBusinessCaseData));
                    vm.EffectiveDate = newBusinessCaseDetail.data.EffectiveDate;
                    ExpirationDate = newBusinessCaseDetail.data.ExpirationDate;
                    startDate = newBusinessCaseDetail.data.EffectiveDate;
                }
                else {
                    vm.EffectiveDate = landlordStandardData.EffectiveDate;
                    ExpirationDate = landlordStandardData.ExpirationDate;
                }
                
               
                if (!sessionStorageService.get(keyConstService.IsNewEditTransaction)) {
                    var isEdit = JSON.parse(sessionStorageService.get(keyConstService.IsNewEditTransaction));
                    if (isEdit !== false && JSON.parse(sessionStorageService.get(keyConstService.IsCopyQuote)) != true) {
                        isNewEditTransaction = true;
                        sessionStorageService.set(keyConstService.IsNewEditTransaction, isNewEditTransaction);
                    }
                }
              
                if (landlordStandardData.Status == "Draft") {

                    vm.searchText = null;
                    vm.mannualSearchText = null;
                }
                if (vm.state.PolicyHolder.ContentCover == true) {
                    if (vm.state.ContentsSumInsured.GeneralContentSumInsured == 0) {
                        vm.ContentSiFlag = true;
                    }
                }
                if (vm.state.PolicyHolder.BuildingCover == true) {
                    if (vm.state.CordellResponse.BuildingSumInsured == 0) {
                        vm.BuildingSiFlag = true;
                    }
                }
                var convertContentSumInsuredToInt = parseInt(landlordStandardData.LandlordStandardQuestion.ContentsSumInsured.ContentsSumInsured);
                landlordStandardData.LandlordStandardQuestion.ContentsSumInsured.ContentsSumInsured = convertContentSumInsuredToInt;
                if (landlordStandardData.LandlordStandardQuestion.ContentsSumInsured.ContentsSumInsured !== 0) {
                    vm.isNullContentInsured = false;
                }
                sessionStorageService.set(keyConstService.rowVersion, landlordStandardData.RowVersion);
                sessionStorageService.set(keyConstService.caseId, landlordStandardData.QuoteCase.Id);
                caseId = sessionStorageService.get(keyConstService.caseId);

                if (vm.endorsementVM) {
                    sessionStorageService.set(keyConstService.quoteTransactionId, landlordStandardData.QuoteTransactionId);
                    if (!(getQuoteTransactionId == vm.getTransactionIdWithoutSaving && getParsedQuestionSetWithoutSaving)) {
                        vm.state.Excess.BuildingExcess1 = vm.endorsementVM.BuildingExcess;
                        vm.state.Excess.BuildingExcess2 = null;
                        vm.state.Excess.BuildingExcess3 = null;
                        vm.state.Excess.ContentExcess2 = null;
                        vm.state.Excess.ContentExcess3 = null;
                        vm.state.Excess.ContentExcess1 = vm.endorsementVM.ContentExcess;
                    }
                }
                else if (vm.landlordStandardData.DDlProcessTypeId === 4) {
                    if (vm.landlordStandardData.LandlordStandardQuestion.CuppingCappingFactor.ExpirationBuildingExcess !== null) {
                        var buildingExcessCount = 0;
                        if (vm.landlordStandardData.LandlordStandardQuestion.Excess.BuildingExcess1 !== null)
                            buildingExcessCount++;
                        if (vm.landlordStandardData.LandlordStandardQuestion.Excess.BuildingExcess2 !== null)
                            buildingExcessCount++;
                        if (vm.landlordStandardData.LandlordStandardQuestion.Excess.BuildingExcess3 !== null)
                            buildingExcessCount++;
                        if (buildingExcessCount === 1) {
                            if (vm.landlordStandardData.LandlordStandardQuestion.Excess.BuildingExcess1 !== null)
                                vm.state.Excess.BuildingExcess1 = vm.landlordStandardData.LandlordStandardQuestion.Excess.BuildingExcess1;
                            else if (vm.landlordStandardData.LandlordStandardQuestion.Excess.BuildingExcess2 !== null)
                                vm.state.Excess.BuildingExcess1 = vm.landlordStandardData.LandlordStandardQuestion.Excess.BuildingExcess2;
                            else if (vm.landlordStandardData.LandlordStandardQuestion.Excess.BuildingExcess3 !== null)
                                vm.state.Excess.BuildingExcess1 = vm.landlordStandardData.LandlordStandardQuestion.Excess.BuildingExcess3;
                            vm.state.Excess.BuildingExcess2 = null;
                            vm.state.Excess.BuildingExcess3 = null;
                        }
                    }
                    if (vm.landlordStandardData.LandlordStandardQuestion.CuppingCappingFactor.ExpirationContentExcess !== null) {
                        var contentExcessCount = 0;
                        if (vm.landlordStandardData.LandlordStandardQuestion.Excess.ContentExcess1 !== null)
                            contentExcessCount++;
                        if (vm.landlordStandardData.LandlordStandardQuestion.Excess.ContentExcess2 !== null)
                            contentExcessCount++;
                        if (vm.landlordStandardData.LandlordStandardQuestion.Excess.ContentExcess3 !== null)
                            contentExcessCount++;
                        if (contentExcessCount === 1) {
                            if (vm.landlordStandardData.LandlordStandardQuestion.Excess.ContentExcess1 !== null)
                                vm.state.Excess.ContentExcess1 = vm.landlordStandardData.LandlordStandardQuestion.Excess.ContentExcess1;
                            else if (vm.landlordStandardData.LandlordStandardQuestion.Excess.ContentExcess2 !== null)
                                vm.state.Excess.ContentExcess1 = vm.landlordStandardData.LandlordStandardQuestion.Excess.ContentExcess2;
                            else if (vm.landlordStandardData.LandlordStandardQuestion.Excess.ContentExcess3 !== null)
                                vm.state.Excess.ContentExcess1 = vm.landlordStandardData.LandlordStandardQuestion.Excess.ContentExcess3;
                            vm.state.Excess.ContentExcess2 = null;
                            vm.state.Excess.ContentExcess3 = null;
                        }
                    }
                }

                sessionStorageService.set(keyConstService.caseNumber, vm.CaseNumber);
                vm.getNewBusinessCaseData = sessionStorageService.get(keyConstService.newBusinessCaseData);
                vm.getNewBusinessCaseData = JSON.parse(sessionStorageService.get(keyConstService.newBusinessCaseData));
                sessionStorageService.set(keyConstService.newBusinessData, vm.getNewBusinessCaseData);
                IsNewBusinessEdit = sessionStorageService.get(keyConstService.IsNewBusinessEdit);

                sessionStorageService.remove(keyConstService.quoteTransactionId);
                sessionStorageService.set(keyConstService.quoteTransactionId, landlordStandardData.QuoteTransactionId);
                if (landlordStandardData.LandlordStandardQuestion.PropertyDetail.AddressText != null && !landlordStandardData.LandlordStandardQuestion.PropertyDetail.IsManualAddress && landlordStandardData.Status != "Draft" && getQuoteTransactionId != vm.getTransactionIdWithoutSaving) {
                    vm.selectedAddress = landlordStandardData.LandlordStandardQuestion.PropertyDetail.AddressText;
                    vm.selectAddress = landlordStandardData.LandlordStandardQuestion.PropertyDetail.AddressValue;
                }

                if (vm.IsEndorsement) {
                    if (vm.state.PropertyDetail.IsManualAddress == false) {
                        vm.state.PropertyDetail.AddressLine1 = null;
                        vm.selectedMannualAddress = null;
                    }

                    endorsementPropertyData = angular.copy(vm.state.CordellResponse.Propertydata);
                }

                var occupancyType = landlordStandardData.LandlordStandardQuestion.PolicyHolder.HomeOccupancyType;
                var isEdit = sessionStorageService.get(keyConstService.IsNewEditTransaction);

                //// enabling disabling building content cover once a saved quote is open
                if (isEdit !== false && (occupancyType === "Renting" ||
                    vm.state.PropertyDetail.BuildingType === keyConstService.Apartments ||
                    vm.state.PropertyDetail.BuildingType === keyConstService.OtherDwellingType ||
                    (vm.state.PropertyDetail.BuildingType === keyConstService.SemiDetachedHome && vm.state.PropertyDetail.IsStrataManagement) ||
                    (vm.state.PropertyDetail.BuildingType === keyConstService.MultipleUnits && vm.state.PropertyDetail.IsStrataManagement === true) ||
                    (vm.state.PropertyDetail.BuildingType === keyConstService.MultipleUnits && vm.state.PropertyDetail.AllOwnedByInsured === false))) {
                    vm.disableBuilding = true;
                    vm.disableContent = true;
                }
                
                var productName = landlordStandardData.LOB;
                var brokerCommissionRequestOnEdit = quotesService.getBrokerCommissiononEdit({
                    EffectiveDate: startDate,
                    ProductName: productName,
                    ProductId: null,
                })
                    .then(function (result) {
                        vm.data = result.data.brokerBranchCommissionFeeVM;
                        if (vm.data) {
                            for (var i = 0; i < vm.data.length; i++) {
                                if (vm.state.PolicyHolder.BuildingCover && !vm.state.PolicyHolder.ContentCover) {
                                    if (vm.data[i].coverCode === "BUILDING") {
                                        vm.maxbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMax;
                                        vm.minbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMin;
                                    }
                                }
                                if (!vm.state.PolicyHolder.BuildingCover && vm.state.PolicyHolder.ContentCover) {
                                    if (vm.data[i].coverCode === "CONTENT") {
                                        vm.maxbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMax;
                                        vm.minbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMin;
                                    }
                                }
                                if (vm.state.PolicyHolder.BuildingCover && vm.state.PolicyHolder.ContentCover) {
                                    if (vm.data[i].coverCode === "BUILDING,CONTENT") {
                                        vm.maxbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMax;
                                        vm.minbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMin;
                                    }
                                }
                                if (!vm.ReadOnly && !vm.IsEndorsement) {
                                    vm.checkBrkerCommissionLimit();
                                }
                            }

                            if (getQuoteTransactionId === vm.getTransactionIdWithoutSaving && vm.getTransactionIdWithoutSaving !== null && getQuoteTransactionId !== null) {
                                vm.state.PolicyHolder.DateOfBirthApp = vm.policyHolderDateOfBirthApp;
                            }
                        }
                    })
                SetCordelFields();
                if (JSON.parse(sessionStorageService.get(keyConstService.IsCopyQuote)) !== true) {
                    vm.getSecondaryInsuredList(landlordStandardData.LandlordStandardQuestion.PolicyHolder.DateOfBirthApp);
                }

                if (vm.state.ContentsSumInsured.IsValuableContent && sessionStorageService.get(keyConstService.specialContentvalidity) && landlordStandardData.Status !== "Draft") {
                    vm.parseSpecialContentvalidity = JSON.parse(sessionStorageService.get(keyConstService.specialContentvalidity))
                    for (i = 0; i < vm.parseSpecialContentvalidity.length; i++) {
                        if (vm.parseSpecialContentvalidity[i].IsValid === true) {
                            vm.setSpecialContentValidity = false;
                        }
                        else
                        {
                            vm.setSpecialContentValidity = true;
                        }

                    }
                }

                if (landlordStandardData.Status === "Draft" && getQuoteTransactionId !== vm.getTransactionIdWithoutSaving) {
                    if (landlordStandardData.LandlordStandardQuestion.ContentsSumInsured.ValuableContents &&
                        landlordStandardData.LandlordStandardQuestion.ContentsSumInsured.ValuableContents[0].Value) {
                        for (var i = 0; i < landlordStandardData.LandlordStandardQuestion.ContentsSumInsured.ValuableContents.length; i++)
                        {
                            if (landlordStandardData.LandlordStandardQuestion.ContentsSumInsured.ValuableContents[i].Value < 20000)
                                vm.state.ContentsSumInsured.ValuableContents[i].IsValid = true;
                            vm.setSpecialContentValidity = true;
                        }
                    }
                }

                //retaining Claims state on previous/next
                vm.checkClaims();
                vm.checkWeeklyRentalAmount(vm.state.OptionalCover.WeeklyRentalAmount);
                // checking for duplicate excess in case of previous/next
                vm.isDuplicateExcess();

                if (vm.state.PolicyHolder.ContentCover) {
                    vm.checkSumInsuredValue();
                }
                checkDefaultBuildingSumInsured(vm.state.CordellResponse.BuildingSumInsured);
                BuildingSumInsuredRange(vm.state.CordellResponse.BuildingSumInsured);

                if (vm.state.PolicyHolder.AdditionalPolicyHolderList.length !== 0 && vm.state.PolicyHolder.AdditionalPolicyHolderList[0].OtherDateOfBirthApp != null) {
                    for (var i = 0; i < vm.state.PolicyHolder.AdditionalPolicyHolderList.length; i++) {
                        if (vm.state.PolicyHolder.AdditionalPolicyHolderList[i].AdditionalDateOfBirth === "Other") {
                            var dateofBirth = vm.state.PolicyHolder.AdditionalPolicyHolderList[i].OtherDateOfBirthApp;
                            var response = dateService.validateBirthDDMMYYYY(dateofBirth, 115);
                            if (!response.isValid) {
                                vm.validDOBOtherInsurer = false;
                                vm.message = response.errorMsg;
                                break;
                            }
                            else {
                                vm.validDOBOtherInsurer = true;
                            }
                        }
                        else {
                            break;
                        }
                    }
                    if (!vm.validDOBOtherInsurer && vm.message === messageConstService.errFutureDateNotAllowed) {
                        toastr.warning(messageConstService.errFutureDatedForAddHolder);
                    }
                    else if (!vm.validDOBOtherInsurer && vm.message === messageConstService.errDateNotAllowed) {
                        toastr.warning(messageConstService.errDateNotAllowed);
                    }
                }

                if (vm.state.ContentsSumInsured.IsValuableContent || vm.state.ContentsSumInsured.GeneralContentSumInsured > keyConstService.LLContentSumInsuredLimit)
                    doorChecked();

                // removing questionset from session for valid newbusiness quote
                if (!getParsedQuestionSetWithoutSaving) {
                    sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
                }                                

                var isCopyQuote = JSON.parse(sessionStorageService.get(keyConstService.IsCopyQuote));
                if (!IsNewBusinessEdit && !isCopyQuote) {
                    sessionStorageService.remove(keyConstService.newBusinessCaseData);
                }
                else {
                    if (vm.getNewBusinessCaseData) {
                        vm.landlordStandardData.PackageDetail.PaymentFrequency = vm.getNewBusinessCaseData.data.PaymentFrequency;
                        vm.landlordStandardData.PackageDetail.InstallmentDate = vm.getNewBusinessCaseData.data.InstallmentDate;
                    }
                }

                // set buildingsiflag = true in case of edit if vm.state.PolicyHolder.BuildingCover and vm.state.CordellResponse. is not null :- bug 2295
                if (vm.state.PolicyHolder.BuildingCover && !vm.state.CordellResponse.BuildingSumInsured) {
                    vm.BuildingSiFlag = true;
                }
                getInsuredNameList(true);
                if (vm.version < keyConstService.Version) {
                    //// resets rennovation start and end date back to the format for it to be visible on UI
                    if (vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate) {
                        vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate = utilityService.ConvertDateTimeForUi(vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate);
                    }
                    if (vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate) {
                        vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate = utilityService.ConvertDateTimeForUi(vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate);
                    }
                }
            }

            vm.state.PaymentFrequency.ModeOfPayment = vm.landlordStandardData.PackageDetail.PaymentFrequency;
            vm.state.PaymentFrequency.DayofInstallment = 0;
            if (vm.state.PaymentFrequency.ModeOfPayment === 'Monthly') {
                vm.state.PaymentFrequency.DayofInstallment = vm.landlordStandardData.PackageDetail.InstallmentDate;
            }
            vm.previousAddressLine1ForIllion = vm.state.PropertyDetail.AddressLine1;
            //// if call Illion API if copy quote or Edit or endorsement quote when IsIllionCallOnEdit is true
            if ((vm.IsEndorsement == false || vm.landlordStandardData.DDlProcessTypeId != 4) && (vm.IsEndorsement == false && vm.landlordStandardData.DDlProcessTypeId != 4)) {

                if (JSON.parse(sessionStorageService.get(keyConstService.IsCopyQuote)) || (vm.landlordStandardData.IsIllionCallOnEdit && (JSON.parse(sessionStorageService.get(keyConstService.IsNewEditTransaction)) || vm.IsEndorsement))) {
                    vm.state.IllionClaimResponse = null;
                    vm.state.IllionClaimResponseId = null;
                    vm.getAdressEnquiryDetails();
                }
            }
            // updating claims data after changing effective date
            quotesService.updateClaimsInfo(vm.state.Claims);
            // retaining claims validation on previous/next
            vm.checkClaims();

            //disable getquote if insured name is not in list
            if (vm.state.PolicyHolder.InsuredName !== "Other") {
                var existInsuredName = utilityService.valueExistsInArray(vm.state.PolicyHolder.InsuredName, vm.state.PolicyHolder.InsuredNameList);
                if (!existInsuredName) {
                    vm.disableButtons = true;
                }
            }

            if (vm.version < keyConstService.Version) {
                // enable building and content cover if version is less than 2.0
                 vm.disableBuilding = false;
                 vm.disableContent = false;
            }

                // for additional insured
                //checkAdditionalInsuredInList();
        };
        //end of init

        function rentDefaultEndorsementConditions() {
            vm.ishide = false;
            vm.isdisable = false;
            if (vm.tempLandlordStandardData.QuoteCase !== null && vm.tempLandlordStandardData.QuoteCase.RenewalCounter > 0) {
                vm.ishide = true;
            }      
            else if (vm.IsEndorsementPolicyEffectiveDate) {
                if (vm.LastBoundRentDefaultAnswers!==null && vm.LastBoundRentDefaultAnswers.IsRentDefault) {
                    vm.ishide = !vm.state.OptionalCover.IsRentDefault;
                    vm.isdisable = vm.state.OptionalCover.IsRentDefault;
                    if (vm.state.OptionalCover.IsRentDefault) {
                        vm.state.OptionalCover.IsStatementForRentDefault = vm.LastBoundRentDefaultAnswers.IsStatementForRentDefault;
                        vm.state.OptionalCover.IsPropertyStatementForRentDefault = vm.LastBoundRentDefaultAnswers.IsPropertyStatementForRentDefault;
                    }
                    else {
                        vm.state.OptionalCover.IsStatementForRentDefault = null;
                        vm.state.OptionalCover.IsPropertyStatementForRentDefault = null;
                    }
                }
                else {
                    vm.ishide = true;
                    vm.state.OptionalCover.IsStatementForRentDefault = null;
                    vm.state.OptionalCover.IsPropertyStatementForRentDefault = null;
                }
            }
            if (vm.ReadOnly && vm.state.OptionalCover.IsStatementForRentDefault === null && vm.state.OptionalCover.IsPropertyStatementForRentDefault === null) {
                vm.ishide = true;
            }
            }

        function Back() {
            var isactivePM = sessionStorageService.get('IsPackageManagerNavigationMode');
            if (isactivePM === "true") {
                sessionStorageService.set(keyConstService.IsPackageManagerNavigationMode, "preTrue");
            }
            vm.disableButtons = true;
            if (vm.IsEndorsement) {
                if (vm.state.PropertyDetail.IsManualAddress === false) {
                    vm.selectedMannualAddress = null;
                    vm.state.PropertyDetail.AddressLine1 = null;
                }
                sessionStorageService.set(keyConstService.AddressValue, vm.state.PropertyDetail.AddressValue)
            }
            sessionStorageService.remove(keyConstService.resetNonRegoData);
            sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
            sessionStorageService.remove(keyConstService.isManualRegoEnabled);
            getQuestionSetWithoutSaving = sessionStorageService.set(keyConstService.getQuestionSetWithoutSaving, vm.state);
            var quoteTransactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
            sessionStorageService.get(keyConstService.newBusinessCaseData);
            sessionStorageService.set(keyConstService.sessionStorageState, true);
            getTransactionIdWithoutSaving = sessionStorageService.set(keyConstService.getTransactionIdWithoutSaving, quoteTransactionId);
            var transactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
            sessionStorageService.set(keyConstService.IllionAddressEnquiry, true);
            if (vm.IsEndorsement) {
                window.location = webUrlConstService.endorsementRequest + sessionStorageService.getEncryption("quoteTransactionId=" + transactionId);
            }
            else {
                if (sessionStorageService.get(keyConstService.IsNewEditTransaction) !== "true") {
                    sessionStorageService.set(keyConstService.IsNewEditTransaction, isNewEditTransaction);
                }
                window.location = webUrlConstService.newBusinessIndex + sessionStorageService.getEncryption("transactionId=" + transactionId);
            }

        }
        //diabling building cover version 2
        function disablecover(field) {
           
            if (vm.state.PropertyDetail.BuildingType !== null) {
                //// making building si 0 when building type or dependent questions are clicked
                if (vm.state.PolicyHolder.BuildingCover === true) {
                    if (vm.landlordStandardData.DDlProcessTypeId !== 4)
                        vm.state.CordellResponse.BuildingSumInsured = 0;
                    vm.state.CordellResponse.BuildingSumInsuredEstimate = 0;
                    if (vm.landlordStandardData.DDlProcessTypeId !== 4)
                        vm.BuildingSiFlag = true;
                    else
                        vm.BuildingSiFlag = false;
                }

                if (vm.state.PropertyDetail.BuildingType === keyConstService.Apartments || vm.state.PropertyDetail.BuildingType === keyConstService.OtherDwellingType) {
                    vm.state.PolicyHolder.BuildingCover = false;
                    vm.state.PolicyHolder.ContentCover = true;
                    vm.disableBuilding = true;
                    vm.disableContent = true;
                    vm.BuildingSiFlag = false;
                    vm.resetValuesOnBuildingCoverFalse();
                    vm.ResetBuildingSumInsureforV2(field);
                    DefaultContentExcessOnCoverChange();
                }
                else if (vm.state.PropertyDetail.BuildingType === keyConstService.SemiDetachedHome && vm.state.PropertyDetail.IsStrataManagement) {
                    vm.state.PolicyHolder.BuildingCover = false;
                    vm.state.PolicyHolder.ContentCover = true;
                    vm.disableBuilding = true;
                    vm.disableContent = true;
                    vm.BuildingSiFlag = false;
                    vm.resetValuesOnBuildingCoverFalse();
                    vm.ResetBuildingSumInsureforV2(field);
                    DefaultContentExcessOnCoverChange();
                }
                else if (vm.state.PropertyDetail.BuildingType === keyConstService.MultipleUnits && (vm.state.PropertyDetail.IsStrataManagement === true || vm.state.PropertyDetail.AllOwnedByInsured === false)) {
                    vm.state.PolicyHolder.BuildingCover = false;
                    vm.state.PolicyHolder.ContentCover = true;
                    vm.disableBuilding = true;
                    vm.disableContent = true;
                    vm.BuildingSiFlag = false;
                    vm.resetValuesOnBuildingCoverFalse();
                    vm.ResetBuildingSumInsureforV2(field);
                }
                else {
                    vm.disableBuilding = false;
                    vm.disableContent = false;
                }
            }
        }

        function ResetBuildingSumInsureforV2(field) {
            field.$setValidity('validcurrency', true);
        }

        //function to set values to null on Building cover false
        function resetValuesOnBuildingCoverFalse() {
            if (vm.version >= keyConstService.Version) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsHomeUnderConstructionRenovation = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsPoorlyMaintainedProperty = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsPropertyHeriatgeListed = null;
                vm.ResetHomeConstructionSection();
                vm.ResetHeritageSection();
            }

        }

        function BindBuildingType(value) {
            vm.state.PropertyDetail.BuildingType = value;
        }

        function BindBuiltOnType(value) {
            vm.state.PropertyDetail.BuiltOn = value;
        }
        function BindApartmentType(value) {
            vm.state.PropertyDetail.ApartmentType = value;
        }

        function BindSemiDetached(value) {
            vm.state.PropertyDetail.SemiDetachedHomeType = value;
        }

        function BindOtherDwellingType(value) {
            vm.state.PropertyDetail.OtherDwellingTypeHome = value;
        }

        //reset function for buildingType version 2
        vm.resetBuildingType = function (value, bindvalue) {
            if (value !== bindvalue) {
                vm.state.PropertyDetail.BuiltOn = null;
                vm.state.PropertyDetail.ApartmentType = null;
                vm.state.PropertyDetail.SemiDetachedHomeType = null;
                vm.state.PropertyDetail.IsStrataManagement = null;
                vm.state.PropertyDetail.OtherDwellingTypeHome = null;
                vm.state.PropertyDetail.AllOwnedByInsured = null;
                vm.state.PropertyDetail.NumberOfUnitsOrResidencesToBeInsured = null;
                vm.state.PropertyDetail.ListOfUnitsOrResidencesRequiringCoverage = null;
            }
        };

        //reset function for Other section version 2
        vm.resetOthersection = function () {
            if (!vm.state.OtherInfo.PolicyHolderHoldInsurance)
                vm.state.OtherInfo.PeriodOfInsuranceHoldByPolicyholder = null;
        };

        vm.resetmultipleunitssection = function () {
            vm.state.PropertyDetail.ListOfUnitsOrResidencesRequiringCoverage = null;
        };

        vm.Cancel = function () {
            vm.disableButtons = true;
            if (vm.IsEndorsement) {
                quotesService.quoteDiscardRequest(sessionStorageService.get(keyConstService.quoteTransactionId)).then(function (result) {
                    if (result.data) {
                        if (vm.showManagePkg) {
                            vm.packageNumber = sessionStorageService.get('PackageNumberInformation');
                            vm.renewalCounter = sessionStorageService.get('RenewalCounter');
                            sessionStorageService.remove('IsPackageManagerNavigationMode');
                            sessionStorageService.remove('PackageNumberInformation');
                            sessionStorageService.remove('RenewalCounter');
                            $window.location.href = webUrlConstService.getPackageInfo + sessionStorageService.getEncryption("packageNumber=" + JSON.parse(vm.packageNumber) + "&&renewalCounter=" + vm.renewalCounter);
                        }
                        else {
                            $timeout(function () {
                                var Id = vm.dataState.PolicyId;
                                window.location = "/Bind?" + sessionStorageService.getEncryption("id=" + Id);
                            }, 1000);
                        }
                    } else {
                        toastr.error(messageConstService.errServiceUnavailable);
                        vm.disableButtons = false;
                    }
                },
                    function (error) {
                        $log.error('error', error);
                        toastr.error(messageConstService.errServiceUnavailable);
                        vm.disableButtons = false;
                    });
            }
            else {
                $window.location = webUrlConstService.homeIndex;
            }
        }

        vm.addSecondaryInsured = function () {
            vm.state.PolicyHolder.AdditionalPolicyHolderList.push({ AdditionalPolicyHolder: null, AdditionalDateOfBirth: null, AdditionalPolicyHolderType: null, OtherPolicyHolderName: null, OtherDateOfBirth: null });
            vm.AdditionalPolicyHolderListLength = vm.state.PolicyHolder.AdditionalPolicyHolderList.length;
        }

        vm.checkFutureDate = function (length) {             
            var isvalidDOB = true;
            for (var i = 0; i < length; i++) {
                if (vm.state.PolicyHolder.AdditionalPolicyHolderList[i].AdditionalPolicyHolder === "Other") {
                    var dateofBirth = vm.state.PolicyHolder.AdditionalPolicyHolderList[i].OtherDateOfBirthApp;
                    isvalidDOB = dateService.validateBirthDDMMYYYY(dateofBirth, 150);
                    // this code should be working like this
                    if (isvalidDOB.isValid) {
                        vm.validDOBOtherInsurer = true;
                    }
                    else {
                        vm.validDOBOtherInsurer = false;
                        break;
                    }
                }
                else {
                    continue;
                }

            }
        }

        vm.removeSecondaryInsured = function (item) {
            var index = vm.state.PolicyHolder.AdditionalPolicyHolderList.indexOf(item);
            var isvalidDOB = true;
            vm.state.PolicyHolder.AdditionalPolicyHolderList.splice(index, 1);
            vm.AdditionalPolicyHolderListLength = vm.state.PolicyHolder.AdditionalPolicyHolderList.length;
            vm.checkFutureDate();
            // for additional insured
            //checkAdditionalInsuredInList();
        };

        vm.getOtherConvertedDate = function (dob, index, formElement) {
            var dateofBirth = dob;
            vm.validDOBOtherInsurer = false;
            if (dateofBirth) {
                var response = dateService.validateBirthDDMMYYYY(dateofBirth, 150);

                if (!response.isValid) {
                    vm.state.PolicyHolder.AdditionalPolicyHolderList[index].OtherDateOfBirth = '';
                    vm.state.PolicyHolder.OtherDateOfBirthApp = '';
                    formElement.$setValidity("OtherDateOfBirth_", false)
                    toastr.warning(response.errorMsg);
                }
                else {
                    formElement.$setValidity("OtherDateOfBirth_", true)
                }

                vm.state.PolicyHolder.AdditionalPolicyHolderList[index].OtherDateOfBirth = response.date;
                vm.checkFutureDate(vm.state.PolicyHolder.AdditionalPolicyHolderList.length);
            }

        }

        vm.addClaims = function () {
            if (vm.state.Claims.ClaimsList.length <= 6) {
                vm.state.Claims.ClaimsList.push({ ClaimYear: null, ClaimType: null, CostOfClaim: 0 });
            }
            else {
                vm.DisableAddClaim = true;
            }

            if (vm.state.Claims.ClaimsList.length > 1) {
                for (var i = 0; i < vm.state.Claims.ClaimsList.length; i++) {
                    if (vm.state.Claims.ClaimsList[i].ClaimYear == null) {
                        vm.checkNullClaimList = true;
                    }
                    else if (vm.state.Claims.ClaimsList[i].ClaimType == null) {
                        vm.checkNullClaimList = true;
                    }
                }
            }
        }

        vm.checkClaims = function () {
            if (vm.state.Claims.ClaimsList.length >= 1 && vm.state.Claims.IsClaimsInLast3Years) {
                for (var i = 0; i < vm.state.Claims.ClaimsList.length; i++) {
                    if (!vm.state.Claims.ClaimsList[i].ClaimYear) {
                        vm.checkNullClaimList = true;
                    }
                    else if (!vm.state.Claims.ClaimsList[i].ClaimType) {
                        vm.checkNullClaimList = true;
                    }
                }
            }
        }

        vm.removeClaims = function (item) {
            var index = vm.state.Claims.ClaimsList.indexOf(item);
            vm.state.Claims.ClaimsList.splice(index, 1);
            vm.DisableAddClaim = false;
            if (vm.state.Claims.ClaimsList.length <= 1) {
                if (vm.state.Claims.ClaimsList[0].ClaimYear == null) {
                    vm.checkNullClaimList = true;
                    vm.state.Claims.ClaimsList = [{ ClaimYear: null, ClaimType: null, CostOfClaim: 0 }];
                }
            }
        }

        vm.checkRentalAmount = function () {
            vm.invalidRentalAmount = false;
            if (vm.state.PolicyHolder.WeeklyRentalAmount < vm.minRentalAmount || vm.state.PolicyHolder.WeeklyRentalAmount > vm.maxRentalAmount) {
                vm.invalidRentalAmount = true;
            }
        }

        vm.checkBrkerCommissionLimit = function () {
            vm.brokerCommissionLimitMessage = false;
            var regexp = /^[0-9]+(\.[0-9]{1,2})?$/;
            if (!regexp.test(vm.state.BrokerCommission.BrokerCommissionPercentage)) {
                vm.state.BrokerCommission.BrokerCommissionPercentage = null;
                vm.brokerCommissionLimitMessage = true;
            }

            if (vm.state.BrokerCommission.BrokerCommissionPercentage > vm.maxbrokerCommissionPercentage || vm.state.BrokerCommission.BrokerCommissionPercentage < vm.minbrokerCommissionPercentage)
                vm.brokerCommissionLimitMessage = true;
        }

        vm.ResetAdditionalPolicyHolder = function () {
            if (!vm.state.PolicyHolder.IsAdditionalPolicyHolder) {
                vm.state.PolicyHolder.AdditionalPolicyHolderList = [{ AdditionalPolicyHolder: null, OtherPolicyHolderName: null, OtherDateOfBirth: null }];
                vm.validDOBOtherInsurer = true;
            }
            else if (vm.IsEndorsement && vm.state.PolicyHolder.IsAdditionalPolicyHolder && endorsementState != null) {
                vm.state.PolicyHolder.AdditionalPolicyHolderList = angular.copy(endorsementState.PolicyHolder.AdditionalPolicyHolderList);
            }
        }

        vm.IsAdditionalButtonDisabled = function (name, index, nameObj) {
            if (name && !vm.otherreadonly) {
                vm.isSecondaryDisabled = false;
                if (name !== "Other") {
                    nameObj.OtherDateOfBirth = null;
                    nameObj.OtherDateOfBirthApp = null;
                    nameObj.OtherPolicyHolderName = null;
                }
            }

            var duplicateCount = 0;
            //check if the name already exists twice if yes then remove
            vm.state.PolicyHolder.AdditionalPolicyHolderList.forEach(function (ele, index) {
                if (ele.AdditionalPolicyHolder !== "Other" && ele.AdditionalPolicyHolder === name) {
                    duplicateCount++;
                }
            });


            if (duplicateCount > 1) {
                toastr.error(messageConstService.errDuplicatePolicyHolder);
                nameObj.AdditionalPolicyHolder = "";
                return;
            }

            if (vm.otherreadonly && name === "Other" && index === vm.state.PolicyHolder.AdditionalPolicyHolderList.length - 1) {
                if (vm.state.PolicyHolder.AdditionalPolicyHolderList[index].OtherPolicyHolderName === null) {
                    toastr.error("Other is not allowed");
                    nameObj.AdditionalPolicyHolder = "";
                    return;
                }
            }

            for (var i = 0; i < vm.state.PolicyHolder.InsuredNameList.length; i++) {
                if (vm.state.PolicyHolder.InsuredNameList[i].value === name) {

                    for (var j = 0; j < vm.state.PolicyHolder.AdditionalPolicyHolderList.length; j++) {
                        if (vm.state.PolicyHolder.AdditionalPolicyHolderList[j].AdditionalPolicyHolder === name) {
                            vm.state.PolicyHolder.AdditionalPolicyHolderList[j].AdditionalDateOfBirth = vm.state.PolicyHolder.InsuredNameList[i].dateOfBirth;
                            vm.state.PolicyHolder.AdditionalPolicyHolderList[j].AdditionalPolicyHolderType = vm.state.PolicyHolder.InsuredNameList[i].clientType;
                        }
                    }
                }
            }

            //checkAdditionalInsuredInList();

            if (name === 'OtherInsured') {
                vm.AdditionalPolicyHolderIndex = index;
                angular.element('#add-insured').modal('show');
            }
            else if (name != "OtherInsured") {
                vm.tempAdditonalPolicyHolders = angular.copy(vm.state.PolicyHolder.AdditionalPolicyHolderList);
            }
        }

        vm.ResetHasInsuredInLast3YearsSection = function () {
            if (!vm.state.UnderwritingCriteria.HasInsuredInLast3Years) {
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsEverInsuranceDeclined = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.AnyInsurancePolicyCancelledOrDeclinedInPreviousYears = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.NoOfCancellationOrDeclinationOccurredInPreviousYearsForInsured = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.CancellationReason = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsCriminalConvictionFraudTheftBurglaryArson = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsClaimDeclinedIn3Years = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.ReasonClaimDeclinedIn3Years = null;
            }
            else {
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsEverInsuranceDeclined = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.AnyInsurancePolicyCancelledOrDeclinedInPreviousYears = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsCriminalConvictionFraudTheftBurglaryArson = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsClaimDeclinedIn3Years = null;

            }
        }

        vm.ResetInsurancePolicyCancelledSection = function () {
            vm.state.UnderwritingCriteria.InsuredInLast3YearsData.NoOfCancellationOrDeclinationOccurredInPreviousYearsForInsured = null;
            vm.state.UnderwritingCriteria.InsuredInLast3YearsData.CancellationReason = null;
        }

        vm.ResetDeclineSection = function () {
            if (!vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsEverInsuranceDeclined) {
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.ReasonEverInsuranceDeclined = null;
            }
            if (!vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsClaimDeclinedIn3Years) {
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.ReasonClaimDeclinedIn3Years = null;
            }
        }

        vm.checkSumInsuredValue = function () {
            vm.invalidSuminsuredAmount = false;
            if (vm.state.ContentsSumInsured.GeneralContentSumInsured < vm.minContentsSumInsured) {
                vm.invalidSuminsuredAmount = true;
            }
        }

        vm.ResetPropertyUsedSection = function () {
            if (!vm.state.UnderwritingCriteria.IsPropertyUsed) {
                vm.state.UnderwritingCriteria.PropertyUsed.IsBoardingHouse = false;
                vm.state.UnderwritingCriteria.PropertyUsed.IsHostel = false;
                vm.state.UnderwritingCriteria.PropertyUsed.IsBreakfast = false;
            }
        }

        vm.InvalidZero = function (field, value) {
            var inp = $filter('number')(value);
            if (value) {
                if (inp != '0' && inp != '') {
                    field.$setValidity('validcurrency', true)
                }
                else {
                    field.$setValidity('validcurrency', false);
                }
            }
            else {
                field.$setValidity('validcurrency', false);
            }
        }

        vm.querySearch = function (query) {
            return $http.get(apiUrlConstService.addressURL + 'IntechAddressListAsync?address=' + query, { skipInterceptor: true })
                .then(function (result) {
                    let obj = {
                        text: messageConstService.manualAddressList,
                        value: 'N/A',
                        postCode: null
                    };

                    let resultantdata = result.data.data;
                    if (resultantdata.length > 0) {
                        resultantdata.push(obj);
                    }
                    return resultantdata;
                });
        }

        vm.mannualSearchQuery = function (query) {
            return $http.get(apiUrlConstService.addressURL + 'MannualAddressList?searchAddress=' + query, { skipInterceptor: true })
                .then(function (result) {
                    return result.data.data;
                });
        }

        function addressMapped(address, field) {
            if (!address) {
                vm.state.PropertyDetail.AddressText = null;
                //vm.ResetBuildingSection();
                vm.resetPropertySection();
                $scope.IsChangeAddress = false;
            }

            if (address && address.value == 'N/A') {
                address = null;
                vm.selectedAddress = null;
                onClickAddressNotFound();
            }

            if (address) {
                var qCheckDate = new Date(vm.tempLandlordStandardData.DWCAdjustmentDate);
                var newBusinessCaseData = sessionStorageService.get(keyConstService.newBusinessCaseData);
                var newBusinessCaseDetail = JSON.parse(newBusinessCaseData);
                var qStartDate = newBusinessCaseDetail != null ? new Date(newBusinessCaseDetail.data.EffectiveDate) : new Date(vm.tempLandlordStandardData.StartDate);
                $scope.IsChangeAddress = true;
                if (vm.IsRentDefaultChanges && vm.state.PropertyDetail.AddressValue !== address.value && (vm.state.PropertyDetail.AddressValue!= null || (vm.state.PropertyDetail.AddressValue === null && vm.IsAddressavailable) ) ) {
                    toastr.error(messageConstService.OptionalCoverChangeOnAddress);
                }
                if (!address.text) {
                    vm.state.PropertyDetail.AddressText = address;
                }
                if (address.text) {
                    vm.state.PropertyDetail.AddressText = address.text;
                    vm.selectedAddressValue = address.value; 
                    if (address.value) {
                        vm.state.PropertyDetail.AddressValue = address.value;
                        vm.state.CordellResponse.Propertydata.postcode = address.postCode === null ? null : address.postCode;
                        vm.IsAddressavailable = true;
                        if ($scope.subFormContent != undefined) {
                            validateConstructionPeriod($scope.subFormContent.OriginalYearBuilt);
                            setValidity();
                        }
                        var splitSate = address.value.split('|');
                        vm.AddressState = splitSate[0];
                        if (vm.AddressState === "NSW") {
                            vm.showStampDuty = true;
                        }
                        if (vm.AddressState) {
                            if ((qStartDate < qCheckDate) && (vm.AddressState === "WA" || vm.AddressState === "ACT" || vm.AddressState === "TAS")) {
                                vm.showDomesticWorkerCompensation = true;
                                vm.state.OptionalCover.IsDomesticWorkerCompensation = vm.state.OptionalCover.IsDomesticWorkerCompensation ;

                            }
                            else {
                                vm.showDomesticWorkerCompensation = false;
                                vm.state.OptionalCover.IsDomesticWorkerCompensation  = null;
                            }
                        }
                        else {
                            vm.showStampDuty = false;
                            vm.state.OtherInfo.IsStampDutyExemption = null;
                        }


                        if (vm.IsEndorsement && vm.stampDutyEligibilty) {
                            if (vm.AddressState != vm.storeAddress) {
                                vm.showStampDuty = false;
                            }
                            else {
                                vm.showStampDuty = true;
                                vm.state.OtherInfo.IsStampDutyExemption = vm.state.OtherInfo.IsStampDutyExemption;
                                if (vm.state.OtherInfo.IsStampDutyExemption != null) {
                                    vm.stampDutyEligibilty = true;
                                }
                                else {
                                    vm.sDExemption = JSON.parse(sessionStorageService.get(keyConstService.stampDutyExemption));
                                    vm.state.OtherInfo.IsStampDutyExemption = vm.sDExemption;
                                }
                            }

                        }
                        if (vm.IsEndorsement) {
                            if (vm.state.OtherInfo.IsStampDutyExemption == null) {
                                vm.showStampDuty = false;
                            }
                        }
                        if (!vm.state.PropertyDetail.IsManualAddress) {
                            findAddress(field);
                        }
                    }
                }
                var illionCall = JSON.parse(sessionStorageService.get(keyConstService.IllionAddressEnquiry));
                sessionStorageService.remove(keyConstService.IllionAddressEnquiry);
                if (illionCall === null || illionCall === undefined || !illionCall) {
                    vm.getAdressEnquiryDetails();
                }
            }
        }

        function findAddress(field) {
            if ($scope.IsChangeAddress) {
                //$scope.tempBuildingSumInsured = 0;
                vm.state.CordellResponse.BuildingSumInsured = 0;
            }

            // comment this line because in case of content only then referral generate, In invalid case
            // if ((vm.state.PolicyHolder.ContentCover && vm.state.PolicyHolder.BuildingCover) || (!vm.state.PolicyHolder.ContentCover && vm.state.PolicyHolder.BuildingCover)){
            var addressLogVM = {
                Address: vm.state.PropertyDetail.AddressText,
                DelimeterAddress: vm.state.PropertyDetail.AddressValue,
                IsManualAddress: vm.state.PropertyDetail.IsManualAddress
            };

            //// if there is already an entered address before going for manual address then restore data back on valid address
            if (vm.previousAddress && vm.previousSelectedAddress) {
                vm.RestoreCordellData();

                vm.state.PropertyDetail.AddressText = vm.previousSelectedAddress;
                vm.selectedAddress = null;
                if (vm.state.PropertyDetail.IsManualAddress) {
                    vm.selectedAddress = null;
                }
                if (vm.previousAddress[0].text) {
                    vm.selectedAddress = vm.previousAddress[0];
                }
            }
            else if (vm.state.PropertyDetail.AddressText !== null) {
                quotesService.intechCrordellApi(addressLogVM).then(function (response) {
                    if (response.data !== null) {
                        if (response.data.cordellResponse === null && response.data.errorCode === 0) {
                            toastr.warning(messageConstService.errCordellWarning);
                            if (!vm.IsManualBuildingSumInsured && !vm.IsEndorsement && vm.landlordStandardData.DDlProcessTypeId !== 4) {
                                vm.state.CordellResponse.BuildingSumInsured = 0;
                            }
                            vm.state.CordellResponse.BuildingSumInsuredEstimate = 0;
                        }
                        else if (response.data.errorCode === 400) {
                            toastr.warning(messageConstService.errCordellPropertyType);
                            vm.state.CordellResponse.BuildingSumInsured = 0;
                            vm.state.CordellResponse.BuildingSumInsuredEstimate = 0;
                        }
                        else if (response.data.errorCode === 405) {
                            toastr.info(messageConstService.errCompleteAddress);
                        }
                        else if (response.data.errorCode === 0 && response.data.cordellResponse !== null && vm.landlordStandardData.DDlProcessTypeId !== 4) {
                            //if (vm.state.PolicyHolder.BuildingCover) {
                            vm.BuildingSumInsuredValue = response.data.cordellResponse.buildingSumInsured;
                            if ($scope.IsChangeAddress) {
                                vm.state.CordellResponse.BuildingSumInsured = 0;
                            }
                            vm.state.CordellResponse.BuildingSumInsuredEstimate = response.data.cordellResponse.buildingSumInsuredEstimate;
                            if (vm.state.PolicyHolder.BuildingCover) {
                                vm.InvalidZero(field, vm.state.CordellResponse.BuildingSumInsuredEstimate);
                            } else {
                                field.$setValidity('validcurrency', true);
                            }
                            //vm.InvalidZero(field, vm.state.CordellResponse.BuildingSumInsured);
                            //}
                            if (response.data.cordellResponse.propertydata !== null) {
                                vm.state.CordellResponse.Propertydata = response.data.cordellResponse.propertydata;
                                vm.cordellBackupForFloorReset = angular.copy(vm.state.CordellResponse.Propertydata);
                                SetCordelFields();
                                
                            }
                        }
                        //// if bedroom and bathroom are 0 make them blank
                        MakeBedRoomBathRoomBlank();
                    }

                }, function (error) {
                    $log.log("Cordell Error:", error);
                    toastr.error(messageConstService.errSumInsuredCalculation);
                    vm.isCordellResponseNotValid = true;

                });
            }
        }

        vm.ResetPoolSpaSection = function () {
            if (vm.state.CordellResponse.Propertydata.poolSpa_Included) {
                if (vm.IsEndorsement) {
                    vm.state.CordellResponse.Propertydata.poolSpa_SpaType = angular.copy(endorsementState.CordellResponse.Propertydata.poolSpa_SpaType);
                    vm.state.CordellResponse.Propertydata.poolSpa_ConcretePoolSize = angular.copy(endorsementState.CordellResponse.Propertydata.poolSpa_ConcretePoolSize);
                    vm.state.CordellResponse.Propertydata.poolSpa_FibreglassPoolSize = angular.copy(endorsementState.CordellResponse.Propertydata.poolSpa_FibreglassPoolSize);
                    vm.state.CordellResponse.Propertydata.poolSpa_VinylPoolSize = angular.copy(endorsementState.CordellResponse.Propertydata.poolSpa_VinylPoolSize);
                }
                else {
                    vm.state.CordellResponse.Propertydata.poolSpa_SpaType = vm.cordellBackupForFloorReset.poolSpa_SpaType;
                    vm.state.CordellResponse.Propertydata.poolSpa_ConcretePoolSize = vm.cordellBackupForFloorReset.poolSpa_ConcretePoolSize;
                    vm.state.CordellResponse.Propertydata.poolSpa_FibreglassPoolSize = vm.cordellBackupForFloorReset.poolSpa_FibreglassPoolSize;
                    vm.state.CordellResponse.Propertydata.poolSpa_VinylPoolSize = vm.cordellBackupForFloorReset.poolSpa_VinylPoolSize;
                }
            }
            else {
                vm.state.CordellResponse.Propertydata.poolSpa_SpaType = null;
                vm.state.CordellResponse.Propertydata.poolSpa_ConcretePoolSize = null;
                vm.state.CordellResponse.Propertydata.poolSpa_FibreglassPoolSize = null;
                vm.state.CordellResponse.Propertydata.poolSpa_VinylPoolSize = null;
            }
        }

        vm.checkRentalAmount = function () {
            vm.invalidRentalAmount = false;
            if (vm.state.PolicyHolder.WeeklyRentalAmount < vm.minRentalAmount || vm.state.PolicyHolder.WeeklyRentalAmount > vm.maxRentalAmount) {
                vm.invalidRentalAmount = true;
            }
        }

        function removeNote(item) {
            vm.state.Notes.splice(vm.state.Notes.indexOf(item), 1);
        }

        function addNote(currentNote) {
            var newNote = {
                Note: null,
                IsPrintable: (!currentNote.IsPrintable)
            };
            if (vm.state.Notes.length < 2) {
                vm.state.Notes.push(newNote);
            };
        }

        vm.removeClaims = function (item) {
            var index = vm.state.Claims.ClaimsList.indexOf(item);
            vm.state.Claims.ClaimsList.splice(index, 1);
            vm.DisableAddClaim = false;
            if (vm.state.Claims.ClaimsList.length <= 1) {
                if (vm.state.Claims.ClaimsList[0].ClaimYear == null) {
                    vm.checkNullClaimList = true;
                    vm.state.Claims.ClaimsList = [{ ClaimYear: null, ClaimType: null, CostOfClaim: 0 }];
                }
            }
        }

        vm.addClaims = function () {
            if (vm.state.Claims.ClaimsList.length <= 6) {
                vm.state.Claims.ClaimsList.push({ ClaimYear: null, ClaimType: null, CostOfClaim: 0 });
            }
            else {
                vm.DisableAddClaim = true;
            }

            if (vm.state.Claims.ClaimsList.length > 1) {
                for (var i = 0; i < vm.state.Claims.ClaimsList.length; i++) {
                    if (vm.state.Claims.ClaimsList[i].ClaimYear == null) {
                        vm.checkNullClaimList = true;
                    }
                    else if (vm.state.Claims.ClaimsList[i].ClaimType == null) {
                        vm.checkNullClaimList = true;
                    }
                }
            }
        }

        vm.CoverChange = function () {
            if (vm.state.PolicyHolder.LandlordOccupancyType == "Holiday") {
                vm.invalidRentalAmount = false;
            }
        }

        function BuildingSumInsuredRange(field) {
            vm.checkDefaultBuildingSumInsured(field)
            vm.IsManualBuildingSumInsured = true;
            if (vm.state.CordellResponse.BuildingSumInsured !== undefined) {
                var minRange = vm.state.CordellResponse.BuildingSumInsuredEstimate - (vm.state.CordellResponse.BuildingSumInsuredEstimate * vm.AllowedBuildingSumInsuredRange);
                var maxRange = vm.state.CordellResponse.BuildingSumInsuredEstimate + (vm.state.CordellResponse.BuildingSumInsuredEstimate * vm.AllowedBuildingSumInsuredRange);

                if (vm.state.CordellResponse.BuildingSumInsured < minRange) {
                    vm.lessOrMoreMessage = 'less';
                    vm.IsBuildingSumInsuredOutRange = true;
                }
                else {
                    vm.IsBuildingSumInsuredOutRange = false;
                    if (field) {
                        if (field.$setValidity) {
                            field.$setValidity('validcurrency', true);
                        }
                    }
                }
                if (vm.state.CordellResponse.BuildingSumInsured != 0) {
                    vm.BuildingSiFlag = false;
                }
            }
        }

        vm.addSpecifiedItems = function () {
            vm.state.ContentsSumInsured.ValuableContents.push({ Category: null, Description: null, Value: null, AwayFromHome: false, IsValid: false });

        }

        vm.removeSpecifiedItems = function (item, field, value, index) {
            var index = vm.state.ContentsSumInsured.ValuableContents.indexOf(item);
            vm.state.ContentsSumInsured.ValuableContents.splice(index, 1);
            defaultValueForSpecialContent(field, value, index);
        }

        vm.ResetValuableContent = function () {
            resetSecurityDetails();
            if (!vm.state.ContentsSumInsured.IsValuableContent) {
                vm.state.ContentsSumInsured.ValuableContents = [{ Category: null, Description: null, Value: null, AwayFromHome: false }];
                vm.setSpecialContentValidity = true;
            }
            else if (vm.IsEndorsement && vm.state.ContentsSumInsured.IsValuableContent) {
                vm.state.ContentsSumInsured.ValuableContents = [{ Category: null, Description: null, Value: null, AwayFromHome: false }];
            }
            if (vm.state.ContentsSumInsured.IsValuableContent)
                doorChecked();
        }

        function removeNote(item) {
            vm.state.Notes.splice(vm.state.Notes.indexOf(item), 1);
        }

        function addNote(currentNote) {
            var newNote = {
                Note: null,
                IsPrintable: (!currentNote.IsPrintable)
            };
            if (vm.state.Notes.length < 2) {
                vm.state.Notes.push(newNote);
            };
        }

        function propertyDecline() {
            
            if (vm.state.UnderwritingCriteria.IsPropertyUsed == true) {
                toastr.error(messageConstService.errPropertyUsed)
            }
        }
        function propertyDeclineForTotalUnits() {
            if (vm.state.PropertyDetail.NumberOfUnitsOrResidencesToBeInsured === '5+') {
                toastr.error(messageConstService.errPropertyUsed)
            }
        }
        function ContentChanges(cover, field) {
            vm.disableCoverOnOccupancy(cover, field);
            if (vm.landlordStandardData.LOB && !vm.IsEndorsement) {
                var startDate = vm.landlordStandardData.StartDate;
                var productName = vm.landlordStandardData.LOB;
                var brokerCommissionRequestOnEdit = quotesService.getBrokerCommissiononEdit({
                    EffectiveDate: startDate,
                    ProductName: productName,
                    Productid: null,
                })
                    .then(function (result) {
                        vm.data = result.data.brokerBranchCommissionFeeVM;
                    })
            }

            if (vm.data && !vm.IsEndorsement) {
                for (var i = 0; i < vm.data.length; i++) {
                    if ((vm.state.PolicyHolder.BuildingCover && !vm.state.PolicyHolder.ContentCover && vm.data[i].coverCode === "BUILDING") || (!vm.state.PolicyHolder.BuildingCover && vm.state.PolicyHolder.ContentCover && vm.data[i].coverCode === "CONTENT") || (vm.state.PolicyHolder.BuildingCover && vm.state.PolicyHolder.ContentCover && vm.data[i].coverCode === "BUILDING,CONTENT")) {
                        vm.state.BrokerCommission.BrokerCommissionPercentage = vm.data[i].brokerCommissionFee;
                        vm.maxbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMax;
                        vm.minbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMin;
                        vm.checkBrkerCommissionLimit();
                    }
                }
            }

            if (!vm.state.PolicyHolder.ContentCover && !vm.IsEndorsement) {
                vm.state.ContentsSumInsured.GeneralContentSumInsured = null;
                vm.state.ContentsSumInsured.UnspecifiedPortableItem = null;
                vm.state.ContentsSumInsured.ValuableContents = [{ Category: null, Description: null, Value: null, AwayFromHome: false, validationMessage: false }];
                vm.state.ContentsSumInsured.SpecifiedPortableItems = [{ PortableCategory: null, PortableDescription: null, PortableValue: null }];
                vm.state.ContentsSumInsured.IsValuableContent = false;
                vm.state.ContentsSumInsured.IsPortableValueCover = false;
                vm.state.ContentsSumInsured.IsSpecifiedPortableItems = false;
                vm.state.ContentsSumInsured.IsUnspecifiedPortableItems = false;
                vm.state.SecurityDetails.WindowSecurities = null;
                vm.state.SecurityDetails.IsAlarmSecurity = null;
                vm.state.SecurityDetails.AlarmType = null;
                vm.state.SecurityDetails.DoorSecurities = [];
                vm.isNullContentInsured = false;
                vm.state.OtherInfo.IsBuyBusinessExtensionOption = false;
                vm.state.OtherInfo.BusinessName = null;
                vm.state.OtherInfo.OccupationName = null;
                vm.state.OtherInfo.AnnualRevenue = null;
                vm.state.OtherInfo.OccupationANZSIC = null;
                vm.state.OtherInfo.IsStampDutyExemption = null;
            }
            else {
                if (vm.state.ContentsSumInsured.ContentsSumInsured == 0 || vm.state.ContentsSumInsured.ContentsSumInsured == 0.00) {
                    vm.isNullContentInsured = true;
                }
            }

        }

        vm.defaultCheck = function (field, cover) {
            $scope.isDefaultCheckClick = true;
            $scope.IsChangeAddress = false;
            //if (!$scope.tempBuildingSumInsured && vm.state.CordellResponse.BuildingSumInsured > 0) {
            //    $scope.tempBuildingSumInsured = vm.state.CordellResponse.BuildingSumInsured;
            //}

            //if ((vm.state.CordellResponse.BuildingSumInsured == 0 || vm.state.CordellResponse.BuildingSumInsured == null) && $scope.tempBuildingSumInsured) {
            //    vm.state.CordellResponse.BuildingSumInsured = $scope.tempBuildingSumInsured;
            //}
            //else {
            //    $scope.tempBuildingSumInsured = vm.state.CordellResponse.BuildingSumInsured;
            //}

            vm.brokerCommissionLimitMessage = false;
            if (vm.state.ContentsSumInsured.GeneralContentSumInsured === null) {
                vm.state.ContentsSumInsured.GeneralContentSumInsured = vm.DefaultSumInsured;
            }
            if (vm.previousContentSumInsured) {
                vm.state.ContentsSumInsured.GeneralContentSumInsured = vm.previousContentSumInsured;
            }
            var item = { Value: "DamageCausedByTenants,PetsOrOtherAccidentalDamage", Text: "Damage caused by tenants, pets or other accidental damage" };
            var index = -1;
            vm.state.Claims.ClaimTypeList.some(function (x, i) {
                if (x.Value === "DamageCausedByTenants,PetsOrOtherAccidentalDamage") {
                    index = i;
                }
            });

            if (vm.state.PolicyHolder.ContentCover && index == -1) {
                vm.state.Claims.ClaimTypeList.splice(vm.state.Claims.ClaimTypeList.length - 1, 0, item);
            } else if (!vm.state.PolicyHolder.ContentCover && index != -1) {
                vm.state.Claims.ClaimTypeList.splice(index, 1);
            }
            
            if (vm.state.PolicyHolder.ContentCover) {
                vm.showDefaultBuildingSumInsuredRange = false;
                if (vm.state.ContentsSumInsured.GeneralContentSumInsured == 0) {
                    vm.ContentSiFlag = true;
                }
                else {
                    vm.ContentSiFlag = false;
                }
                if (!vm.IsEndorsement && vm.landlordStandardData.DDlProcessTypeId !== 4) {
                    if (vm.state.Excess.ContentExcess1 === null) {
                        vm.state.Excess.ContentExcess1 = "500";
                    }

                    if (vm.state.Excess.ContentExcess2 === null) {
                        vm.state.Excess.ContentExcess2 = "750";
                    }
                    if (vm.state.Excess.ContentExcess3 === null) {
                        vm.state.Excess.ContentExcess3 = "1000";
                    }
                }
                if (vm.IsEndorsement && cover === "Content") {
                    if (vm.endorsementVM && vm.endorsementVM.ContentExcess) {
                        vm.state.Excess.ContentExcess1 = vm.endorsementVM.ContentExcess;
                    }
                    else {
                        vm.state.Excess.ContentExcess1 = endorsementState.Excess.ContentExcess1;
                    }
                    if (vm.state.Excess.ContentExcess1 === null) {
                        vm.state.Excess.ContentExcess1 = "500";
                    }

                }
            }
            else if (!vm.state.PolicyHolder.ContentCover && !vm.IsEndorsement) {
                vm.state.Excess.ContentExcess1 = null;
                vm.state.Excess.ContentExcess2 = null;
                vm.state.Excess.ContentExcess3 = null;
                vm.ContentSiFlag = false;
            }
            if (vm.state.PolicyHolder.BuildingCover) {
                vm.showDefaultContentSumInsuredRange = false;
                vm.InvalidZero(field, vm.state.CordellResponse.BuildingSumInsured);

                if (!vm.IsEndorsement && vm.landlordStandardData.DDlProcessTypeId !== 4) {
                    if (vm.state.Excess.BuildingExcess1 === null) {
                        vm.state.Excess.BuildingExcess1 = "500";
                    }

                    if (vm.state.Excess.BuildingExcess2 === null) {
                        vm.state.Excess.BuildingExcess2 = "750";
                    }
                    if (vm.state.Excess.BuildingExcess3 === null) {
                        vm.state.Excess.BuildingExcess3 = "1000";
                    }

                }
                if (vm.IsEndorsement && cover === "Building") {
                    if (vm.version >= keyConstService.Version && endorsementPropertyData !== null) {
                        vm.state.CordellResponse.Propertydata.roof = endorsementPropertyData.roof;
                        vm.state.CordellResponse.Propertydata.externalWallMaterial = endorsementPropertyData.externalWallMaterial;
                    }
                    // restoring to endorsement state for building cover dependent questions
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsHomeUnderConstructionRenovation = endorsementState.UnderwritingCriteria.AnswerYesToFollowingData.IsHomeUnderConstructionRenovation;
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData = angular.copy(endorsementState.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData);
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsPoorlyMaintainedProperty = endorsementState.UnderwritingCriteria.AnswerYesToFollowingData.IsPoorlyMaintainedProperty;
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsPropertyHeriatgeListed = endorsementState.UnderwritingCriteria.AnswerYesToFollowingData.IsPropertyHeriatgeListed;
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.PropertyHeritgeListingDetail = endorsementState.UnderwritingCriteria.AnswerYesToFollowingData.PropertyHeritgeListingDetail;

                    if (vm.endorsementVM && vm.endorsementVM.BuildingExcess) {
                        vm.state.Excess.BuildingExcess1 = vm.endorsementVM.BuildingExcess;
                    }
                    else {
                        vm.state.Excess.BuildingExcess1 = endorsementState.Excess.BuildingExcess1;
                    }
                    if (endorsementState.Excess.BuildingExcess1 === null) {
                        vm.state.Excess.BuildingExcess1 = "500";
                    }

                    vm.InvalidZero(field, vm.state.CordellResponse.BuildingSumInsured);

                }
            }
            else if (!vm.state.PolicyHolder.BuildingCover && !vm.IsEndorsement) {
                vm.state.Excess.BuildingExcess1 = null;
                vm.state.Excess.BuildingExcess2 = null;
                vm.state.Excess.BuildingExcess3 = null;
                //if (vm.landlordStandardData.DDlProcessTypeId !== 4)
                //    vm.state.CordellResponse.BuildingSumInsured = 0;
                //vm.state.CordellResponse.BuildingSumInsuredEstimate = 0;
                vm.BuildingSiFlag = false;
                field.$setValidity('validcurrency', true);
            }
            vm.isDuplicateExcess();
            vm.ContentChanges(cover, field);

            if ((vm.state.PolicyHolder.ContentCover || cover === 'Content') && !vm.state.PolicyHolder.BuildingCover) {
                if (vm.state.Excess.ContentExcess1 === null && vm.state.Excess.ContentExcess2 === null && vm.state.Excess.ContentExcess3 === null)
                    vm.state.Excess.ContentExcess1 = "500";
            }
            else if ((vm.state.PolicyHolder.BuildingCover || cover === 'Building') && !vm.state.PolicyHolder.ContentCover) {
                if (vm.state.Excess.BuildingExcess1 === null && vm.state.Excess.BuildingExcess2 === null && vm.state.Excess.BuildingExcess3 === null)
                    vm.state.Excess.BuildingExcess1 = "500";
            }

            if (vm.state.PolicyHolder.BuildingCover && !vm.state.PolicyHolder.ContentCover) {
                vm.ResetValuableContent();
            }
            // content only case
            if (!vm.state.PolicyHolder.BuildingCover && vm.state.PolicyHolder.ContentCover) {
                // only for content only for new version
                vm.resetValuesOnBuildingCoverFalse();
                vm.state.CordellResponse.Propertydata.propertyRewired = null;
                // make questions dependent to building cover default
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsHomeUnderConstructionRenovation = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsPoorlyMaintainedProperty = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsPropertyHeriatgeListed = null;
            }

        };

        vm.checkBrkerCommissionLimit = function () {
            vm.brokerCommissionLimitMessage = false;
            var regexp = /^[0-9]+(\.[0-9]{1,2})?$/;
            if (!regexp.test(vm.state.BrokerCommission.BrokerCommissionPercentage)) {
                vm.state.BrokerCommission.BrokerCommissionPercentage = null;
                vm.brokerCommissionLimitMessage = true;
            }

            if (vm.state.BrokerCommission.BrokerCommissionPercentage > vm.maxbrokerCommissionPercentage || vm.state.BrokerCommission.BrokerCommissionPercentage < vm.minbrokerCommissionPercentage)
                vm.brokerCommissionLimitMessage = true;
        }

        function chnageBrokerCommission() {
            getQuoteTransactionId = sessionStorageService.get(keyConstService.getTransactionIdWithoutSaving);
            if (vm.landlordStandardData.LOB) {
                var startDate = vm.landlordStandardData.StartDate;
                var productName = vm.landlordStandardData.LOB;
                var brokerCommissionRequestOnEdit = quotesService.getBrokerCommissiononEdit({
                    EffectiveDate: startDate,
                    ProductName: productName,
                    Productid: null,
                })
                    .then(function (result) {
                        vm.data = result.data.brokerBranchCommissionFeeVM;
                    })
            }
            if (vm.data) {
                if (vm.state.PolicyHolder.ContentCover && !vm.IsEndorsement) {
                    for (var i = 0; i < vm.data.length; i++) {
                        if (vm.data[i].coverCode === "CONTENT") {
                            vm.state.BrokerCommission.BrokerCommissionPercentage = vm.data[i].brokerCommissionFee;
                            vm.maxbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMax;
                            vm.minbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMin;
                            vm.checkBrkerCommissionLimit();
                        }
                    }
                }
            }
        }

        vm.isDuplicateExcess = function () {
            if (vm.state.PolicyHolder.BuildingCover && vm.state.PolicyHolder.ContentCover) {
                if (vm.state.Excess.BuildingExcess1 === null && vm.state.Excess.ContentExcess1 === null && (vm.state.Excess.BuildingExcess2 !== null && vm.state.Excess.BuildingExcess2 !== "")
                    && (vm.state.Excess.ContentExcess2 !== null && vm.state.Excess.ContentExcess2 !== "")) {
                    vm.message = "Please select Excess option1.";
                    vm.ExcessValueFlag = true;
                    return;
                }

                if ((vm.state.Excess.BuildingExcess3 !== null && vm.state.Excess.BuildingExcess3 !== "") && (vm.state.Excess.ContentExcess3 !== null && vm.state.Excess.ContentExcess3 !== "") &&
                    (vm.state.Excess.BuildingExcess2 === null || vm.state.Excess.BuildingExcess2 === "") && (vm.state.Excess.ContentExcess2 === null || vm.state.Excess.ContentExcess2 === "")) {
                    vm.message = "Please select Excess Option2.";
                    vm.ExcessValueFlag = true;
                    return;
                }
                else {
                    vm.ExcessValueFlag = false;
                }

                if ((vm.state.Excess.BuildingExcess1 !== null && vm.state.Excess.BuildingExcess1 !== "") && (vm.state.Excess.ContentExcess1 === null || vm.state.Excess.ContentExcess1 === "")) {
                    vm.ExcessValueFlag = true;
                    vm.message = "Please select Content Excess Option1.";
                    return;
                }
                else if ((vm.state.Excess.BuildingExcess1 === null || vm.state.Excess.BuildingExcess1 === "") && (vm.state.Excess.ContentExcess1 !== null && vm.state.Excess.ContentExcess1 !== "")) {
                    vm.ExcessValueFlag = true;
                    vm.message = "Please select Building Excess Option1.";
                    return;
                }

                if ((vm.state.Excess.BuildingExcess2 !== null && vm.state.Excess.BuildingExcess2 !== "") && (vm.state.Excess.ContentExcess2 === null || vm.state.Excess.ContentExcess2 === "")) {
                    vm.ExcessValueFlag = true;
                    vm.message = "Please select Content Excess Option2.";
                    return;
                }
                else if ((vm.state.Excess.BuildingExcess2 === null || vm.state.Excess.BuildingExcess2 === "") && (vm.state.Excess.ContentExcess2 !== null && vm.state.Excess.ContentExcess2 !== "")) {
                    vm.ExcessValueFlag = true;
                    vm.message = "Please select Building Excess Option2.";
                    return;
                }
                else {
                    if ((vm.state.Excess.BuildingExcess2 !== null && vm.state.Excess.BuildingExcess2 !== "") && (vm.state.Excess.ContentExcess2 !== null && vm.state.Excess.ContentExcess2 !== "") &&
                        (vm.state.Excess.BuildingExcess1 === vm.state.Excess.BuildingExcess2) && (vm.state.Excess.ContentExcess1 === vm.state.Excess.ContentExcess2)) {

                        vm.ExcessValueFlag = true;
                        vm.message = "Excess value cannot be same.";
                        return;
                    }
                    else {
                        vm.ExcessValueFlag = false;
                    }

                }

                if ((vm.state.Excess.BuildingExcess3 !== null && vm.state.Excess.BuildingExcess3 !== "") && (vm.state.Excess.ContentExcess3 === null || vm.state.Excess.ContentExcess3 === "")) {
                    vm.ExcessValueFlag = true;
                    vm.message = "Please select Content Excess Option3."
                    return;
                }
                else if ((vm.state.Excess.BuildingExcess3 === null || vm.state.Excess.BuildingExcess3 === "") && (vm.state.Excess.ContentExcess3 !== null && vm.state.Excess.ContentExcess3 !== "")) {
                    vm.ExcessValueFlag = true;
                    vm.message = "Please select Building Excess Option3."
                    return;
                }
                else {
                    if ((vm.state.Excess.BuildingExcess3 !== null && vm.state.Excess.BuildingExcess3 !== "") && (vm.state.Excess.ContentExcess3 !== null && vm.state.Excess.ContentExcess3 !== "")
                        && ((vm.state.Excess.BuildingExcess2 === vm.state.Excess.BuildingExcess3) && (vm.state.Excess.ContentExcess2 === vm.state.Excess.ContentExcess3) ||
                            (vm.state.Excess.BuildingExcess1 === vm.state.Excess.BuildingExcess3) && (vm.state.Excess.ContentExcess1 === vm.state.Excess.ContentExcess3) ||
                            ((vm.state.Excess.BuildingExcess1 === vm.state.Excess.BuildingExcess2) && (vm.state.Excess.ContentExcess1 === vm.state.Excess.ContentExcess2)))) {
                        vm.ExcessValueFlag = true;
                        vm.message = "Excess value cannot be same."
                        return;
                    }
                    else {
                        vm.ExcessValueFlag = false;
                    }
                }

            }
            else if (vm.state.PolicyHolder.BuildingCover) {
                if ((vm.state.Excess.BuildingExcess2 !== null && vm.state.Excess.BuildingExcess2 !== "") && (vm.state.Excess.BuildingExcess2 === vm.state.Excess.BuildingExcess1)) {
                    vm.ExcessValueFlag = true;
                    vm.message = "Excess value cannot be same."
                    return;
                }
                else {
                    if ((vm.state.Excess.BuildingExcess3 !== null && vm.state.Excess.BuildingExcess3 !== "") && ((vm.state.Excess.BuildingExcess2 === vm.state.Excess.BuildingExcess3) || (vm.state.Excess.BuildingExcess1 === vm.state.Excess.BuildingExcess3))) {
                        vm.ExcessValueFlag = true;
                        vm.message = "Excess value cannot be same."
                        return;
                    }
                    else {
                        if ((vm.state.Excess.BuildingExcess2 === null || vm.state.Excess.BuildingExcess2 === "") && (vm.state.Excess.BuildingExcess3 !== null && vm.state.Excess.BuildingExcess3 !== "")) {
                            vm.ExcessValueFlag = true;
                            vm.message = "Please select Excess Option2."
                            return;
                        }
                        else {
                            //if-else removed for Sonar Qube Report bug 
                                vm.ExcessValueFlag = false;
                        }
                    }
                }
            }
            else {
                if ((vm.state.Excess.ContentExcess2 !== null && vm.state.Excess.ContentExcess2 !== "") && (vm.state.Excess.ContentExcess1 === vm.state.Excess.ContentExcess2)) {
                    vm.ExcessValueFlag = true;
                    vm.message = "Excess value cannot be same."
                    return;
                }
                else {
                    if ((vm.state.Excess.ContentExcess3 !== null && vm.state.Excess.ContentExcess3 !== "") && ((vm.state.Excess.ContentExcess2 === vm.state.Excess.ContentExcess3) || (vm.state.Excess.ContentExcess1 === vm.state.Excess.ContentExcess3))) {
                        vm.ExcessValueFlag = true;
                        vm.message = "Excess value cannot be same."
                        return;
                    }
                    else {
                        if ((vm.state.Excess.ContentExcess2 === null || vm.state.Excess.ContentExcess2 === "") && (vm.state.Excess.ContentExcess3 !== null && vm.state.Excess.ContentExcess3 !== "")) {
                            vm.ExcessValueFlag = true;
                            vm.message = "Please select Excess Option2."
                            return;
                        }
                        else {
                            //if-else removed for Sonar Qube Report bug
                                vm.ExcessValueFlag = false;
                        }
                    }
                }
            }
        }

        vm.disableCoverOnOccupancy = function (cover, field) {
            //if (!$scope.tempBuildingSumInsured && vm.state.CordellResponse.BuildingSumInsured > 0) {
            //    $scope.tempBuildingSumInsured = vm.state.CordellResponse.BuildingSumInsured;
            //}
            //if ((vm.state.CordellResponse.BuildingSumInsured == 0 || vm.state.CordellResponse.BuildingSumInsured == null) && $scope.tempBuildingSumInsured) {
            //    vm.state.CordellResponse.BuildingSumInsured = $scope.tempBuildingSumInsured;
            //}
            //else {
            //    $scope.tempBuildingSumInsured = vm.state.CordellResponse.BuildingSumInsured;
            //}

            if (!vm.state.PolicyHolder.BuildingCover && !vm.state.PolicyHolder.ContentCover) {
                if (cover === 'Content') {
                    vm.state.PolicyHolder.BuildingCover = true;
                    if (vm.state.CordellResponse.BuildingSumInsured == 0) {
                        vm.BuildingSiFlag = true;
                    }
                    else {
                        vm.BuildingSiFlag = false;
                    }
                    if (!vm.IsEndorsement && vm.landlordStandardData.DDlProcessTypeId !== 4) {
                        if (vm.state.Excess.BuildingExcess1 === null) {
                            vm.state.Excess.BuildingExcess1 = "500";
                        }
                        if (vm.state.Excess.BuildingExcess2 === null) {
                            vm.state.Excess.BuildingExcess2 = "750";
                        }
                        if (vm.state.Excess.BuildingExcess3 === null) {
                            vm.state.Excess.BuildingExcess3 = "1000";
                        }
                    }
                    if (vm.IsEndorsement) {
                        if (vm.version >= keyConstService.Version && endorsementState !== null) {
                            vm.state.CordellResponse.Propertydata.roof = endorsementState.CordellResponse.Propertydata.roof;
                            vm.state.CordellResponse.Propertydata.externalWallMaterial = endorsementState.CordellResponse.Propertydata.externalWallMaterial;
                        }
                        //vm.state.CordellResponse.BuildingSumInsured = endorsementState.CordellResponse.BuildingSumInsured;
                        vm.state.CordellResponse.BuildingSumInsuredEstimate = endorsementState.CordellResponse.BuildingSumInsuredEstimate;
                        // restoring to endorsement state for building cover dependent questions
                        vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsHomeUnderConstructionRenovation = endorsementState.UnderwritingCriteria.AnswerYesToFollowingData.IsHomeUnderConstructionRenovation;
                        vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData = angular.copy(endorsementState.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData);
                        vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsPoorlyMaintainedProperty = endorsementState.UnderwritingCriteria.AnswerYesToFollowingData.IsPoorlyMaintainedProperty;
                        vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsPropertyHeriatgeListed = endorsementState.UnderwritingCriteria.AnswerYesToFollowingData.IsPropertyHeriatgeListed;
                        vm.state.UnderwritingCriteria.AnswerYesToFollowingData.PropertyHeritgeListingDetail = endorsementState.UnderwritingCriteria.AnswerYesToFollowingData.PropertyHeritgeListingDetail;
                        
                        if (vm.endorsementVM && vm.endorsementVM.BuildingExcess) {
                            vm.state.Excess.BuildingExcess1 = vm.endorsementVM.BuildingExcess;
                        }
                        else {
                            vm.state.Excess.BuildingExcess1 = endorsementState.Excess.BuildingExcess1;
                        }
                        if (endorsementState.Excess.BuildingExcess1 === null) {
                            vm.state.Excess.BuildingExcess1 = "500";
                        }

                        if (vm.state.CordellResponse.BuildingSumInsured == 0) {
                            vm.BuildingSiFlag = true;
                        }
                        else {
                            vm.BuildingSiFlag = false;
                        }
                    }
                }
                else if (cover === 'Building') {
                    field.$setValidity('validcurrency', true);
                    vm.BuildingSiFlag = false;
                    vm.state.PolicyHolder.ContentCover = true;
                    var item = { Value: "DamageCausedByTenants,PetsOrOtherAccidentalDamage", Text: "Damage caused by tenants, pets or other accidental damage" };
                    var index = -1;
                    vm.state.Claims.ClaimTypeList.some(function (x, i) {
                        if (x.Value === "DamageCausedByTenants,PetsOrOtherAccidentalDamage") {
                            index = i;
                        }
                    });

                    if (vm.state.PolicyHolder.ContentCover && index == -1) {
                        vm.state.Claims.ClaimTypeList.splice(vm.state.Claims.ClaimTypeList.length - 1, 0, item);
                    } else if (!vm.state.PolicyHolder.ContentCover && index != -1) {
                        vm.state.Claims.ClaimTypeList.splice(index, 1);
                    }
                    if (vm.state.ContentsSumInsured.GeneralContentSumInsured == 0) {
                        vm.ContentSiFlag = true;
                    }
                    else {
                        vm.ContentSiFlag = false;
                    }
                    if (!vm.IsEndorsement && vm.landlordStandardData.DDlProcessTypeId !== 4) {
                        if (vm.state.Excess.ContentExcess1 === null) {
                            vm.state.Excess.ContentExcess1 = "500";
                        }

                        if (vm.state.Excess.ContentExcess2 === null) {
                            vm.state.Excess.ContentExcess2 = "750";
                        }
                        if (vm.state.Excess.ContentExcess3 === null) {
                            vm.state.Excess.ContentExcess3 = "1000";
                        }
                    }
                    // make questions dependent to building cover default
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsHomeUnderConstructionRenovation = null;
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsPoorlyMaintainedProperty = null;
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsPropertyHeriatgeListed = null;

                    if (vm.IsEndorsement) {
                        vm.state.ContentsSumInsured.GeneralContentSumInsured = endorsementState.ContentsSumInsured.GeneralContentSumInsured;
                        vm.state.SecurityDetails.WindowSecurities = endorsementState.SecurityDetails.WindowSecurities;
                        vm.state.SecurityDetails.IsAlarmSecurity = endorsementState.SecurityDetails.IsAlarmSecurity;
                        vm.state.SecurityDetails.AlarmType = endorsementState.SecurityDetails.AlarmType;
                        vm.state.SecurityDetails.DoorSecurities = angular.copy(endorsementState.SecurityDetails.DoorSecurities);
                        vm.state.ContentsSumInsured.IsValuableContent = endorsementState.ContentsSumInsured.IsValuableContent;
                        vm.state.ContentsSumInsured.IsPortableValueCover = endorsementState.ContentsSumInsured.IsPortableValueCover;
                        vm.state.ContentsSumInsured.IsSpecifiedPortableItems = endorsementState.ContentsSumInsured.IsSpecifiedPortableItems;
                        vm.state.ContentsSumInsured.IsUnspecifiedPortableItems = endorsementState.ContentsSumInsured.IsUnspecifiedPortableItems;
                        vm.state.ContentsSumInsured.UnspecifiedPortableItem = endorsementState.ContentsSumInsured.UnspecifiedPortableItem;
                        vm.state.ContentsSumInsured.ValuableContents = angular.copy(endorsementState.ContentsSumInsured.ValuableContents);
                        vm.state.ContentsSumInsured.SpecifiedPortableItems = angular.copy(endorsementState.ContentsSumInsured.SpecifiedPortableItems);
                        vm.state.OtherInfo.IsBuyBusinessExtensionOption = endorsementState.OtherInfo.IsBuyBusinessExtensionOption;
                        vm.state.OtherInfo.BusinessName = endorsementState.OtherInfo.BusinessName;
                        vm.state.OtherInfo.OccupationName = endorsementState.OtherInfo.OccupationName;
                        vm.state.OtherInfo.AnnualRevenue = endorsementState.OtherInfo.AnnualRevenue;
                        vm.state.OtherInfo.OccupationANZSIC = endorsementState.OtherInfo.OccupationANZSIC;
                        vm.state.OtherInfo.IsStampDutyExemption = endorsementState.OtherInfo.IsStampDutyExemption;
                        if (vm.endorsementVM && vm.endorsementVM.ContentExcess) {
                            vm.state.Excess.ContentExcess1 = vm.endorsementVM.ContentExcess;
                        }
                        else {
                            vm.state.Excess.ContentExcess1 = endorsementState.Excess.ContentExcess1;
                        }
                        if (vm.state.Excess.ContentExcess1 === null) {
                            vm.state.Excess.ContentExcess1 = "500";
                        }
                    }

                }

            }
            else if (vm.state.PolicyHolder.HomeOccupancyType === 'Renting') {
                if (vm.state.PropertyDetail.IsManualAddress) {
                    vm.state.CordellResponse.BuildingSumInsuredEstimate = 0;
                }
                vm.state.PolicyHolder.BuildingCover = false;
                field.$setValidity('validcurrency', true);
                vm.BuildingSiFlag = false;
                vm.state.PolicyHolder.ContentCover = true;
                vm.disableBuilding = true;
                vm.disableContent = true;
                if (vm.state.Excess.ContentExcess1 === null) {
                    vm.state.Excess.ContentExcess1 = "500";
                }

                if (vm.state.Excess.ContentExcess2 === null) {
                    vm.state.Excess.ContentExcess2 = "750";
                }
                if (vm.state.Excess.ContentExcess3 === null) {
                    vm.state.Excess.ContentExcess3 = "1000";
                }
                if (vm.state.ContentsSumInsured.GeneralContentSumInsured !== 0) {
                    vm.ContentSiFlag = false;
                }
            }
            else {
                vm.disableBuilding = false;
                vm.disableContent = false;
            }
        }


        function changeNotesPrintable(currentNote) {
            if (vm.state.Notes.length > 1) {
                var currentIndex = vm.state.Notes.indexOf(currentNote);
                var index = 1 - currentIndex;
                vm.state.Notes[index].IsPrintable = (!currentNote.IsPrintable);
            }

        }
        
        function resetAlarmSecurity() {
            if (!vm.state.SecurityDetails.IsAlarmSecurity) {
                vm.state.SecurityDetails.AlarmType = null;
            }
            else if (vm.IsEndorsement && vm.state.SecurityDetails.IsAlarmSecurity) {
                vm.state.SecurityDetails.AlarmType = endorsementState.SecurityDetails.AlarmType;
            }
        }

        function addDoorSecurity(doorSecurity) {

            if (doorSecurity) {
                if (doorSecurity === 'NoneOfTheAbove') {
                    vm.state.SecurityDetails.DoorSecurities = [];
                    return;
                }

                vm.state.SecurityDetails.DoorSecurities.push(doorSecurity);
            }
        }

        function isClaimsInLast3YearsChanged() {
            if (!vm.state.Claims.IsClaimsInLast3Years) {
                vm.state.Claims.ClaimsList = [{ ClaimYear: null, ClaimType: null, CostOfClaim: 0 }];
                vm.checkNullClaimList = false;
            }
            else if (vm.IsEndorsement && vm.state.Claims.IsClaimsInLast3Years) {
                vm.state.Claims.ClaimsList = angular.copy(endorsementState.Claims.ClaimsList);
                vm.checkNullClaimList = true;
            }
            else
                vm.checkNullClaimList = true;

        }

        vm.decimalConfig = {
            sbMin: 0,
            sbMax: keyConstService.AmountMax999999999,
            sbPrecision: 2,
            sbMaxPrecision: 2
        }

        vm.textChange = function (field) {
            if (vm.selectedAddress === null) {
                field.$setValidity('invalid', false);
            } else {
                field.$setValidity('invalid', true);
            }
        };

        vm.checkValidManualAddress = function (field) {
            if (vm.mannualSearchText) {
                if (!vm.selectedMannualAddress) {
                    field.$setValidity('invalid', false);
                }
                else {
                    field.$setValidity('invalid', true);
                }
            }
        }

        function resetAddressData() {
            vm.showDomesticWorkerCompensation = false;
            vm.state.OptionalCover.IsDomesticWorkerCompensation = null;
            if (vm.state.PropertyDetail.IsManualAddress) {
                    vm.cordellBackupForFloorReset = null;
                    vm.previousAddress = [{
                        postcode: vm.state.PropertyDetail.Postcode,
                        text: vm.state.PropertyDetail.AddressText,
                        value: vm.state.PropertyDetail.AddressValue,
                    }];

                    vm.previousSelectedAddress = vm.state.PropertyDetail.AddressText;
                    vm.state.PropertyDetail.Address = null;
                    vm.selectedMannualAddress = null;
                    vm.state.PropertyDetail.AddressLine1 = null;
                    vm.state.PropertyDetail.AddressValue = null;
                    vm.resetPropertySection();
                } else {
                    //restore the address
                    vm.RestoreCordellData();
                    vm.state.PropertyDetail.AddressText = vm.previousSelectedAddress;
                     if (vm.previousAddress && vm.previousAddress[0].text) {
                        vm.selectedAddress = vm.previousAddress[0];
                    }
                    else {
                        vm.resetPropertySection();
                    }
                }
            //}

             }

       


        function RestoreCordellData() {
            if (vm.cordellDataBackup) {
                vm.state.CordellResponse.Propertydata.periodName = vm.cordellDataBackup.periodName;
                vm.state.CordellResponse.Propertydata.yearBuilt = vm.cordellDataBackup.yearBuilt;
                vm.state.CordellResponse.Propertydata.externalWallMaterial = vm.cordellDataBackup.externalWallMaterial;
                vm.state.CordellResponse.Propertydata.roof = vm.cordellDataBackup.roof;
                vm.state.CordellResponse.Propertydata.quality = vm.cordellDataBackup.quality;
                vm.state.CordellResponse.Propertydata.levels = vm.cordellDataBackup.levels;
                vm.state.CordellResponse.Propertydata.knowTheArea = vm.cordellDataBackup.knowTheArea;
                vm.state.CordellResponse.Propertydata.floorArea = vm.cordellDataBackup.floorArea;
                vm.state.CordellResponse.Propertydata.bushland = vm.cordellDataBackup.bushland;
                vm.state.CordellResponse.Propertydata.slope = vm.cordellDataBackup.slope;
                vm.state.CordellResponse.Propertydata.roomBathSizeList = vm.cordellDataBackup.roomBathSizeList;
                vm.state.CordellResponse.Propertydata.roomBath1Size = vm.cordellDataBackup.roomBath1Size;
                vm.state.CordellResponse.Propertydata.roomBath2Size = vm.cordellDataBackup.roomBath2Size;
                vm.state.CordellResponse.Propertydata.roomBath3Size = vm.cordellDataBackup.roomBath3Size;
                vm.state.CordellResponse.Propertydata.roomBath4Size = vm.cordellDataBackup.roomBath4Size;
                vm.state.CordellResponse.Propertydata.roomBath5Size = vm.cordellDataBackup.roomBath5Size;
                vm.state.CordellResponse.Propertydata.roomBath6Size = vm.cordellDataBackup.roomBath6Size;
                vm.state.CordellResponse.Propertydata.knowTheArea = vm.cordellDataBackup.knowTheArea;

            }
        }

        function ResetCordellData() {
            vm.state.CordellResponse.Propertydata.periodName = null,
                vm.state.CordellResponse.Propertydata.yearBuilt = null;
            vm.state.CordellResponse.Propertydata.bushland = null;
            vm.state.CordellResponse.Propertydata.slope = null;
            vm.state.CordellResponse.Propertydata.externalWallMaterial = null;
            vm.state.CordellResponse.Propertydata.roof = null;
            vm.state.CordellResponse.Propertydata.floorArea = null;
            vm.state.CordellResponse.Propertydata.quality = null;
            vm.state.CordellResponse.Propertydata.levels = 0;
            vm.state.CordellResponse.Propertydata.knowTheArea = null;
            resetCordellRestData();

        }

        function resetCordellRestData() {
            vm.state.CordellResponse.Propertydata.roomBed = 0;
            vm.state.CordellResponse.Propertydata.roomBedSizeList = null;
            vm.state.CordellResponse.Propertydata.roomBed1Size = null,
                vm.state.CordellResponse.Propertydata.roomBed2Size = null,
                vm.state.CordellResponse.Propertydata.roomBed3Size = null,
                vm.state.CordellResponse.Propertydata.roomBed4Size = null,
                vm.state.CordellResponse.Propertydata.roomBed5Size = null,
                vm.state.CordellResponse.Propertydata.roomBed6Size = null,
                vm.state.CordellResponse.Propertydata.roomBed7Size = null,
                vm.state.CordellResponse.Propertydata.roomBed8Size = null,
                vm.state.CordellResponse.Propertydata.roomBed9Size = null,
                vm.state.CordellResponse.Propertydata.roomBath = 0;
            vm.state.CordellResponse.Propertydata.roomBathSizeList = null;
            vm.state.CordellResponse.Propertydata.roomBath1Size = null,
                vm.state.CordellResponse.Propertydata.roomBath2Size = null,
                vm.state.CordellResponse.Propertydata.roomBath3Size = null,
                vm.state.CordellResponse.Propertydata.roomBath4Size = null,
                vm.state.CordellResponse.Propertydata.roomBath5Size = null,
                vm.state.CordellResponse.Propertydata.roomBath6Size = null,
                vm.state.CordellResponse.Propertydata.roomToilet = 0;
            vm.state.CordellResponse.Propertydata.garage = 0;
            vm.state.CordellResponse.Propertydata.roomKitchen = 0;
            vm.state.CordellResponse.Propertydata.kitchenSizeList = null;
            vm.state.CordellResponse.Propertydata.roomKitchen1Size = null,
                vm.state.CordellResponse.Propertydata.roomKitchen2Size = null,
                vm.state.CordellResponse.Propertydata.roomLaundry = 0;
            vm.state.CordellResponse.Propertydata.roomLaundrySizeList = null;
            vm.state.CordellResponse.Propertydata.roomLaundry1Size = null,
                vm.state.CordellResponse.Propertydata.roomLaundry2Size = null,
                vm.state.CordellResponse.Propertydata.roomEntryFoyerSize = null;
            vm.state.CordellResponse.Propertydata.roomLivingSize = null;
            vm.state.CordellResponse.Propertydata.roomDiningSize = null;
            vm.state.CordellResponse.Propertydata.roomFamilySize = null;
            vm.state.CordellResponse.Propertydata.roomRumpusSize = null;
            vm.state.CordellResponse.Propertydata.roomSunSize = null;
            vm.state.CordellResponse.Propertydata.roomBilliardSize = null;
            vm.state.CordellResponse.Propertydata.roomHomeTheatreSize = null;
            vm.state.CordellResponse.Propertydata.roomOther = null;
            vm.state.CordellResponse.Propertydata.roomOtherSizeList = null;
            vm.state.CordellResponse.Propertydata.roomOther1Size = null,
                vm.state.CordellResponse.Propertydata.roomOther2Size = null,
                vm.state.CordellResponse.Propertydata.roomWardrobeBuiltin = null;
            vm.state.CordellResponse.Propertydata.roomLinenCloset = null;
            vm.state.CordellResponse.Propertydata.roomWardrobeWalkin = null;
            vm.state.CordellResponse.Propertydata.carport = 0;
            vm.state.CordellResponse.Propertydata.balconyDeck = 0;
            vm.state.CordellResponse.Propertydata.porchVerandah = 0;
            vm.state.CordellResponse.Propertydata.retainingWalls = null;
            vm.state.CordellResponse.Propertydata.cabin = 0;
            vm.state.CordellResponse.Propertydata.cabinSizeList = null;
            vm.state.CordellResponse.Propertydata.cabin1Size = null,
                vm.state.CordellResponse.Propertydata.cabin2Size = null,
                vm.state.CordellResponse.Propertydata.cabin3Size = null,
                vm.state.CordellResponse.Propertydata.heatingCooling_Included = null;
            vm.state.CordellResponse.Propertydata.heatingCooling_airConDuctedType = null;
            vm.state.CordellResponse.Propertydata.heatingCooling_airConStandalone = null;
            vm.state.CordellResponse.Propertydata.heatingCooling_fireplace = null;
            vm.state.CordellResponse.Propertydata.solar_Included = null;
            vm.state.CordellResponse.Propertydata.solar_HotWater = null;
            vm.state.CordellResponse.Propertydata.solar_Electricity = null;
            vm.state.CordellResponse.Propertydata.shed_Included = null;
            vm.state.CordellResponse.Propertydata.shed_Small = 0;
            vm.state.CordellResponse.Propertydata.shed_Large = 0;
            vm.state.CordellResponse.Propertydata.poolSpa_Included = null;
            vm.state.CordellResponse.Propertydata.poolSpa_SpaType = null;
            vm.state.CordellResponse.Propertydata.poolSpa_ConcretePoolSize = null;
            vm.state.CordellResponse.Propertydata.poolSpa_FibreglassPoolSize = null;
            vm.state.CordellResponse.Propertydata.poolSpa_VinylPoolSize = null;
            vm.state.CordellResponse.Propertydata.tennisCourt_Included = null;
            vm.state.CordellResponse.Propertydata.tennisCourt_Number = 0;
            vm.state.CordellResponse.Propertydata.tennisCourt_SurfaceType = null;
            vm.state.CordellResponse.Propertydata.tennisCourt_Lighting = null;
        }

        function setNonFloorAreaDetail() {
            if (!vm.state.CordellResponse.Propertydata.knowTheArea) {
                if (vm.cordellBackupForFloorReset) {
                    vm.state.CordellResponse.Propertydata.floorArea = vm.cordellBackupForFloorReset.floorArea;
                    vm.state.CordellResponse.Propertydata.roomBed = vm.cordellBackupForFloorReset.roomBed;
                    vm.state.CordellResponse.Propertydata.roomBed1Size = vm.cordellBackupForFloorReset.roomBed1Size,
                        vm.state.CordellResponse.Propertydata.roomBed2Size = vm.cordellBackupForFloorReset.roomBed2Size,
                        vm.state.CordellResponse.Propertydata.roomBed3Size = vm.cordellBackupForFloorReset.roomBed3Size,
                        vm.state.CordellResponse.Propertydata.roomBed4Size = vm.cordellBackupForFloorReset.roomBed4Size,
                        vm.state.CordellResponse.Propertydata.roomBed5Size = vm.cordellBackupForFloorReset.roomBed5Size,
                        vm.state.CordellResponse.Propertydata.roomBed6Size = vm.cordellBackupForFloorReset.roomBed6Size,
                        vm.state.CordellResponse.Propertydata.roomBed7Size = vm.cordellBackupForFloorReset.roomBed7Size,
                        vm.state.CordellResponse.Propertydata.roomBed8Size = vm.cordellBackupForFloorReset.roomBed8Size,
                        vm.state.CordellResponse.Propertydata.roomBed9Size = vm.cordellBackupForFloorReset.roomBed9Size,
                        vm.state.CordellResponse.Propertydata.roomBedSizeList = vm.cordellBackupForFloorReset.roomBedSizeList;
                    vm.state.CordellResponse.Propertydata.roomBath = vm.cordellBackupForFloorReset.roomBath;
                    vm.state.CordellResponse.Propertydata.roomBathSizeList = vm.cordellBackupForFloorReset.roomBathSizeList;
                    vm.state.CordellResponse.Propertydata.roomBath1Size = vm.cordellBackupForFloorReset.roomBath1Size;
                    vm.state.CordellResponse.Propertydata.roomBath2Size = vm.cordellBackupForFloorReset.roomBath2Size;
                    vm.state.CordellResponse.Propertydata.roomBath3Size = vm.cordellBackupForFloorReset.roomBath3Size;
                    vm.state.CordellResponse.Propertydata.roomBath4Size = vm.cordellBackupForFloorReset.roomBath4Size;
                    vm.state.CordellResponse.Propertydata.roomBath5Size = vm.cordellBackupForFloorReset.roomBath5Size;
                    vm.state.CordellResponse.Propertydata.roomBath6Size = vm.cordellBackupForFloorReset.roomBath6Size;
                    vm.state.CordellResponse.Propertydata.roomToilet = vm.cordellBackupForFloorReset.roomToilet;
                    vm.state.CordellResponse.Propertydata.garage = vm.cordellBackupForFloorReset.garage;
                    vm.state.CordellResponse.Propertydata.roomKitchen = vm.cordellBackupForFloorReset.roomKitchen;
                    vm.state.CordellResponse.Propertydata.kitchenSizeList = vm.cordellBackupForFloorReset.kitchenSizeList;
                    vm.state.CordellResponse.Propertydata.roomKitchen1Size = vm.cordellBackupForFloorReset.roomKitchen1Size;
                    vm.state.CordellResponse.Propertydata.roomKitchen2Size = vm.cordellBackupForFloorReset.roomKitchen2Size;
                    vm.state.CordellResponse.Propertydata.roomLaundry = vm.cordellBackupForFloorReset.roomLaundry;
                    vm.state.CordellResponse.Propertydata.roomLaundrySizeList = vm.cordellBackupForFloorReset.roomLaundrySizeList;
                    vm.state.CordellResponse.Propertydata.roomLaundry1Size = vm.cordellBackupForFloorReset.roomLaundry1Size;
                    vm.state.CordellResponse.Propertydata.roomLaundry2Size = vm.cordellBackupForFloorReset.roomLaundry2Size;
                    vm.state.CordellResponse.Propertydata.roomEntryFoyerSize = vm.cordellBackupForFloorReset.roomEntryFoyerSize;
                    vm.state.CordellResponse.Propertydata.roomLivingSize = vm.cordellBackupForFloorReset.roomLivingSize;
                    vm.state.CordellResponse.Propertydata.roomDiningSize = vm.cordellBackupForFloorReset.roomDiningSize;
                    vm.state.CordellResponse.Propertydata.roomFamilySize = vm.cordellBackupForFloorReset.roomFamilySize;
                    vm.state.CordellResponse.Propertydata.roomRumpusSize = vm.cordellBackupForFloorReset.roomRumpusSize;
                    vm.state.CordellResponse.Propertydata.roomSunSize = vm.cordellBackupForFloorReset.roomSunSize;
                    vm.state.CordellResponse.Propertydata.roomBilliardSize = vm.cordellBackupForFloorReset.roomBilliardSize;
                    vm.state.CordellResponse.Propertydata.roomHomeTheatreSize = vm.cordellBackupForFloorReset.roomHomeTheatreSize;
                    vm.state.CordellResponse.Propertydata.roomOther = vm.cordellBackupForFloorReset.roomOther;
                    vm.state.CordellResponse.Propertydata.roomOtherSizeList = vm.cordellBackupForFloorReset.roomOtherSizeList;
                    vm.state.CordellResponse.Propertydata.roomOther1Size = vm.cordellBackupForFloorReset.roomOther1Size;
                    vm.state.CordellResponse.Propertydata.roomOther2Size = vm.cordellBackupForFloorReset.roomOther2Size;
                    vm.state.CordellResponse.Propertydata.roomWardrobeBuiltin = vm.cordellBackupForFloorReset.roomWardrobeBuiltin;
                    vm.state.CordellResponse.Propertydata.roomLinenCloset = vm.cordellBackupForFloorReset.roomLinenCloset;
                    vm.state.CordellResponse.Propertydata.roomWardrobeWalkin = vm.cordellBackupForFloorReset.roomWardrobeWalkin;
                    vm.state.CordellResponse.Propertydata.carport = vm.cordellBackupForFloorReset.carport;
                    vm.state.CordellResponse.Propertydata.balconyDeck = vm.cordellBackupForFloorReset.balconyDeck;
                    vm.state.CordellResponse.Propertydata.porchVerandah = vm.cordellBackupForFloorReset.porchVerandah;
                    vm.state.CordellResponse.Propertydata.retainingWalls = vm.cordellBackupForFloorReset.retainingWalls;
                    vm.state.CordellResponse.Propertydata.cabin = vm.cordellBackupForFloorReset.cabin;
                    vm.state.CordellResponse.Propertydata.cabinSizeList = vm.cordellBackupForFloorReset.cabinSizeList;
                    vm.state.CordellResponse.Propertydata.cabin1Size = vm.cordellBackupForFloorReset.cabin1Size;
                    vm.state.CordellResponse.Propertydata.cabin2Size = vm.cordellBackupForFloorReset.cabin2Size;
                    vm.state.CordellResponse.Propertydata.cabin3Size = vm.cordellBackupForFloorReset.cabin3Size;
                    vm.state.CordellResponse.Propertydata.heatingCooling_Included = vm.cordellBackupForFloorReset.heatingCooling_Included;
                    vm.state.CordellResponse.Propertydata.heatingCooling_airConDuctedType = vm.cordellBackupForFloorReset.heatingCooling_airConDuctedType;
                    vm.state.CordellResponse.Propertydata.heatingCooling_airConStandalone = vm.cordellBackupForFloorReset.heatingCooling_airConStandalone;
                    vm.state.CordellResponse.Propertydata.heatingCooling_fireplace = vm.cordellBackupForFloorReset.heatingCooling_fireplace;
                    vm.state.CordellResponse.Propertydata.solar_Included = vm.cordellBackupForFloorReset.solar_Included;
                    vm.state.CordellResponse.Propertydata.solar_HotWater = vm.cordellBackupForFloorReset.solar_HotWater;
                    vm.state.CordellResponse.Propertydata.solar_Electricity = vm.cordellBackupForFloorReset.solar_Electricity;
                    vm.state.CordellResponse.Propertydata.shed_Included = vm.cordellBackupForFloorReset.shed_Included;
                    vm.state.CordellResponse.Propertydata.shed_Small = vm.cordellBackupForFloorReset.shed_Small;
                    vm.state.CordellResponse.Propertydata.shed_Large = vm.cordellBackupForFloorReset.shed_Large;
                    vm.state.CordellResponse.Propertydata.poolSpa_Included = vm.cordellBackupForFloorReset.poolSpa_Included;
                    vm.state.CordellResponse.Propertydata.poolSpa_SpaType = vm.cordellBackupForFloorReset.poolSpa_SpaType;
                    vm.state.CordellResponse.Propertydata.poolSpa_ConcretePoolSize = vm.cordellBackupForFloorReset.poolSpa_ConcretePoolSize;
                    vm.state.CordellResponse.Propertydata.poolSpa_FibreglassPoolSize = vm.cordellBackupForFloorReset.poolSpa_FibreglassPoolSize;
                    vm.state.CordellResponse.Propertydata.poolSpa_VinylPoolSize = vm.cordellBackupForFloorReset.poolSpa_VinylPoolSize;
                    vm.state.CordellResponse.Propertydata.tennisCourt_Included = vm.cordellBackupForFloorReset.tennisCourt_Included;
                    vm.state.CordellResponse.Propertydata.tennisCourt_Number = vm.cordellBackupForFloorReset.tennisCourt_Number;
                    vm.state.CordellResponse.Propertydata.tennisCourt_SurfaceType = vm.cordellBackupForFloorReset.tennisCourt_SurfaceType;
                    vm.state.CordellResponse.Propertydata.tennisCourt_Lighting = vm.cordellBackupForFloorReset.tennisCourt_Lighting;
                    SetCordelFields();
                }
                if (vm.IsEndorsement && vm.state.PropertyDetail.AddressText === endorsementState.PropertyDetail.AddressText) {
                    vm.state.CordellResponse.Propertydata.floorArea = angular.copy(endorsementState.CordellResponse.Propertydata.floorArea);
                    vm.state.CordellResponse.Propertydata.roomBed = angular.copy(endorsementState.CordellResponse.Propertydata.roomBed);
                    vm.state.CordellResponse.Propertydata.roomKitchen = angular.copy(endorsementState.CordellResponse.Propertydata.roomKitchen);
                    vm.state.CordellResponse.Propertydata.kitchenSizeList = angular.copy(endorsementState.CordellResponse.Propertydata.kitchenSizeList);
                    vm.state.CordellResponse.Propertydata.roomKitchen1Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomKitchen1Size);
                    vm.state.CordellResponse.Propertydata.roomKitchen2Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomKitchen2Size);
                    vm.state.CordellResponse.Propertydata.roomBedSizeList = angular.copy(endorsementState.CordellResponse.Propertydata.roomBedSizeList);
                    vm.state.CordellResponse.Propertydata.roomBed1Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomBed1Size);
                    vm.state.CordellResponse.Propertydata.roomBed2Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomBed2Size);
                    vm.state.CordellResponse.Propertydata.roomBed3Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomBed3Size);
                    vm.state.CordellResponse.Propertydata.roomBed4Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomBed4Size);
                    vm.state.CordellResponse.Propertydata.roomBed5Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomBed5Size);
                    vm.state.CordellResponse.Propertydata.roomBed6Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomBed6Size);
                    vm.state.CordellResponse.Propertydata.roomBed7Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomBed7Size);
                    vm.state.CordellResponse.Propertydata.roomBed8Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomBed8Size);
                    vm.state.CordellResponse.Propertydata.roomBed9Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomBed9Size);
                    vm.state.CordellResponse.Propertydata.roomBath = angular.copy(endorsementState.CordellResponse.Propertydata.roomBath);
                    vm.state.CordellResponse.Propertydata.roomBathSizeList = angular.copy(endorsementState.CordellResponse.Propertydata.roomBathSizeList);
                    vm.state.CordellResponse.Propertydata.roomBath1Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomBath1Size);
                    vm.state.CordellResponse.Propertydata.roomBath2Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomBath2Size);
                    vm.state.CordellResponse.Propertydata.roomBath3Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomBath3Size);
                    vm.state.CordellResponse.Propertydata.roomBath4Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomBath4Size);
                    vm.state.CordellResponse.Propertydata.roomBath5Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomBath5Size);
                    vm.state.CordellResponse.Propertydata.roomBath6Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomBath6Size);
                    vm.state.CordellResponse.Propertydata.roomToilet = angular.copy(endorsementState.CordellResponse.Propertydata.roomToilet);
                    vm.state.CordellResponse.Propertydata.garage = angular.copy(endorsementState.CordellResponse.Propertydata.garage);
                    vm.state.CordellResponse.Propertydata.roomLaundry = angular.copy(endorsementState.CordellResponse.Propertydata.roomLaundry);
                    vm.state.CordellResponse.Propertydata.roomLaundrySizeList = angular.copy(endorsementState.CordellResponse.Propertydata.roomLaundrySizeList);
                    vm.state.CordellResponse.Propertydata.roomLaundry1Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomLaundry1Size);
                    vm.state.CordellResponse.Propertydata.roomLaundry2Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomLaundry2Size);
                    vm.state.CordellResponse.Propertydata.roomEntryFoyerSize = angular.copy(endorsementState.CordellResponse.Propertydata.roomEntryFoyerSize);
                    vm.state.CordellResponse.Propertydata.roomLivingSize = angular.copy(endorsementState.CordellResponse.Propertydata.roomLivingSize);
                    vm.state.CordellResponse.Propertydata.roomDiningSize = angular.copy(endorsementState.CordellResponse.Propertydata.roomDiningSize);
                    vm.state.CordellResponse.Propertydata.roomFamilySize = angular.copy(endorsementState.CordellResponse.Propertydata.roomFamilySize);
                    vm.state.CordellResponse.Propertydata.roomRumpusSize = angular.copy(endorsementState.CordellResponse.Propertydata.roomRumpusSize);
                    vm.state.CordellResponse.Propertydata.roomSunSize = angular.copy(endorsementState.CordellResponse.Propertydata.roomSunSize);
                    vm.state.CordellResponse.Propertydata.roomBilliardSize = angular.copy(endorsementState.CordellResponse.Propertydata.roomBilliardSize);
                    vm.state.CordellResponse.Propertydata.roomHomeTheatreSize = angular.copy(endorsementState.CordellResponse.Propertydata.roomHomeTheatreSize);
                    vm.state.CordellResponse.Propertydata.roomOther = angular.copy(endorsementState.CordellResponse.Propertydata.roomOther);
                    vm.state.CordellResponse.Propertydata.roomOtherSizeList = angular.copy(endorsementState.CordellResponse.Propertydata.roomOtherSizeList);
                    vm.state.CordellResponse.Propertydata.roomOther1Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomOther1Size);
                    vm.state.CordellResponse.Propertydata.roomOther2Size = angular.copy(endorsementState.CordellResponse.Propertydata.roomOther2Size);
                    vm.state.CordellResponse.Propertydata.roomWardrobeBuiltin = angular.copy(endorsementState.CordellResponse.Propertydata.roomWardrobeBuiltin);
                    vm.state.CordellResponse.Propertydata.roomLinenCloset = angular.copy(endorsementState.CordellResponse.Propertydata.roomLinenCloset);
                    vm.state.CordellResponse.Propertydata.roomWardrobeWalkin = angular.copy(endorsementState.CordellResponse.Propertydata.roomWardrobeWalkin);
                    vm.state.CordellResponse.Propertydata.carport = angular.copy(endorsementState.CordellResponse.Propertydata.carport);
                    vm.state.CordellResponse.Propertydata.balconyDeck = angular.copy(endorsementState.CordellResponse.Propertydata.balconyDeck);
                    vm.state.CordellResponse.Propertydata.porchVerandah = angular.copy(endorsementState.CordellResponse.Propertydata.porchVerandah);
                    vm.state.CordellResponse.Propertydata.retainingWalls = angular.copy(endorsementState.CordellResponse.Propertydata.retainingWalls);
                    vm.state.CordellResponse.Propertydata.cabin = angular.copy(endorsementState.CordellResponse.Propertydata.cabin);
                    vm.state.CordellResponse.Propertydata.cabinSizeList = angular.copy(endorsementState.CordellResponse.Propertydata.cabinSizeList);
                    vm.state.CordellResponse.Propertydata.cabin1Size = angular.copy(endorsementState.CordellResponse.Propertydata.cabin1Size);
                    vm.state.CordellResponse.Propertydata.cabin2Size = angular.copy(endorsementState.CordellResponse.Propertydata.cabin2Size);
                    vm.state.CordellResponse.Propertydata.cabin3Size = angular.copy(endorsementState.CordellResponse.Propertydata.cabin3Size);
                    vm.state.CordellResponse.Propertydata.heatingCooling_Included = angular.copy(endorsementState.CordellResponse.Propertydata.heatingCooling_Included);
                    vm.state.CordellResponse.Propertydata.heatingCooling_airConDuctedType = angular.copy(endorsementState.CordellResponse.Propertydata.heatingCooling_airConDuctedType);
                    vm.state.CordellResponse.Propertydata.heatingCooling_airConStandalone = angular.copy(endorsementState.CordellResponse.Propertydata.heatingCooling_airConStandalone);
                    vm.state.CordellResponse.Propertydata.heatingCooling_fireplace = angular.copy(endorsementState.CordellResponse.Propertydata.heatingCooling_fireplace);
                    vm.state.CordellResponse.Propertydata.solar_Included = angular.copy(endorsementState.CordellResponse.Propertydata.solar_Included);
                    vm.state.CordellResponse.Propertydata.solar_HotWater = angular.copy(endorsementState.CordellResponse.Propertydata.solar_HotWater);
                    vm.state.CordellResponse.Propertydata.solar_Electricity = angular.copy(endorsementState.CordellResponse.Propertydata.solar_Electricity);
                    vm.state.CordellResponse.Propertydata.shed_Included = angular.copy(endorsementState.CordellResponse.Propertydata.shed_Included);
                    vm.state.CordellResponse.Propertydata.shed_Small = angular.copy(endorsementState.CordellResponse.Propertydata.shed_Small);
                    vm.state.CordellResponse.Propertydata.shed_Large = angular.copy(endorsementState.CordellResponse.Propertydata.shed_Large);
                    vm.state.CordellResponse.Propertydata.poolSpa_Included = angular.copy(endorsementState.CordellResponse.Propertydata.poolSpa_Included);
                    vm.state.CordellResponse.Propertydata.poolSpa_SpaType = angular.copy(endorsementState.CordellResponse.Propertydata.poolSpa_SpaType);
                    vm.state.CordellResponse.Propertydata.poolSpa_ConcretePoolSize = angular.copy(endorsementState.CordellResponse.Propertydata.poolSpa_ConcretePoolSize);
                    vm.state.CordellResponse.Propertydata.poolSpa_FibreglassPoolSize = angular.copy(endorsementState.CordellResponse.Propertydata.poolSpa_FibreglassPoolSize);
                    vm.state.CordellResponse.Propertydata.poolSpa_VinylPoolSize = angular.copy(endorsementState.CordellResponse.Propertydata.poolSpa_VinylPoolSize);
                    vm.state.CordellResponse.Propertydata.tennisCourt_Included = angular.copy(endorsementState.CordellResponse.Propertydata.tennisCourt_Included);
                    vm.state.CordellResponse.Propertydata.tennisCourt_Number = angular.copy(endorsementState.CordellResponse.Propertydata.tennisCourt_Number);
                    vm.state.CordellResponse.Propertydata.tennisCourt_SurfaceType = angular.copy(endorsementState.CordellResponse.Propertydata.tennisCourt_SurfaceType);
                    vm.state.CordellResponse.Propertydata.tennisCourt_Lighting = angular.copy(endorsementState.CordellResponse.Propertydata.tennisCourt_Lighting);
                    SetCordelFields();
                }
            }
        }

        function nextPremium() {
            if (vm.policyTransactionId) {
                $window.location.href = webUrlConstService.bindIndex + sessionStorageService.getEncryption('id=' + vm.policyTransactionId);
                sessionStorageService.remove(keyConstService.getTransactionIdWithoutSaving);
                sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
            }
            else {
                window.location = webUrlConstService.quoteCasePremiumURL + sessionStorageService.getEncryption('quoteTransactionId=' + vm.TransactionId);
            }
        }

        function isAdditionalPolicyHolderChange() {
            if (!vm.state.Insured.IsAdditionalPolicyHolder) {
                vm.state.Insured.AdditionalPolicyHolderList = [{ AdditionalPolicyHolder: null, AdditionalDateOfBirth: null, AdditionalPolicyHolderType: null, OtherPolicyHolderName: null, OtherDateOfBirth: null }];
            }

        }

        function AnnualRevenueRange(field) {
            var prevValue = 0;
            var total = vm.maxOccupationTurnover.reduce(function (prevValue, elem) {
                if (vm.state.OtherInfo.OccupationName === elem.Text) {
                    vm.maxTurnOver = elem.MaxTurnOver;
                    vm.state.OtherInfo.OccupationANZSIC = elem.Value;
                }
                return elem;
            }, 0);

            if ((vm.state.OtherInfo.AnnualRevenue !== 0) && (vm.state.OtherInfo.AnnualRevenue > vm.maxTurnOver)) {
                field.$setValidity('invalid', false);
            } else {
                field.$setValidity('invalid', true);
            }
        }

        vm.removePortableSpecifiedItems = function (item) {
            var index = vm.state.ContentsSumInsured.SpecifiedPortableItems.indexOf(item);
            vm.state.ContentsSumInsured.SpecifiedPortableItems.splice(index, 1);
        }

        vm.addPortableSpecifiedItems = function () {
            vm.state.ContentsSumInsured.SpecifiedPortableItems.push({ PortableCategory: null, PortableDescription: null, PortableValue: null });
        }

        vm.checkConstructionPeriod = function () {
            var defaultStart = '01/01/' + new Date().getFullYear();
            vm.state.CordellResponse.Propertydata.yearBuilt
        }

        vm.IsAdditionalClaimDisabled = function (item, index) {

            if (item !== null) {
                vm.DisableAddClaim = false;
            }

            if (vm.state.Claims.ClaimsList.length <= 1) {
                if (!item) {
                    vm.checkNullClaimList = true;
                    vm.state.Claims.ClaimsList = [{ ClaimYear: null, ClaimType: null, CostOfClaim: 0 }];
                }
            }

            if (item === 'TheftWithoutBreakIn' || item === 'Bushfire' || item === 'Storm') {
                vm.state.Claims.ClaimsList[index].CostOfClaim = 0;
            }

            if (isNewEditTransaction) {
                if (item !== 'Theft' || item !== 'BushfireOrflood') {
                    vm.state.Claims.ClaimsList[index].CostOfClaim = 0;
                }
            }
            // check validation of claim lists
            vm.checkClaims();
        };

        vm.IsSpecifiedItemDisabled = function (item) {
            if (item != null) {
                vm.DisableSpecifiedItem = false;
            }
        }

        function resetSumInsuredValue() {

            if (vm.state.PolicyHolder.BuildingCover) {
                if (vm.IsEndorsement) {
                    vm.state.CordellResponse.BuildingSumInsuredEstimate = 0;
                }
                else {
                    if (vm.cordellBackupForFloorReset) {
                        //During Page Load Condition at new business
                        if (vm.version >= keyConstService.Version) {
                            //// adding roombed and roombath for version > 2
                            if ((vm.state.CordellResponse.Propertydata.externalWallMaterial !== vm.cordellBackupForFloorReset.externalWallMaterial) || (vm.state.CordellResponse.Propertydata.roof !== vm.cordellBackupForFloorReset.roof) || (vm.state.CordellResponse.Propertydata.quality !== vm.cordellBackupForFloorReset.quality) || (vm.state.CordellResponse.Propertydata.levels !== vm.cordellBackupForFloorReset.levels) || (vm.state.CordellResponse.Propertydata.yearBuilt !== vm.cordellBackupForFloorReset.yearBuilt) || (vm.state.CordellResponse.Propertydata.periodName !== vm.cordellBackupForFloorReset.periodName) || (vm.state.CordellResponse.Propertydata.roomBath !== vm.cordellBackupForFloorReset.roomBath) || (vm.state.CordellResponse.Propertydata.roomBed !== vm.cordellBackupForFloorReset.roomBed)) {
                                if (vm.landlordStandardData.DDlProcessTypeId !== 4)
                                    vm.state.CordellResponse.BuildingSumInsured = 0;
                                vm.state.CordellResponse.BuildingSumInsuredEstimate = 0;
                                if (vm.landlordStandardData.DDlProcessTypeId !== 4)
                                    vm.BuildingSiFlag = true;
                                else
                                    vm.BuildingSiFlag = false;
                            }
                        }
                        else {
                            if ((vm.state.CordellResponse.Propertydata.externalWallMaterial != vm.cordellBackupForFloorReset.externalWallMaterial) || (vm.state.CordellResponse.Propertydata.roof != vm.cordellBackupForFloorReset.roof) || (vm.state.CordellResponse.Propertydata.quality != vm.cordellBackupForFloorReset.quality) || (vm.state.CordellResponse.Propertydata.levels != vm.cordellBackupForFloorReset.levels) || (vm.state.CordellResponse.Propertydata.yearBuilt != vm.cordellBackupForFloorReset.yearBuilt) || (vm.state.CordellResponse.Propertydata.periodName != vm.cordellBackupForFloorReset.periodName)) {
                                if (vm.landlordStandardData.DDlProcessTypeId !== 4)
                                    vm.state.CordellResponse.BuildingSumInsured = 0;
                                vm.state.CordellResponse.BuildingSumInsuredEstimate = 0;
                                if (vm.landlordStandardData.DDlProcessTypeId !== 4)
                                    vm.BuildingSiFlag = true;
                                else
                                    vm.BuildingSiFlag = false;
                            }
                        }
                    }
                    else if ($scope.isDefaultCheckClick === false){
                        if (vm.landlordStandardData.DDlProcessTypeId !== 4)
                            vm.state.CordellResponse.BuildingSumInsured = 0;
                        vm.state.CordellResponse.BuildingSumInsuredEstimate = 0;
                        if (vm.landlordStandardData.DDlProcessTypeId !== 4)
                            vm.BuildingSiFlag = true;
                        else
                            vm.BuildingSiFlag = false;
                    }
                }
            }
            $scope.isDefaultCheckClick = false;
        }

        vm.ResetBusinessSection = function () {
            if (!vm.state.OtherInfo.IsBusinessConductedHome) {
                vm.state.OtherInfo.IsBuyBusinessExtensionOption = false;
                vm.state.OtherInfo.BusinessName = null;
                vm.state.OtherInfo.OccupationName = null;
                vm.state.OtherInfo.AnnualRevenue = null;
                vm.state.OtherInfo.OccupationANZSIC = null;
                vm.state.OtherInfo.IsStampDutyExemption = null;
            }
            else if (vm.IsEndorsement && vm.state.OtherInfo.IsBusinessConductedHome) {
                vm.state.OtherInfo.IsBuyBusinessExtensionOption = endorsementState.OtherInfo.IsBuyBusinessExtensionOption;
                vm.state.OtherInfo.BusinessName = endorsementState.OtherInfo.BusinessName;
                vm.state.OtherInfo.OccupationName = endorsementState.OtherInfo.OccupationName;
                vm.state.OtherInfo.AnnualRevenue = endorsementState.OtherInfo.AnnualRevenue;
                vm.state.OtherInfo.OccupationANZSIC = endorsementState.OtherInfo.OccupationANZSIC;
                vm.state.OtherInfo.IsStampDutyExemption = endorsementState.OtherInfo.IsStampDutyExemption;
            }
        }

        vm.ResetBusinessExtensionSection = function () {
            if (!vm.state.OtherInfo.IsBuyBusinessExtensionOption) {
                vm.state.OtherInfo.BusinessName = null;
                vm.state.OtherInfo.OccupationName = null;
                vm.state.OtherInfo.AnnualRevenue = null;
                vm.state.OtherInfo.OccupationANZSIC = null;
                vm.state.OtherInfo.IsStampDutyExemption = null;
            }
            else if (vm.IsEndorsement && vm.state.OtherInfo.IsBuyBusinessExtensionOption) {
                vm.state.OtherInfo.BusinessName = endorsementState.OtherInfo.BusinessName;
                vm.state.OtherInfo.OccupationName = endorsementState.OtherInfo.OccupationName;
                vm.state.OtherInfo.AnnualRevenue = endorsementState.OtherInfo.AnnualRevenue;
                vm.state.OtherInfo.OccupationANZSIC = endorsementState.OtherInfo.OccupationANZSIC;
                vm.state.OtherInfo.IsStampDutyExemption = endorsementState.OtherInfo.IsStampDutyExemption;
            }
        }

        vm.ResetPreviousInsurer = function () {
            if (vm.state.OtherInfo.PreviousInsurer !== "Other") {
                vm.state.OtherInfo.OtherPreviousInsurer = null;
            }
        }

        vm.ResetUnOccupiedProperty = function () {
            if (!vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsUnoccupiedProperty100days) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.UnoccupiedProperty100days = null;
                if (vm.version >= keyConstService.Version) {
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsPropertyBeingChecked = null;
                }
                }
            else if (vm.IsEndorsement && vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsUnoccupiedProperty100days) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.UnoccupiedProperty100days = endorsementState.UnderwritingCriteria.AnswerYesToFollowingData.UnoccupiedProperty100days;
            }
        }

        vm.ResetHomeConstructionSection = function () {
            if (!vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsHomeUnderConstructionRenovation) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.IsCostofRenovation = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.IsOpeningExternalRoofWalls = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.IsBuildingSecured = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.IsBuildingRainWaterProtected = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.IsContractWorksPolicy = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.ValueOfRenovation = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.WorkUndertaken = null;

            }
            else if (vm.IsEndorsement && vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsHomeUnderConstructionRenovation) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData = angular.copy(endorsementState.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData);
            }
        }

        // function for On click of address not found
        function onClickAddressNotFound() {
            vm.state.PropertyDetail.IsManualAddress = true;
            vm.searchText = null;
            resetAddressData();
        }
        //function to reset values on address input change
        function resetAddressNotFound() {
            vm.state.PropertyDetail.IsManualAddress = false;
            if (vm.state.PropertyDetail.AddressText) {
                vm.previousAddressTextForIllion = vm.state.PropertyDetail.AddressText;
            }            
            vm.resetAddressData();
        }
        //function for On click of address not found other insured
        function onClickAddressNotFoundOtherInsured() {
            vm.otherInsuredAddress.isManualAddress = true;
            vm.searchText1 = null;
            resetAddress();
        }
        //function to reset values on address input change other insured
        function resetAddressNotFoundOtherInsured() {
            vm.otherInsuredAddress.isManualAddress = false;
            resetAddress();
        }

        //reset costRenovation section version 2
        vm.resetCostOfRenovationsection = function() {
            if (!vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.IsCostofRenovation) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.ValueOfRenovation = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.WorkUndertaken = null;
            }
        }
        vm.ResetHeritageSection = function () {
            if (!vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsPropertyHeriatgeListed) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.PropertyHeritgeListingDetail = null;
            }
            else if (vm.IsEndorsement && vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsPropertyHeriatgeListed) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.PropertyHeritgeListingDetail = endorsementState.UnderwritingCriteria.AnswerYesToFollowingData.PropertyHeritgeListingDetail;
            }
        };

        vm.ResetAnswerYesToDataSection = function () {
            if (!vm.state.UnderwritingCriteria.IsAnswerYesToFollowing) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsUnoccupiedProperty100days = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.UnoccupiedProperty100days = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsHomeUnderConstructionRenovation = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsPoorlyMaintainedProperty = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsPropertyHeriatgeListed = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.PropertyHeritgeListingDetail = null;
                if (vm.version >= keyConstService.Version) {

                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.IsCostofRenovation = null;
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.IsOpeningExternalRoofWalls = null;
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.IsBuildingSecured = null;
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.IsBuildingRainWaterProtected = null;
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsPropertyBeingChecked = null;
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.IsHomeUnderConstructionRenovation = null;
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.ValueOfRenovation = null;
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate = null;
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate = null;
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.WorkUndertaken = null;
                    vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.IsContractWorksPolicy = null;
                }
            }
            else if (vm.IsEndorsement && vm.state.UnderwritingCriteria.IsAnswerYesToFollowing) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData = angular.copy(endorsementState.UnderwritingCriteria.AnswerYesToFollowingData);
            }
        };

      

        vm.ResetPortableItems = function (fieldSpecified, fieldUnspecified) {
            if (!vm.state.ContentsSumInsured.IsPortableValueCover) {
                vm.state.ContentsSumInsured.IsSpecifiedPortableItems = null;
                vm.state.ContentsSumInsured.IsUnspecifiedPortableItems = null;
                resetUnspecifiedItemsCover(fieldSpecified, fieldUnspecified);
                resetSpecifiedPortableItems(fieldSpecified, fieldUnspecified);
            }
            else if (vm.IsEndorsement && vm.state.ContentsSumInsured.IsPortableValueCover) {
                vm.state.ContentsSumInsured.IsSpecifiedPortableItems = endorsementState.ContentsSumInsured.IsSpecifiedPortableItems;
                vm.state.ContentsSumInsured.IsUnspecifiedPortableItems = endorsementState.ContentsSumInsured.IsUnspecifiedPortableItems;
                vm.state.ContentsSumInsured.UnspecifiedPortableItem = endorsementState.ContentsSumInsured.UnspecifiedPortableItem;
                vm.state.ContentsSumInsured.SpecifiedPortableItems = angular.copy(endorsementState.ContentsSumInsured.SpecifiedPortableItems);
            }
        }

        vm.InvalidZero = function (field, value) {
            var inp = $filter('number')(value);
            if (value) {
                if (inp != '0' && inp != '') {
                    field.$setValidity('validcurrency', true)
                    BuildingSumInsuredRange(field);
                    if (field.$name === 'ContentSumInsured') {
                        vm.ContentSiFlag = false;
                    }
                    if (field.$name === 'BuildingsSumInsured') {
                        vm.BuildingSiFlag = false;
                    }
                }
                else {
                    field.$setValidity('validcurrency', false);
                }
            }
            else {
                field.$setValidity('validcurrency', false);
            }
        }

        vm.RemoveInvalidZero = function (field, value, index) {           
            var inp = $filter('number')(value);
            if (value) {
                if (inp == '0') {
                    field.value = '';
                }
            }
        }

        function declineOnRewireCondition() {
            if (vm.state.CordellResponse.Propertydata.propertyRewired == false && !vm.IsEndorsement) {
                toastr.error(messageConstService.errDeclineOnPropertryRewire);
            }
        }

        function resetUnspecifiedItemsCover(fieldSpecified, fieldUnspecified) {
            if (!vm.state.ContentsSumInsured.IsUnspecifiedPortableItems) {
                vm.state.ContentsSumInsured.UnspecifiedPortableItem = null;
            }
            if (!vm.state.ContentsSumInsured.IsUnspecifiedPortableItems && !vm.state.ContentsSumInsured.IsSpecifiedPortableItems) {
                fieldUnspecified.$setValidity("fieldUnSpecified", false);

            }
            else {
                fieldUnspecified.$setValidity("fieldUnSpecified", true);
                fieldSpecified.$setValidity("fieldSpecified", true);
            }
            if (vm.IsEndorsement && vm.state.ContentsSumInsured.IsUnspecifiedPortableItems) {
                vm.state.ContentsSumInsured.UnspecifiedPortableItem = endorsementState.ContentsSumInsured.UnspecifiedPortableItem;
            }
        }

        function resetSpecifiedPortableItems(fieldSpecified, fieldUnspecified) {
            if (!vm.state.ContentsSumInsured.IsSpecifiedPortableItems) {
                vm.state.ContentsSumInsured.SpecifiedPortableItems = [{ PortableCategory: null, PortableDescription: null, PortableValue: null }]
            }

            if (!vm.state.ContentsSumInsured.IsUnspecifiedPortableItems && !vm.state.ContentsSumInsured.IsSpecifiedPortableItems) {
                fieldSpecified.$setValidity("fieldSpecified", false);
            }
            else {
                fieldUnspecified.$setValidity("fieldUnSpecified", true);
                fieldSpecified.$setValidity("fieldSpecified", true);
            }
            if (vm.IsEndorsement && vm.state.ContentsSumInsured.IsSpecifiedPortableItems) {
                vm.state.ContentsSumInsured.SpecifiedPortableItems = angular.copy(endorsementState.ContentsSumInsured.SpecifiedPortableItems);
            }
        }

        function resetPropertySection() {
            if (!vm.state.PropertyDetail.AddressText || vm.state.PropertyDetail.IsManualAddress === true) {

                vm.cordellDataBackup = angular.copy(vm.state.CordellResponse.Propertydata);
                vm.ResetCordellData();
                vm.state.CordellResponse.Propertydata.periodName = null;
                vm.state.CordellResponse.Propertydata.yearBuilt = null;
                vm.state.CordellResponse.Propertydata.externalWallMaterial = null;
                vm.state.CordellResponse.Propertydata.roof = null;
                vm.state.CordellResponse.Propertydata.quality = null;
                vm.state.CordellResponse.Propertydata.levels = null;
                vm.state.CordellResponse.BuildingSumInsuredEstimate = 0;

                if (!vm.IsEndorsement && vm.landlordStandardData.DDlProcessTypeId !== 4) {
                    vm.state.CordellResponse.BuildingSumInsured = 0;
                }
            }
        }

        vm.saveQuote = function () {
            if (vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate = dateService.getDateDDMMtoMMDD(vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate);
            }

            if (vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate = dateService.getDateDDMMtoMMDD(vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate);
            }
            if (vm.version >= keyConstService.Version) {
                //// as per requirement
                if (vm.state.CordellResponse.Propertydata.roomBed === null) {
                    vm.state.CordellResponse.Propertydata.roomBed = 0;
                }
                //// as per requirement
                if (vm.state.CordellResponse.Propertydata.roomBath === null) {
                    vm.state.CordellResponse.Propertydata.roomBath = 0;
                }
            }

            vm.disableButtons = true;
            sessionStorageService.remove(keyConstService.getTransactionIdWithoutSaving);
            sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
            sessionStorageService.remove(keyConstService.resetNonRegoData);
            sessionStorageService.remove(keyConstService.IllionAddressEnquiry);
            sessionStorageService.set(keyConstService.sessionStorageState, false);
            var transactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
            previousTransactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
            vm.rowVersion = JSON.parse(sessionStorageService.get(keyConstService.rowVersion));
            var automaticPayment = -1;
            if (vm.transactionStatus == "Draft") {
                isNewEditTransaction = false;
            }
            else {
                isNewEditTransaction = sessionStorageService.get(keyConstService.IsNewEditTransaction);
            }
            if (vm.endorsementVM != null) {
                vm.EffectiveDate = vm.endorsementVM.EndorsementEffectiveDate;
                ExpirationDate = vm.endorsementVM.ExpirationDate;
                vm.endorsementVM.BuildingExcess = vm.state.Excess.BuildingExcess1;
                vm.endorsementVM.ContentExcess = vm.state.Excess.ContentExcess1;

                sessionStorageService.set(keyConstService.endorsementRequestVM, vm.endorsementVM);
            }
            else {
                var newBusinessData = JSON.parse(sessionStorageService.get(keyConstService.newBusinessCaseData));
                if (newBusinessData) {
                    vm.EffectiveDate = newBusinessData.data.EffectiveDate;
                    ExpirationDate = newBusinessData.data.ExpirationDate;
                    automaticPayment = newBusinessData.data.BrokerManagedPayment;
                }
            }
            if (automaticPayment == -1) {
                automaticPayment = vm.brokerManagedPayment
            }
            vm.state.PaymentFrequency.BrokerManagedPayment = automaticPayment;
            var data = JSON.stringify(vm.state);
            var finalData = { SaveContent: data, EffectiveDate: vm.EffectiveDate, ExpirationDate: ExpirationDate, TransactionId: transactionId, NewEditTransaction: isNewEditTransaction, RowVersion: vm.rowVersion, PaymentFrequency: vm.state.PaymentFrequency.ModeOfPayment, InstallmentDate: vm.state.PaymentFrequency.DayofInstallment, BrokerManagedPayment: automaticPayment };
            var quoteRequest = quotesService.generateRequest(finalData, "LandlordStandard");
            quotesService.saveQuote(quoteRequest, "LandlordStandard").then(function (data) {
                if (data != null && data.data != null && data.data.error !== null && data.data.error.number === 402) {
                    $timeout(function () {
                        $window.location.href = webUrlConstService.homeIndex;
                    }, 1000);
                    return;
                }
                if (data && data.status === false) {
                    toastr.error(messageConstService.errRecordUpdated);
                    vm.disableButtons = false;
                }
                else if (data && data.status === true) {
                    toastr.success("Saved!");
                    //convert date back to orginal for UI display
                    if (vm.version >= keyConstService.Version) {
                        RenovationDateFormatReset();
                    }
                    //Remove PrimaryClientInsuredId
                    sessionStorageService.remove(keyConstService.PrimaryInsuredId);
                    vm.rowVersion = data.data.quoteTransaction.rowVersion;
                    isNewEditTransaction = false;
                    sessionStorageService.set(keyConstService.IsNewEditTransaction, isNewEditTransaction);
                    sessionStorageService.set(keyConstService.rowVersion, vm.rowVersion);
                    sessionStorageService.set(keyConstService.quoteTransactionId, data.data.quoteTransaction.id);
                    sessionStorageService.set(keyConstService.newBusinessCaseData.status, data.data.quoteTransaction.status);
                    var handledResponse = quotesService.handleResponse(data, "LandlordStandard");
                    vm.disableButtons = false;
                }
            }, function (e) {
                var myJSON = JSON.stringify(e);
                $log.error('error myJSON', myJSON);
                vm.disableButtons = false;
            });
        }

        function getTermsAndConditons() {
            $mdDialog.show($mdDialog.alert({
                title: 'Terms and Conditions',
                htmlContent: vm.landlordStandardData.CordelsTermsAndCondition,
                ok: 'Ok'
            }));

        }

        function finalSaving(finalData) {
            var quoteRequest = quotesService.generateRequest(finalData, "Home");
            quotesService.saveQuote(quoteRequest, "Home").then(function (data) {
                var handledResponse = quotesService.handleResponse(data, "Home");
            }, function (e) {
                var myJSON = JSON.stringify(e);
                $log.error('error myJSON', myJSON);
            });
        }

        //get quote for version 2.0 
        function getQuoteV2() {

            //// if contents only case , set default wallType, roof, roombed, roombath as per validatiton
            if (vm.state.PolicyHolder.ContentCover && !vm.state.PolicyHolder.BuildingCover) {
                vm.state.CordellResponse.Propertydata.externalWallMaterial = null;
                vm.state.CordellResponse.Propertydata.roof = null;
            }

            /// Overwriting roof and walltype for certain buiding types

            if (vm.state.PropertyDetail.BuildingType !== null) {
                if (vm.state.PropertyDetail.BuildingType === keyConstService.Apartments || vm.state.PropertyDetail.BuildingType === keyConstService.OtherDwellingType) {
                    vm.state.CordellResponse.Propertydata.externalWallMaterial = 'AAC panel';
                    vm.state.CordellResponse.Propertydata.roof = 'Concrete tile';
                }
            }

            //// as per requirement
            if (vm.state.CordellResponse.Propertydata.roomBed === null) {
                vm.state.CordellResponse.Propertydata.roomBed = 0;
            }

             //// as per requirement
            if (vm.state.CordellResponse.Propertydata.roomBath === null) {
                vm.state.CordellResponse.Propertydata.roomBath = 0;
            }

            //// old questions not in Version 2 should be null
            vm.state.OtherInfo.PreviousInsurer = null;
            vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsEverInsuranceDeclined = null;
            vm.state.UnderwritingCriteria.InsuredInLast3YearsData.ReasonEverInsuranceDeclined = null;

            //questions to be null if rent default date changes
            if (vm.IsRentDefaultChanges != null && !vm.IsRentDefaultChanges) {
                vm.state.OptionalCover.IsStatementForRentDefault = null;
                vm.state.OptionalCover.IsPropertyStatementForRentDefault = null;
            }
            else {
                vm.state.OptionalCover.IsRentMoreThan14Days = null;
            }

            /// Rent default child questions reset condition
            if (vm.IsRentDefaultChanges !== null && vm.IsRentDefaultChanges && !vm.state.OptionalCover.IsRentDefault && !vm.IsEndorsementPolicyEffectiveDate) {
                vm.state.OptionalCover.IsStatementForRentDefault = null;
                vm.state.OptionalCover.IsPropertyStatementForRentDefault = null;
            }

            var handledResponse = vm.getQuote();
            //// resets rennovation start and end date back to the format for it to be visible on UI
            RenovationDateFormatReset();
            if (handledResponse.data.error.number) {
                toastr.error(handledResponse.data.validationMessages);
            }         
        }

        function RenovationDateFormatReset() {
            if (vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate = dateService.getDateMMDDtoDDMM(vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate);
            }

            if (vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate = dateService.getDateMMDDtoDDMM(vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate);
            }
        }

        function finalGetQuote(finalData) {
            vm.disableButtons = true;
            sessionStorageService.remove(keyConstService.getTransactionIdWithoutSaving);
            sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
            sessionStorageService.remove(keyConstService.resetNonRegoData);
            sessionStorageService.remove(keyConstService.specialContentvalidity);
            sessionStorageService.remove(keyConstService.IllionAddressEnquiry);
            sessionStorageService.set(keyConstService.sessionStorageState, false);
            sessionStorageService.set(keyConstService.stampDutyExemption, vm.state.OtherInfo.IsStampDutyExemption);
            quotesService.generateQuote(quotesService.generateRequest(finalData, "LandlordStandard"), "LandlordStandard").then(function (data) {
                var handledResponse = quotesService.handleResponse(data, "LandlordStandard");
                if (handledResponse.status) {
                    sessionStorageService.remove(keyConstService.IsNewEditTransaction);
                    sessionStorageService.remove(keyConstService.IsCopyQuote);
                    sessionStorageService.remove(keyConstService.IsRenewalPolicy);
                    //Remove PrimaryClientInsuredId
                    sessionStorageService.remove(keyConstService.PrimaryInsuredId);
                    vm.rowVersion = handledResponse.data.rowVersion;
                    sessionStorageService.set(keyConstService.quoteTransactionId, handledResponse.data.transactionId);
                    if (handledResponse.data.error !== null) {
                        if (handledResponse.data.error.number === 401 || handledResponse.data.error.number === 402) {
                            if (handledResponse.data.error.number === 401) {
                                toastr.error(messageConstService.errServiceUnavailable);
                            }
                            $timeout(function () {
                                $window.location.href = webUrlConstService.homeIndex;
                            }, 1000);
                            return;
                        }
                    }
                    if (handledResponse.data.decisionResult) {
                        //
                        if (handledResponse.data.decisionResult.isDeclined || handledResponse.data.decisionResult.isReferral || handledResponse.data.ratingResult) {
                            var quoteTransactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
                            $window.location.href = webUrlConstService.quoteCaseIndex + "?" + sessionStorageService.getEncryption("quoteTransactionId=" + quoteTransactionId);
                        }
                        else {
                            toastr.error(messageConstService.errRatingService);
                        }

                    } else {
                        toastr.error(messageConstService.errDecisionService);
                    }

                }
                else {
                    //error handling for version 2.0 
                    if (handledResponse.errors.length > 0) {
                        if (handledResponse.errors.filter((x) => x.Severity > 10).length > 0) {

                            var severerrors = handledResponse.errors.filter((x) => x.Severity > 10);
                            for (var i = 0; i < severerrors.length; i++) {
                                let servererror = severerrors[0];
                                let msg = servererror.Message;
                                let msgcontent = msg.split(',')[2];
                                toastr.error(msgcontent);
                            }

                            vm.disableButtons = false;
                        }
                        else {
                            toastr.error(messageConstService.errServiceUnavailable);
                        }
                    }
                    else if (handledResponse.data.error.number === 600) {
                        return handledResponse;
                    }
                }

            }, function (e) {
                var myJSON = JSON.stringify(e);
                $log.log('error myJSON', myJSON);
                toastr.error(messageConstService.errMessageWhenDuplicateEntryIssue);
            });
        }

        //for version2.0 renovation date change
        function OnRenovationDateChange(dateToValidate, isFrom) {

            var mFromDate = moment(vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate, 'DD/MM/YYYY').toDate();
            var mToDate = moment(vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate, 'DD/MM/YYYY').toDate();
            if ((mFromDate >= mToDate) && dateToValidate) {
                toastr.warning("Please enter a valid range.");
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate = null;
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate = null;
                return;
            }

            if (!dateToValidate && typeof (isFrom) !== 'undefined') {
                return;
            }
        }


        vm.secondaryListChange = function (DOBFlag, DOBonEdit) {
            for (var i = 0; i < vm.state.PolicyHolder.InsuredNameList.length; i++) {
                if (vm.state.PolicyHolder.InsuredNameList[i].value == vm.state.PolicyHolder.InsuredName && vm.state.PolicyHolder.InsuredName != 'Other' && vm.state.PolicyHolder.InsuredName != 'OtherInsured') {
                    var index = vm.state.PolicyHolder.InsuredNameList.indexOf(vm.state.PolicyHolder.InsuredNameList[i]);
                    var temporarylist = angular.copy(vm.state.PolicyHolder.InsuredNameList);
                    // commented as per bug 7095
                    //vm.state.PolicyHolder.OtherInsuredName = null;
                    if (DOBFlag) {
                        if (vm.state.PolicyHolder.InsuredNameList[i].dateOfBirth !== null) {
                            vm.state.PolicyHolder.DateOfBirthApp = vm.state.PolicyHolder.InsuredNameList[i].dateOfBirth;
                            if (JSON.parse(sessionStorageService.get(keyConstService.IsCopyQuote)) === true) {
                                vm.state.PolicyHolder.DateOfBirth = null;
                            }
                        }
                        else {
                            vm.state.PolicyHolder.DateOfBirthApp = "2000-01-01T00:00:00";
                        }
                    }
                    if (!DOBFlag) {
                        vm.state.PolicyHolder.DateOfBirthApp = DOBonEdit;
                    }
                    vm.state.PolicyHolder.InsuredClientId = vm.state.PolicyHolder.InsuredNameList[i].id;
                    vm.state.PolicyHolder.SecondaryInsuredsList = temporarylist;
                    vm.state.PolicyHolder.SecondaryInsuredsList.splice(index, 1);
                    vm.state.PolicyHolder.SecondaryInsuredsList = vm.state.PolicyHolder.SecondaryInsuredsList;

                    // Commentd by Ankur as per us 6829
                    //var secondaryInsuredOtherPos = vm.state.PolicyHolder.SecondaryInsuredsList.findIndex(p => p.value === "Other");
                    //if (secondaryInsuredOtherPos !== -1) {
                    //    vm.state.PolicyHolder.SecondaryInsuredsList.splice(secondaryInsuredOtherPos, 1);
                    //}

                    // Changes Related to SME, update Primary Insured Id
                    sessionStorageService.set(keyConstService.PrimaryInsuredId, vm.state.PolicyHolder.InsuredNameList[i].id);
                }
                // else if (vm.state.PolicyHolder.InsuredName === 'Other') {
                //    angular.element('#add-insured').modal('show');
                //}
                ////else if (vm.state.PolicyHolder.InsuredName == 'Other') {
                ////    vm.state.PolicyHolder.InsuredClientId = null;
                ////    var temporarylist = angular.copy(vm.state.PolicyHolder.InsuredNameList);
                ////    vm.state.PolicyHolder.SecondaryInsuredsList = temporarylist;
                ////    if (DOBFlag) {
                ////        vm.state.PolicyHolder.DateOfBirthApp = null;
                ////    }
                ////    if (vm.OtherInsuredName !== null) {
                ////        vm.state.PolicyHolder.OtherInsuredName = vm.OtherInsuredName;
                ////        vm.state.PolicyHolder.DateOfBirthApp = vm.DateOfBirthApp;
                ////    }

                ////}
            }
            if (vm.state.PolicyHolder.InsuredName != "OtherInsured") {
                vm.tempPrimaryInsured = vm.state.PolicyHolder.InsuredName;
            } else if (vm.state.PolicyHolder.InsuredName === 'OtherInsured') {
                angular.element('#add-insured').modal('show');
                vm.IsOpenAddInsuredPopup = true;
            }
        }

        function CordellDataState() {
            vm.CordellStateBeforeEstimate = angular.copy(vm.state.CordellResponse.Propertydata);
        }

        function RestoreCordellFields() {
            if (vm.CordellStateBeforeEstimate) {
                vm.state.CordellResponse.Propertydata.knowTheArea = vm.CordellStateBeforeEstimate.knowTheArea;
                vm.state.CordellResponse.Propertydata.floorArea = vm.CordellStateBeforeEstimate.floorArea;
                vm.state.CordellResponse.Propertydata.slope = vm.CordellStateBeforeEstimate.slope;
                vm.state.CordellResponse.Propertydata.bushland = vm.CordellStateBeforeEstimate.bushland;
                vm.state.CordellResponse.Propertydata.roomBed = vm.CordellStateBeforeEstimate.roomBed;
                vm.state.CordellResponse.Propertydata.roomBed1Size = vm.CordellStateBeforeEstimate.roomBed1Size,
                    vm.state.CordellResponse.Propertydata.roomBed2Size = vm.CordellStateBeforeEstimate.roomBed2Size,
                    vm.state.CordellResponse.Propertydata.roomBed3Size = vm.CordellStateBeforeEstimate.roomBed3Size,
                    vm.state.CordellResponse.Propertydata.roomBed4Size = vm.CordellStateBeforeEstimate.roomBed4Size,
                    vm.state.CordellResponse.Propertydata.roomBed5Size = vm.CordellStateBeforeEstimate.roomBed5Size,
                    vm.state.CordellResponse.Propertydata.roomBed6Size = vm.CordellStateBeforeEstimate.roomBed6Size,
                    vm.state.CordellResponse.Propertydata.roomBed7Size = vm.CordellStateBeforeEstimate.roomBed7Size,
                    vm.state.CordellResponse.Propertydata.roomBed8Size = vm.CordellStateBeforeEstimate.roomBed8Size,
                    vm.state.CordellResponse.Propertydata.roomBed9Size = vm.CordellStateBeforeEstimate.roomBed9Size,
                    vm.state.CordellResponse.Propertydata.roomBedSizeList = vm.CordellStateBeforeEstimate.roomBedSizeList;
                vm.state.CordellResponse.Propertydata.roomBath = vm.CordellStateBeforeEstimate.roomBath;
                vm.state.CordellResponse.Propertydata.roomBathSizeList = vm.CordellStateBeforeEstimate.roomBathSizeList;
                vm.state.CordellResponse.Propertydata.roomBath1Size = vm.CordellStateBeforeEstimate.roomBath1Size;
                vm.state.CordellResponse.Propertydata.roomBath2Size = vm.CordellStateBeforeEstimate.roomBath2Size;
                vm.state.CordellResponse.Propertydata.roomBath3Size = vm.CordellStateBeforeEstimate.roomBath3Size;
                vm.state.CordellResponse.Propertydata.roomBath4Size = vm.CordellStateBeforeEstimate.roomBath4Size;
                vm.state.CordellResponse.Propertydata.roomBath5Size = vm.CordellStateBeforeEstimate.roomBath5Size;
                vm.state.CordellResponse.Propertydata.roomBath6Size = vm.CordellStateBeforeEstimate.roomBath6Size;
                vm.state.CordellResponse.Propertydata.roomToilet = vm.CordellStateBeforeEstimate.roomToilet;
                vm.state.CordellResponse.Propertydata.garage = vm.CordellStateBeforeEstimate.garage;
                vm.state.CordellResponse.Propertydata.roomKitchen = vm.CordellStateBeforeEstimate.roomKitchen;
                vm.state.CordellResponse.Propertydata.kitchenSizeList = vm.CordellStateBeforeEstimate.kitchenSizeList;
                vm.state.CordellResponse.Propertydata.roomKitchen1Size = vm.CordellStateBeforeEstimate.roomKitchen1Size;
                vm.state.CordellResponse.Propertydata.roomKitchen2Size = vm.CordellStateBeforeEstimate.roomKitchen2Size;
                vm.state.CordellResponse.Propertydata.roomLaundry = vm.CordellStateBeforeEstimate.roomLaundry;
                vm.state.CordellResponse.Propertydata.roomLaundrySizeList = vm.CordellStateBeforeEstimate.roomLaundrySizeList;
                vm.state.CordellResponse.Propertydata.roomLaundry1Size = vm.CordellStateBeforeEstimate.roomLaundry1Size;
                vm.state.CordellResponse.Propertydata.roomLaundry2Size = vm.CordellStateBeforeEstimate.roomLaundry2Size;
                vm.state.CordellResponse.Propertydata.roomEntryFoyerSize = vm.CordellStateBeforeEstimate.roomEntryFoyerSize;
                vm.state.CordellResponse.Propertydata.roomLivingSize = vm.CordellStateBeforeEstimate.roomLivingSize;
                vm.state.CordellResponse.Propertydata.roomDiningSize = vm.CordellStateBeforeEstimate.roomDiningSize;
                vm.state.CordellResponse.Propertydata.roomFamilySize = vm.CordellStateBeforeEstimate.roomFamilySize;
                vm.state.CordellResponse.Propertydata.roomRumpusSize = vm.CordellStateBeforeEstimate.roomRumpusSize;
                vm.state.CordellResponse.Propertydata.roomSunSize = vm.CordellStateBeforeEstimate.roomSunSize;
                vm.state.CordellResponse.Propertydata.roomBilliardSize = vm.CordellStateBeforeEstimate.roomBilliardSize;
                vm.state.CordellResponse.Propertydata.roomHomeTheatreSize = vm.CordellStateBeforeEstimate.roomHomeTheatreSize;
                vm.state.CordellResponse.Propertydata.roomOther = vm.CordellStateBeforeEstimate.roomOther;
                vm.state.CordellResponse.Propertydata.roomOtherSizeList = vm.CordellStateBeforeEstimate.roomOtherSizeList;
                vm.state.CordellResponse.Propertydata.roomOther1Size = vm.CordellStateBeforeEstimate.roomOther1Size;
                vm.state.CordellResponse.Propertydata.roomOther2Size = vm.CordellStateBeforeEstimate.roomOther2Size;
                vm.state.CordellResponse.Propertydata.roomWardrobeBuiltin = vm.CordellStateBeforeEstimate.roomWardrobeBuiltin;
                vm.state.CordellResponse.Propertydata.roomLinenCloset = vm.CordellStateBeforeEstimate.roomLinenCloset;
                vm.state.CordellResponse.Propertydata.roomWardrobeWalkin = vm.CordellStateBeforeEstimate.roomWardrobeWalkin;
                vm.state.CordellResponse.Propertydata.carport = vm.CordellStateBeforeEstimate.carport;
                vm.state.CordellResponse.Propertydata.balconyDeck = vm.CordellStateBeforeEstimate.balconyDeck;
                vm.state.CordellResponse.Propertydata.porchVerandah = vm.CordellStateBeforeEstimate.porchVerandah;
                vm.state.CordellResponse.Propertydata.retainingWalls = vm.CordellStateBeforeEstimate.retainingWalls;
                vm.state.CordellResponse.Propertydata.cabin = vm.CordellStateBeforeEstimate.cabin;
                vm.state.CordellResponse.Propertydata.cabinSizeList = vm.CordellStateBeforeEstimate.cabinSizeList;
                vm.state.CordellResponse.Propertydata.cabin1Size = vm.CordellStateBeforeEstimate.cabin1Size;
                vm.state.CordellResponse.Propertydata.cabin2Size = vm.CordellStateBeforeEstimate.cabin2Size;
                vm.state.CordellResponse.Propertydata.cabin3Size = vm.CordellStateBeforeEstimate.cabin3Size;
                vm.state.CordellResponse.Propertydata.heatingCooling_Included = vm.CordellStateBeforeEstimate.heatingCooling_Included;
                vm.state.CordellResponse.Propertydata.heatingCooling_airConDuctedType = vm.CordellStateBeforeEstimate.heatingCooling_airConDuctedType;
                vm.state.CordellResponse.Propertydata.heatingCooling_airConStandalone = vm.CordellStateBeforeEstimate.heatingCooling_airConStandalone;
                vm.state.CordellResponse.Propertydata.heatingCooling_fireplace = vm.CordellStateBeforeEstimate.heatingCooling_fireplace;
                vm.state.CordellResponse.Propertydata.solar_Included = vm.CordellStateBeforeEstimate.solar_Included;
                vm.state.CordellResponse.Propertydata.solar_HotWater = vm.CordellStateBeforeEstimate.solar_HotWater;
                vm.state.CordellResponse.Propertydata.solar_Electricity = vm.CordellStateBeforeEstimate.solar_Electricity;
                vm.state.CordellResponse.Propertydata.shed_Included = vm.CordellStateBeforeEstimate.shed_Included;
                vm.state.CordellResponse.Propertydata.shed_Small = vm.CordellStateBeforeEstimate.shed_Small;
                vm.state.CordellResponse.Propertydata.shed_Large = vm.CordellStateBeforeEstimate.shed_Large;
                vm.state.CordellResponse.Propertydata.poolSpa_Included = vm.CordellStateBeforeEstimate.poolSpa_Included;
                vm.state.CordellResponse.Propertydata.poolSpa_SpaType = vm.CordellStateBeforeEstimate.poolSpa_SpaType;
                vm.state.CordellResponse.Propertydata.poolSpa_ConcretePoolSize = vm.CordellStateBeforeEstimate.poolSpa_ConcretePoolSize;
                vm.state.CordellResponse.Propertydata.poolSpa_FibreglassPoolSize = vm.CordellStateBeforeEstimate.poolSpa_FibreglassPoolSize;
                vm.state.CordellResponse.Propertydata.poolSpa_VinylPoolSize = vm.CordellStateBeforeEstimate.poolSpa_VinylPoolSize;
                vm.state.CordellResponse.Propertydata.tennisCourt_Included = vm.CordellStateBeforeEstimate.tennisCourt_Included;
                vm.state.CordellResponse.Propertydata.tennisCourt_Number = vm.CordellStateBeforeEstimate.tennisCourt_Number;
                vm.state.CordellResponse.Propertydata.tennisCourt_SurfaceType = vm.CordellStateBeforeEstimate.tennisCourt_SurfaceType;
                vm.state.CordellResponse.Propertydata.tennisCourt_Lighting = vm.CordellStateBeforeEstimate.tennisCourt_Lighting;
                SetCordelFields();
            }
        }

        function SetCordelFields() {
            if (vm.state.CordellResponse.Propertydata.roomBed > 0) {
                vm.state.CordellResponse.Propertydata.roomBedSizeList = {};
                vm.state.CordellResponse.Propertydata.roomBedSizeList["0"] = vm.state.CordellResponse.Propertydata.roomBed1Size;
                vm.state.CordellResponse.Propertydata.roomBedSizeList["1"] = vm.state.CordellResponse.Propertydata.roomBed2Size;
                vm.state.CordellResponse.Propertydata.roomBedSizeList["2"] = vm.state.CordellResponse.Propertydata.roomBed3Size;
                vm.state.CordellResponse.Propertydata.roomBedSizeList["3"] = vm.state.CordellResponse.Propertydata.roomBed4Size;
                vm.state.CordellResponse.Propertydata.roomBedSizeList["4"] = vm.state.CordellResponse.Propertydata.roomBed5Size;
                vm.state.CordellResponse.Propertydata.roomBedSizeList["5"] = vm.state.CordellResponse.Propertydata.roomBed6Size;
                vm.state.CordellResponse.Propertydata.roomBedSizeList["6"] = vm.state.CordellResponse.Propertydata.roomBed7Size;
                vm.state.CordellResponse.Propertydata.roomBedSizeList["7"] = vm.state.CordellResponse.Propertydata.roomBed8Size;
                vm.state.CordellResponse.Propertydata.roomBedSizeList["8"] = vm.state.CordellResponse.Propertydata.roomBed9Size;
            }

            if (vm.state.CordellResponse.Propertydata.roomBath > 0) {
                vm.state.CordellResponse.Propertydata.roomBathSizeList = {};
                vm.state.CordellResponse.Propertydata.roomBathSizeList["0"] = vm.state.CordellResponse.Propertydata.roomBath1Size;
                vm.state.CordellResponse.Propertydata.roomBathSizeList["1"] = vm.state.CordellResponse.Propertydata.roomBath2Size;
                vm.state.CordellResponse.Propertydata.roomBathSizeList["2"] = vm.state.CordellResponse.Propertydata.roomBath3Size;
                vm.state.CordellResponse.Propertydata.roomBathSizeList["3"] = vm.state.CordellResponse.Propertydata.roomBath4Size;
                vm.state.CordellResponse.Propertydata.roomBathSizeList["4"] = vm.state.CordellResponse.Propertydata.roomBath5Size;
                vm.state.CordellResponse.Propertydata.roomBathSizeList["5"] = vm.state.CordellResponse.Propertydata.roomBath6Size;
            }

            if (vm.state.CordellResponse.Propertydata.roomLaundry > 0) {
                vm.state.CordellResponse.Propertydata.roomLaundrySizeList = {};
                vm.state.CordellResponse.Propertydata.roomLaundrySizeList["0"] = vm.state.CordellResponse.Propertydata.roomLaundry1Size;
                vm.state.CordellResponse.Propertydata.roomLaundrySizeList["1"] = vm.state.CordellResponse.Propertydata.roomLaundry2Size;
            }

            if (vm.state.CordellResponse.Propertydata.roomOther > 0) {
                vm.state.CordellResponse.Propertydata.roomOtherList = {};
                vm.state.CordellResponse.Propertydata.roomOtherList["0"] = vm.state.CordellResponse.Propertydata.roomOther1Size;
                vm.state.CordellResponse.Propertydata.roomOtherList["1"] = vm.state.CordellResponse.Propertydata.roomOther2Size;
            }

            if (vm.state.CordellResponse.Propertydata.roomKitchen > 0) {
                vm.state.CordellResponse.Propertydata.kitchenSizeList = {};
                vm.state.CordellResponse.Propertydata.kitchenSizeList["0"] = vm.state.CordellResponse.Propertydata.roomKitchen1Size;
                vm.state.CordellResponse.Propertydata.kitchenSizeList["1"] = vm.state.CordellResponse.Propertydata.roomKitchen2Size;
            }

            if (vm.state.CordellResponse.Propertydata.cabin > 0) {
                vm.state.CordellResponse.Propertydata.cabinSizeList = {};
                vm.state.CordellResponse.Propertydata.cabinSizeList["0"] = vm.state.CordellResponse.Propertydata.cabin1Size;
                vm.state.CordellResponse.Propertydata.cabinSizeList["1"] = vm.state.CordellResponse.Propertydata.cabin2Size;
                vm.state.CordellResponse.Propertydata.cabinSizeList["2"] = vm.state.CordellResponse.Propertydata.cabin3Size;
            }
        }

        vm.getArray = function (number) {
            if (number == null)
                return new Array(0);
            else
                return new Array(parseInt(number));
        }

        vm.ResetRoomLaundrySection = function () {
            vm.state.CordellResponse.Propertydata.roomLaundrySizeList = null;
        }

        vm.ResetBathroomSection = function () {
            vm.state.CordellResponse.Propertydata.roomBathSizeList = null;
        }

        vm.ResetBedroomSection = function () {
            vm.state.CordellResponse.Propertydata.roomBedSizeList = null;
        }

        vm.ResetOtherRoomSection = function () {
            vm.state.CordellResponse.Propertydata.roomOtherList = null;
        }

        vm.ResetCabinPoolSection = function () {
            vm.state.CordellResponse.Propertydata.cabinSizeList = null;
        }

        vm.ResetKitchenSection = function () {
            vm.state.CordellResponse.Propertydata.kitchenSizeList = null;
        }

        vm.ResetHeatingCoolingSection = function () {
            if (vm.state.CordellResponse.Propertydata.heatingCooling_Included) {
                if (vm.IsEndorsement) {
                    vm.state.CordellResponse.Propertydata.heatingCooling_airConDuctedType = angular.copy(endorsementState.CordellResponse.Propertydata.heatingCooling_airConDuctedType);
                    vm.state.CordellResponse.Propertydata.heatingCooling_airConStandalone = angular.copy(endorsementState.CordellResponse.Propertydata.heatingCooling_airConStandalone);
                    vm.state.CordellResponse.Propertydata.heatingCooling_fireplace = angular.copy(endorsementState.CordellResponse.Propertydata.heatingCooling_fireplace);
                }
                else {
                    vm.state.CordellResponse.Propertydata.heatingCooling_airConDuctedType = vm.cordellBackupForFloorReset.heatingCooling_airConDuctedType;
                    vm.state.CordellResponse.Propertydata.heatingCooling_airConStandalone = vm.cordellBackupForFloorReset.heatingCooling_airConStandalone;
                    vm.state.CordellResponse.Propertydata.heatingCooling_fireplace = vm.cordellBackupForFloorReset.heatingCooling_fireplace;
                }
            }
            else {
                vm.state.CordellResponse.Propertydata.heatingCooling_airConDuctedType = null;
                vm.state.CordellResponse.Propertydata.heatingCooling_airConStandalone = null;
                vm.state.CordellResponse.Propertydata.heatingCooling_fireplace = null;
            }
        }

        vm.ResetSolarPowerSection = function () {
            if (vm.state.CordellResponse.Propertydata.solar_Included) {
                if (vm.IsEndorsement) {
                    vm.state.CordellResponse.Propertydata.solar_HotWater = angular.copy(endorsementState.CordellResponse.Propertydata.solar_HotWater);
                    vm.state.CordellResponse.Propertydata.solar_Electricity = angular.copy(endorsementState.CordellResponse.Propertydata.solar_Electricity);
                }
                else {
                    vm.state.CordellResponse.Propertydata.solar_HotWater = vm.cordellBackupForFloorReset.solar_HotWater;
                    vm.state.CordellResponse.Propertydata.solar_Electricity = vm.cordellBackupForFloorReset.solar_Electricity;
                }
            }
            else {
                vm.state.CordellResponse.Propertydata.solar_HotWater = null;
                vm.state.CordellResponse.Propertydata.solar_Electricity = null;
            }
        }

        vm.ResetShedsSection = function () {
            if (vm.state.CordellResponse.Propertydata.shed_Included) {
                if (vm.IsEndorsement) {
                    vm.state.CordellResponse.Propertydata.shed_Small = angular.copy(endorsementState.CordellResponse.Propertydata.shed_Small);
                    vm.state.CordellResponse.Propertydata.shed_Large = angular.copy(endorsementState.CordellResponse.Propertydata.shed_Large);
                }
                else {
                    vm.state.CordellResponse.Propertydata.shed_Small = vm.cordellBackupForFloorReset.shed_Small;
                    vm.state.CordellResponse.Propertydata.shed_Large = vm.cordellBackupForFloorReset.shed_Large;
                }
            }
            else {
                vm.state.CordellResponse.Propertydata.shed_Small = 0;
                vm.state.CordellResponse.Propertydata.shed_Large = 0;
            }
        }

        vm.ResetTennisCourtSection = function () {
            if (vm.state.CordellResponse.Propertydata.tennisCourt_Included) {
                if (vm.IsEndorsement) {
                    vm.state.CordellResponse.Propertydata.tennisCourt_Number = angular.copy(endorsementState.CordellResponse.Propertydata.tennisCourt_Number);
                    vm.state.CordellResponse.Propertydata.tennisCourt_SurfaceType = angular.copy(endorsementState.CordellResponse.Propertydata.tennisCourt_SurfaceType);
                    vm.state.CordellResponse.Propertydata.tennisCourt_Lighting = angular.copy(endorsementState.CordellResponse.Propertydata.tennisCourt_Lighting);
                }
                else {
                    vm.state.CordellResponse.Propertydata.tennisCourt_Number = vm.cordellBackupForFloorReset.tennisCourt_Number;
                    vm.state.CordellResponse.Propertydata.tennisCourt_SurfaceType = vm.cordellBackupForFloorReset.tennisCourt_SurfaceType;
                    vm.state.CordellResponse.Propertydata.tennisCourt_Lighting = vm.cordellBackupForFloorReset.tennisCourt_Lighting;
                }
            }
            else {
                vm.state.CordellResponse.Propertydata.tennisCourt_Number = null;
                vm.state.CordellResponse.Propertydata.tennisCourt_SurfaceType = null;
                vm.state.CordellResponse.Propertydata.tennisCourt_Lighting = null;
            }
        }

        vm.ResetPoolSpaSection = function () {
            if (vm.state.CordellResponse.Propertydata.poolSpa_Included) {
                if (vm.IsEndorsement) {
                    vm.state.CordellResponse.Propertydata.poolSpa_SpaType = angular.copy(endorsementState.CordellResponse.Propertydata.poolSpa_SpaType);
                    vm.state.CordellResponse.Propertydata.poolSpa_ConcretePoolSize = angular.copy(endorsementState.CordellResponse.Propertydata.poolSpa_ConcretePoolSize);
                    vm.state.CordellResponse.Propertydata.poolSpa_FibreglassPoolSize = angular.copy(endorsementState.CordellResponse.Propertydata.poolSpa_FibreglassPoolSize);
                    vm.state.CordellResponse.Propertydata.poolSpa_VinylPoolSize = angular.copy(endorsementState.CordellResponse.Propertydata.poolSpa_VinylPoolSize);
                }
             
            }
            else {
                vm.state.CordellResponse.Propertydata.poolSpa_SpaType = null;
                vm.state.CordellResponse.Propertydata.poolSpa_ConcretePoolSize = null;
                vm.state.CordellResponse.Propertydata.poolSpa_FibreglassPoolSize = null;
                vm.state.CordellResponse.Propertydata.poolSpa_VinylPoolSize = null;
            }
        }

        vm.checkNullValue = function () {
            vm.isNullContentInsured = false;
            if ((vm.state.ContentsSumInsured.GeneralContentsSumInsured === "0" || vm.state.ContentsSumInsured.ContentsSumInsured === "0.00") && vm.state.PolicyHolder.ContentCover === true) {
                vm.isNullContentInsured = true;
            }
        }

        vm.getConvertedDate = function () {
            var dateofBirth = vm.state.PolicyHolder.DateOfBirthApp;
            if (dateofBirth) {
                var response = dateService.validateBirthDDMMYYYY(dateofBirth, 150);

                if (!response.isValid) {
                    vm.state.PolicyHolder.DateOfBirth = '';
                    vm.state.PolicyHolder.DateOfBirthApp = '';
                    toastr.warning(response.errorMsg);
                    return;
                }

                vm.state.PolicyHolder.DateOfBirth = response.date;
            }

        }

        vm.getDeclineConvertedDate = function () {
            var dateofBirth = vm.state.DutyOfDisclosure.DeclineDate;
            if (dateofBirth) {
                var response = dateService.validateBirthDDMMYYYY(dateofBirth, 150);

                if (!response.isValid) {
                    vm.state.DutyOfDisclosure.DateOfDecline = '';
                    vm.state.DutyOfDisclosure.DeclineDate = '';
                    toastr.warning(response.errorMsg);
                    return;
                }

                vm.state.DutyOfDisclosure.DateOfDecline = response.date;
            }

        }

        angular.element(document).ready(function () {
            validateConstructionPeriod($scope.subFormContent.OriginalYearBuilt);
            setValidity();
        });

        function setValidity() {
            if ($scope.subFormContent.$invalid) {
                if ($scope.subFormContent.OriginalYearBuilt.$viewValue) {
                    $scope.form1.OriginalYearBuilt.$setValidity("size", false);
                    $scope.form1.OriginalYearBuilt.$touched = true;
                    $scope.form1.$setValidity("size", false);
                }
                else {
                    $scope.form1.OriginalYearBuilt.$setValidity("size", true);
                    $scope.form1.OriginalYearBuilt.$touched = false;
                    $scope.form1.$setValidity("size", true);
                }
            }
        }

        function validateConstructionPeriod(field) {
            if (vm.state.CordellResponse.Propertydata.yearBuilt != undefined) {
                if (vm.state.CordellResponse.Propertydata.periodName != null && vm.state.CordellResponse.Propertydata.periodName == 'Modern project home design (1960 to present)' || vm.state.CordellResponse.Propertydata.periodName == 'Modern architect design (1960 to present)') {                    
                    //if (vm.state.CordellResponse.Propertydata.yearBuilt < 1960 || vm.state.CordellResponse.Propertydata.yearBuilt > new Date().getFullYear()) {
                    if (vm.state.CordellResponse.Propertydata.yearBuilt < 1960 || (vm.startDateForYear && vm.state.CordellResponse.Propertydata.yearBuilt > new Date(vm.startDateForYear).getFullYear())) {
                        field.$setValidity("size", false);
                        $scope.subFormContent.$invalid = true;
                        $scope.form1.$setValidity("size", false);
                        setValidity();
                    }
                    else {
                        field.$setValidity("size", true);
                        $scope.subFormContent.$invalid = false;
                        $scope.form1.$setValidity("size", true);
                        setValidity();
                    }
                }
                else {
                    field.$setValidity("size", true);
                    $scope.subFormContent.$invalid = false;
                    $scope.form1.$setValidity("size", true);
                    setValidity();
                }
            }
            //Reset Value of PropertyRewired Question
            if (vm.state.CordellResponse.Propertydata.periodName != null && vm.state.CordellResponse.Propertydata.periodName !== 'Victorian (1840 - 1890)' && vm.state.CordellResponse.Propertydata.periodName !== 'Federation (1891 - 1913)') {
                vm.state.CordellResponse.Propertydata.propertyRewired = null;
            }
            else if (vm.state.CordellResponse.Propertydata.periodName != null && (vm.state.CordellResponse.Propertydata.periodName == 'Victorian (1840 - 1890)' || vm.state.CordellResponse.Propertydata.periodName == 'Federation (1891 - 1913)') && vm.IsEndorsement) {
                vm.state.CordellResponse.Propertydata.propertyRewired = angular.copy(endorsementState.CordellResponse.Propertydata.propertyRewired);
            }
        }

        //returns true if the property details are filled
        function validateCalculateSumInsuredButton(form) {
   
            if (form.autocompleteMannualAddress && form.autocompleteMannualAddress.$invalid) {
                return false;
            }
            //if (form.ConstructionStyle.$invalid || form.OriginalYearBuilt.$invalid || form.ExternalWallList.$invalid || form.RoofMaterial.$invalid || form.QualityOfConstruction.$invalid || form.Storeys.$invalid || form.Address1.$invalid || (vm.state.PropertyDetail.IsManualAddress && !vm.selectedMannualAddress)) {
            //    return false;
            //}
            if ((form.ConstructionStyle && form.ConstructionStyle.$invalid) ||
                (form.OriginalYearBuilt && form.OriginalYearBuilt.$invalid) ||
                (form.ExternalWallList && form.ExternalWallList.$invalid) ||
                (form.RoofMaterial && form.RoofMaterial.$invalid) ||
                (form.QualityOfConstruction && form.QualityOfConstruction.$invalid) ||
                (form.Storeys && form.Storeys.$invalid) ||
                (form.Address1.$invalid) ||
                (vm.state.PropertyDetail.IsManualAddress && !vm.selectedMannualAddress)) {
                return false;
            }
            else if (vm.state.CordellResponse.Propertydata.externalWallMaterial === 'RammedEarthStrawMudbrick' || vm.state.CordellResponse.Propertydata.externalWallMaterial === 'SandwichFoamEPS' ||
                vm.state.CordellResponse.Propertydata.externalWallMaterial === 'FibrecementAsbestos' || vm.state.CordellResponse.Propertydata.externalWallMaterial === 'FibrecementNoAsbestos' || vm.state.CordellResponse.Propertydata.externalWallMaterial === 'AluminiumMetal') {
                return false;
            }
            else if (vm.state.CordellResponse.Propertydata.roof === 'FibrecementAsbestos' || vm.state.CordellResponse.Propertydata.roof === 'FibrecementNoAsbestos' || vm.state.CordellResponse.Propertydata.roof === 'SandwichFoamEPS' ||
                vm.state.CordellResponse.Propertydata.roof === 'ColorBond') {
                return false;
            } 

            return true;
        }

        function changeInOccupation() {
            //get the occupation and set the message for the revenue.

            occupationService.get(vm.state.OtherInfo.OccupationANZSIC).then(function (response) {
                $log.log('response', response);
                vm.state.OtherInfo.OccupationMinTurnover = response.data.minTurnOver;
                vm.state.OtherInfo.OccupationMaxTurnover = response.data.maxTurnOver;
                vm.state.OtherInfo.OccupationName = response.data.occupationName;
            }, function (error) {
                $log.log('error', error);

            });
        }

        function ResetotherInterestedPartyText() {
            vm.state.OtherInfo.OtherInterestPartyText = null;
        }

        function brokerFeeChange() {
            var regexp = /^[0-9]+(\.[0-9]{1,2})?$/;
            if (!regexp.test(vm.state.PaymentFrequency.BrokerFee)) {
                vm.state.PaymentFrequency.BrokerFee = null;
            }
        }

        function getSecondaryInsuredList(DOBonEdit) {
            var caseid = caseNumberForSecondaryInsured;
            vm.state.PolicyHolder.InsuredNameList = [];
            vm.state.PolicyHolder.SecondaryInsuredsList = [];
            var secondaryInsuredListOnEdit = clientService.getSecondaryInmsured(
                caseid)
                .then(function (result) {
                    if (result) {
                        vm.data = result.data.policyHolder;
                        for (var i = 0; i < result.data.policyHolder.insuredNameList.length; i++) {

                            vm.state.PolicyHolder.InsuredNameList.push(result.data.policyHolder.insuredNameList[i]);
                            vm.state.PolicyHolder.SecondaryInsuredsList.push(result.data.policyHolder.insuredNameList[i]);
                            vm.secondaryListChange(vm.DOBFlag, DOBonEdit);
                        }

                        // for additional insured
                        //checkAdditionalInsuredInList();
                    }
                })
        }

        function sumInsuredEstimate(field) {

            var roomBathObject = vm.state.CordellResponse.Propertydata.roomBathSizeList;
            if (roomBathObject != null) {
                vm.state.CordellResponse.Propertydata.roomBath1Size = Object.keys(roomBathObject).length > 0 ? roomBathObject[Object.keys(roomBathObject)[0]] : null;
                vm.state.CordellResponse.Propertydata.roomBath2Size = Object.keys(roomBathObject).length > 1 ? roomBathObject[Object.keys(roomBathObject)[1]] : null;
                vm.state.CordellResponse.Propertydata.roomBath3Size = Object.keys(roomBathObject).length > 2 ? roomBathObject[Object.keys(roomBathObject)[2]] : null;
                vm.state.CordellResponse.Propertydata.roomBath4Size = Object.keys(roomBathObject).length > 3 ? roomBathObject[Object.keys(roomBathObject)[3]] : null;
                vm.state.CordellResponse.Propertydata.roomBath5Size = Object.keys(roomBathObject).length > 4 ? roomBathObject[Object.keys(roomBathObject)[4]] : null;
                vm.state.CordellResponse.Propertydata.roomBath6Size = Object.keys(roomBathObject).length > 5 ? roomBathObject[Object.keys(roomBathObject)[5]] : null;
            }

            var roomBedObject = vm.state.CordellResponse.Propertydata.roomBedSizeList;
            if (roomBedObject != null) {
                vm.state.CordellResponse.Propertydata.roomBed1Size = Object.keys(roomBedObject).length > 0 ? roomBedObject[Object.keys(roomBedObject)[0]] : null;
                vm.state.CordellResponse.Propertydata.roomBed2Size = Object.keys(roomBedObject).length > 1 ? roomBedObject[Object.keys(roomBedObject)[1]] : null;
                vm.state.CordellResponse.Propertydata.roomBed3Size = Object.keys(roomBedObject).length > 2 ? roomBedObject[Object.keys(roomBedObject)[2]] : null;
                vm.state.CordellResponse.Propertydata.roomBed4Size = Object.keys(roomBedObject).length > 3 ? roomBedObject[Object.keys(roomBedObject)[3]] : null;
                vm.state.CordellResponse.Propertydata.roomBed5Size = Object.keys(roomBedObject).length > 4 ? roomBedObject[Object.keys(roomBedObject)[4]] : null;
                vm.state.CordellResponse.Propertydata.roomBed6Size = Object.keys(roomBedObject).length > 5 ? roomBedObject[Object.keys(roomBedObject)[5]] : null;
                vm.state.CordellResponse.Propertydata.roomBed7Size = Object.keys(roomBedObject).length > 6 ? roomBedObject[Object.keys(roomBedObject)[6]] : null;
                vm.state.CordellResponse.Propertydata.roomBed8Size = Object.keys(roomBedObject).length > 7 ? roomBedObject[Object.keys(roomBedObject)[7]] : null;
                vm.state.CordellResponse.Propertydata.roomBed9Size = Object.keys(roomBedObject).length > 8 ? roomBedObject[Object.keys(roomBedObject)[8]] : null;
            }

            var roomLaundryObject = vm.state.CordellResponse.Propertydata.roomLaundrySizeList;
            if (roomLaundryObject != null) {
                vm.state.CordellResponse.Propertydata.roomLaundry1Size = Object.keys(roomLaundryObject).length > 0 ? roomLaundryObject[Object.keys(roomLaundryObject)[0]] : null;
                vm.state.CordellResponse.Propertydata.roomLaundry2Size = Object.keys(roomLaundryObject).length > 1 ? roomLaundryObject[Object.keys(roomLaundryObject)[1]] : null;
            }

            var roomOtherObject = vm.state.CordellResponse.Propertydata.roomOtherList;
            if (roomOtherObject != null) {
                vm.state.CordellResponse.Propertydata.roomOther1Size = Object.keys(roomOtherObject).length > 0 ? roomOtherObject[Object.keys(roomOtherObject)[0]] : null;
                vm.state.CordellResponse.Propertydata.roomOther2Size = Object.keys(roomOtherObject).length > 1 ? roomOtherObject[Object.keys(roomOtherObject)[1]] : null;
            }

            var cabinSizeObject = vm.state.CordellResponse.Propertydata.cabinSizeList;
            if (cabinSizeObject != null) {
                vm.state.CordellResponse.Propertydata.cabin1Size = Object.keys(cabinSizeObject).length > 0 ? cabinSizeObject[Object.keys(cabinSizeObject)[0]] : null;
                vm.state.CordellResponse.Propertydata.cabin2Size = Object.keys(cabinSizeObject).length > 1 ? cabinSizeObject[Object.keys(cabinSizeObject)[1]] : null;
                vm.state.CordellResponse.Propertydata.cabin3Size = Object.keys(cabinSizeObject).length > 2 ? cabinSizeObject[Object.keys(cabinSizeObject)[2]] : null;
            }

            var kitchenSizeObject = vm.state.CordellResponse.Propertydata.kitchenSizeList;
            if (kitchenSizeObject != null) {
                vm.state.CordellResponse.Propertydata.roomKitchen1Size = Object.keys(kitchenSizeObject).length > 0 ? kitchenSizeObject[Object.keys(kitchenSizeObject)[0]] : null;
                vm.state.CordellResponse.Propertydata.roomKitchen2Size = Object.keys(kitchenSizeObject).length > 1 ? kitchenSizeObject[Object.keys(kitchenSizeObject)[1]] : null;
            }

            quotesService.sumInsuredEstimateApi(vm.state.CordellResponse.Propertydata).then(function (response) {
                if (response === null || response.data === 0 || response.data === null) {
                    $('#calculate-sum-insured').modal('hide');
                    $log.log("Cordell Error:Building Sum Insured Not Calculated!");
                    toastr.warning(messageConstService.errCordellWarning);
                    if (!vm.IsManualBuildingSumInsured && !vm.IsEndorsement && vm.landlordStandardData.DDlProcessTypeId !== 4) {
                        vm.state.CordellResponse.BuildingSumInsured = 0;
                    }
                    vm.state.CordellResponse.BuildingSumInsuredEstimate = 0;
                    return;
                }
                if (response.data !== 0 || response.data !== null) {
                    $('#calculate-sum-insured').modal('hide');
                    //if (vm.IsEndorsement) {
                    //    vm.state.CordellResponse.BuildingSumInsured = vm.BuildingSumInsuredValue;
                    //}
                    //else
                        if (vm.landlordStandardData.DDlProcessTypeId !== 4) {
                        //vm.BuildingSumInsuredValue = response.data;
                        vm.IsManualBuildingSumInsured = false;
                    }

                    field.$setValidity('invalid', true);
                }
                    // if-else removed for Sonar Qube Report bug
                   vm.state.CordellResponse.BuildingSumInsuredEstimate = response.data;
               
                vm.InvalidZero(field, vm.state.CordellResponse.BuildingSumInsured);
            }, function (error) {
                $log.log("Cordell Error:", error);
                toastr.error(messageConstService.errService3rdAPIUnavailable);

            });
        }

        function checkDefaultBuildingSumInsured(buildingSumInsured) {
            if (vm.state.PolicyHolder.ContentCover && !vm.state.PolicyHolder.BuildingCover) {
                vm.showDefaultBuildingSumInsuredRange = false;
            }
            else {
                vm.showDefaultBuildingSumInsuredRange = false;
                if (vm.state.CordellResponse.BuildingSumInsured) {
                    if (vm.state.CordellResponse.BuildingSumInsured < 100000)
                        vm.showDefaultBuildingSumInsuredRange = true;
                }
                else {
                    if (buildingSumInsured) {
                        if (buildingSumInsured.$modelValue) {
                            if (buildingSumInsured.$modelValue < 100000) {
                                vm.showDefaultBuildingSumInsuredRange = true;
                            }
                            if (buildingSumInsured.$modelValue == 0 || buildingSumInsured.$modelValue == undefined) {
                                if (vm.state.CordellResponse.BuildingSumInsured < 100000) {
                                    vm.showDefaultBuildingSumInsuredRange = true;
                                }
                                else {
                                    vm.showDefaultBuildingSumInsuredRange = false;
                                }
                            }
                        }
                    }
                }

            }
        }

        function checkDefaultContentSumInsured(contentSumInsured) {
            vm.showDefaultContentSumInsuredRange = false;
            if (contentSumInsured < 10000) {
                vm.showDefaultContentSumInsuredRange = true;
            }

            if (contentSumInsured == null) {
                vm.showDefaultContentSumInsuredRange = false;
            }
        }

        function checkWeeklyRentalAmount(amount) {
                vm.checkWeeklyRentalAmountLimit = false;
                if (amount < 150 || amount > 5000) {
                    vm.checkWeeklyRentalAmountLimit = true;
                }
                if (vm.state.OptionalCover.IsLossOfRent === false && amount === null) {
                    vm.checkWeeklyRentalAmountLimit = false;
                }

                if (vm.state.OptionalCover.IsLossOfRent === true && amount === null) {
                    vm.checkWeeklyRentalAmountLimit = false;
                }
                if (amount == null) {
                    vm.checkWeeklyRentalAmountLimit = false;
                }
        }

        vm.getQuote = function () {
            vm.isDisabled = true;
            vm.getConvertedDate();
            //// resets rennovation start and end date to the format for it to parse in Json
            if (vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate = dateService.getDateDDMMtoMMDD(vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationStartDate);
            }

            if (vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate) {
                vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate = dateService.getDateDDMMtoMMDD(vm.state.UnderwritingCriteria.AnswerYesToFollowingData.HomeUnderConstructionRenovationData.RenovationEndDate);
            }
            if (vm.state.PolicyHolder.BuildingCover == false && vm.state.PolicyHolder.ContentCover == true) {
                vm.state.CordellResponse.BuildingSumInsured = 0;
            }
            if (vm.IsEndorsement) {
                vm.state.PaymentFrequency.BrokerFee = 0;
                vm.state.PaymentFrequency.BrokerFeeGST = 0;
            }
          
            var transactionId = JSON.parse(sessionStorageService.get(keyConstService.quoteTransactionId));
            if (vm.transactionStatus == "Draft") {
                isNewEditTransaction = false;
            }
            else {
                isNewEditTransaction = sessionStorageService.get(keyConstService.IsNewEditTransaction);
            }
            vm.rowVersion = JSON.parse(sessionStorageService.get(keyConstService.rowVersion));
            var automaticPayment = -1;
            if (vm.endorsementVM != null) {
                vm.EffectiveDate = vm.endorsementVM.EndorsementEffectiveDate;
                ExpirationDate = vm.endorsementVM.ExpirationDate;
                sessionStorageService.remove(keyConstService.endorsementRequestVM);
                sessionStorageService.remove(keyConstService.IsEndorsementEdit);

            }
            else {
                var newBusinessData = JSON.parse(sessionStorageService.get(keyConstService.newBusinessCaseData));
                if (newBusinessData) {
                    vm.EffectiveDate = newBusinessData.data.EffectiveDate;
                    ExpirationDate = newBusinessData.data.ExpirationDate;
                    automaticPayment = newBusinessData.data.BrokerManagedPayment;
                }
            }
            if (automaticPayment == -1) {
                automaticPayment = vm.brokerManagedPayment
            }
            vm.state.PaymentFrequency.BrokerManagedPayment = automaticPayment;
            sessionStorageService.set(keyConstService.quoteState, vm.state);
            var data = sessionStorageService.get(keyConstService.quoteState);
            var pData = JSON.parse(data);
            if (sessionStorageService.get(keyConstService.IsCopyQuote) === "true")
                isNewEditTransaction = false;
            var finalData = { SaveContent: data, EffectiveDate: vm.EffectiveDate, ExpirationDate: ExpirationDate, TransactionId: transactionId, NewEditTransaction: isNewEditTransaction, RowVersion: vm.rowVersion, PaymentFrequency: vm.state.PaymentFrequency.ModeOfPayment, InstallmentDate: vm.state.PaymentFrequency.DayofInstallment, BrokerManagedPayment: automaticPayment };
            if (vm.version >= keyConstService.Version) {
                var handledResponse = vm.finalGetQuote(finalData);
                return handledResponse;
            }
            else {
                vm.finalGetQuote(finalData);
            }
        }

        vm.OccupancyChange = function () {
            if (vm.state.PolicyHolder.LandlordOccupancyType === "Permanent") {
                if (!vm.IsRentDefaultChanges && vm.version < keyConstService.Version) {
                    vm.state.OptionalCover.IsRentDefault = true;
                }
                               
                if (vm.IsEndorsement && vm.getID != vm.getTransactionIdWithoutSaving) {
                    if (vm.landlordStandardData.LandlordStandardQuestion.OptionalCover) {
                        vm.state.OptionalCover.IsLossOfRent = vm.landlordStandardData.LandlordStandardQuestion.OptionalCover.IsLossOfRent;
                    }
                }

                if (vm.getID === vm.getTransactionIdWithoutSaving)
                {
                    vm.state.OptionalCover.IsLossOfRent = vm.retainValueforQuestion.OptionalCover.IsLossOfRent;
                }

                else {
                    vm.state.OptionalCover.IsLossOfRent = true;
                }
              
            }
            else if (vm.state.PolicyHolder.LandlordOccupancyType === "Holiday") {
                if (!vm.IsRentDefaultChanges) {
                    vm.state.OptionalCover.IsRentDefault = false;
                }
                vm.state.OptionalCover.IsRentMoreThan14Days = null;
                if (vm.IsRentDefaultChanges) {
                    vm.state.OptionalCover.IsRentDefault = null;
                    vm.state.OptionalCover.IsStatementForRentDefault = null;
                    vm.state.OptionalCover.IsPropertyStatementForRentDefault = null;
                }
                vm.state.OptionalCover.WeeklyRentalAmount = null;
                vm.checkWeeklyRentalAmountLimit = false;
                if (vm.IsEndorsement && vm.getID != vm.getTransactionIdWithoutSaving) {
                    if (vm.landlordStandardData.LandlordStandardQuestion.OptionalCover) {
                        vm.state.OptionalCover.IsLossOfRent = vm.landlordStandardData.LandlordStandardQuestion.OptionalCover.IsLossOfRent;
                    }
                }

                if (vm.getID === vm.getTransactionIdWithoutSaving) {
                    vm.state.OptionalCover.IsLossOfRent = vm.retainValueforQuestion.OptionalCover.IsLossOfRent;
                }

                else {
                    vm.state.OptionalCover.IsLossOfRent = true;
                }
            }
            else {
                vm.state.OptionalCover.IsRentDefault = null;
                vm.state.OptionalCover.IsLossOfRent = null;
            }
        }

        function defaultValueForSpecialContent(field, value, index) {
            vm.setSpecialContentValidity = true;
            vm.indexOfContent = vm.state.ContentsSumInsured.ValuableContents[index];
            if (vm.indexOfContent) {
                if (vm.indexOfContent.Value < 20000) {
                    vm.state.ContentsSumInsured.ValuableContents[index].IsValid = true;
                    if (field) {
                        field.$setValidity("valuableItem", false);
                        vm.setSpecialContentValidity = false;
                        sessionStorageService.set(keyConstService.specialContentvalidity, vm.state.ContentsSumInsured.ValuableContents);
                    }
                }

                else {
                    vm.state.ContentsSumInsured.ValuableContents[index].IsValid = false;
                    if (field) {
                        field.$setValidity("valuableItem", true);
                        vm.setSpecialContentValidity = true;
                        sessionStorageService.set(keyConstService.specialContentvalidity, vm.state.ContentsSumInsured.ValuableContents);
                    }
                }
            }

            if (sessionStorageService.get(keyConstService.specialContentvalidity)) {
                for (var i = 0; i < vm.state.ContentsSumInsured.ValuableContents.length; i++) {

                if (vm.state.ContentsSumInsured.ValuableContents[i].IsValid === true) {
                        vm.setSpecialContentValidity = false;
                    }
                }
            }
       
        }

        function resetLossOfRent(value) {
            if (value === false && vm.state.OptionalCover.IsRentDefault !== true) {
                vm.state.OptionalCover.WeeklyRentalAmount = null;
            }
        }

        function resetRentDefault(rentDefaultValue) {
           
            if (rentDefaultValue === false) {
                if (rentDefaultValue === false && vm.state.OptionalCover.IsLossOfRent !== true) {
                    vm.state.OptionalCover.WeeklyRentalAmount = null;
                }
                if (vm.IsRentDefaultChanges !== null && vm.IsRentDefaultChanges && !vm.IsEndorsement) {
                    vm.state.OptionalCover.IsStatementForRentDefault = null;
                    vm.state.OptionalCover.IsPropertyStatementForRentDefault = null;
                }
                else {
                    vm.state.OptionalCover.IsRentMoreThan14Days = null;
                }
            }
        }

        function resetSecurityDetails() {
            if (vm.state.ContentsSumInsured.IsValuableContent == false) {
                vm.state.SecurityDetails.WindowSecurities = null;
                vm.state.SecurityDetails.AlarmType = null;
                vm.state.SecurityDetails.IsAlarmSecurity = null;
                vm.state.SecurityDetails.DoorSecurities = [];
            }

            if (vm.state.ContentsSumInsured.GeneralContentSumInsured < 150000) {
                vm.state.SecurityDetails.WindowSecurities = null;
                vm.state.SecurityDetails.AlarmType = null;
                vm.state.SecurityDetails.IsAlarmSecurity = null;
                vm.state.SecurityDetails.DoorSecurities = [];
            }
        }

        function continueOrNavigateBackToPackageManager() {
            var packageNumber = sessionStorageService.get('PackageNumberInformation');
            var renewalCounter = sessionStorageService.get('RenewalCounter');
            sessionStorageService.remove('IsPackageManagerNavigationMode');
            sessionStorageService.remove('PackageNumberInformation');
            sessionStorageService.remove('RenewalCounter');
            $window.location.href = webUrlConstService.getPackageInfo + sessionStorageService.getEncryption("packageNumber=" + JSON.parse(packageNumber) + "&&renewalCounter=" + renewalCounter);
        }

        function changeOtherInsuredName() {
            if (form1 && form1.OtherInsuredName) {
                if (form1.OtherInsuredName.value.length > 100) {
                    vm.showMessageGrt100OtherInsuredName = true;
                    form1.OtherInsuredName.value = form1.OtherInsuredName.value.substring(0, 100);
                } else {
                    vm.showMessageGrt100OtherInsuredName = false;
                }
            }
        }

        function checkAdditionalInsuredInList() {
            for (var j = 0; j < vm.state.PolicyHolder.AdditionalPolicyHolderList.length; j++) {
                var ele = vm.state.PolicyHolder.AdditionalPolicyHolderList[j];
                //if (ele.AdditionalPolicyHolder !== "Other") {
                    var existInsuredName = utilityService.valueExistsInArray(ele.AdditionalPolicyHolder, vm.state.PolicyHolder.SecondaryInsuredsList);
                    if (!existInsuredName) {
                        var res = false;
                        //break;
                    }
                    else {
                        res = true;
                    }
                //}
                //else {
                //    vm.otherreadonly = true;
                //}
            }
            return res;
        }

        function addOtherInsured() {
            vm.ClientDetail.SecondaryInsuredClientVM = vm.addSecondaryClient;
            vm.ClientDetail.SecondaryInsuredClientVM[0].AddressLogVM = vm.otherInsuredAddress;

            var client = {
                ClientViewModel: vm.ClientDetail.clientViewModel !== null ? vm.ClientDetail.clientViewModel : null,
                SecondaryInsuredClientVM: vm.ClientDetail.SecondaryInsuredClientVM
            };

            var request = clientService.updateClientData({
                client: client
            });
            request.then(function success(response) {
                if (vm.ClientDetail.SecondaryInsuredClientVM[0].ClientType == 'Individual') {
                    if (vm.IsOpenAddInsuredPopup) {
                        vm.state.PolicyHolder.InsuredName = vm.ClientDetail.SecondaryInsuredClientVM[0].FirstName + " " + vm.ClientDetail.SecondaryInsuredClientVM[0].LastName;
                        vm.state.PolicyHolder.DateOfBirthApp = vm.ClientDetail.SecondaryInsuredClientVM[0].DateOfBirthStringAsDDMMYYYY;
                        vm.IsOpenAddInsuredPopup = false;
                    } else {
                        vm.state.PolicyHolder.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].AdditionalPolicyHolder = vm.ClientDetail.SecondaryInsuredClientVM[0].FirstName + " " + vm.ClientDetail.SecondaryInsuredClientVM[0].LastName;
                        vm.state.PolicyHolder.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].DateOfBirthApp = "2000-01-01T00:00:00";
                        vm.state.PolicyHolder.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].AdditionalPolicyHolderType = "Secondary";
                    }
                } else {
                    if (vm.IsOpenAddInsuredPopup) {
                        vm.state.PolicyHolder.InsuredName = vm.ClientDetail.SecondaryInsuredClientVM[0].OrganisationName;
                        vm.state.PolicyHolder.DateOfBirthApp = "2000-01-01T00:00:00";
                        vm.IsOpenAddInsuredPopup = false;
                    } else {
                        vm.state.PolicyHolder.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].AdditionalPolicyHolder = vm.ClientDetail.SecondaryInsuredClientVM[0].OrganisationName;
                        vm.state.PolicyHolder.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].DateOfBirthApp = "2000-01-01T00:00:00";
                        vm.state.PolicyHolder.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].AdditionalPolicyHolderType = "Secondary";
                    }
                }
                return getInsuredNameList(false);
            });
        }

        function getInsuredNameList(isEdit) {
            var qCheckDate = new Date(vm.tempLandlordStandardData.DWCAdjustmentDate);
            var newBusinessCaseData = sessionStorageService.get(keyConstService.newBusinessCaseData);
            var newBusinessCaseDetail = JSON.parse(newBusinessCaseData);
            var qStartDate = newBusinessCaseDetail != null ? new Date(newBusinessCaseDetail.data.EffectiveDate) : new Date(vm.tempLandlordStandardData.StartDate);
            caseId = sessionStorageService.get(keyConstService.caseId);
            quotesService.getInsuredNameList(caseId).then(function (ResponseData) {
                if (ResponseData.data !== null) {
                    if (!isEdit) {
                        vm.state.PolicyHolder.InsuredNameList = ResponseData.data.policyHolder.insuredNameList;
                        //vm.state.PolicyHolder.InsuredClientId = ResponseData.data.policyHolder.insuredClientId;
                        vm.state.PolicyHolder.SecondaryInsuredsList = ResponseData.data.policyHolder.secondaryInsuredsList;
                        vm.ClientDetail = ResponseData.data.clientDetail;
                        vm.addSecondaryClient = ResponseData.data.clientDetail.secondaryInsuredClientVM;
                        vm.otherInsuredAddress = ResponseData.data.clientDetail.addressLogVM;
                        //vm.state.PolicyHolder.InsuredName = ResponseData.data.policyHolder.insuredName;
                        vm.PropertyDetail = angular.copy(ResponseData.data.buildingInfo);
                        var splitSate = ResponseData.data.buildingInfo.addressValue.split('|');
                        vm.AddressState = splitSate[0];
                        if (vm.AddressState === "NSW") {
                            vm.showStampDuty = true;

                        }

                        ////  7533
                        //if ((qStartDate < qCheckDate) && ((vm.AddressState === "WA" || vm.AddressState === "ACT" || vm.AddressState === "TAS") && vm.selectedAddress)) {
                        //    vm.showDomesticWorkerCompensation = true;
                        //}
                        //else {
                        //    vm.showDomesticWorkerCompensation = false;
                        //    vm.state.OtherInfo.IsStampDutyExemption = null;
                        //}

                        //  7533
                        //if (vm.IsEndorsement && vm.policyEffectiveDate != undefined && vm.endorsementEffectiveDate != undefined) {
                        //    if (vm.policyEffectiveDate === vm.endorsementEffectiveDate) {
                        //        vm.showDomesticWorkerCompensation = true;
                        //    }
                        //}

                        ////  7533
                        //if (getQuoteTransactionId === vm.getTransactionIdWithoutSaving) {
                        //    if ((qStartDate < qCheckDate) && (vm.getAddressState === "WA" || vm.getAddressState === "ACT" || vm.getAddressState === "TAS")) {
                        //        vm.showDomesticWorkerCompensation = true;

                        //    }
                        //    else {
                        //        vm.showDomesticWorkerCompensation = false;
                        //        vm.state.OptionalCover.IsDomesticWorkerCompensation = null;
                        //    }
                        //}

                        //vm.state.CordellResponse.Propertydata.postcode = ResponseData.data.buildingInfo.postcode;
                        
                    }
                    else {
                        // test Other   --------------------------------------------------------------------------
                        //vm.state.PolicyHolder.InsuredName = "Other";
                        //vm.state.PolicyHolder.OtherInsuredName = "Other Ankur";
                        //vm.state.PolicyHolder.DateOfBirthApp = "2000-01-01T00:00:00";

                        vm.ClientDetail = ResponseData.data.clientDetail;
                        vm.addSecondaryClient = ResponseData.data.clientDetail.secondaryInsuredClientVM;
                        vm.otherInsuredAddress = ResponseData.data.clientDetail.addressLogVM;
                        vm.PropertyDetail = angular.copy(ResponseData.data.buildingInfo);
                        vm.IsAddressavailable = true;
                        if (vm.state.PolicyHolder.InsuredName === "Other") {
                            var indexOfInsured = vm.state.PolicyHolder.InsuredNameList.findIndex(p => p.value === "Other");
                            if (indexOfInsured === -1) {
                                vm.state.PolicyHolder.InsuredNameList.push({ clientType: "Secondary", name: vm.state.PolicyHolder.InsuredName, value: vm.state.PolicyHolder.InsuredName, dateOfBirth: vm.state.PolicyHolder.DateOfBirth, Id: 0 });
                                vm.state.PolicyHolder.SecondaryInsuredsList.push({ clientType: "Secondary", name: vm.state.PolicyHolder.InsuredName, value: vm.state.PolicyHolder.InsuredName, dateOfBirth: vm.state.PolicyHolder.DateOfBirth, Id: 0 });
                            }
                            vm.OtherInsuredName = vm.state.PolicyHolder.OtherInsuredName;
                            vm.DateOfBirthApp = vm.state.PolicyHolder.DateOfBirthApp;
                            vm.otherreadonly = true;
                        }
                        if (vm.state.PropertyDetail.IsManualAddress === false) {
                            vm.selectedAddress = vm.state.PropertyDetail.AddressText;
                        }
                        //test Other  --------------------------------------------------------------------------
                        //vm.state.PolicyHolder.AdditionalPolicyHolderList[0].AdditionalPolicyHolder = "Other";
                        //vm.state.PolicyHolder.AdditionalPolicyHolderList[0].OtherPolicyHolderName = "Test Other ANkur";
                        //vm.state.PolicyHolder.AdditionalPolicyHolderList[0].OtherDateOfBirthApp = "2000-01-01T00:00:00";

                        if ((vm.state.PolicyHolder.AdditionalPolicyHolderList.findIndex(p => p.AdditionalPolicyHolder === "Other")) >= 0) {
                            var indexOfInsured = vm.state.PolicyHolder.InsuredNameList.findIndex(p => p.value === "Other");
                            if (indexOfInsured === -1) {
                                vm.state.PolicyHolder.InsuredNameList.push({ clientType: "Secondary", name: "Other", value: "Other", dateOfBirth: null, Id: 0 });
                                vm.state.PolicyHolder.SecondaryInsuredsList.push({ clientType: "Secondary", name: "Other", value: "Other", dateOfBirth: null, Id: 0 });
                                vm.otherreadonly = true;
                            }
                        }

                        // If Insured name is not other and additional list is having other but Insuredlist and secondaryInsured list is having remove it array.
                        if (vm.state.PolicyHolder.InsuredName !== "Other" && (vm.state.PolicyHolder.AdditionalPolicyHolderList.findIndex(p => p.AdditionalPolicyHolder === "Other")) !== -1) {
                            var insuredotherPosition = vm.state.PolicyHolder.InsuredNameList.findIndex(p => p.value === "Other");
                            if (insuredotherPosition !== -1) {
                                vm.state.PolicyHolder.InsuredNameList.splice(insuredotherPosition, 1);
                            }
                            //var secondaryInsuredOtherPos = vm.state.PolicyHolder.SecondaryInsuredsList.findIndex(p => p.value === "Other");
                            //if (secondaryInsuredOtherPos !== -1) {
                            //    vm.state.PolicyHolder.SecondaryInsuredsList.splice(secondaryInsuredOtherPos, 1);
                            //}
                        }

                        if (vm.state.PolicyHolder.InsuredName == "Other" && (vm.state.PolicyHolder.AdditionalPolicyHolderList.findIndex(p => p.AdditionalPolicyHolder === "Other")) === -1) {
                            var secondaryInsuredOtherPos = vm.state.PolicyHolder.SecondaryInsuredsList.findIndex(p => p.value === "Other");
                            if (secondaryInsuredOtherPos !== -1) {
                                vm.state.PolicyHolder.SecondaryInsuredsList.splice(secondaryInsuredOtherPos, 1);
                            }
                        }
                    }

                    vm.tempPrimaryInsured = vm.state.PolicyHolder.InsuredName;
                    vm.tempAdditonalPolicyHolders = angular.copy(vm.state.PolicyHolder.AdditionalPolicyHolderList);
                }

                if (!isEdit) {
                    if (vm.state.PolicyHolder.AdditionalPolicyHolderList.length != 0 && vm.state.PolicyHolder.AdditionalPolicyHolderList[0].OtherDateOfBirthApp != null) {
                        for (var i = 0; i < vm.state.PolicyHolder.AdditionalPolicyHolderList.length; i++) {
                            if (vm.state.PolicyHolder.AdditionalPolicyHolderList[i].AdditionalDateOfBirth === "Other") {
                                var dateofBirth = vm.state.PolicyHolder.AdditionalPolicyHolderList[i].OtherDateOfBirthApp;
                                var response = dateService.validateBirthDDMMYYYY(dateofBirth, 115);
                                if (!response.isValid) {
                                    vm.validDOBOtherInsurer = false;
                                    vm.message = response.errorMsg;
                                    break;
                                }
                                else {
                                    vm.validDOBOtherInsurer = true;
                                }
                            }
                            else {
                                break;
                            }
                        }
                        if (!vm.validDOBOtherInsurer && vm.message === messageConstService.errFutureDateNotAllowed) {
                            toastr.warning(messageConstService.errFutureDatedForAddHolder);
                        }
                        else if (!vm.validDOBOtherInsurer && vm.message === messageConstService.errDateNotAllowed) {
                            toastr.warning(messageConstService.errDateNotAllowed);
                        }
                    }

                    if (vm.state.ContentsSumInsured.IsValuableContent || vm.state.ContentsSumInsured.GeneralContentSumInsured > keyConstService.LLContentSumInsuredLimit)
                        doorChecked();

                    //retaining Claims state on previous/next
                    vm.checkClaims();
                    vm.checkWeeklyRentalAmount(vm.state.OptionalCover.WeeklyRentalAmount);
                    checkDefaultBuildingSumInsured(vm.state.CordellResponse.BuildingSumInsured);
                    BuildingSumInsuredRange(vm.state.CordellResponse.BuildingSumInsured);
                    if (vm.state.PolicyHolder.ContentCover) {
                        vm.checkSumInsuredValue();
                    }

                    if (getQuoteTransactionId !== vm.getTransactionIdWithoutSaving) {
                        var newDate = new Date(ResponseData.data.policyHolder.dateOfBirthApp);
                        vm.state.PolicyHolder.DateOfBirthApp = newDate;
                    }
                    //else {
                        if (vm.state.PolicyHolder.InsuredName === "Other") {
                            var indexOfInsured = vm.state.PolicyHolder.InsuredNameList.findIndex(p => p.value === "Other");
                            if (indexOfInsured === -1) {
                                vm.state.PolicyHolder.InsuredNameList.push({ clientType: "Secondary", name: vm.state.PolicyHolder.InsuredName, value: vm.state.PolicyHolder.InsuredName, dateOfBirth: vm.state.PolicyHolder.DateOfBirth, Id: 0 });
                               // vm.state.PolicyHolder.SecondaryInsuredsList.push({ clientType: "Secondary", name: vm.state.PolicyHolder.InsuredName, value: vm.state.PolicyHolder.InsuredName, dateOfBirth: vm.state.PolicyHolder.DateOfBirth, Id: 0 });
                            }
                            vm.OtherInsuredName = vm.state.PolicyHolder.OtherInsuredName;
                            vm.DateOfBirthApp = vm.state.PolicyHolder.DateOfBirthApp;
                            vm.otherreadonly = true;
                        } else {
                            var indexOfInsured = vm.state.PolicyHolder.InsuredNameList.findIndex(p => p.value === "Other");
                            if (indexOfInsured >= 0) {
                                vm.state.PolicyHolder.InsuredNameList.splice(indexOfInsured, 1);
                            }
                        }

                        if ((vm.state.PolicyHolder.AdditionalPolicyHolderList.findIndex(p => p.AdditionalPolicyHolder === "Other")) >= 0) {
                            //var indexOfInsured = vm.state.PolicyHolder.InsuredNameList.findIndex(p => p.value === "Other");
                            //if (indexOfInsured === -1) {
                            //    vm.state.PolicyHolder.InsuredNameList.push({ clientType: "Secondary", name: "Other", value: "Other", dateOfBirth: null, Id: 0 });
                            //    vm.state.PolicyHolder.SecondaryInsuredsList.push({ clientType: "Secondary", name: "Other", value: "Other", dateOfBirth: null, Id: 0 });
                            //    vm.otherreadonly = true;
                            //}
                            var indexOfInsured = vm.state.PolicyHolder.SecondaryInsuredsList.findIndex(p => p.value === "Other");
                            if (indexOfInsured === -1) {
                                vm.state.PolicyHolder.SecondaryInsuredsList.push({ clientType: "Secondary", name: "Other", value: "Other", dateOfBirth: null, Id: 0 });
                            }
                            vm.otherreadonly = true;
                        } else {
                            var indexOfInsured = vm.state.PolicyHolder.SecondaryInsuredsList.findIndex(p => p.value === "Other");
                            if (indexOfInsured >= 0) {
                                vm.state.PolicyHolder.SecondaryInsuredsList.splice(indexOfInsured, 1);
                            }
                        }

                    if (vm.state.PolicyHolder.InsuredName !== "Other" && (vm.state.PolicyHolder.AdditionalPolicyHolderList.findIndex(p => p.AdditionalPolicyHolder === "Other")) == -1) {
                        if (vm.state.PolicyHolder.InsuredClientId !== null && vm.state.PolicyHolder.OtherInsuredName === null) {
                            vm.state.PolicyHolder.InsuredName = vm.state.PolicyHolder.InsuredName;//ResponseData.data.policyHolder.insuredName;
                        }
                        else {
                            vm.state.PolicyHolder.InsuredName = ResponseData.data.policyHolder.insuredName;
                        }
                    }
                    // If Insured name is not other and additional list is having other but Insuredlist and secondaryInsured list is having remove it array.
                    // Commented InsuredList bcoz need to add Other option in insured list
                    // Commentd by Ankur as per us 6829
                    //if (vm.state.PolicyHolder.InsuredName !== "Other" && (vm.state.PolicyHolder.AdditionalPolicyHolderList.findIndex(p => p.AdditionalPolicyHolder === "Other")) === -1) {
                    //        //var insuredotherPosition = vm.state.PolicyHolder.InsuredNameList.findIndex(p => p.value === "Other");
                    //        //if (insuredotherPosition !== -1) {
                    //        //    vm.state.PolicyHolder.InsuredNameList.splice(insuredotherPosition, 1);
                    //        //}
                    //        var secondaryInsuredOtherPos = vm.state.PolicyHolder.SecondaryInsuredsList.findIndex(p => p.value === "Other");
                    //        if (secondaryInsuredOtherPos !== -1) {
                    //            vm.state.PolicyHolder.SecondaryInsuredsList.splice(secondaryInsuredOtherPos, 1);
                    //        }
                    //    }
                    //}

                    if (vm.state.PolicyHolder.InsuredName != "Other") {
                        var objSelectedInsured = vm.state.PolicyHolder.InsuredNameList.filter(function (e) { return e.value === vm.state.PolicyHolder.InsuredName })
                        vm.state.PolicyHolder.InsuredClientId = objSelectedInsured[0].id;
                    } else {
                        vm.state.PolicyHolder.InsuredClientId = -2;
                    }

                    for (var i = 0; i < ResponseData.data.policyHolder.secondaryInsuredsList.length; i++) {
                        if (ResponseData.data.policyHolder.secondaryInsuredsList[i].value === vm.state.PolicyHolder.InsuredName && ResponseData.data.policyHolder.secondaryInsuredsList[i].id === vm.state.PolicyHolder.InsuredClientId) {
                            var index = ResponseData.data.policyHolder.secondaryInsuredsList.indexOf(ResponseData.data.policyHolder.secondaryInsuredsList[i]);
                            ResponseData.data.policyHolder.secondaryInsuredsList.splice(index, 1);
                            vm.state.PolicyHolder.SecondaryInsuredsList = ResponseData.data.policyHolder.secondaryInsuredsList;

                            if (getQuoteTransactionId === vm.getTransactionIdWithoutSaving) {
                                vm.getQuestionSetWithoutSavingData = JSON.parse(sessionStorageService.get(keyConstService.getQuestionSetWithoutSaving));
                                if (vm.getQuestionSetWithoutSavingData.PolicyHolder.InsuredName === "Other") {
                                    vm.state.PolicyHolder.InsuredName = vm.getQuestionSetWithoutSavingData.PolicyHolder.InsuredName;
                                    vm.state.PolicyHolder.OtherInsuredName = vm.getQuestionSetWithoutSavingData.PolicyHolder.OtherInsuredName;
                                    for (var i = 0; i < vm.getQuestionSetWithoutSavingData.PolicyHolder.SecondaryInsuredsList.length; i++) {
                                        vm.state.PolicyHolder.SecondaryInsuredsList[i] = vm.getQuestionSetWithoutSavingData.PolicyHolder.SecondaryInsuredsList[i];
                                    }
                                }
                            }

                        }
                        // Commentd by Ankur as per us 6829
                        //else {
                        //    if (vm.state.PolicyHolder.InsuredName) {
                        //        vm.state.PolicyHolder.InsuredName = ResponseData.data.policyHolder.insuredName;
                        //    }
                        //}
                    }
                }
            });
            if (!isEdit) {
                resetAddress();
            }

        }

        function storeOtherInsuredAddress(address) {
            if (address && address.value == 'N/A') {
                address = null;
                vm.selectedAddress1 = null;
                onClickAddressNotFoundOtherInsured();
            }
            if (address !== null && address !== undefined) {
                if (address.value) {
                    vm.addSecondaryClient[0].IsStampDutyExempted = false;
                    var splitSate = address.value.split('|');
                    var AddressState = splitSate[0];
                    vm.addSecondaryClient[0].IsStampDutyExempted = false;
                    if (AddressState === "NSW") {
                        vm.addSecondaryClient[0].showStampDuty = true;
                    }
                    else {
                        vm.addSecondaryClient[0].showStampDuty = false;
                    }

                    if (vm.addSecondaryClient[0].IsSameAsPrimaryAddress && vm.otherInsuredAddress && vm.PropertyDetail.addressText !== address.text) {
                        vm.addSecondaryClient[0].IsSameAsPrimaryAddress = false;
                    }

                    if (vm.otherInsuredAddress) {
                        vm.otherInsuredAddress.Address = address.text;
                        vm.otherInsuredAddress.DelimeterAddress = address.value;
                        vm.otherInsuredAddress.PostCode = address.postCode === null ? null : address.postCode;
                        if (address.isManualAddress) {
                            vm.selectedOtherMannualItem = vm.selectedOtherMannualAddress.text;
                            vm.otherInsuredAddress.AddressLine1 = vm.selectedOtherMannualAddress.addressLine1;
                        }
                    }
                    else {
                        vm.otherInsuredAddress = {
                            Address: address.text,
                            DelimeterAddress: address.value,
                            PostCode: address.postCode === null ? null : address.postCode
                        };
                    }
                }
            }
        }

        function checkSameAsPrimary() {
            if (vm.addSecondaryClient[0].IsSameAsPrimaryAddress) {

                if (!vm.PropertyDetail.isManualAddress) {
                    vm.selectedAddress1 = { postCode: vm.PropertyDetail.postcode, text: vm.PropertyDetail.addressText, value: vm.PropertyDetail.addressValue };
                    storeOtherInsuredAddress(vm.selectedAddress1);
                }
                else {
                    vm.selectedOtherMannualAddress = { postCode: vm.PropertyDetail.postcode, text: vm.PropertyDetail.addressText, addressLine1: vm.PropertyDetail.addressLine1, value: vm.PropertyDetail.addressValue, isManualAddress: vm.PropertyDetail.isManualAddress };
                    storeOtherInsuredAddress(vm.selectedOtherMannualAddress);
                }
                vm.otherInsuredAddress.isManualAddress = vm.PropertyDetail.isManualAddress;
                if (vm.otherInsuredAddress.isManualAddress === false) {
                    vm.otherInsuredAddress.AddressLine1 = null;
                    vm.mannualOtherSearchText = null;
                    vm.selectedOtherMannualItem = null;
                }
            }
        }


        function resetAddress() {
                vm.selectedAddress1 = null;
                vm.otherInsuredAddress.Address = null;
                vm.otherInsuredAddress.DelimeterAddress = null;
                vm.otherInsuredAddress.PostCode = null;
                vm.showStampDuty = false;
            if (vm.addSecondaryClient.length > 0) {
                vm.addSecondaryClient[0].IsStampDutyExempted = false;
                vm.addSecondaryClient[0].IsSameAsPrimaryAddress = false;
            }
                //vm.searchText1 = null;
            if (vm.otherInsuredAddress.isManualAddress === false) {
                vm.otherInsuredAddress.AddressLine1 = null;
                vm.mannualOtherSearchText = null;
                vm.selectedOtherMannualItem = null;
            }
        }

        function cancelOtherInsured(type) {
            if (vm.addSecondaryClient.length > 0) {
                vm.addSecondaryClient[0].FirstName = null;
                vm.addSecondaryClient[0].LastName = null;
                vm.addSecondaryClient[0].DateOfBirthStringAsDDMMYYYY = null;
                vm.addSecondaryClient[0].OrganisationName = null;
                vm.addSecondaryClient[0].TradingName = null;
                vm.searchText1 = null;
                if (type === 'cancelButton') {
                    vm.addSecondaryClient[0].ClientType = null;
                }
            }
            if (type.$name === 'otherInsuredForm' && vm.otherInsuredAddress.isManualAddress === false) {
                type.otherAutocompleteAddress.$invalid = true;
                type.otherAutocompleteAddress.$touched = false;
            }

            if (type === 'cancelButton') {
                if (vm.IsOpenAddInsuredPopup) {
                    vm.state.PolicyHolder.InsuredName = vm.tempPrimaryInsured;
                    vm.IsOpenAddInsuredPopup = false;
                } else if (vm.tempAdditonalPolicyHolders != null) {
                    vm.state.PolicyHolder.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].AdditionalPolicyHolder = vm.tempAdditonalPolicyHolders[vm.AdditionalPolicyHolderIndex] == undefined ? null : vm.tempAdditonalPolicyHolders[vm.AdditionalPolicyHolderIndex].AdditionalPolicyHolder;
                    vm.state.PolicyHolder.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].AdditionalPolicyHolderType = "Secondary";
                } else {
                    vm.state.PolicyHolder.AdditionalPolicyHolderList[vm.AdditionalPolicyHolderIndex].AdditionalPolicyHolder = null;
                }
            }

            //vm.tempPrimaryInsured = vm.state.PolicyHolder.InsuredNameList.filter(function (e) { return e.clientType === 'Primary' })
            //vm.state.PolicyHolder.InsuredName = vm.tempPrimaryInsured[0].name;
            vm.otherInsuredAddress.isManualAddress = false;
            resetAddress();
        }

        function OtherSubmitEnabled(otherInsuredForm) {
            if (otherInsuredForm.$invalid || (vm.selectedAddress1 === null && !vm.otherInsuredAddress.isManualAddress)) {
                return true;
            }
            else {
                return false;
            }
        }

        vm.checkValidOtherManualAddress = function (field) {
            if (vm.mannualOtherSearchText) {
                if (!vm.selectedOtherMannualItem) {
                    field.$setValidity('invalid', false);
                }
                else {
                    field.$setValidity('invalid', true);
                }
            }
        };

        function DefaultExcessOnAddress() {
            if (vm.primaryClientAddressState.toUpperCase() === "SA" && !getParsedQuestionSetWithoutSaving) {
                vm.state.Excess.BuildingExcess1 = "500";
                vm.state.Excess.BuildingExcess2 = "750";
                vm.state.Excess.BuildingExcess3 = "1000";
                vm.state.Excess.ContentExcess1 = "500";
                vm.state.Excess.ContentExcess2 = "750";
                vm.state.Excess.ContentExcess3 = "1000";
            }
        }

        function DefaultContentExcessOnCoverChange() {
            var addressState = vm.AddressState !== null && vm.AddressState !== undefined ? vm.AddressState.toUpperCase() : null;

            if (vm.landlordStandardData.DDlProcessTypeId !== 4) {
                if (vm.state.Excess.ContentExcess1 === null || vm.state.Excess.ContentExcess1 === "") {
                    vm.state.Excess.ContentExcess1 = addressState === "SA" ? keyConstService.DefautExcess1Sa : keyConstService.DefautExcess1OtherStates;
                }
                if (!vm.IsEndorsement) {
                    if (vm.state.Excess.ContentExcess2 === null || vm.state.Excess.ContentExcess2 === "") {
                        vm.state.Excess.ContentExcess2 = addressState === "SA" ? keyConstService.DefautExcess2Sa : keyConstService.DefautExcess2OtherStates;
                    }
                    if (vm.state.Excess.ContentExcess3 === null || vm.state.Excess.ContentExcess3 === "") {
                        vm.state.Excess.ContentExcess3 = addressState === "SA" ? keyConstService.DefautExcess3Sa : keyConstService.DefautExcess3OtherStates;;
                    }
                }
            }
            if (vm.endorsementVM && vm.endorsementVM.ContentExcess) {
                vm.state.Excess.ContentExcess1 = vm.endorsementVM.ContentExcess;
            }
            else if (endorsementState && endorsementState.Excess.ContentExcess1) {
                vm.state.Excess.ContentExcess1 = endorsementState.Excess.ContentExcess1;
            }
        }

        function CheckRoofANdWallValuePresentInDropDown() {
            if (vm.version < keyConstService.Version) {
                var resultWallMaterial = utilityService.valueExistsInDropDown(vm.state.CordellResponse.Propertydata.externalWallMaterial, vm.state.CordellDropDownValues.ExternalWallList);
                var resultRoofType = utilityService.valueExistsInDropDown(vm.state.CordellResponse.Propertydata.roof, vm.state.CordellDropDownValues.RoofMaterialList);
                vm.state.CordellResponse.Propertydata.externalWallMaterial = resultWallMaterial === true ? vm.state.CordellResponse.Propertydata.externalWallMaterial : null;
                vm.state.CordellResponse.Propertydata.roof = resultRoofType === true ? vm.state.CordellResponse.Propertydata.roof : null;
            }
            else {
                var resultWallMaterialV2 = utilityService.valueExistsInDropDown(vm.state.CordellResponse.Propertydata.externalWallMaterial, vm.LandlordStandardDropDownListV2.ExternalWallTypeList);
                var resultRoofTypeV2 = utilityService.valueExistsInDropDown(vm.state.CordellResponse.Propertydata.roof, vm.LandlordStandardDropDownListV2.RoofMaterialList);
                vm.state.CordellResponse.Propertydata.externalWallMaterial = resultWallMaterialV2 === true ? vm.state.CordellResponse.Propertydata.externalWallMaterial : null;
                vm.state.CordellResponse.Propertydata.roof = resultRoofTypeV2 === true ? vm.state.CordellResponse.Propertydata.roof : null;
            }
        }

        function MakeBedRoomBathRoomBlank() {
            if (vm.version >= keyConstService.Version) {
                //// as per requirement
                if (vm.state.CordellResponse.Propertydata.roomBed === 0) {
                    vm.state.CordellResponse.Propertydata.roomBed = null;
                }
                //// as per requirement
                if (vm.state.CordellResponse.Propertydata.roomBath === 0) {
                    vm.state.CordellResponse.Propertydata.roomBath = null;
                }
            }
        }

        function checkManualAddressChange(flag) {
            if (vm.state.PropertyDetail.AddressText !== null && vm.state.PropertyDetail.AddressText !== undefined) {
                vm.previousAddressTextForIllion = vm.state.PropertyDetail.AddressText;
            }
            if (flag) {
                vm.previousAddressLine1ForIllion = null;
            }
        }

        vm.getAdressEnquiryDetails = function () {
            if (vm.IsEndorsement == true || vm.landlordStandardData.DDlProcessTypeId == 4) {
                return;
            }

            if (vm.state.PropertyDetail && vm.state.PropertyDetail.AddressValue) {
                if (vm.previousAddressTextForIllion && vm.previousAddressTextForIllion === vm.state.PropertyDetail.AddressText) {
                    if (vm.state.PropertyDetail.IsManualAddress) {
                        if (!vm.checkAddressLine1 && vm.state.PropertyDetail.AddressLine1) {
                            if (vm.previousAddressLine1ForIllion) {
                                if (vm.previousAddressLine1ForIllion == vm.state.PropertyDetail.AddressLine1) {
                                    return;
                                }
                            }
                            else {
                                vm.previousAddressLine1ForIllion = vm.state.PropertyDetail.AddressLine1;
                                return;
                            }
                        }                        
                    }
                    else {
                        return;
                    }
                }
                let addLine1 = null;
                if (!vm.state.PropertyDetail.IsManualAddress) {
                    let addressTextSplit = vm.state.PropertyDetail.AddressText.split(',');
                    addLine1 = addressTextSplit[0];
                }
                else {
                    addLine1 = vm.state.PropertyDetail.AddressLine1;
                    vm.previousAddressLine1ForIllion = addLine1;
                }
                if (addLine1 === null || addLine1 === undefined) {
                    vm.checkAddressLine1 = true;
                    return;
                }
                vm.checkAddressLine1 = false;
                vm.state.IllionClaimResponse = null;
                vm.state.IllionClaimResponseId = null;                
                let addressSplitSate = vm.state.PropertyDetail.AddressValue.split('|');
                let addState = addressSplitSate[0];
                let addPostcode = addressSplitSate[1];
                let addSuburb = addressSplitSate[2];
                var illionAddressEnquiryRequestVM = {
                    "AddressLine1": addLine1,
                    "Suburb": addSuburb,
                    "State": addState,
                    "Postcode": addPostcode,
                    "AddressText": addLine1 + "," + addSuburb + " " + addState + " " + addPostcode
                };
                utilityService.getAddressEnquiry(illionAddressEnquiryRequestVM).then(function (data) {
                    vm.state.IllionClaimResponseId = data.data;                   
                });
            }
        }

        function OnRentDefaulChildQuestionChange() {
            vm.ShowRentDefaultDeclineText = false;
            if (vm.state.OptionalCover.IsRentDefault && !vm.ReadOnly) {
                if ((vm.state.OptionalCover.IsStatementForRentDefault === false && vm.state.OptionalCover.IsPropertyStatementForRentDefault === false) ||
                    (vm.state.OptionalCover.IsStatementForRentDefault && vm.state.OptionalCover.IsPropertyStatementForRentDefault) ||
                    (vm.state.OptionalCover.IsStatementForRentDefault && vm.state.OptionalCover.IsPropertyStatementForRentDefault === false)) {
                    vm.ShowRentDefaultDeclineText = true;
                }
            }
        }

        function claimTypeListSelection() {
            let previousClaimTypeListsection = vm.state.Claims.ClaimTypeList;
            vm.state = getParsedQuestionSetWithoutSaving;

            if (vm.state.Claims.ClaimTypeList.length != previousClaimTypeListsection.length) {
                if (vm.landlordStandardData.DDlProcessTypeId == 1 || vm.landlordStandardData.DDlProcessTypeId == 0) {
                    vm.state.Claims.ClaimTypeList = previousClaimTypeListsection;
                }
            }

            for (let i = 0; i < vm.state.Claims.ClaimsList.length; i++) {
                let currentitem = vm.state.Claims.ClaimsList[i];
                if (vm.state.Claims.ClaimTypeList.filter(x => x.Value == currentitem.ClaimType).length == 0) {
                    vm.state.Claims.ClaimsList[i].ClaimType = null;
                    vm.state.Claims.ClaimsList[i].CostOfClaim = null;
                }
            }
        }
    }
})();;
(function () {
    'use strict';

    var appUI = angular.module('appUI');

    appUI.controller('quoteTransactionCtrl', ['$rootScope', '$q', 'responsiveService', 'sessionStorageService', quoteTransactionCtrl]);

    function quoteTransactionCtrl($rootScope, $q, responsiveService, sessionStorageService) {
        var rootModel = this;
        var transactionId = 0;
        rootModel.state = {};
        var caseId = "0";

        rootModel.getArray = function (q) {
            var genericArray = [];

            if (rootModel.state.quoteData.coverType == "BuildingAndContents")
            {
                if (q.buildingExcess1 != null) {
                    genericArray.push({ id: 1, label: "Building: " + q.buildingExcess1 + "Content: " + q.contentExcess1, excessPremiums: angular.copy(q.excess1Premiums) });
                }
                if (q.buildingExcess2 != null) {
                    genericArray.push({ id: 2, label: "Building: " + q.buildingExcess2 + "Content: " + q.contentExcess2, excessPremiums: angular.copy(q.excess2Premiums) });
                }
                if (q.buildingExcess3 != null) {
                    genericArray.push({ id: 3, label: "Building: " + q.buildingExcess3 + "Content: " + q.contentExcess3, excessPremiums: angular.copy(q.excess3Premiums) });
                }
            }
            if (rootModel.state.quoteData.coverType == "Building") {
                if (q.buildingExcess1 != null) {
                    genericArray.push({ id: 1, label: "Building: " + q.buildingExcess1, excessPremiums: angular.copy(q.excess1Premiums)});
                }
                if (q.buildingExcess2 != null) {
                    genericArray.push({ id: 2, label: "Building: " + q.buildingExcess2, excessPremiums: angular.copy(q.excess2Premiums)});
                }
                if (q.buildingExcess3 != null) {
                    genericArray.push({ id: 3, label: "Building: " + q.buildingExcess3, excessPremiums: angular.copy(q.excess3Premiums)});
                }
            }
            if (rootModel.state.quoteData.coverType == "Contents") {
                if (q.buildingExcess1 != null) {
                    genericArray.push({ id: 1, label: "Content: " + q.contentExcess1, excessPremiums: angular.copy(q.excess1Premiums) });
                }
                if (q.buildingExcess2 != null) {
                    genericArray.push({ id: 2, label: "Content: " + q.contentExcess2, excessPremiums: angular.copy(q.excess2Premiums) });
                }
                if (q.buildingExcess3 != null) {
                    genericArray.push({ id: 3, label: "Content: " + q.contentExcess3, excessPremiums: angular.copy(q.excess3Premiums) });
                }
            }

            return genericArray;
        }

        rootModel.switch = function (q) {
            q.isExpanded = !q.isExpanded;
        }

        rootModel.init = function () {
            rootModel.ready = true;
            var quoteData1 = {};

            rootModel.state.quoteData = {
                caseId: "2241",
                coverage: "Accidental Coverage",
                coverType: "BuildingAndContents",
                quotes: 
                [
                    {
                        quoteNumber: "CH-QHYYMMDDYYYY-02",
                        quoteDate: 'Sep 13, 2017 11:45:22 AM',
                        buildingExcess1: 500,
                        buildingExcess2: 100,
                        buildingExcess3: null,
                        contentExcess1: 200,
                        contentExcess2: 300,
                        contentExcess3: null,
                        excess1Premiums: [
                            { label: "Base Premium", amount: 0.00 },
                            { label: "FSL", amount: 0.00 },
                            { label: "GST", amount: 0.00 },
                            { label: "Stamp Duty", amount: 0.00 },
                            { label: "Commision", amount: 0.00 },
                            { label: "Commision GST", amount: 10.00 },
                            { label: "Total Premium", amount: 10.00 }
                        ],
                        excess2Premiums: [
                            { label: "Base Premium", amount: 0.00 },
                            { label: "FSL", amount: 0.00 },
                            { label: "GST", amount: 0.00 },
                            { label: "Stamp Duty", amount: 0.00 },
                            { label: "Commision", amount: 0.00 },
                            { label: "Commision GST", amount: 0.00 },
                            { label: "Total Premium", amount: 0.00 }
                        ],
                        excess3Premiums : null
                    },
                    {
                        quoteNumber: "CH-QHYYMMDDYYYY-01",
                        quoteDate: '2017-11-20',
                        buildingExcess1: 500,
                        buildingExcess2: null,
                        buildingExcess3: null,
                        contentExcess1: 200,
                        contentExcess2: null,
                        contentExcess3: null,
                        excess1Premiums: [
                            { label: "Base Premium", amount: 0.00 },
                            { label: "FSL", amount: 0.00 },
                            { label: "GST", amount: 0.00 },
                            { label: "Stamp Duty", amount: 0.00 },
                            { label: "Commision", amount: 0.00 },
                            { label: "Commision GST", amount: 0.00 },
                            { label: "Total Premium", amount: 0.00 }
                        ],
                        excess2Premiums: null,
                        excess3Premiums: null
                    },
                    {
                        quoteNumber: "CH-QHYYMMDDYYYY-00",
                        quoteDate: '2017-10-19',
                        buildingExcess1: 500,
                        buildingExcess2: 400,
                        buildingExcess3: 300,
                        contentExcess1: 200,
                        contentExcess2: 1000,
                        contentExcess3: 2000,
                        excess1Premiums: [
                            { label: "Base Premium", amount: 0.00 },
                            { label: "FSL", amount: 0.00 },
                            { label: "GST", amount: 0.00 },
                            { label: "Stamp Duty", amount: 0.00 },
                            { label: "Commision", amount: 0.00 },
                            { label: "Commision GST", amount: 0.00 },
                            { label: "Total Premium", amount: 0.00 }
                        ],
                        excess2Premiums: [
                            { label: "Base Premium", amount: 0.00 },
                            { label: "FSL", amount: 0.00 },
                            { label: "GST", amount: 0.00 },
                            { label: "Stamp Duty", amount: 0.00 },
                            { label: "Commision", amount: 0.00 },
                            { label: "Commision GST", amount: 0.00 },
                            { label: "Total Premium", amount: 0.00 }
                        ],
                        excess3Premiums: [
                            { label: "Base Premium", amount: 0.00 },
                            { label: "FSL", amount: 0.00 },
                            { label: "GST", amount: 0.00 },
                            { label: "Stamp Duty", amount: 0.00 },
                            { label: "Commision", amount: 0.00 },
                            { label: "Commision GST", amount: 0.00 },
                            { label: "Total Premium", amount: 0.00 }
                        ]
                    }
                ]
            };
            /*Active quote is at first index from .net side*/

            for (var i = 0; i < rootModel.state.quoteData.quotes.length; i++) {
                if (i == 0) {
                    rootModel.state.quoteData.quotes[i].showHide = true;
                    rootModel.state.quoteData.quotes[i].isExpanded = true;
                }
                else {
                    rootModel.state.quoteData.quotes[i].showHide = false;
                    rootModel.state.quoteData.quotes[i].isExpanded = false;
                }
            }
            console.log(rootModel.quoteData);
        }

    }
})();   ;


(function () {
    'use strict';

    var appUI = angular.module('appUI');
    appUI.controller('quoteCaseCtrl', ['$rootScope', '$q', 'responsiveService', 'sessionStorageService', 'quoteCaseService', 'bindService', 'quotesService', 'keyConstService', '$http', '$mdDialog', 'webUrlConstService', 'apiUrlConstService', '$window', 'cfpLoadingBar', '$log', 'messageConstService', 'FileSaver', 'Blob', '$resource', '$timeout', 'utilityService', quoteCaseCtrl]);

    function quoteCaseCtrl($rootScope, $q, responsiveService, sessionStorageService, quoteCaseService, bindService, quotesService, keyConstService, $http, $mdDialog, webUrlConstService, apiUrlConstService, $window, cfpLoadingBar, $log, messageConstService, FileSaver, Blob, $resource, $timeout, utilityService) {

        var vm = this;
        var quotepremiumResponseData;
        vm.state = {};
        vm.init = init;
        vm.referralMessages = [];
        vm.isBrokerCommentsMandatory = false;
        vm.showNBQuoteDocGrid = false;
        vm.hideNBQuoteDocGrid = true;
        vm.declineMessages = {};
        vm.referralValue = false;
        vm.declineValue = false;
        vm.coverType = "";
        vm.coverageType = null;
        var coverTypevalue = "";
        var caseId = "0";
        vm.genericArray = [];
        vm.isErrors = false;
        vm.status = '';
        vm.buyNow = buyNow;
        vm.IsEditEnabled = true;
        vm.brokerComment = '';
        vm.underwriterComment = '';
        vm.referToUnderwriter = referToUnderwriter;
        var ruleIdArray = [];
        var arr = [];
        var arr1 = [];
        vm.disableValue = false;
        vm.hideUnderwriterComments = true;
        vm.premiumResponseData = {};
        vm.getReferenceNumber = getReferenceNumber;
        vm.docDetail = [];
        vm.endorsementPremiumArray = [];
        vm.AttachementData = [{ attachementText: null, file: null }];
        vm.addAttachementData = addAttachementData;
        vm.removeAttachementData = removeAttachementData;
        vm.discardQuote = discardQuote;
        vm.discard = discard;
        vm.referenceNumberCoverage = [];
        vm.showBrokerFee = true;
        vm.numberOfInstallment = 1;
        vm.showMonthlyBreakDown = true;
        vm.paymentInfoExist = false;
        vm.paymentCollectedByBroker = false;
        vm.activatePaymentModule = false;
        vm.isEndorsement = false;
        vm.cancel = cancel;
        vm.Isdisabletoberef = false;
        vm.policyDuration;
        vm.buildingExcess = 0;
        vm.contentExcess = 0;
        vm.motorExcess = 0;
        vm.message = '';
        vm.displayCoverageType = '';
        vm.hideAttachments = false;
        vm.disablebrokercomment = false;
        vm.isAnnual = false;
        vm.brokerbranchcheck;
        vm.disableButtons = false;
        vm.hasAgencyFeeDistributed = false;
        vm.continueOrNavigateBackToPackageManager = continueOrNavigateBackToPackageManager;
        vm.disbaleCopyQuote = false;

        var premiums = {
            BasePremium: null,
            FSL: null,
            GST: null,
            StampDuty: null,
            Commission: null,
            CommissionGST: null,
            TotalPremium: null

        };

        function addAttachementData() {
            vm.AttachementData.push({ attachementText: null, file: null });
        }

        function removeAttachementData(index) {
            if (vm.AttachementData.length > 1) {
                vm.AttachementData.splice(index, 1);
            }
            else {
                if (vm.AttachementData.length === 1) {
                    vm.AttachementData.splice(index, 1);
                    vm.AttachementData = [{ attachementText: null, file: null }];
                }
            }
        }

        function discardQuote() {
            vm.disableButtons = true;
            quotesService.quoteDiscardRequest(vm.state.quotePremiumData.quoteTransactionId).then(function (result) {
                if (result.data) {
                    if (vm.showManagePkg) {
                        vm.packageNumber = sessionStorageService.get('PackageNumberInformation');
                        vm.renewalCounter = sessionStorageService.get('RenewalCounter');
                        sessionStorageService.remove('IsPackageManagerNavigationMode');
                        sessionStorageService.remove('PackageNumberInformation');
                        sessionStorageService.remove('RenewalCounter');
                        $window.location.href = webUrlConstService.getPackageInfo + sessionStorageService.getEncryption("packageNumber=" + JSON.parse(vm.packageNumber) + "&&renewalCounter=" + vm.renewalCounter);
                    }
                    else {
                        $timeout(function () {
                            var Id = vm.premiumResponseData.policyTransactionId;
                            window.location = "/Bind?" + sessionStorageService.getEncryption("id=" + Id);
                        }, 1000);
                    }
                } else {
                    toastr.error(messageConstService.errServiceUnavailable);
                    vm.disableButtons = true;
                }
            },
                function (error) {
                    $log.error('error', error);
                    toastr.error(messageConstService.errServiceUnavailable);
                    vm.disableButtons = true;
                });
        }

        vm.policySearch = function (query) {
            return $http.get(apiUrlConstService.bindURL + 'CheckBindQuote?' + sessionStorageService.getEncryption("quoteTransactionId=" + query))
                .then(function (result) {
                    vm.resultPolicyNumber = result.data.data;
                    if (vm.resultPolicyNumber === null) {
                        vm.IsEditEnabled = false;
                    }
                });
        }

        vm.bindDocumentGrid = function (coverage, quoteTransactionid) {
            var quoteDocGrid = quoteCaseService.bindDocumentGrid({
                coverType: vm.state.quotePremiumData.CoverType,
                coverageType: vm.coverageType,
                quoteTransactionId: quoteTransactionid
            })
                .then(function (result) {

                    if (vm.showNBQuoteDocGrid === true)
                        vm.showNBQuoteDocGrid = false;
                    else
                        vm.showNBQuoteDocGrid = true;
                    vm.docDetail = result.data;

                    return result;
                })
        }


        vm.GetQuoteDownloadSelected = function (quoteTransactionId, referenceNumber) {
            var flag = 0;
            vm.docDetail.forEach(function (trans) {
                if (trans.isChecked === true) {
                    flag++;
                    return $http
                        ({
                            url: "/mediaProxy/Bind/DownloadQuoteRequest/?QuoteTransactionId=" + quoteTransactionId + "&QuoteReferenceNumber=" + referenceNumber + "&quoteDocumentId=" + trans.id,
                            method: "GET",
                            responseType: 'blob'
                        })
                        .then(function (result) {
                            var blob = new Blob([result.data], { type: [result.data.type] });
                            var ext = result.data.type === 'application/pdf' ? keyConstService.pdf : keyConstService.rtf;
                            trans.isDynamic === true ? FileSaver.saveAs(blob, utilityService.RemoveFilePostFix(trans.templateName) + '_' + vm.state.quotePremiumData.quoteNumber + ext) : FileSaver.saveAs(blob, trans.templateName + '_' + vm.state.quotePremiumData.quoteNumber + ext);
                            return result.data.data;
                        },
                            function (data) {
                                toastr.error("System is currently not working. Please try after sometime.");
                                return;
                            });
                };
            });
            if (flag === 0) {
                toastr.error("Please select atleast one document");
                return;
            }
        };

        vm.GetQuoteEmailSelected = function (policyTransactionId, referenceNumber) {
            var idChecked = [];
            var flag = 0;
            vm.docDetail.forEach(function (trans) {
                if (trans.isChecked === true) {
                    idChecked.push(trans.id);
                    flag++;
                }
            });
            if (flag === 0) {
                toastr.error("Please select atleast one document");
                return;
            } else {
                return $http
                    ({
                        url: "/mediaProxy/Bind/DownloadSelectedQuoteRequest/?QuoteTransactionId=" + policyTransactionId + "&QuoteReferenceNumber=" + referenceNumber + "&documentDetail=" + JSON.stringify(idChecked),
                        method: "GET"
                    })
                    .then(function (result) {
                        var email = sessionStorageService.get('userEmail');
                        if (result && result.data && result.data.data) {
                            toastr.success("E-mail sent successfully to " + result.data.data);
                        }
                        else {
                            toastr.success("E-mail sent successfully to " + email.split('"')[1]);
                        }
                        return result.data.data;

                    },
                        function (data) {
                            toastr.error("System is currently not working. Please try after sometime.");
                            return;
                        });
            }
        };
        //

        function findPremiumreferenceNumber(excessNumber, coverageType) {
            var coveragesItems = {};
            coveragesItems = vm.state.quotePremiumData.coverages;
            for (var i = 0; i < coveragesItems.length; i++) {
                if (coveragesItems[i].coverageType === coverageType) {
                    var excessItems = coveragesItems[i].excesses;

                    for (var j = 0; j < excessItems.length; j++) {
                        if (excessItems[j].excessNumber === excessNumber) {
                            var excess = {};
                            excess.excessPremiums = excessItems[j].excessPremiums;
                            excess.referenceNumber = excessItems[j].referenceNumber;
                            return excess;
                        }
                    }
                }

            }
        };

        function getReferenceNumber(excessNumber, coverageType) {

            var excess = findPremiumreferenceNumber(excessNumber, coverageType);
            if (excess) {
                return excess.referenceNumber;
            }

        }

        vm.getLink = function (item) {
            if (vm.state.LineOfBusiness === "Cyber") {
                sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                location.href = "/Home/UpdateHome?" + sessionStorageService.getEncryption("productName=" + vm.state.LineOfBusiness + "&&quoteCaseNumber=" + vm.state.quotePremiumData.caseId);
            }
            else if (vm.state.LineOfBusiness === "Home") {
                sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                location.href = "/Home/UpdateHome?" + sessionStorageService.getEncryption("productName=" + vm.state.LineOfBusiness + "&&quoteCaseNumber=" + vm.state.quotePremiumData.caseId + "&&startDate=" + vm.premiumResponseData.quoteTransaction.effectiveDate);
            }
            else if (vm.state.LineOfBusiness === "Motor") {
                sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                location.href = "/Home/UpdateMotor?" + sessionStorageService.getEncryption("productName=" + vm.state.LineOfBusiness + "&&quoteCaseNumber=" + vm.state.quotePremiumData.caseId);
            }

            else if (vm.state.LineOfBusiness === "Landlord – Essentials") {
                sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                location.href = "/Home/UpdateLandlordProtection?" + sessionStorageService.getEncryption("productName=" + vm.state.LineOfBusiness + "&&quoteCaseNumber=" + vm.state.quotePremiumData.caseId);
            }
            else if (vm.state.LineOfBusiness === "Landlord – AD and LE") {
                sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                location.href = "/Home/UpdateLandlordStandard?" + sessionStorageService.getEncryption("productName=" + vm.state.LineOfBusiness + "&&quoteCaseNumber=" + vm.state.quotePremiumData.caseId + "&&startDate=" + vm.premiumResponseData.quoteTransaction.effectiveDate);
            }
            else if (vm.state.LineOfBusiness === keyConstService.PaProductDescription) {
                sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                location.href = "/Home/UpdatePersonalAccident?" + sessionStorageService.getEncryption("productName=" + vm.state.LineOfBusiness + "&&quoteCaseNumber=" + vm.state.quotePremiumData.caseId);
            }
        };

        vm.getViewLink = function (item) {
            if (vm.state.LineOfBusiness === "Home") {
                sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                location.href = "/Home/ViewHome?" + sessionStorageService.getEncryption("productName=" + vm.state.LineOfBusiness + "&&quoteCaseNumber=" + vm.state.quotePremiumData.caseId);
            }
            else if (vm.state.LineOfBusiness === "Motor") {
                sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                location.href = "/Home/ViewMotor?" + sessionStorageService.getEncryption("productName=" + vm.state.LineOfBusiness + "&&quoteCaseNumber=" + vm.state.quotePremiumData.caseId);
            }
            else if (vm.state.LineOfBusiness === "Landlord – Essentials") {
                sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                location.href = "/Home/ViewLandlordProtection?" + sessionStorageService.getEncryption("productName=" + vm.state.LineOfBusiness + "&&quoteCaseNumber=" + vm.state.quotePremiumData.caseId);
            }
            else if (vm.state.LineOfBusiness === "Landlord – AD and LE") {
                sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                location.href = "/Home/ViewLandlordStandard?" + sessionStorageService.getEncryption("productName=" + vm.state.LineOfBusiness + "&&quoteCaseNumber=" + vm.state.quotePremiumData.caseId);
            }
            else if (vm.state.LineOfBusiness === keyConstService.PaProductDescription) {
                sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                location.href = "/Home/ViewPersonalAccident?" + sessionStorageService.getEncryption("productName=" + vm.state.LineOfBusiness + "&&quoteCaseNumber=" + vm.state.quotePremiumData.caseId);
            }
        };

        vm.GetCopyQuoteLink = function (quoteTransacionId) {
            sessionStorageService.set(keyConstService.CopyQuoteOldTransactionId, quoteTransacionId);
            sessionStorageService.set(keyConstService.IsCopyQuote, true);
            location.href = webUrlConstService.newBusinessIndex + sessionStorageService.getEncryption("transactionId=" + quoteTransacionId + "&&" + "hasCopyQuote=" + true);
        };

        vm.findTotalPremium = function (excessNumber, coverageType) {
            if (vm.premiumResponseData.isEndorsement === true && (vm.premiumResponseData.newCurrentTerm === vm.premiumResponseData.previousCurrentTerm)) {
                return vm.selectedPremium.PolicyPremium;
            }
            var excess = findPremiumreferenceNumber(excessNumber, coverageType);
            if (excess) {
                return excess.excessPremiums.TotalPremium;

            }
        };

        vm.getPremiumBreakup = function (excessNumber, coverageType) {
            var excess = findPremiumreferenceNumber(excessNumber, coverageType);
            vm.selectedPremium = excess.excessPremiums;
            var selectedQuotePremiumId = excess.excessPremiums.QuotePremiumId;
            vm.selectedPremiumInstallments = getInstallments(selectedQuotePremiumId);
            vm.selectedReferenceNumber = excess.referenceNumber;
            vm.coverageType = coverageType;
            if (vm.showNBQuoteDocGrid === true) {
                vm.showNBQuoteDocGrid = false;
                vm.bindDocumentGrid(vm.coverageType, quoteTransactionId);
            }
        };

        vm.showConfirm = function (transactionId, referenceNumber, ev) {
            // Appending dialog to document.body to cover sidenav in docs app
            var message = null;
            vm.disableButtons = true;
            if (!vm.isEndorsement)
                message = 'Please click on ‘Accept’ below if you are not aware of any claims from the date of inception to current date. Your answer will be stored on the policy file. If you are aware of any claims, please click ‘decline’.';
            else
                message = 'Please click on ‘Accept’ below if you are not aware of any claims from effective date to current date. Your answer will be stored on the policy file. If you are aware of any claims, please click ‘decline’.';

            $mdDialog.show({
                controller: DialogController,
                templateUrl: 'app/pages/shared/modal-form.html',
                parent: angular.element(document.body),
                targetEvent: ev,
                locals: { modalTitle: message },
                clickOutsideToClose: true,
                escapeToClose: false,
            }).then(function (answer) {
                if (answer === 'Accept') {
                    vm.disableButtons = true;
                    // add 5th parameter (true) for set value (NoClaimsInBind = true) as per requirement of 'Save the No Claim "Acceptance"'.
                    bindService.bind(transactionId, referenceNumber, vm.paymentCollectedByBroker, true, true).then(function (data) {
                        handleResponse(transactionId, referenceNumber, data, ev);
                    });
                } else {
                    toastr.warning(messageConstService.errMessageDecline);
                    vm.disableButtons = false;
                }
            },
                function () {
                    toastr.warning(messageConstService.errMessageDecline);
                    vm.disableButtons = false;
                });
        };

        function DialogController($scope, $mdDialog, modalTitle) {
            $scope.modalTitle = modalTitle;
            $scope.hide = function () {
                $mdDialog.hide();
            };

            $scope.cancel = function () {
                $mdDialog.cancel();
            };

            $scope.answer = function (answer) {
                $mdDialog.hide(answer);
            };
        }

        function quoteReferralRequest(transactionId) {
            quotesService.quoteReferralRequest(transactionId).then(function (result) {
                if (result.data) {
                    $window.location.reload();
                }
            }, function (error) { $log.error('error', error); });
        }

        vm.Cancel = function () {
            $window.location.href = webUrlConstService.homeIndex;
        };
        function init(responseData, bbcheck) {  
            vm.hasAgencyFeeDistributed = responseData.data.hasAgencyFeeDistributed;
            sessionStorageService.remove(keyConstService.NVIcNotFound);
            sessionStorageService.remove(keyConstService.specialContentvalidity);
            var isPM = sessionStorageService.get('IsPackageManagerNavigationMode');
            var renewalCounter = sessionStorageService.get('RenewalCounter');
            if (isPM === "true" || renewalCounter !== null) {
                vm.showManagePkg = true;
            }
            vm.PolicyNumber = responseData.data.policyNumber;
            sessionStorageService.set('IsBranchViewOnly', bbcheck);
            vm.brokerbranchcheck = sessionStorageService.get('IsBranchViewOnly') !== "false";
            sessionStorageService.set(keyConstService.sessionStorageState, false);
            if (!responseData.status) {
                toastr.error(messageConstService.errServiceUnavailable);
            }
            sessionStorageService.set(keyConstService.quoteDetail, responseData);
            vm.ready = true;
            vm.premiumResponseData = responseData.data;
            vm.paymentInfoExist = responseData.data.paymentInfoExist;
            vm.paymentCollectedByBroker = responseData.data.paymentCollectedByBroker;
            vm.activatePaymentModule = responseData.data.activatePaymentModule;
            vm.isAnnual = responseData.data.isBranchAnnualPayment;
            sessionStorageService.remove(keyConstService.IsNewEditTransaction);
            sessionStorageService.remove(keyConstService.IsNewBusinessEdit);
            sessionStorageService.remove(keyConstService.IsNewBusinessReadOnly);
            sessionStorageService.remove(keyConstService.endorsementRequestVM);
            sessionStorageService.remove(keyConstService.newBusinessCaseData);
            ////sessionStorageService.remove(keyConstService.IsCopyQuote);
            ////parse the installments
            vm.InstallmentsData = [];
            parseInstallments(responseData.data.installments);
            vm.isEndorsement = responseData.data.isEndorsement;
            vm.policyCondition = vm.premiumResponseData.policyCondition;


            /////***TableCorrectionIn Premium
            //vm.endorsementPremiumArray.push({ Text: 'Current premium for this period:', Value: responseData.data.previousCurrentTerm });
            //vm.endorsementPremiumArray.push({ Text: 'Net change from endorsement:', Value: responseData.data.newNetChange });
            //vm.endorsementPremiumArray.push({ Text: 'New premium for this period:', Value: responseData.data.newCurrentTerm });
            vm.PreviousInstallmentsData = responseData.data.previousInstallments;
            vm.PreviousCurrentTerm = responseData.data.previousCurrentTerm;
            vm.NewCurrentTerm = responseData.data.newCurrentTerm;
            vm.NewNetChange = responseData.data.newNetChange;

            quotepremiumResponseData = vm.premiumResponseData;
            if (vm.isEndorsement) {
                vm.showBrokerFee = false;
            }
            else {
                vm.showBrokerFee = true;
            }

            //// monthly breakup
            function totalInstallments(d1, d2) {
                var diff = Date.parse(d2) - Date.parse(d1);
                var monthDiff = Math.floor(diff / (1000 * 60 * 60 * 24 * 30));
                if (monthDiff > 4) {
                    ////vm.numberOfInstallment = monthDiff - 2;
                    vm.numberOfInstallment = monthDiff;
                    vm.showMonthlyBreakDown = true;
                }
                else {
                    vm.showMonthlyBreakDown = false;
                }
            }
            var effectiveDate = vm.premiumResponseData.quoteTransaction.effectiveDate;
            var expirationDate = vm.premiumResponseData.quoteTransaction.expirationDate;
            totalInstallments(effectiveDate, expirationDate);

            vm.state.quotePremiumData = {};
            vm.state.quotePremiumData.excesses = [];
            //vm.state.quotePremiumData.excesses = [{
            //    number: 1,
            //    types: [{
            //        name: "Building",
            //        value: ""
            //    }, {
            //        name: "Content",
            //        value: ""
            //    }]
            //}];


            vm.state.quotePremiumData.quoteTransactionId = vm.premiumResponseData.transactionId;
            //set the quoteTransactionId in the sessionStorage
            sessionStorageService.set(keyConstService.quoteTransactionId, vm.premiumResponseData.transactionId);

            // vm.policySearch(vm.state.quotePremiumData.quoteTransactionId);

            ////parse the data.payload
            if (vm.premiumResponseData.payload != null) {
                for (var i = 0; i < vm.premiumResponseData.payload.length; i++) {
                    if (vm.premiumResponseData.payload[i].key === "CreatedDate") {
                        var date = vm.premiumResponseData.payload[i].value;
                        var momentDate = moment(date.toString()).format('MMM DD YYYY, h:mm:ss A');
                        vm.state.quotePremiumData.quoteDate = momentDate;
                    }
                    else if (vm.premiumResponseData.payload[i].key === "CaseNumber") {
                        vm.state.quotePremiumData.caseId = vm.premiumResponseData.payload[i].value;
                    }
                    else if (vm.premiumResponseData.payload[i].key === "QuoteNumber") {
                        vm.state.quotePremiumData.quoteNumber = vm.premiumResponseData.payload[i].value;
                    }
                    else if (vm.premiumResponseData.payload[i].key === "PackageId") {
                        vm.state.quotePremiumData.packageId = vm.premiumResponseData.payload[i].value;
                    }
                    else if (vm.premiumResponseData.payload[i].key === "CoverType") {
                        vm.state.quotePremiumData.CoverType = vm.premiumResponseData.payload[i].value;
                    }
                    else if (vm.premiumResponseData.payload[i].key === "LineOfBusiness") {
                        vm.state.LineOfBusiness = vm.premiumResponseData.payload[i].value;
                    }
                    else if (vm.premiumResponseData.payload[i].key === "PaymentFrequency") {
                        vm.state.quotePremiumData.installment = vm.premiumResponseData.payload[i].value;
                    }

                }
            }
            
            //set coveragesOrder 
            if (vm.state.LineOfBusiness == "Home") {
                vm.state.quotePremiumData.coveragesOrder = [
                    { 'coverageType': "HomeDefinedEvents", 'textValue': 'Basic' },
                    { 'coverageType': "HomeDefinedEventsPlus", 'textValue': 'Listed Events' },
                    { 'coverageType': "HomeAccidentalDamage", 'textValue': 'Accidental Damage' },
                ];
            }
            else if (vm.state.LineOfBusiness == "Motor") {
                vm.state.quotePremiumData.coveragesOrder = [
                    { 'coverageType': "TPPD", 'textValue': 'Third Party Property Damage' },
                    { 'coverageType': "Comprehensive", 'textValue': 'Comprehensive' },
                    { 'coverageType': "ComprehensivePlus", 'textValue': 'Comprehensive Plus' }
                   
                ];
            }

            else if (vm.state.LineOfBusiness == "Landlord – AD and LE") {
                vm.state.quotePremiumData.coveragesOrder = [
                    { 'coverageType': "LandlordListedEvents", 'textValue': 'Listed Events' },
                    { 'coverageType': "LandlordAccidentalDamage", 'textValue': 'Accidental Damage' },
                ];
            }


            else if (vm.state.LineOfBusiness == "Landlord – Essentials") {
                vm.state.quotePremiumData.coveragesOrder = [
                    { 'coverageType': "LandlordProtection", 'textValue': 'Landlord Essentials' },
                ];
            }

            else if (vm.state.LineOfBusiness === keyConstService.PaProductDescription) {
                vm.state.quotePremiumData.coveragesOrder = [
                    {
                        'coverageType': keyConstService.paAccidentOnlyCoverageKey,
                        'textValue': keyConstService.AccidentOnlyCoverageDescription
                    },
                    {
                        'coverageType': keyConstService.paAccidnetAndSicknessCoverageKey,
                        'textValue': keyConstService.AccidentSicknessCoverageDescription
                    }  
                ];
                //// disable copy quote for specified product
                vm.disbaleCopyQuote = true;
            }

            vm.state.quotePremiumData.coverages = [];

            if (vm.premiumResponseData.decisionResult) {
                var isNotQuoted = ((vm.premiumResponseData.quoteTransaction.status.toLowerCase() === keyConstService.toBeReferredQuoteStatus.toLowerCase())
                    || (vm.premiumResponseData.quoteTransaction.status.toLowerCase() === keyConstService.declineQuoteStatus.toLowerCase())
                    || (vm.premiumResponseData.quoteTransaction.status.toLowerCase() === keyConstService.moreInfoQuoteStatus.toLowerCase())
                    || (vm.premiumResponseData.quoteTransaction.status.toLowerCase() === keyConstService.referredQuoteStatus.toLowerCase())
                    || vm.premiumResponseData.quoteTransaction.status.toLowerCase() === keyConstService.referredReturnQuoteStatus.toLowerCase());
                if (vm.premiumResponseData.decisionResult.isReferral && isNotQuoted) {
                    vm.referralValue = true;
                    vm.isBrokerCommentsMandatory = vm.premiumResponseData.mandatoryBrokerComment;
                    vm.premiumResponseData.decisionResult.messages.map(element => {
                        if (jQuery.inArray(element.ruleID, ruleIdArray) === -1) {
                            ruleIdArray.push(element.ruleID);
                            vm.referralMessages.push(element);
                        }
                    });
                }

                if (vm.premiumResponseData.isRenewal && vm.premiumResponseData.quoteTransaction.status.toLowerCase() === keyConstService.declineQuoteStatus.toLowerCase() && !vm.premiumResponseData.decisionResult.isDeclined && !vm.premiumResponseData.decisionResult.isReferral) {
                    vm.declineValue = true;
                    var message = {
                        text: messageConstService.errManuallyDeclinedForQuotedToBeReleased
                    }
                    vm.declineMessages[0] = message;
                }
                if (vm.premiumResponseData.decisionResult.isDeclined) {
                    vm.declineValue = true;
                    vm.declineMessages = vm.premiumResponseData.decisionResult.messages;
                }
                if (vm.premiumResponseData.quoteTransaction) {
                    if (vm.premiumResponseData.quoteTransaction.status.toLowerCase() === keyConstService.declineQuoteStatus.toLowerCase()) {
                        vm.disableValue = true;
                        vm.IsEditEnabled = false;
                        vm.hideUnderwriterComments = false;
                        vm.brokerComment = vm.premiumResponseData.quoteDetail.brokerComment;

                        vm.underwriterComment = vm.premiumResponseData.underWritterComment;
                    }

                    if (vm.premiumResponseData.quoteTransaction.status.toLowerCase() === keyConstService.referredQuoteStatus.toLowerCase()) {
                        vm.disableValue = true;
                        vm.IsEditEnabled = false;
                    }

                    if (vm.premiumResponseData.quoteTransaction.status.toLowerCase() === keyConstService.moreInfoQuoteStatus.toLowerCase()) {
                        vm.disableValue = false;
                        vm.IsEditEnabled = false;
                        vm.hideUnderwriterComments = false;
                        vm.underwriterComment = vm.premiumResponseData.underWritterComment;
                    }
                    if (vm.premiumResponseData.quoteTransaction.status.toLowerCase() === keyConstService.referredReturnQuoteStatus.toLowerCase()) {
                        vm.disableValue = false;
                        vm.disablebrokercomment = true;
                        vm.IsEditEnabled = true;
                        vm.Isdisabletoberef = true;
                        vm.hideUnderwriterComments = false;
                        vm.hideAttachments = true;
                        vm.underwriterComment = vm.premiumResponseData.underWritterComment;
                    }
                    if (vm.premiumResponseData.quoteTransaction.status.toLowerCase() === keyConstService.toBeReferredQuoteStatus.toLowerCase()) {
                        vm.hideUnderwriterComments = false;
                        vm.underwriterComment = vm.premiumResponseData.underWritterComment;
                    }
                }
            }

            if (!vm.referralValue && !vm.declineValue) {
                angular.forEach(vm.premiumResponseData.ratingResult, function (value, key) {
                    ////itrate through the ratingResult items and get coverageType and excess number and create if not present.
                    var coverageWithPremium = {};
                    coverageWithPremium.coverageType = null;
                    coverageWithPremium.excesses = [];
                    var coverageExcess = {};
                    coverageExcess.excessNumber = value.order;
                    coverageExcess.referenceNumber = value.referenceNumber;
                    coverageExcess.excessPremiums = {};
                    coverageExcess.excessPremiums.QuotePremiumId = value.quotePremiumId;
                    coverageExcess.excessPremiums.BasePremium = value.preTaxPremium;
                    coverageExcess.excessPremiums.PolicyPremium = value.postTaxPremium;
                    coverageExcess.excessPremiums.TotalPremium = value.totalAmountDue;
                    coverageExcess.excessPremiums.Commission = value.brokerCommission;
                    coverageExcess.excessPremiums.CommissionGST = value.brokerCommissionGST;
                    coverageExcess.excessPremiums.AgencyFee = value.agencyFee;
                    coverageExcess.excessPremiums.AgencyFeeGST = value.agencyFeeGST;
                    //only for motor
                    if (vm.state.LineOfBusiness == "Motor") {
                        coverageExcess.excessPremiums.preTaxPremiumRoadSideAssistance = value.preTaxPremiumRoadSideAssistance;
                        coverageExcess.excessPremiums.preTaxPremiumRoadsideAssistanceGST = value.preTaxPremiumRoadsideAssistanceGST;
                    }
                    // reference number
                    angular.forEach(value.payload, function (payvalue, key) {
                        if (payvalue.key === "CoverageType") {
                            coverageWithPremium.coverageType = payvalue.value;
                            vm.referenceNumberCoverage.push({ ReferenceNumber: coverageExcess.referenceNumber, CoverageType: payvalue.value });
                        }
                        if (payvalue.key === "ExcessA") {
                            coverageExcess.ExcessValue = payvalue.value;
                        }
                    });
                    // tax
                    angular.forEach(value.taxList, function (taxvalue, key) {
                        if (taxvalue.taxName === "FSL") {
                            coverageExcess.excessPremiums.FSL = taxvalue.taxAmount;
                        }
                        else if (taxvalue.taxName === "GST") {
                            coverageExcess.excessPremiums.GST = taxvalue.taxAmount;
                        }
                        else if (taxvalue.taxName === "SD") {
                            coverageExcess.excessPremiums.StampDuty = taxvalue.taxAmount;
                        }
                    });
                    coverageWithPremium.excesses.push(coverageExcess);
                    if (vm.state.LineOfBusiness !== keyConstService.PaProductDescription) {
                        getExcesses(value.payload);
                    }                               
                  
                    //check if this already exists or not.
                    var isCoverageNotFound = true;
                    var coverageWithPremiumItems = {};
                    // adding coverages
                    coverageWithPremiumItems = vm.state.quotePremiumData.coverages;
                    for (var i = 0; i < coverageWithPremiumItems.length; i++) {
                        if (coverageWithPremiumItems[i].coverageType === coverageWithPremium.coverageType) {
                            //merge
                            vm.state.quotePremiumData.coverages[i].excesses.push(coverageExcess);

                            isCoverageNotFound = false;
                            break;
                        }
                        else {
                            //add new coverages object
                            isCoverageNotFound = true;
                        }
                    }


                    if (isCoverageNotFound) {
                        vm.state.quotePremiumData.coverages.push(coverageWithPremium);
                    }

                });


                //remove the coverages from  coveragesOrder if not present
                var tempCoveragesOrderArr = [];
                var newCoveragesOrderArr = [];
                tempCoveragesOrderArr = vm.state.quotePremiumData.coveragesOrder;
                tempCoveragesOrderArr.map(function (currenValue, index, arr) {

                    var ifFound = false;
                    var coveragesTemp = vm.state.quotePremiumData.coverages;
                    for (var i = 0; i < coveragesTemp.length; i++) {
                        if (currenValue.coverageType === coveragesTemp[i].coverageType) {
                            ifFound = true;
                            break;
                        }
                    }

                    if (ifFound) {
                        newCoveragesOrderArr.push(currenValue);
                    }


                });
                var excesses;
                vm.state.quotePremiumData.coveragesOrder = newCoveragesOrderArr;
                //default selected value to display the premium
                if (!vm.isEndorsement && !vm.premiumResponseData.isRenewal) {

                    for (var i = 0; i < vm.state.quotePremiumData.coverages.length; i++) {
                        if (vm.state.quotePremiumData.coverages[i].coverageType === "HomeAccidentalDamage") {
                            excesses = vm.state.quotePremiumData.coverages[i].excesses;
                            break;
                        }
                        if (vm.state.quotePremiumData.coverages[i].coverageType === keyConstService.MotorComprehensiveCoverageKey) {
                            excesses = vm.state.quotePremiumData.coverages[i].excesses;
                            break;
                        }

                        if (vm.state.quotePremiumData.coverages[i].coverageType === "LandlordAccidentalDamage") {
                            excesses = vm.state.quotePremiumData.coverages[i].excesses;
                            break;
                        }
                        if (vm.state.quotePremiumData.coverages[i].coverageType === "LandlordListedEvents") {
                            excesses = vm.state.quotePremiumData.coverages[i].excesses;
                            break;
                        }
                        if (vm.state.quotePremiumData.coverages[i].coverageType === "LandlordProtection") {
                            excesses = vm.state.quotePremiumData.coverages[i].excesses;
                            break;
                        }
                        if (vm.state.quotePremiumData.coverages[i].coverageType === keyConstService.paAccidnetAndSicknessCoverageKey) {
                            excesses = vm.state.quotePremiumData.coverages[i].excesses;
                            break;
                        }
                    }
                }
                else if (vm.premiumResponseData.isRenewal) {
                    var expirationBuildingExcess = JSON.parse(vm.premiumResponseData.quoteTransaction.requestContent).CuppingCappingFactor.ExpirationBuildingExcess;
                    var expirationContentExcess = JSON.parse(vm.premiumResponseData.quoteTransaction.requestContent).CuppingCappingFactor.ExpirationContentExcess;
                    var expirationCoverageType = JSON.parse(vm.premiumResponseData.quoteTransaction.requestContent).CuppingCappingFactor.ExpirationCoverageType;
                    var expirationMotorExcess = JSON.parse(vm.premiumResponseData.quoteTransaction.requestContent).CuppingCappingFactor.ExpirationMotorExcess;
                    //var expirationPersonalAccidentExcess = JSON.parse(vm.premiumResponseData.quoteTransaction.requestContent).CuppingCappingFactor.ExpirationPersonalAccidentExcess;
                    var expirationPersonalAccidentExcess = null;
                    var choosenReferenceNumber = null;

                    for (var index = 0; index < vm.premiumResponseData.ratingResult.length; index++) {
                        if (vm.premiumResponseData.ratingResult[index].payload[0].value === expirationCoverageType) {
                            if (vm.state.quotePremiumData.CoverType === "Building & Content") {
                                if (vm.premiumResponseData.ratingResult[index].payload[2].value === expirationBuildingExcess
                                    && vm.premiumResponseData.ratingResult[index].payload[3].value === expirationContentExcess) {
                                    choosenReferenceNumber = vm.premiumResponseData.ratingResult[index].referenceNumber;
                                    break;
                                }
                            }
                            else if (vm.state.quotePremiumData.CoverType === "Building") {
                                if (vm.premiumResponseData.ratingResult[index].payload[2].value === expirationBuildingExcess) {
                                    choosenReferenceNumber = vm.premiumResponseData.ratingResult[index].referenceNumber;
                                    break;
                                }
                            }
                            else if (vm.state.quotePremiumData.CoverType === "Content") {
                                if (vm.premiumResponseData.ratingResult[index].payload[2].value === expirationContentExcess) {
                                    choosenReferenceNumber = vm.premiumResponseData.ratingResult[index].referenceNumber;
                                    break;
                                }
                            }
                            else if (vm.state.quotePremiumData.CoverType === keyConstService.MotorComprehensiveCoverageKey || vm.state.quotePremiumData.CoverType === keyConstService.MotorComprehensivePlusCoverageKey || vm.state.quotePremiumData.CoverType.ToUpper() === keyConstService.MotorThirdPartyCoverageKey) {
                                if (vm.premiumResponseData.ratingResult[index].payload[2].value === expirationMotorExcess) {
                                    choosenReferenceNumber = vm.premiumResponseData.ratingResult[index].referenceNumber;
                                    break;
                                }
                            }
                            else if (vm.state.quotePremiumData.CoverType === keyConstService.paCoverType) {
                                if (vm.premiumResponseData.ratingResult[index].payload[2].value === expirationPersonalAccidentExcess) {
                                    choosenReferenceNumber = vm.premiumResponseData.ratingResult[index].referenceNumber;
                                    break;
                                }
                            }
                        }
                    }

                    if (choosenReferenceNumber === null) {
                        for (var coverageIndex = 0; coverageIndex < vm.state.quotePremiumData.coverages.length; coverageIndex++) {
                            if (vm.state.quotePremiumData.coverages[coverageIndex].coverageType === expirationCoverageType) {
                                excesses = vm.state.quotePremiumData.coverages[coverageIndex].excesses.sort(GetSortOrder("excessNumber"));
                                break;
                            }
                        }
                    }
                    else {
                        for (coverageIndex = 0; coverageIndex < vm.state.quotePremiumData.coverages.length; coverageIndex++) {
                            var doBreak = false;
                            for (var excessIndex = 0; excessIndex < vm.state.quotePremiumData.coverages[coverageIndex].excesses.length; excessIndex++) {
                                if (vm.state.quotePremiumData.coverages[coverageIndex].excesses[excessIndex].referenceNumber === choosenReferenceNumber) {
                                    excesses = [];
                                    excesses.push(vm.state.quotePremiumData.coverages[coverageIndex].excesses[excessIndex]);
                                    doBreak = true;
                                    break;
                                }
                            }
                            if (doBreak)
                                break;
                        }
                    }
                }
                else {
                    if (vm.state.LineOfBusiness === keyConstService.PaProductDescription && !vm.isEndorsement) {
                        if (vm.state.quotePremiumData.coverages[0].coverageType === keyConstService.paAccidnetAndSicknessCoverageKey) {
                            excesses = vm.state.quotePremiumData.coverages[0].excesses;
                        }
                        else {
                            excesses = vm.state.quotePremiumData.coverages[1].excesses;
                        }
                    }
                    else {
                        excesses = vm.state.quotePremiumData.coverages[0].excesses;
                    }
                }

                if (excesses) {
                    for (var i = 0; i < excesses.length; i++) {
                        if (!vm.premiumResponseData.isRenewal) {
                            if (excesses[i].excessNumber === 1) {
                                vm.selectedReferenceNumber = excesses[i].referenceNumber;
                                vm.selectedPremium = excesses[i].excessPremiums;
                                selectedQuotePremiumId = vm.selectedPremium.QuotePremiumId;
                                vm.selectedPremiumInstallments = getInstallments(selectedQuotePremiumId);
                            }
                        }
                        else {
                            if (vm.premiumResponseData.isRenewal && choosenReferenceNumber === null) {
                                vm.selectedReferenceNumber = excesses[i].referenceNumber;
                                vm.selectedPremium = excesses[i].excessPremiums;
                                var selectedQuotePremiumId = vm.selectedPremium.QuotePremiumId;
                                vm.selectedPremiumInstallments = getInstallments(selectedQuotePremiumId);
                                break;
                            }
                            else if (excesses[i].excessNumber === 1) {
                                vm.selectedReferenceNumber = excesses[i].referenceNumber;
                                vm.selectedPremium = excesses[i].excessPremiums;
                                selectedQuotePremiumId = vm.selectedPremium.QuotePremiumId;
                                vm.selectedPremiumInstallments = getInstallments(selectedQuotePremiumId);
                            }
                            else if (excesses[i].excessNumber === 2 || excesses[i].excessNumber === 3) {
                                vm.selectedReferenceNumber = excesses[i].referenceNumber;
                                vm.selectedPremium = excesses[i].excessPremiums;
                                selectedQuotePremiumId = vm.selectedPremium.QuotePremiumId;
                                vm.selectedPremiumInstallments = getInstallments(selectedQuotePremiumId);
                            }
                        }
                    }
                }

                for (var i = 0; i < vm.referenceNumberCoverage.length; i++) {
                    if (vm.referenceNumberCoverage[i].ReferenceNumber === vm.selectedReferenceNumber) {
                        vm.coverageType = vm.referenceNumberCoverage[i].CoverageType;
                    }
                }

                if (vm.premiumResponseData.isEndorsement == true && (vm.premiumResponseData.newCurrentTerm === vm.premiumResponseData.previousCurrentTerm)) {
                    vm.selectedPremium.FSL = vm.premiumResponseData.quotePremiumList[0].ftfsl;
                    vm.selectedPremium.BasePremium = vm.premiumResponseData.quotePremiumList[0].ftPreTaxPremium;
                    vm.selectedPremium.Commission = vm.premiumResponseData.quotePremiumList[0].ftCommission;
                    vm.selectedPremium.CommissionGST = vm.premiumResponseData.quotePremiumList[0].ftgstOnCommission;
                    vm.selectedPremium.GST = vm.premiumResponseData.quotePremiumList[0].ftgst;
                    vm.selectedPremium.PolicyPremium = vm.premiumResponseData.quotePremiumList[0].ftPostTaxPremium;
                    vm.selectedPremium.StampDuty = vm.premiumResponseData.quotePremiumList[0].ftStampDuty;
                }
            }
            //console.log(vm.state.quotePremiumData);
        }  //end of init function

        function GetSortOrder(prop) {
            return function (a, b) {
                if (a[prop] > b[prop]) {
                    return 1;
                } else if (a[prop] < b[prop]) {
                    return -1;
                }
                return 0;
            }
        }

        function findPremiumreferenceNumber(excessNumber, coverageType) {
            var coveragesItems = {};
            coveragesItems = vm.state.quotePremiumData.coverages;
            for (var i = 0; i < coveragesItems.length; i++) {
                if (coveragesItems[i].coverageType === coverageType) {
                    var excessItems = coveragesItems[i].excesses;

                    for (var j = 0; j < excessItems.length; j++) {
                        if (excessItems[j].excessNumber === excessNumber) {
                            var excess = {};
                            excess.excessPremiums = excessItems[j].excessPremiums;
                            excess.referenceNumber = excessItems[j].referenceNumber;
                            return excess;
                        }
                    }
                }

            }
        };

        function getInstallments(selectedQuotePremiumId) {
            //iterate over vm.InstallmentsData to get the installment
            var data = vm.InstallmentsData;
            for (var i = 0; i < data.length; i++) {
                if (data[i].QuotePremiumId === selectedQuotePremiumId) {
                    return data[i];
                }
            }

        };

        function parseInstallments(allInstallment) {
            if (allInstallment) {
                for (var i = 0; i < allInstallment.length; i++) {
                    //itrate through and do the grouping
                    if (vm.InstallmentsData.length === 0) {
                        var newInstallments = [];
                        var totalAmount = allInstallment[i].amount + allInstallment[i].brokerFeeWithGST + allInstallment[i].agencyFeeWithGST;
                        newInstallments.push({ Amount: totalAmount, DueDate: allInstallment[i].scheduleDate, BrokerFeeWithGST: allInstallment[i].brokerFeeWithGST, AgencyFeeWithGST: allInstallment[i].agencyFeeWithGST });
                        vm.InstallmentsData.push({ QuotePremiumId: allInstallment[i].quotePremiumId, Installments: newInstallments });
                        continue;
                    }
                    var isIDFound = false;

                    for (var j = 0; j < vm.InstallmentsData.length; j++) {
                        //search the for each 

                        if (vm.InstallmentsData[j].QuotePremiumId === allInstallment[i].quotePremiumId) {
                            //found the quotePremiumId
                            //update
                            isIDFound = true;
                            totalAmount = allInstallment[i].amount + allInstallment[i].brokerFeeWithGST + allInstallment[i].agencyFeeWithGST;
                            vm.InstallmentsData[j].Installments.push({ Amount: totalAmount, DueDate: allInstallment[i].scheduleDate, BrokerFeeWithGST: allInstallment[i].brokerFeeWithGST, AgencyFeeWithGST: allInstallment[i].agencyFeeWithGST });
                            //
                            break;
                        }
                    }

                    if (!isIDFound) {
                        //create new 
                        var newInstallments1 = [];
                        totalAmount = allInstallment[i].amount + allInstallment[i].brokerFeeWithGST + allInstallment[i].agencyFeeWithGST;
                        newInstallments1.push({ Amount: totalAmount, DueDate: allInstallment[i].scheduleDate, BrokerFeeWithGST: allInstallment[i].brokerFeeWithGST, AgencyFeeWithGST: allInstallment[i].agencyFeeWithGST });
                        vm.InstallmentsData.push({ QuotePremiumId: allInstallment[i].quotePremiumId, Installments: newInstallments1 });
                    }
                }
            }

        }
        function buyNow(transactionId, referenceNumber, ev) {
            sessionStorageService.remove('IsPackageManagerNavigationMode');
            vm.disableButtons = true;
            ////To check the expiration of the policy when endorsement is pending
            //var verifyEndorsement = verifyEndorse(vm.premiumResponseData);
            var verifyEndorsement = false;
            if (!verifyEndorsement) {
                ////To check payment type of package and quote when payment type is changed from annual to monthly
                if (vm.premiumResponseData.packagePaymentFrequency === vm.premiumResponseData.quoteDetail.paymentFrequency) {
                    if (vm.premiumResponseData.packagePaymentFrequency === "Monthly") {
                        if (vm.premiumResponseData.installmentDate !== vm.premiumResponseData.quoteDetail.installmentDate) {
                            var instalmenDateChange = $mdDialog.alert()
                                .escapeToClose(false)
                                .htmlContent('Payment schedule of this quote has changed. To view the updated payment schedule please edit and get quote before binding')
                                .ariaLabel('Lucky day')
                                .ok('OK')
                            $mdDialog.show(instalmenDateChange)
                            vm.disableButtons = false;
                            return;
                        }
                    }
                    if (vm.premiumResponseData.processType !== 'NEWBUSINESS' && vm.premiumResponseData.processType !== 'RENEWAL') {

                        bindService.bind(transactionId, referenceNumber, vm.paymentCollectedByBroker, false).then(function (data) {
                            handleResponse(transactionId, referenceNumber, data, ev);
                        });
                    } else {
                        var premiumDetails = vm.premiumResponseData.ratingResult.filter(x => x.referenceNumber == referenceNumber);
                        var commissionPercentage = vm.premiumResponseData.quoteDetail.commissionPercentage;
                        var quotePremium = vm.premiumResponseData.quotePremiumList.filter(x => x.referenceNumber == referenceNumber);
                        var quoteEffectiveDate = vm.premiumResponseData.effectiveDate;
                        var quoteExpirationDate = vm.premiumResponseData.expirationDate;
                        var coverType = vm.premiumResponseData.payload.filter(x => x.key == 'CoverType');
                        var displayBrokerFee = (parseFloat(vm.premiumResponseData.quoteDetail.brokerFee) + parseFloat(vm.premiumResponseData.quoteDetail.brokerFeeGST)).toFixed(2);
                        var automaticPayment = '';
                        if (vm.state.quotePremiumData.installment === "Annual" && vm.isAnnual) {
                            if (vm.paymentCollectedByBroker == false) { automaticPayment = "</br><div> <b>Broker Collection : </b>NO</div>" }
                            else { automaticPayment = "</br><div> <b>Broker Collection : </b>YES</div>" }
                        }
                        if (vm.premiumResponseData.productName === 'Home') {
                            switch (quotePremium[0].coverageType) {
                                case 'HomeDefinedEvents':
                                    vm.displayCoverageType = 'Basic';
                                    break;
                                case 'HomeDefinedEventsPlus':
                                    vm.displayCoverageType = 'Listed Events';
                                    break;
                                case 'HomeAccidentalDamage':
                                    vm.displayCoverageType = 'Accidental Damage';
                                    break;
                            }

                            if (coverType[0].value === 'Building & Content') {
                                vm.buildingExcess = quotePremium[0].excessAmount;
                                vm.contentExcess = quotePremium[0].contentExcess;
                                vm.message = '<div> <b>Period of insurance : </b>' + quoteEffectiveDate + ' to ' + quoteExpirationDate + '</div>' + '</br>' + '<div><b>Coverage type : </b>' + vm.displayCoverageType + '</div> </br>' + '<div><b>Building Excess : </b>$' + vm.buildingExcess + '</div></br>' + '<div><b>Content Excess : </b>$' + vm.contentExcess + '</div></br>' + '<div><b> Payment method : </b>' + vm.premiumResponseData.quoteDetail.paymentFrequency + '</div></br>' + '<div><b>Total amount due : </b>$' + premiumDetails[0].totalAmountDue.toFixed(2) + '</div></br>' + '<div><b>Commission :</b> ' + commissionPercentage + '%</div></br>' + '<div><b>Broker fee : </b>$' + displayBrokerFee + '</div>' + automaticPayment + '<div class="md-title-details">Would you like to proceed?</div>';

                            } else if (coverType[0].value === 'Building') {
                                vm.buildingExcess = quotePremium[0].excessAmount;
                                vm.message = '<div><b> Period of insurance : </b>' + quoteEffectiveDate + ' to ' + quoteExpirationDate + '</div>' + '</br> ' + ' <div><b> Coverage type :</b> ' + vm.displayCoverageType + '</div> </br> ' + ' <div><b>Building Excess :</b> $' + vm.buildingExcess + '</div></br >' + '<div> <b>Payment method : </b>' + vm.premiumResponseData.quoteDetail.paymentFrequency + '</div></br> ' + '<div><b>Total amount due :</b> $' + premiumDetails[0].totalAmountDue.toFixed(2) + '</div></br> ' + ' <div><b> Commission :</b> ' + commissionPercentage + '%</div></br> ' + '<div><b>Broker fee : </b>$' + displayBrokerFee + '</div>' + automaticPayment + ' <div class="md-title-details"> Would you like to proceed?</div> ';

                            } else if (coverType[0].value === 'Content') {
                                vm.contentExcess = quotePremium[0].excessAmount;
                                vm.message = '<div> <b>Period of insurance :</b> ' + quoteEffectiveDate + ' to ' + quoteExpirationDate + '</div>' + '</br>' + '<div><b>Coverage type : </b>' + vm.displayCoverageType + '</div> </br>' + '<div><b>Content Excess :</b> $' + vm.contentExcess + '</div></br>' + '<div> <b>Payment method :</b> ' + vm.premiumResponseData.quoteDetail.paymentFrequency + '</div></br>' + '<div><b>Total amount due :</b> $' + premiumDetails[0].totalAmountDue.toFixed(2) + '</div></br>' + '<div><b>Commission :</b> ' + commissionPercentage + '%</div></br>' + '<div><b>Broker fee : </b>$' + displayBrokerFee + '</div>' + automaticPayment + '<div class="md-title-details">Would you like to proceed?</div>';

                            }
                        }
                        else if (vm.premiumResponseData.productName === 'Motor') {
                            vm.motorExcess = quotePremium[0].excessAmount;
                            switch (quotePremium[0].coverageType.toUpperCase()) {
                                case 'COMPREHENSIVE':
                                    vm.displayCoverageType = 'Comprehensive';
                                    break;
                                case 'COMPREHENSIVEPLUS':
                                    vm.displayCoverageType = 'Comprehensive Plus';
                                    break;
                                case 'TPPD':
                                    vm.displayCoverageType = 'Third Party Property Damage';
                                    break;
                            }
                            vm.message = '<div> <b>Period of insurance : </b>' + quoteEffectiveDate + ' to ' + quoteExpirationDate + '</div>' + '</br>' + '<div><b>Coverage type : </b>' + vm.displayCoverageType + '</div> </br>' + '<div><b>Excess :</b> $' + vm.motorExcess + '</div></br>' + '<div><b> Payment method :</b> ' + vm.premiumResponseData.quoteDetail.paymentFrequency + '</div></br>' + '<div><b>Total amount due :</b> $' + premiumDetails[0].totalAmountDue.toFixed(2) + '</div></br>' + '<div><b>Commission : </b>' + commissionPercentage + '%</div></br>' + '<div><b>Broker fee : </b>$' + displayBrokerFee + '</div>' + automaticPayment + '<h2 class="md-title-details">Would you like to proceed?</div>';
                        }

                        if (vm.premiumResponseData.productName === 'Landlord – AD and LE') {
                            switch (quotePremium[0].coverageType) {
                                case 'LandlordListedEvents':
                                    vm.displayCoverageType = 'Listed Events';
                                    break;
                                case 'LandlordAccidentalDamage':
                                    vm.displayCoverageType = 'Accidental Damage';
                                    break;
                            }

                            if (coverType[0].value === 'Building & Content') {
                                vm.buildingExcess = quotePremium[0].excessAmount;
                                vm.contentExcess = quotePremium[0].contentExcess;
                                vm.message = '<div> <b>Period of insurance : </b>' + quoteEffectiveDate + ' to ' + quoteExpirationDate + '</div>' + '</br>' + '<div><b>Coverage type : </b>' + vm.displayCoverageType + '</div> </br>' + '<div><b>Building Excess : </b>$' + vm.buildingExcess + '</div></br>' + '<div><b>Content Excess : </b>$' + vm.contentExcess + '</div></br>' + '<div><b> Payment method : </b>' + vm.premiumResponseData.quoteDetail.paymentFrequency + '</div></br>' + '<div><b>Total amount due : </b>$' + premiumDetails[0].totalAmountDue.toFixed(2) + '</div></br>' + '<div><b>Commission :</b> ' + commissionPercentage + '%</div></br>' + '<div><b>Broker fee : </b>$' + displayBrokerFee + '</div>' + automaticPayment + '<div class="md-title-details">Would you like to proceed?</div>';

                            } else if (coverType[0].value === 'Building') {
                                vm.buildingExcess = quotePremium[0].excessAmount;
                                vm.message = '<div><b> Period of insurance : </b>' + quoteEffectiveDate + ' to ' + quoteExpirationDate + '</div>' + '</br> ' + ' <div><b> Coverage type :</b> ' + vm.displayCoverageType + '</div> </br> ' + ' <div><b>Building Excess :</b> $' + vm.buildingExcess + '</div></br >' + '<div> <b>Payment method : </b>' + vm.premiumResponseData.quoteDetail.paymentFrequency + '</div></br> ' + '<div><b>Total amount due :</b> $' + premiumDetails[0].totalAmountDue.toFixed(2) + '</div></br> ' + ' <div><b> Commission :</b> ' + commissionPercentage + '%</div></br> ' + '<div><b>Broker fee : </b>$' + displayBrokerFee + '</div>' + automaticPayment + ' <div class="md-title-details"> Would you like to proceed?</div> ';

                            } else if (coverType[0].value === 'Content') {
                                vm.contentExcess = quotePremium[0].excessAmount;
                                vm.message = '<div> <b>Period of insurance :</b> ' + quoteEffectiveDate + ' to ' + quoteExpirationDate + '</div>' + '</br>' + '<div><b>Coverage type : </b>' + vm.displayCoverageType + '</div> </br>' + '<div><b>Content Excess :</b> $' + vm.contentExcess + '</div></br>' + '<div> <b>Payment method :</b> ' + vm.premiumResponseData.quoteDetail.paymentFrequency + '</div></br>' + '<div><b>Total amount due :</b> $' + premiumDetails[0].totalAmountDue.toFixed(2) + '</div></br>' + '<div><b>Commission :</b> ' + commissionPercentage + '%</div></br>' + '<div><b>Broker fee : </b>$' + displayBrokerFee + '</div>' + automaticPayment + '<div class="md-title-details">Would you like to proceed?</div>';

                            }
                        }


                        if (vm.premiumResponseData.productName === 'Landlord – Essentials') {
                            switch (quotePremium[0].coverageType) {
                                case 'LandlordProtection':
                                    vm.displayCoverageType = 'Landlord Essentials';
                                    break;
                            }

                            if (coverType[0].value === 'Content') {
                                vm.contentExcess = quotePremium[0].excessAmount;
                                vm.message = '<div> <b>Period of insurance :</b> ' + quoteEffectiveDate + ' to ' + quoteExpirationDate + '</div>' + '</br>' + '<div><b>Coverage type : </b>' + vm.displayCoverageType + '</div> </br>' + '<div><b>Excess :</b> $' + vm.contentExcess + '</div></br>' + '<div> <b>Payment method :</b> ' + vm.premiumResponseData.quoteDetail.paymentFrequency + '</div></br>' + '<div><b>Total amount due :</b> $' + premiumDetails[0].totalAmountDue.toFixed(2) + '</div></br>' + '<div><b>Commission :</b> ' + commissionPercentage + '%</div></br>' + '<div><b>Broker fee : </b>$' + displayBrokerFee + '</div>' + automaticPayment + '<div class="md-title-details">Would you like to proceed?</div>';

                            }
                        }

                        // coverages to display on quote case
                        if (vm.premiumResponseData.productName.toLowerCase() === keyConstService.PaProductDescription.toLowerCase()) {
                            switch (quotePremium[0].coverageType) {
                                case "PaAccidentAndSickness":
                                    vm.displayCoverageType = keyConstService.AccidentSicknessCoverageDescription;
                                    break;

                                case "PaAccidentOnly":
                                    vm.displayCoverageType = keyConstService.AccidentOnlyCoverageDescription;
                                    break;
                            }
                            var excessDays = quotePremium[0].excessAmount + ' days';
                            vm.message = '<div> <b>Period of insurance :</b> ' + quoteEffectiveDate + ' to ' + quoteExpirationDate + '</div>' + '</br>' + '<div><b>Coverage type : </b>' + vm.displayCoverageType + '</div> </br>' + '<div><b>Waiting Period :</b>' + excessDays  + '</div></br>' + '<div> <b>Payment method :</b> ' + vm.premiumResponseData.quoteDetail.paymentFrequency + '</div></br>' + '<div><b>Total amount due :</b> $' + premiumDetails[0].totalAmountDue.toFixed(2) + '</div></br>' + '<div><b>Commission :</b> ' + commissionPercentage + '%</div></br>' + '<div><b>Broker fee : </b>$' + displayBrokerFee + '</div>' + automaticPayment + '<div class="md-title-details">Would you like to proceed?</div>';
                        }

                        // Appending dialog to document.body to cover sidenav in docs app
                        var confirmBankDetails = $mdDialog.confirm()
                            .escapeToClose(false)
                            .title('You are about to bind cover with the following details:')
                            .htmlContent(vm.message)
                            .ariaLabel('Lucky day')
                            .targetEvent(ev)
                            .ok('Yes')
                            .cancel('No');
                        $mdDialog.show(confirmBankDetails).then(function () {

                            vm.paymentCollectedByBroker = (vm.state.quotePremiumData.installment === "Annual") ? (vm.paymentCollectedByBroker == false ? false : true) : vm.paymentCollectedByBroker;

                            if (vm.paymentInfoExist || vm.paymentCollectedByBroker) {
                                bindService.bind(transactionId, referenceNumber, vm.paymentCollectedByBroker, false).then(function (data) {
                                    handleResponse(transactionId, referenceNumber, data, ev);
                                });
                            } else if (vm.state.quotePremiumData.installment === "Annual" && !vm.paymentInfoExist) {
                                bindService.bind(transactionId, referenceNumber, vm.paymentCollectedByBroker, false).then(function (data) {
                                    handleResponse(transactionId, referenceNumber, data, ev);
                                });
                            } else if (vm.state.quotePremiumData.installment === "Monthly") {
                                vm.paymentCollectedByBroker = false;
                                bindService.bind(transactionId, referenceNumber, vm.paymentCollectedByBroker, false).then(function (data) {
                                    handleResponse(transactionId, referenceNumber, data, ev);
                                });
                            }
                        }, function () {
                            $mdDialog.hide();
                            vm.disableButtons = false;
                        });
                    }
                }
                else {
                    var annualToInstallment = $mdDialog.alert()
                        .escapeToClose(false)
                        .htmlContent('Payment type of this quote has changed from Annual to Instalment. Please edit and get quote before binding.')
                        .ariaLabel('Lucky day')
                        .ok('OK')
                    $mdDialog.show(annualToInstallment)
                    vm.disableButtons = false;
                }
            }
            else {
                var endorsedetail = $mdDialog.alert()
                    .escapeToClose(false)
                    .title('Policy has been expired')
                    .htmlContent('We can not bind this policy')
                    .ariaLabel('Lucky day')
                    .ok('Close')
                $mdDialog.show(endorsedetail)
                vm.disableButtons = false;
            }
        }

        ////To check the expiration of the policy when endorsement is pending
        function verifyEndorse(data) {
            var policyExpiryTime = data.policyExpirationTime;
            var currentDate = moment(new Date()).format('YYYY-MM-DD'); 
            var expirationDate = moment(data.expirationDate).format('YYYY-MM-DD');
            var currentTime = moment(new Date()).format('HH:mm:ss');
            if (data.isEndorsement == true && ((expirationDate < currentDate) || (expirationDate == currentDate && currentTime >= policyExpiryTime))) {
                return true;
            }
            else {
                return false;
            }
        }

        function referToUnderwriter(formData) {
            vm.disableButtons = true;
            var detailsForReferral = { QuoteTransactionId: vm.state.quotePremiumData.quoteTransactionId, BrokerComment: formData.brokerComment, QuoteStatus: vm.premiumResponseData.quoteTransaction.status };

            quotesService.quoteReferralAttachement(detailsForReferral, vm.AttachementData).then(function (data) {
                if (data.data) {
                    toastr.info(messageConstService.succdetailUpdated);
                    if (vm.showManagePkg) {
                        vm.packageNumber = sessionStorageService.get('PackageNumberInformation');
                        vm.renewalCounter = sessionStorageService.get('RenewalCounter');
                        sessionStorageService.remove('IsPackageManagerNavigationMode');
                        sessionStorageService.remove('PackageNumberInformation');
                        sessionStorageService.remove('RenewalCounter');
                        $window.location.href = webUrlConstService.getPackageInfo + sessionStorageService.getEncryption("packageNumber=" + JSON.parse(vm.packageNumber) + "&&renewalCounter=" + vm.renewalCounter);
                    }
                    else {
                        $timeout(function () {
                            $window.location.href = webUrlConstService.homeIndex;
                        }, 2000);
                    }
                }
                else {
                    toastr.error(messageConstService.errServiceUnavailable);
                    vm.disableButtons = false;
                }
            }, function (error) {
                toastr.error(messageConstService.errServiceUnavailable);
                $log.error('error', error);
                vm.disableButtons = false;
            });

        }

        ////check this first bind request's response is having error related to the old quotes more 5 days.'
        function handleResponse(transactionId, referenceNumber, data, ev) {
            if (data.errors !== null && data.errors.length > 0) {
                toastr.error(messageConstService.errService3rdAPIUnavailable);
                vm.disableButtons = false;
                return;
            }
            if (data.data.errors !== null && data.data.errors.length > 0) {
                for (var i = 0; i < data.data.errors.length; i++) {
                    if (data.data.errors[i].number === 2) {
                        quoteReferralRequest(transactionId);
                    }
                    if (data.data.errors[i].number === 1) {
                        vm.showConfirm(transactionId, referenceNumber, ev);
                    }
                    if (data.data.errors[i].number === 4) {
                        toastr.error(messageConstService.errQuoteAlreadyBound);
                    }
                    if (data.data.errors[i].number === 3) {
                        toastr.error(messageConstService.quoteExpired);
                    }
                    // If Quote creation date in Quotetransaction is null , then error number = 5
                    if (data.data.errors[i].number === 5) {
                        toastr.error(data.data.errors[i].message);
                    }
                }
                vm.errors = data.data.errors;
                vm.isErrors = true;
                vm.disableButtons = false;
                //todo: handle errors
            }
            else {
                //quote binded successfully
                sessionStorageService.set(keyConstService.bindData, data.data);
                if (vm.activatePaymentModule) {
                    if (vm.paymentInfoExist || vm.paymentCollectedByBroker) {
                        $window.location.href = webUrlConstService.bindIndex + sessionStorageService.getEncryption('id=' + data.data.policyTransactionId);
                    } else {
                        $window.location.href = webUrlConstService.paymentInfo + 'id=' + data.data.policyTransactionId;
                    }
                } else {
                    $window.location.href = webUrlConstService.bindIndex + sessionStorageService.getEncryption('id=' + data.data.policyTransactionId);
                }
            }
        }

        // get excess
        function getExcesses(valuePayload) {
            var excesses = vm.state.quotePremiumData.excesses;
            var newExcess = {};
            var newTypes = [];
            angular.forEach(valuePayload, function (excessvalue, key) {
                if (excessvalue.key === "Order") {
                    newExcess.number = excessvalue.value;
                }
                var type = {};
                if (vm.state.quotePremiumData.CoverType === "Building & Content") {
                    if (excessvalue.key === "ExcessA") {
                        type.name = "Building";
                        type.value = excessvalue.value;
                        newTypes.push(type);
                    }
                    if (excessvalue.key === "ExcessB") {
                        type.name = "Content";
                        type.value = excessvalue.value;
                        newTypes.push(type);
                    }
                } else if (vm.state.quotePremiumData.CoverType === "Building") {
                    if (excessvalue.key === "ExcessA") {
                        type.name = "Building";
                        type.value = excessvalue.value;
                        newTypes.push(type);
                    }

                }
                else if (vm.state.quotePremiumData.CoverType === "Content") {
                    if (excessvalue.key === "ExcessA") {
                        type.name = "Content";
                        type.value = excessvalue.value;
                        newTypes.push(type);
                    }
                }
                else if (vm.state.quotePremiumData.CoverType === "Comprehensive") {
                    if (excessvalue.key === "ExcessA") {
                        type.name = "Comprehensive";
                        type.value = excessvalue.value;
                        newTypes.push(type);
                    }
                }
                else if (vm.state.quotePremiumData.CoverType === "ComprehensivePlus") {
                    if (excessvalue.key === "ExcessA") {
                        type.name = "ComprehensivePlus";
                        type.value = excessvalue.value;
                        newTypes.push(type);
                    }
                }

                else if (vm.state.quotePremiumData.CoverType.toUpperCase() === keyConstService.MotorThirdPartyCoverageKey.toUpperCase()) {
                    if (excessvalue.key === "ExcessA") {
                        type.name = "Third Party Property Damage";
                        type.value = excessvalue.value;
                        newTypes.push(type);
                    }
                }

            });

            //check the excesses and insert or update excess
            var isFound = false;
            var index = 0;
            for (var i = 0; i < excesses.length; i++) {
                //if excess.number exists then update the types
                //otherwise insert it
                if (excesses[i].number === newExcess.number) {
                    //found  so update
                    index = i;
                    isFound = true;
                    break;
                }
            }

            if (isFound) {
                //update
                excesses[index].types = newTypes;
            }
            else {
                //insert
                var insertExcess = { number: newExcess.number, types: newTypes };
                excesses.push(insertExcess);
            }
            return excesses;
        }

        function getPaExcess(valuePayLoad) {
                var excesses = vm.state.quotePremiumData.excesses;
                var newExcess = {};
                var newTypes = [];
            angular.forEach(valuePayLoad, function (excessvalue, key) {
                    if (excessvalue.key === "Order") {
                        newExcess.number = excessvalue.value;
                    }
                    if (excessvalue.key === "CoverageType") {
                        newExcess.type = excessvalue.CoverageType;
                    }
                    if (excessvalue.key === "ExcessA") {
                        newExcess.value = excessvalue.CoverageType;
                    }
                });

                //check the excesses and insert or update excess
                var isFound = false;
                var index = 0;
                for (var i = 0; i < excesses.length; i++) {
                    //if excess.number exists then update the types
                    //otherwise insert it
                    if (excesses[i].number === newExcess.number) {
                        //found  so update
                        index = i;
                        isFound = true;
                        break;
                    }
                }

                if (isFound) {
                    //update
                    excesses[index].types = newTypes;
                }
                else {
                    //insert
                    var insertExcess = { number: newExcess.number, types: newTypes };
                    excesses.push(insertExcess);
                }
                return excesses;
        }

        function discard() {
            vm.disableButtons = true;
            quotesService.quoteDiscardRequest(vm.state.quotePremiumData.quoteTransactionId).then(function (result) {
                if (result.data) {
                    if (vm.showManagePkg) {
                        vm.packageNumber = sessionStorageService.get('PackageNumberInformation');
                        vm.renewalCounter = sessionStorageService.get('RenewalCounter');
                        sessionStorageService.remove('IsPackageManagerNavigationMode');
                        sessionStorageService.remove('PackageNumberInformation');
                        sessionStorageService.remove('RenewalCounter');
                        $window.location.href = webUrlConstService.getPackageInfo + sessionStorageService.getEncryption("packageNumber=" + JSON.parse(vm.packageNumber) + "&&renewalCounter=" + vm.renewalCounter);
                    }
                    else {
                        $timeout(function () {
                            var Id = vm.premiumResponseData.policyTransactionId;
                            window.location = "/Bind?" + sessionStorageService.getEncryption("id=" + Id);
                        }, 1000);
                    }
                } else {
                    toastr.error(messageConstService.errServiceUnavailable);
                    vm.disableButtons = false;
                }
            },
                function (error) {
                    $log.error('error', error);
                    toastr.error(messageConstService.errServiceUnavailable);
                    vm.disableButtons = false;
                });
        }

        function cancel() {
            vm.disableButtons = true;
            if (vm.showManagePkg) {
                vm.packageNumber = sessionStorageService.get('PackageNumberInformation');
                vm.renewalCounter = sessionStorageService.get('RenewalCounter');
                sessionStorageService.remove('IsPackageManagerNavigationMode');
                sessionStorageService.remove('PackageNumberInformation');
                sessionStorageService.remove('RenewalCounter');
                $window.location.href = webUrlConstService.getPackageInfo + sessionStorageService.getEncryption("packageNumber=" + JSON.parse(vm.packageNumber) + "&&renewalCounter=" + vm.renewalCounter);
            }
            else {
                $window.location.href = webUrlConstService.homeIndex;
            }
        }



        function continueOrNavigateBackToPackageManager() {
            var packageNumber = sessionStorageService.get('PackageNumberInformation');
            var renewalCounter = sessionStorageService.get('RenewalCounter');
            sessionStorageService.remove('IsPackageManagerNavigationMode');
            sessionStorageService.remove('PackageNumberInformation');
            sessionStorageService.remove('RenewalCounter');
            $window.location.href = webUrlConstService.getPackageInfo + sessionStorageService.getEncryption("packageNumber=" + JSON.parse(packageNumber) + "&&renewalCounter=" + renewalCounter);
        }


    }
})();;
(function () {
    'use strict';

    var appUI = angular.module('appUI');

    appUI.controller('endorsementCtrl', ['$http', 'apiUrlConstService', 'endorsementService', 'webUrlConstService', 'dateService', 'sessionStorageService', 'keyConstService', 'messageConstService', '$window', '$log', 'quotesService', '$timeout', 'portalV2Service', endorsementCtrl]);

    function endorsementCtrl($http, apiUrlConstService, endorsementService, webUrlConstService, dateService, sessionStorageService, keyConstService, messageConstService, $window, $log, quotesService, $timeout, portalV2Service) {
        var vm = this;
        vm.init = init;
        vm.dateCheck = dateCheck;
        vm.quoteTransactionId = null;
        vm.submit = submit;
        vm.startDate = null;
        vm.expirationDate = null;
        vm.endorsementDate = null;
        vm.effectiveDate = null;
        var IsEditEndorsement = false;
        var caseNumber = null;
        vm.isEndorsementReadOnly = false;
        var EndorsementChange = null;
        vm.discard = discard;
        vm.brokerbranchcheck;
        vm.disableButtons = false;
        vm.originalQuoteCaseId = null;
        vm.originalQuoteTransactionId = null;
        vm.continueOrNavigateBackToPackageManager = continueOrNavigateBackToPackageManager;
        vm.help_text_for_Endorsement = keyConstService.help_text_for_Endorsement;
        vm.BrokerPortalV2Debugging = false;

        function init(endorsementVM, userEmail) {
            vm.endorsementDate = null;
            var isPM = sessionStorageService.get('IsPackageManagerNavigationMode');
            var renewalCounter = sessionStorageService.get('RenewalCounter');
            if (isPM === "true" || renewalCounter !== null) {
                vm.showManagePkg = true;
            }
            vm.brokerbranchcheck = sessionStorageService.get('IsBranchViewOnly') !== "false";
            vm.endorsementModel = endorsementVM.EndorsementVM;
            vm.startDate = vm.endorsementModel.StartDate;
            vm.expirationDate = vm.endorsementModel.ExpirationDate;
            vm.originalQuoteCaseId = vm.endorsementModel.OriginalQuoteCaseId;
            vm.originalQuoteTransactionId = vm.endorsementModel.OriginalQuoteTransactionId;
            vm.endorsementTypeList = endorsementVM.EndorsementTypetList;
            vm.SMEEndorsementURL = endorsementVM.SMEEndorsementURL;
            vm.productList = endorsementVM.ProductList;
            vm.effectiveDate = vm.endorsementModel.PolicyEffectiveDate;
            vm.BrokerPortalV2Debugging = endorsementVM.BrokerPortalV2Debugging;
            sessionStorageService.set("userEmail", userEmail);
            var lastEndorsementDetail = JSON.parse(sessionStorageService.get(keyConstService.endorsementRequestVM));
            if (sessionStorageService.get(keyConstService.IsNewEditTransaction))
            {
                EndorsementChange = JSON.parse(sessionStorageService.get(keyConstService.IsNewEditTransaction));
            }
            
            if (lastEndorsementDetail) {
                if (lastEndorsementDetail.EndorsementEffectiveDate) {
                    vm.endorsementDate = new Date(lastEndorsementDetail.EndorsementEffectiveDate);
                    vm.endorsementModel.EndorsementEffectiveDate = lastEndorsementDetail.EndorsementEffectiveDate;
                    vm.endorsementModel.PolicyEffectiveDate = lastEndorsementDetail.PolicyEffectiveDate;
                    IsEditEndorsement = sessionStorageService.get(keyConstService.IsEndorsementEdit);
                }
            }
            
            vm.isEndorsementReadOnly = sessionStorageService.get(keyConstService.IsNewBusinessReadOnly);
            if (vm.isEndorsementReadOnly || EndorsementChange !== null)
            {
                vm.endorsementDate = new Date(vm.endorsementModel.EndorsementEffectiveDate);
            }
            
            //****set endorsementtypeValue as discussion with surbhi by shivam-{9 - April - 2018}****//
            vm.endorsementModel.EndorsementType = 'NonCommissionEndorsement';
        }

        function dateCheck(inputdate) {

           if (inputdate){
                var dateRangeResponse = dateService.validateRangeForEndorsement("days", vm.endorsementModel.EndorsementWindowFromCurrent, inputdate, moment(vm.endorsementModel.PolicyEffectiveDate), moment(vm.endorsementModel.ExpirationDate));
                if (!dateRangeResponse.isValid) {
                    vm.endorsementDate = '';
                    toastr.warning(messageConstService.errEffectiveDateNotAllowed);
                    return;
                }
                vm.endorsementModel.EndorsementEffectiveDate = dateService.getDateDDMMtoMMDD(inputdate);
            }
        }

        function submit() {
            vm.disableButtons = true;
            if (!sessionStorageService.get(keyConstService.endorsementRequestVM)) {
                sessionStorageService.set(keyConstService.endorsementRequestVM, vm.endorsementModel);
            }

            // don't need to get value from session in case of SME & Commercial Motor
            if (vm.endorsementModel.ProductType.toLowerCase() !== keyConstService.SMEProductType.toLowerCase() && vm.endorsementModel.ProductType.toLowerCase() !== keyConstService.CommercialMotorProductDescription.toLowerCase()) {
                vm.endorsementModel = JSON.parse(sessionStorageService.get(keyConstService.endorsementRequestVM));
            }

            if (vm.endorsementModel) {
                vm.endorsementModel.EndorsementEffectiveDate = dateService.getDateDDMMtoMMDD(vm.endorsementDate);
            }
            sessionStorageService.set(keyConstService.endorsementRequestVM, vm.endorsementModel);
            if (vm.isEndorsementReadOnly) {
                caseNumber = JSON.parse(sessionStorageService.get(keyConstService.caseNumber));
                sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                if (vm.endorsementModel.ProductType === "Landlord – Essentials") {
                    location.href = "/Home/ViewLandlordProtection?" + sessionStorageService.getEncryption("productName=" + vm.endorsementModel.ProductType + "&&quoteCaseNumber=" + caseNumber);
                }
                else if (vm.endorsementModel.ProductType === "Landlord – AD and LE") {
                    location.href = "/Home/ViewLandlordStandard?" + sessionStorageService.getEncryption("productName=" + vm.endorsementModel.ProductType + "&&quoteCaseNumber=" + caseNumber);
                }
                else if (vm.endorsementModel.ProductType === keyConstService.PaProductDescription) {
                    location.href = webUrlConstService.PersonalAccidentView + sessionStorageService.getEncryption("productName=" + vm.endorsementModel.ProductType + "&&quoteCaseNumber=" + caseNumber);
                }
                else if (vm.endorsementModel.ProductType === keyConstService.CommercialMotorProductDescription) {
                    portalV2Service.getV2Token().then(function (resp) {
                        var redirectTo = keyConstService.CommercialMotorUrlPrefix + keyConstService.CommercialMotorViewQuote + sessionStorageService.getEncryption("quoteTransactionId=" + vm.originalQuoteTransactionId + '&productId=' + keyConstService.CommercialMotorProductId);
                        portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                    });
                }
                else if (vm.endorsementModel.ProductType === keyConstService.CyberProductDescription) {
                    portalV2Service.getV2Token().then(function (resp) {
                        var redirectTo = keyConstService.CyberUrlPrefix + keyConstService.CyberViewQuote +
                            sessionStorageService.getEncryption("quoteTransactionId=" + vm.originalQuoteTransactionId + '&productId=' + keyConstService.CyberProductId);
                        portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                    });
                }
                else {
                    location.href = "/Home/View" + vm.endorsementModel.ProductType + "?" + sessionStorageService.getEncryption("productName=" + vm.endorsementModel.ProductType + "&&quoteCaseNumber=" + caseNumber);
                }
            }
            else if (EndorsementChange !== null) {
                caseNumber = JSON.parse(sessionStorageService.get(keyConstService.caseNumber));
                if (vm.endorsementModel.ProductType === "Landlord – Essentials") {
                    location.href = "/Home/UpdateLandlordProtection?" + sessionStorageService.getEncryption("productName=" + vm.endorsementModel.ProductType + "&&quoteCaseNumber=" + caseNumber);               
                }
                else if (vm.endorsementModel.ProductType === "Landlord – AD and LE") {
                    location.href = "/Home/UpdateLandlordStandard?" + sessionStorageService.getEncryption("productName=" + vm.endorsementModel.ProductType + "&&quoteCaseNumber=" + caseNumber);
                }
                else if (vm.endorsementModel.ProductType === keyConstService.PaProductDescription) {
                    location.href = webUrlConstService.PersonalAccidentUpdate + "?" + sessionStorageService.getEncryption("productName=" + vm.endorsementModel.ProductType + "&&quoteCaseNumber=" + caseNumber);
                }
                else if (vm.endorsementModel.ProductType === keyConstService.CommercialMotorProductDescription) {
                    portalV2Service.getV2Token().then(function (resp) {
                        var redirectTo = keyConstService.CommercialMotorUrlPrefix + keyConstService.CommercialMotorEditQuote + sessionStorageService.getEncryption("quoteTransactionId=" + vm.originalQuoteTransactionId + '&productId=' + keyConstService.CommercialMotorProductId);
                        portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                    });
                }
                else if (vm.endorsementModel.ProductType === keyConstService.CyberProductDescription) {
                    portalV2Service.getV2Token().then(function (resp) {
                        var redirectTo = keyConstService.CyberUrlPrefix + keyConstService.CyberEditQuote + sessionStorageService.getEncryption("quoteTransactionId=" + vm.originalQuoteTransactionId + '&productId=' + keyConstService.CyberProductId);
                        portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                    });
                }
                else {
                    location.href = "/Home/Update" + vm.endorsementModel.ProductType + "?" + sessionStorageService.getEncryption("productName=" + vm.endorsementModel.ProductType + "&&quoteCaseNumber=" + caseNumber);
                }   
            }
            else if (!IsEditEndorsement) {
                if (vm.endorsementModel.EndorsementType === 'NonCommissionEndorsement') {
                    endorsementService.endorsementNonComisionQuoteRequest(vm.endorsementModel).then(function (Response) {
                        sessionStorageService.set(keyConstService.IsEndorsementEdit, true);
                        sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                        if (vm.endorsementModel.ProductType === "Landlord – Essentials") {
                            location.href = "/Home/UpdateLandlordProtection?" + sessionStorageService.getEncryption("productName=" + vm.endorsementModel.ProductType + "&&quoteCaseNumber=" + Response.data);
                        }
                        else if (vm.endorsementModel.ProductType === "Landlord – AD and LE") {
                            location.href = "/Home/UpdateLandlordStandard?" + sessionStorageService.getEncryption("productName=" + vm.endorsementModel.ProductType + "&&quoteCaseNumber=" + Response.data);
                        }
                        else if (vm.endorsementModel.ProductType === "SME - Commercial Package") {
                            portalV2Service.getV2Token().then(function (resp) {
                                portalV2Service.setKeyToLocalStorage(resp.data.data);
                                $window.location.href = window.location.protocol + '//' + window.location.host + vm.SMEEndorsementURL + '?' + sessionStorageService.getEncryption("oldQuoteTransactionId=" + vm.originalQuoteTransactionId + "&&oldQuoteCaseId=" + vm.originalQuoteCaseId + "&&newQuoteTransactionId=" + Response.data.quoteTransactionId); //redirect to SME page.
                            });
                            }
                        else if (vm.endorsementModel.ProductType === keyConstService.PaProductDescription) {
                            location.href = webUrlConstService.PersonalAccidentUpdate + "?" + sessionStorageService.getEncryption("productName=" + vm.endorsementModel.ProductType + "&&quoteCaseNumber=" + Response.data);
                        }
                        else if (vm.endorsementModel.ProductType === keyConstService.CommercialMotorProductDescription) {
                            portalV2Service.getV2Token().then(function (resp) {
                                var redirectTo = keyConstService.CommercialMotorUrlPrefix + keyConstService.CommercialMotorEditQuote + sessionStorageService.getEncryption("quoteTransactionId=" + Response.data.quoteTransactionId + '&productId=' + keyConstService.CommercialMotorProductId);
                                portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                            });
                        }
                        else if (vm.endorsementModel.ProductType === keyConstService.CyberProductDescription) {
                            portalV2Service.getV2Token().then(function (resp) {
                                var redirectTo = keyConstService.CyberUrlPrefix + keyConstService.CyberEditQuote + sessionStorageService.getEncryption("quoteTransactionId=" + Response.data.quoteTransactionId + '&productId=' + keyConstService.CyberProductId);
                                portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                            });
                        }
                        else {
                            location.href = "/Home/Update" + vm.endorsementModel.ProductType + "?" + sessionStorageService.getEncryption("productName=" + vm.endorsementModel.ProductType + "&&quoteCaseNumber=" + Response.data);
                        }
                    }, function (error) {
                        $log.log('error', error);
                        // enable buttons so that user can do further actions
                        vm.disableButtons = false;

                    });
                }
            }
            else {
                endorsementService.endorsementComisionQuoteRequest(vm.endorsementModel).then(function (data) {

                    // in case of via previous or edit dates come back and changing effective date 
                    if (vm.endorsementModel && vm.endorsementModel.ProductType === keyConstService.SMEProductType) {
                        portalV2Service.getV2Token().then(function (resp) {
                            portalV2Service.setKeyToLocalStorage(resp.data.data);
                            $window.location.href = window.location.protocol + '//' + window.location.host + vm.SMEEndorsementURL + '?' + sessionStorageService.getEncryption("oldQuoteTransactionId=" + data.data.originalQuoteTransactionId + "&&oldQuoteCaseId=" + data.data.originalQuoteCaseId + "&&newQuoteTransactionId=" + data.data.quoteTransactionId); //redirect to SME page.
                        });
                        }
                    if (vm.endorsementModel && vm.endorsementModel.ProductType === keyConstService.CommercialMotorProductDescription) {
                        portalV2Service.getV2Token().then(function (resp) {
                            var redirectTo = keyConstService.CommercialMotorUrlPrefix + keyConstService.CommercialMotorEditQuote + sessionStorageService.getEncryption("quoteTransactionId=" + data.data.quoteTransactionId + '&productId=' + keyConstService.CommercialMotorProductId); //redirect to CM page.
                            portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                        });
                    }
                    if (vm.endorsementModel && vm.endorsementModel.ProductType === keyConstService.CyberProductDescription) {
                        portalV2Service.getV2Token().then(function (resp) {
                            var redirectTo = keyConstService.CyberUrlPrefix + keyConstService.CyberEditQuote + sessionStorageService.getEncryption("quoteTransactionId=" + data.data.quoteTransactionId + '&productId=' + keyConstService.CyberProductId); //redirect to CM page.
                            portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                        });
                    }
                }, function (error) {
                    $log.log('error', error);
                     // enable buttons so that user can do further actions
                    vm.disableButtons = false;
                });
            }
        }

        function discard() {
            // redirect to sme page if product is sme.
            if (vm.endorsementModel && vm.endorsementModel.ProductType === "SME - Commercial Package") {
                portalV2Service.getV2Token().then(function (resp) {
                    portalV2Service.setKeyToLocalStorage(resp.data.data);
                    $window.location.href = window.location.protocol + '//' + window.location.host + keyConstService.SMEUrlPrefix + keyConstService.SMEPolicyPound;
                    return;
                });
            }            
            if (vm.endorsementModel && vm.endorsementModel.ProductType === keyConstService.CyberProductDescription) {
                portalV2Service.getV2Token().then(function (resp) {
                    var redirectTo = keyConstService.CyberUrlPrefix + keyConstService.CyberPolicyBound + sessionStorageService.getEncryption("quoteTransactionId=" + vm.originalQuoteTransactionId + '&productId=' + keyConstService.CyberProductId);
                    portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                });
                return;
            }
            vm.actionEnable = JSON.parse(sessionStorageService.get('ActionButtonEnable'));
            vm.disableButtons = true;
            if (!IsEditEndorsement && !EndorsementChange) {
                if (vm.showManagePkg && vm.actionEnable !== true) {
                    vm.packageNumber = sessionStorageService.get('PackageNumberInformation');
                    vm.renewalCounter = sessionStorageService.get('RenewalCounter');
                    sessionStorageService.remove('IsPackageManagerNavigationMode');
                    sessionStorageService.remove('PackageNumberInformation');
                    sessionStorageService.remove('RenewalCounter');
                    sessionStorageService.remove('IsNewEditTransaction');
                    sessionStorageService.remove('endorsementRequestVM');
                    sessionStorageService.remove('IsNewBusinessReadOnly');
                    $window.location.href = webUrlConstService.getPackageInfo + sessionStorageService.getEncryption("packageNumber=" + JSON.parse(vm.packageNumber) + "&&renewalCounter=" + vm.renewalCounter);
                }
                else {
                    if (vm.endorsementModel.ProductType === keyConstService.CommercialMotorProductDescription) {
                        portalV2Service.getV2Token().then(function (resp) {
                            var redirectTo = keyConstService.CommercialMotorUrlPrefix + keyConstService.CommercialMotorPolicyBound + sessionStorageService.getEncryption("quoteTransactionId=" + vm.originalQuoteTransactionId + '&productId=' + keyConstService.CommercialMotorProductId);
                            portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                        });                        
                    }
                    else {
                        var Id = vm.endorsementModel.PolicyTransactionid;
                        window.location = "/Bind?" + sessionStorageService.getEncryption("id=" + Id);
                    }                    
                }
            }
            else {
                quotesService.quoteDiscardRequest(vm.endorsementModel.QuoteTransactionId).then(function (result) {
                    if (result.data) {
                        if (vm.showManagePkg) {
                            vm.packageNumber = sessionStorageService.get('PackageNumberInformation');
                            vm.renewalCounter = sessionStorageService.get('RenewalCounter');
                            sessionStorageService.remove('IsPackageManagerNavigationMode');
                            sessionStorageService.remove('PackageNumberInformation');
                            sessionStorageService.remove('RenewalCounter');
                            sessionStorageService.remove('IsNewEditTransaction');
                            sessionStorageService.remove('endorsementRequestVM');
                            sessionStorageService.remove('IsNewBusinessReadOnly');
                            $window.location.href = webUrlConstService.getPackageInfo + sessionStorageService.getEncryption("packageNumber=" + JSON.parse(vm.packageNumber) + "&&renewalCounter=" + vm.renewalCounter);
                        }
                        else {
                            $timeout(function () {
                                if (vm.endorsementModel.ProductType === keyConstService.CommercialMotorProductDescription) {
                                    var lastBound = sessionStorageService.get('QuoteState');                                    
                                    var lastBoundJson = JSON.parse(lastBound);
                                    var previousQuoteTransactionId = lastBoundJson.quoteDetails.previousQuoteTransactionId;                                                                       
                                    portalV2Service.getV2Token().then(function (resp) {
                                        var redirectTo = keyConstService.CommercialMotorUrlPrefix + keyConstService.CommercialMotorPolicyBound + sessionStorageService.getEncryption("quoteTransactionId=" + previousQuoteTransactionId + '&productId=' + keyConstService.CommercialMotorProductId);
                                        portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                                    });                                    
                                }
                                else {
                                    var Id = vm.endorsementModel.PolicyTransactionid;
                                    window.location = "/Bind?" + sessionStorageService.getEncryption("id=" + Id);
                                }                                
                            }, 1000);
                        }
                    } else {
                        toastr.error(messageConstService.errServiceUnavailable);
                        vm.disableButtons = false;
                    }
                },
                    function (error) {
                        $log.error('error', error);
                        toastr.error(messageConstService.errServiceUnavailable);
                        vm.disableButtons = false;
                    });
            }
       
        }

        function continueOrNavigateBackToPackageManager() {
            var packageNumber = sessionStorageService.get('PackageNumberInformation');
            var renewalCounter = sessionStorageService.get('RenewalCounter');
            sessionStorageService.remove('IsPackageManagerNavigationMode');
            sessionStorageService.remove('PackageNumberInformation');
            sessionStorageService.remove('RenewalCounter');
            sessionStorageService.remove('IsNewEditTransaction');
            sessionStorageService.remove('endorsementRequestVM');
            sessionStorageService.remove('IsNewBusinessReadOnly');
            sessionStorageService.remove(keyConstService.ActionButtonEnable);
            $window.location.href = webUrlConstService.getPackageInfo + sessionStorageService.getEncryption("packageNumber=" + JSON.parse(packageNumber) + "&&renewalCounter=" + renewalCounter);
        }
    }
})();;
(function () {
    'use strict';

    var appUI = angular.module('appUI');

    appUI.controller('packageManagerCtrl', ['$rootScope', '$q', '$window', 'uiGridConstants', 'packageManagerService', 'apiUrlConstService', 'sessionStorageService', 'keyConstService', '$http', 'webUrlConstService', '$scope', packageManagerCtrl]);

    function packageManagerCtrl($rootScope, $q, $window, uiGridConstants, packageManagerService, apiUrlConstService, sessionStorageService, keyConstService, $http, webUrlConstService, $scope) {
        var vm = this;
        vm.selectionBasis = null;
        vm.ResetOnSelection = ResetOnSelection;
        vm.clientSearch = clientSearch;
        vm.packageSearch = packageSearch;
        vm.policySearch = policySearch;
        vm.init = init;
        vm.Reset = Reset;
        vm.searchItem = searchItem;
        vm.getTableStyle = getTableStyle;
        vm.OnSearchTextChange = OnSearchTextChange;        
        vm.message = false;
        vm.showGrid = false;
        $scope.getParamEncrytion = getParamEncrytion;
        vm.DisableSearchButton = DisableSearchButton;
        vm.showLable = false;
        vm.clientLabel = false;
        vm.policyLabel = false;
        vm.packageLabel = false;
        vm.searchName = null; // this variable is for textbox content associated with client label
        vm.searchPolicy = null;
        vm.packageNumber = null;

        function ResetOnSelection() {
            vm.searchName = null;
            vm.searchPolicy = null;
            vm.packageNumber = null;
            vm.selectedClient = null;
            vm.selectedPolicy = null;
            vm.showGrid = false;
            vm.selectedPackage = null;
        }

        angular.element(document).ready(function () {
            angular.element(window).keydown(function () {             
                if (event.keyCode === 13) {  
                    event.preventDefault();
                    return false;
                }
            });
        });

        function clientSearch(clientName) {
            return packageManagerService.getClientDetail(clientName)
                .then(function (result) {
                    vm.data = result.data;
                    vm.clientSearchResult = [];
                    for (var i = 0; i < vm.data.length; i++) {
                        var client = vm.data[i].fullName + "(" + vm.data[i].clientCode + ")";
                        vm.clientSearchResult.push(client);
                    }
                    return vm.clientSearchResult;
                });
        }

        function policySearch(policyNumber) {
            var result = /^[a-zA-Z0-9'\s]+$/.test(policyNumber);
            if (!result) {
                policyNumber = null;
                vm.searchPolicy = "";
            }
            return packageManagerService.getPolicyDetail(policyNumber)
                .then(function (result) {
                    vm.policy = result.data;
                    return vm.policy;
                },
                function (data) {
                    toastr.error("System is currently not working. Please try after sometime.");
                    return;
                });
        }

        function packageSearch(packageNumber) {
            var result = /^[a-zA-Z0-9'\s]+$/.test(packageNumber);
            if (!result) {
                packageNumber = null;
                vm.packageNumber = "";
            }
            return packageManagerService.getPackageDetail(packageNumber)
                .then(function (result) {
                    vm.package = result.data;                    
                    return Array.from(new Set(vm.package));
                },
                function (data) {
                    toastr.error("System is currently not working. Please try after sometime.");
                    return;
                });
        }

        function init() {
            sessionStorageService.remove(keyConstService.IsCopyQuote);
            sessionStorageService.remove(keyConstService.Colour);
            sessionStorageService.remove(keyConstService.CopyQuoteOldTransactionId);
            sessionStorageService.remove(keyConstService.IsRenewalPolicy);
            vm.client = true;
            vm.clientLabel = true;
            vm.policyOptions = {
                paginationPageSize: 10,
                enablePagination: true,
                paginationPageSizes: [10, 20, 30],
                enableSorting: true,
                rowHeight: 55,
                enableFiltering: false,
                data: null,
                columnDefs: [
                    { name: 'PackageNumber', field: 'packageNumber', cellTemplate: getLink(), width: "250" },
                    { name: 'ClientName', field: 'insuredName', width: "250" },
                    { name: 'PolicyTerm', field: 'renewalTerm', width: "220"},
                    { name: 'Date Created', field: 'createDate', type: 'date', cellFilter: 'date:\'dd-MM-yyyy\'', width: "210" },
                    { name: 'Expiration Date', field: 'endDate', type: 'date', cellFilter: 'date:\'dd-MM-yyyy\'', width: "210" }
                ]
            };

            vm.policyOptions.data = null;
            var isBackSearch = JSON.parse(sessionStorageService.get('backSearch'));
            if (isBackSearch === 1) {
                vm.policyOptions.data = JSON.parse(sessionStorageService.get('backSearch'));
                sessionStorageService.set(keyConstService.backSearch, 0);
            }
            else {
                sessionStorageService.remove(keyConstService.backSearch);
            }
        }

        function Reset() {
            vm.client = true;
            vm.clientLabel = true;
            vm.policyNumber = null;
            vm.packageNumber = null;
            vm.showLable = false;
            vm.showGrid = false;
            vm.message = false;
            if (vm.policyOptions.data) {
                vm.policyOptions.data.length = 1;
            }
            vm.policyLabel = false;
            vm.packageLabel = false;
            vm.pkgNumber = null;
            ResetCheckedValues();
        }

        function searchItem() {            
            var searchValue;
            var packageSearchData = {};

            if (vm.searchName) {
                searchValue = vm.searchName;
                packageSearchData = {
                    "InsuredName": searchValue.split('(')[0],
                    "PolicyNumber": null,
                    "PackageNumber": null
                };
            }
            else if (vm.searchPolicy) {
                searchValue = vm.searchPolicy;
                packageSearchData = {
                    "InsuredName": null,
                    "PolicyNumber": searchValue,
                    "PackageNumber": null
                };
            }
            else {
                searchValue = vm.packageNumber;
                packageSearchData = {
                    "InsuredName": null,
                    "PolicyNumber": null,
                    "PackageNumber": searchValue
                };
                //$window.location.href = webUrlConstService.getPackageInfo + sessionStorageService.getEncryption("packageNumber=" + vm.packageNumber);
            }

            packageManagerService.getSearchResult(packageSearchData).then(function (searchdata) {
                if (searchdata.status) {                    
                    vm.policyOptions.data = searchdata.data;
                    if (vm.policyOptions.data === null || vm.policyOptions.data.length === 0) {
                        vm.message = true;
                        vm.showGrid = false;
                    }
                    else {
                        //if (vm.policyOptions.data.length === 1) {
                        //    getParamEncrytion(searchdata.data[0].packageNumber, searchdata.data[0].renewalCounter);                            
                        //}
                        //else
                        {
                            vm.message = false;
                            vm.showGrid = true;                            
                        }
                    }
                    sessionStorageService.set('backSearch', vm.policyOptions.data);
                }
            }, function (error) {
                toastr.error("Service is currently not available. Please try again or contact system administrator.");
            });
           
        }

        function getLink(item) {
            return '<div class="ui-grid-cell-contents"><a ng-if=\'row.entity.packageNumber !== null\' ng-click="grid.appScope.getParamEncrytion(row.entity.packageNumber,row.entity.renewalCounter)">{{row.entity.packageNumber}}</a> </div >'
        
        }

        function getParamEncrytion(paramString, renewalCounter) {
                var encryptedParam = sessionStorageService.getEncryption("packageNumber=" + paramString + "&&renewalCounter=" + renewalCounter);
                $window.location.href = webUrlConstService.getPackageInfo + encryptedParam;
        }

        function getTableStyle() {            
            var marginHeight = 45;
            var length = 10;
            if (vm.policyOptions.data.length <= 10)
                length = vm.policyOptions.data.length;

            return {
                height: (length * vm.policyOptions.rowHeight + marginHeight) + "px"
            };
        };

        function OnSearchTextChange(searchText) {
            vm.selectedPackage = null;
        }

        vm.checkedOption = function (value, item) {
            if (value === 1 && item === true) {
                vm.policyNumber = null;
                vm.pkgNumber = null;
                vm.showLable = true;
                vm.clientLabel = true;
                vm.policyLabel = false;
                vm.packageLabel = false;
                vm.selectedClient = null;
                vm.searchName = null;
            }
            else if (value === 2 && item === true) {
                vm.client = null;
                vm.pkgNumber = null;
                vm.showLable = true;
                vm.policyLabel = true;
                vm.clientLabel = false;
                vm.packageLabel = false;
                vm.searchPolicy = null;
                vm.selectedPolicy = null;
            }
            else if (value === 3 && item === true) {
                vm.client = null;
                vm.policyNumber = null;
                vm.showLable = true;
                vm.clientLabel = false;
                vm.policyLabel = false;
                vm.packageLabel = true;
                vm.packageNumber = null;
                vm.selectedPackage = null;
            }

            else if (item === false) {
                vm.clientLabel = false;
                vm.policyLabel = false;
                vm.packageLabel = false;
            }
            ResetCheckedValues();
        };

        function ResetCheckedValues() {
            vm.searchName = null;
            vm.selectedClient = null;
            vm.searchPolicy = null;
            vm.selectedPolicy = null;
            vm.packageNumber = null;
            vm.selectedPackage = null;            
        }

        function DisableSearchButton()
        {            
            if ((vm.searchName && vm.selectedClient !== null) || (vm.searchPolicy && vm.selectedPolicy !== null) || (vm.packageNumber && vm.selectedPackage !== null)) {
                return false;
            }
            else {
                return true;
            }
        }
    }

})();;
(function () {
    'use strict';

    angular.module('appUI')
        .controller('documentLibraryCtrl', ['documentLibraryService', 'FileSaver', documentLibraryCtrl]);


    function documentLibraryCtrl(documentLibraryService, FileSaver) {
        var vm = this;
        vm.data = {};        
        vm.isDisabled = false;
        vm.downloadDocument = downloadDocument;
        vm.toggleIcon = toggleIcon;
        documentLibraryList();
        vm.toggleSubolumnsIcon = toggleSubolumnsIcon;

        function getList() {
            documentLibraryService.getDocumentList(function getResponseFromService(response) {
                vm.data = response.data;               
            });
        }

        function documentLibraryList() {
            getList();
        }

        function downloadDocument(fileName, filepath) {            
            vm.isDisabled = true;
            var log = console.log;
            if (fileName && fileName != null && fileName !== '' && fileName != undefined) {
                var fileStatus = false;
                checkFileFormat(fileName, function getResponse(bool) {
                    fileStatus = bool;
                });
                if (fileStatus) {
                    documentLibraryService.downloadDocument(filepath, function getResponseFromService(result) {
                        if (result.status === 200) {
                            var content = result.data;
                            var blob = new Blob([content], { type: result.type });
                            vm.isDisabled = false;
                            FileSaver.saveAs(blob, fileName);
                        } else {
                            toastr.error("file does not exist.");
                        }
                    });
                } else {
                    toastr.warning("file format is not correct.");
                    vm.isDisabled = false;
                }

            } else {
                toastr.error("file does not exist.");
                vm.isDisabled = false;
            }
        };

        function checkFileFormat(file, setResponse) {
            var fileArray = file.split('.');
            var arrayLength = fileArray.length;
            var objItem = fileArray[arrayLength - 1];
            var checkdata = false;
            switch (objItem) {
                case 'pdf': {
                    checkdata = true;
                    break;
                }
                case 'docx': {
                    checkdata = true;
                    break;
                }               
                default: {
                    checkdata = false;
                    break;
                }
            }
            setResponse(checkdata);
        }

        function toggleIcon(item) {
            var data = vm.data;
            data.forEach(function (obj) {
                if (obj.id === item.id) {
                    item.activestatus = !item.activestatus;
                } else {
                    obj.activestatus = false;
                }
            });
        }  
        function toggleSubolumnsIcon(item) {           
            var data = vm.data;
            data.forEach(function (obj) {
                obj.subColumns.forEach(function (subColumns) {
                    if (subColumns.id === item.id) {
                        item.activestatus = !item.activestatus;
                    } 
                });                
            });
        }  
    }
})();
;
(function () {
    'use strict';

    angular.module('appUI')
        .service('packageManagerService', ['$rootScope', '$resource', '$q', '$http', '$log', 'apiUrlConstService', packageManagerService]);

    function packageManagerService($rootScope, $resource, $q, $http, $log, apiUrlConstService) {
        return {
            getClientDetail: getClientDetail,
            getPolicyDetail: getPolicyDetail,
            getPackageDetail: getPackageDetail,
            getSearchResult: getSearchResult,
            getQuoteStatus: getQuoteStatus
        };

        function getClientDetail(query) {
            var clientApi = $resource(apiUrlConstService.clientFirstNameURL, {
                searchClient: query
            }, { get: { method: 'GET', isArray: false } });
            return clientApi.get().$promise;
        }

        function getPolicyDetail(query) {
            var policyApi = $resource(apiUrlConstService.partialPolicySearchUrl, {
                searchPolicy: query
            }, { get: { method: 'GET', isArray: false } });
            return policyApi.get().$promise;
        }

        function getPackageDetail(query) {
            var packageApi = $resource(apiUrlConstService.packageSearchQueryUrl, {
                searchPackage: query
            }, { get: { method: 'GET', isArray: false } });
            return packageApi.get().$promise;
        }

        function getSearchResult(packageSearchData) {
            var PoliciesApi = $resource(apiUrlConstService.packageSearchUrl, {
                packageSearchData: JSON.stringify(packageSearchData)
            }, { get: { method: 'GET', isArray: false} });
            return PoliciesApi.get().$promise;
        }

        function getQuoteStatus(data) {
            var packageApi = $resource(apiUrlConstService.getQuoteStatus, {
                quoteTransactionId: data
            }, { get: { method: 'GET', isArray: false } });
            return packageApi.get().$promise;
        }
    }
})();;
(function () {
    'use strict';

    var appUI = angular.module('appUI');

    appUI.controller('packageDetailCtrl', ['$scope', '$rootScope', '$q', '$window', 'bindService', 'packageManagerService', 'quotesService', 'uiGridConstants', 'packageDetailService', 'apiUrlConstService', 'sessionStorageService', 'keyConstService', '$http', 'webUrlConstService', 'utilityService', 'dateService', 'messageConstService', 'stringService', 'Blob', 'FileSaver', 'portalV2Service', packageDetailCtrl]);

    function packageDetailCtrl($scope, $rootScope, $q, $window, bindService, packageManagerService, quotesService, uiGridConstants, packageDetailService, apiUrlConstService, sessionStorageService, keyConstService, $http, webUrlConstService, utilityService, dateService, messageConstService, stringService, Blob, FileSaver, portalV2Service) {
        var vm = this;
        var model = null;
        vm.scope = $rootScope;
        vm.data = null;
        vm.init = init;
        vm.getTableStyle = getTableStyle;
        vm.saveMonthlyPackagePaymentDay = saveMonthlyPackagePaymentDay;
        vm.saveAnnualPackagePaymentDate = saveAnnualPackagePaymentDate;
        vm.ReadOnly = true;
        vm.reset = reset;
        vm.editPaymentDate = editPaymentDate;
        vm.savePaymentDate = savePaymentDate;
        vm.getTemplate = getTemplate;
        vm.IsEditOn = false;
        vm.changePaymentSource = changePaymentSource;
        vm.IsActiveQuoteAvailable = false;
        vm.packageNumber = null;
        vm.gridQuoteShow = gridQuoteShow;
        vm.gridPolicyShow = gridPolicyShow;
        vm.IsBrokerManaged = false;
        vm.downloadDoc = downloadDoc;
        var isDynamic = true;
        vm.instalmentDayOfMonthList = [];
        vm.updateExpirationInstallmentDate = updateExpirationInstallmentDate;
        vm.validateExpiration = validateExpiration;
        vm.IsDateValid = true;
        $scope.getParamEncrytion = getParamEncrytion;
        vm.isAnnual = false;
        vm.IsBrokerManaged = true;
        vm.PackageTermCounter = "";
        vm.newPaymentDay = null;
        vm.redirectToSearchPkg = redirectToSearchPkg;
        vm.disableChangePay = false;
        vm.minCreateDate = [];
        vm.DownloadpaymentDoc = DownloadpaymentDoc;
        vm.packageDocument = { pdf: null, rtf: null };
        vm.DownloadpaymentDocDisable = DownloadpaymentDocDisable;
        vm.deferinstallmentdate = deferinstallmentdate;
        vm.deferinstallmentdatelabel = null;
        vm.deferinstallmentdateprocess = deferinstallmentdateprocess;
        vm.ValidateInstalmentDateChange = ValidateInstalmentDateChange;
        vm.changeinstallmentdate = changeinstallmentdate;
        vm.defererresult = { message: 'Instalment paused successfully now!', error: false, errorMessage: 'errror' };
        vm.emailPackagedocs = emailPackagedocs;
        vm.quoteTransactionId = null;
        vm.installmentschedule = installmentschedule;
        vm.dataTableResult = null;
        vm.dataTableResultSet = null;
        vm.dateFormat = [];
        vm.paymentsource = null;
        vm.deferConfigure = 1;
        vm.dateConfigure = 0;
        vm.dateConfigureEnable = true;
        vm.disabledatechangebutton = false;
        vm.disabledeferbutton = null;
        vm.retryDate = null;
        vm.renewalCount = null;
        vm.packageNo = null;
        vm.changeAnnualToInstallment = changeAnnualToInstallment;
        vm.getAnnualToInstallmentTerms = getAnnualToInstallmentTerms;
        vm.errorMessageAnnulToInst = null;
        vm.packageErrorMessage = null;
        vm.instalmentDate = null;////Instalment date change
        vm.ShowAnnualToInstallmentBTN = false; //// VM variable for controlling the switching of the AnnualToInstallment button.
        vm.isCancelledPolicy = true;
        vm.resetInstalmetDate = resetInstalmetDate;
        vm.isDateChangeFunctionlityEnable = 0;
        vm.BrokerPortalV2Debugging = false;
        vm.IsCommMotor = false;

        function init(model) {
            if (model.LookUpValues.annualToInstallmentSwitch === undefined) {
                model.LookUpValues = utilityService.toCamel(model.LookUpValues);
            }
            sessionStorageService.set(keyConstService.isCancelledPolicy, vm.isCancelledPolicy);
            vm.instalmentDayOfMonthList = [];
            var currentDate = new Date();
            for (var i = 1; i <= 28; i++) {
                vm.instalmentDayOfMonthList.push({ Value: i.toString(), Text: i });
            }
            model.PackageNumber = model.PackageNumber.toUpperCase();
            vm.packageNo = model.PackageNumber;
            vm.renewalCount = model.RenewalCounter;
            vm.expirationDate = moment(model.ExpirationDate).format('DD-MM-YYYY');
            if (model.ActivePolicyList.length === 0) {
                vm.isCancelledPolicy = false;
                sessionStorageService.set(keyConstService.isCancelledPolicy, vm.isCancelledPolicy);
            }

            for (i = 0; i < model.ActivePolicyList.length; i++) {
                model.ActivePolicyList[i].TotalPremiumValue = model.ActivePolicyList[i].TotalPremiumValue.toFixed(2);
                vm.minCreateDate.push(model.ActivePolicyList[i].CreateDate);
                vm.minCreateDate.sort();
                vm.minCreateDates = vm.minCreateDate[0];
                if (model.ActivePolicyList[i].PolicyStatus !== "Cancelled") {
                    vm.isCancelledPolicy = false;
                    sessionStorageService.set(keyConstService.isCancelledPolicy, vm.isCancelledPolicy);
                }
            }
            vm.startDate = moment(vm.minCreateDates).format('DD-MM-YYYY');
            vm.BrokerPortalV2Debugging = model.BrokerPortalV2Debugging;
            var policyvalue = "";
            policyvalue += '<div><ul class="icons-list" >';
            policyvalue += '<li class="dropdown">';
            policyvalue += '<a href="#" class="dropdown-toggle" data-toggle="dropdown" aria-expanded="false">';
            policyvalue += '<i class="icon-menu4"></i>';
            policyvalue += '</a>';
            policyvalue += '<ul class="dropdown-menu dropdown-menu-right" >';
            policyvalue += '<li><a ng-click="grid.appScope.vm.viewPolicy(grid, row)"><i class="icon-eye pull-right"></i>View</a></li>';
            policyvalue += '<li><a ng-click="grid.appScope.vm.policyEndorsement(grid, row)"><i class="icon-credit-card pull-right"></i> Endorse</a></li>';
            policyvalue += '<li><a ng-click="grid.appScope.vm.policyCancellation(grid, row)"><i class="icon-cross3 pull-right"></i> Cancel</a></li>';
            policyvalue += '<li><a ng-click="grid.appScope.vm.bindPolicyDocumentGrid(grid, row)" data-toggle="modal" data-target="#download-documents"> <i class="icon-files-empty pull-right"></i> Policy Documents </a></li>';
            policyvalue += '</ul>';
            policyvalue += '</li>';
            policyvalue += '</ul></div>';
            //.PackageTermCounter = model.
            vm.policyOptions = {
                paginationPageSize: 10,
                enablePagination: true,
                paginationPageSizes: [10, 20, 30],
                rowHeight: 43,
                headerRowHeight: 80,
                enableSorting: true,
                enableFiltering: false,
                data: null,
                columnDefs: [
                    { name: 'Policy Number', field: 'PolicyNumber', cellTemplate: getLink(1), width: "150" },
                    { name: 'Product', field: 'LineOfBusiness', width: "170" },
                    { name: 'Status', field: 'PolicyStatus', width: "194" },
                    { name: 'Insured Name', field: 'InsuredName', width: "175" },
                    { name: 'Inception', field: 'CreateDate', type: 'date', cellFilter: 'date:\'dd-MM-yyyy\'', width: "170" },
                    { name: 'Total Premium', field: 'TotalPremiumValue', width: "150" },
                    { name: 'Action', cellTemplate: policyvalue, width: "90" }
                ]
            };

            for (i = 0; i < model.ActivePolicyList.length; i++) {
                vm.minCreateDate.push(model.ActivePolicyList[i].CreateDate);
                vm.minCreateDate.sort();
                vm.minCreateDates = vm.minCreateDate[0];
            }

            vm.currentDate = moment(new Date()).format('YYYY-MM-DD');
            vm.addedDate = moment(vm.minCreateDates, 'YYYY-MM-DD').add(30, 'days').format();
            vm.createDate = moment(vm.addedDate).format('YYYY-MM-DD');

            if (vm.createDate > vm.currentDate) {
                vm.disableChangePay = false;
            }
            vm.SMEManagePackageActivePoliciesURL = model.SMEManagePackageActivePoliciesURL;
            vm.SMEManagePackageActiveQuotesURL = model.SMEManagePackageActiveQuotesURL;
            vm.CommercialMotorManagePackageActiveQuotesURL = model.CommercialMotorManagePackageActiveQuotesURL !== null ? model.CommercialMotorManagePackageActiveQuotesURL : vm.CommercialMotorManagePackageActiveQuotesURL;
            vm.CommercialMotorManagePackageActivePoliciesURL = model.CommercialMotorManagePackageActivePoliciesURL !== null ? model.CommercialMotorManagePackageActivePoliciesURL : vm.CommercialMotorManagePackageActivePoliciesURL;
            vm.CommercialMotorViewQuoteURL = model.CommercialMotorViewQuoteURL !== null ? model.CommercialMotorViewQuoteURL : vm.CommercialMotorViewQuoteURL;
            vm.CommercialMotorEditQuoteURL = model.CommercialMotorEditQuoteURL !== null ? model.CommercialMotorEditQuoteURL : vm.CommercialMotorEditQuoteURL;
            vm.policyOptions.data = null;
            //, width: "400"
            var quotevalue = "";
            quotevalue += '<div><ul class="icons-list" >';
            quotevalue += '<li class="dropdown">';
            quotevalue += '<a href="#" class="dropdown-toggle" data-toggle="dropdown" aria-expanded="false">';
            quotevalue += '<i class="icon-menu4"></i>';
            quotevalue += '</a>';
            quotevalue += '<ul class="dropdown-menu dropdown-menu-right" >';
            quotevalue += '<li><a ng-click="grid.appScope.vm.quoteView(grid, row)"><i class="icon-eye pull-right"></i>View</a></li>';
            quotevalue += '<li><a ng-click="grid.appScope.vm.quoteEdit(grid, row)"><i class="icon-pencil7 pull-right"></i>Edit</a></li>';
            quotevalue += '<li><a ng-click="grid.appScope.vm.bindQuote(grid, row)"><i class="icon-credit-card pull-right"></i> Bind</a></li>';
            quotevalue += '<li><a ng-click="grid.appScope.vm.confirmDiscardQuote(grid, row)" data-toggle="modal" data-target="#discard"><i class="icon-cross3 pull-right"></i> Discard</a></li>';
            quotevalue += '</ul>';
            quotevalue += '</li>';
            quotevalue += '</ul></div>';

            vm.quoteOptions = {
                paginationPageSize: 10,
                enablePagination: true,
                paginationPageSizes: [10, 20, 30],
                rowHeight: 43,
                headerRowHeight: 80,
                enableSorting: true,
                enableFiltering: false,
                data: null,
                columnDefs: [
                    { name: 'Quote Number', field: 'QuoteNumber', cellTemplate: getLink(2), width: "150" },
                    { name: 'Case Number', field: 'CaseNumber', width: "170" },
                    { name: 'Product', field: 'LineOfBusiness', width: "190" },
                    { name: 'Status', field: 'Status', width: "190" },
                    { name: 'Insured Name', field: 'InsuredName', width: "170" },
                    { name: 'Inception', field: 'CreateDate', type: 'date', cellFilter: 'date:\'dd-MM-yyyy\'', width: "140" },
                    { name: 'Action', cellTemplate: quotevalue, width: "90" }
                ]
            };

            vm.quoteOptions.data = null;
            vm.data = model;
            vm.ReadOnly = true;
            vm.IsBrokerManaged = model.IsBrokerManaged;
            vm.isAnnual = model.IsBranchAnnualPayment;

            if (model.PaymentSource === "DIRECTDEBIT") {
                vm.paymentsource = "Bank Account";
            }
            else if (model.PaymentSource === "PURCHASE") {
                vm.paymentsource = "Credit Card";
            }
            else {
                vm.paymentsource = "Not Provided";
            }


            if (model.PaymentMethod === "Monthly")
                vm.paymentDayOrDate = true;
            else
                vm.paymentDayOrDate = false;

            if (model.ActivePolicyList.length > 0)
                vm.policyOptions.data = model.ActivePolicyList;

            if (model.ActiveQuoteList.length > 0) {
                vm.quoteOptions.data = model.ActiveQuoteList;
                vm.IsActiveQuoteAvailable = true;
            }

            if (model.PackagePaymentDateDetailList !== null) {
                vm.policyList = utilityService.toCamel(model.PackagePaymentDateDetailList);
                for (var count = 0; count < vm.policyList.length; count++) {
                    vm.policyList[count].minPaymentDate = new Date(vm.policyList[count].minPaymentDate);
                    vm.policyList[count].maxPaymentDate = new Date(vm.policyList[count].maxPaymentDate);
                    vm.policyList[count].paymentDate = new Date(vm.policyList[count].paymentDate);
                }
            }

            vm.selectedPolicy = {};

            var instalmentDayOfMonthList = [];
            for (i = 1; i <= 28; i++) {
                instalmentDayOfMonthList.push({ Value: i.toString(), Text: i });
            }
            vm.PaymentMethod = model.PaymentMethod;
            vm.DayofInstallmentList = instalmentDayOfMonthList;
            vm.data.IsCreditCardMode = true;
            vm.PackageTermCounter = getterm(model.RenewalCounter);
            if (model.PaymentMethod === "Monthly") {
                nextinstallmentdate();
                getPauseAttempts();
            }

            //// annualToInstallmentSwitch initialization as per the look up value retrieved from the model.
            var annualToInstallmentSwitch = (model.LookUpValues !== null) ? (model.LookUpValues.annualToInstallmentSwitch !== null) ? model.LookUpValues.annualToInstallmentSwitch : null : null;
            //// assign lookup value for date change
            if (vm.PaymentMethod === 'Monthly' && vm.data.AnyPolicyExists && model.IsBranchInstallmentON) {
                //// annualToInstallmentSwitch initialization as per the look up value retrieved from the model.
                var dateChangeLookUpCountValues = (model.LookUpValues !== null) ? (model.LookUpValues.dateChange !== null) ? model.LookUpValues.dateChange : null : null;
                var dateChangeLookUpEndableValues = (model.LookUpValues !== null) ? (model.LookUpValues.isDateChangeFunctionlityEnable !== null) ? model.LookUpValues.isDateChangeFunctionlityEnable : null : null;
                vm.dateConfigure = dateChangeLookUpCountValues;
                GetCommonData(1, 'DateChange');
                vm.isDateChangeFunctionlityEnable = dateChangeLookUpEndableValues;
                
            }

            //// initialization of the VM variable ShowAnnualToInstallmentBTN to control the switching of AnnualToInstallment button.
            vm.ShowAnnualToInstallmentBTN = (vm.PaymentMethod === 'Annual' && vm.data.AnyPolicyExists && model.IsBranchInstallmentON && annualToInstallmentSwitch === 'true') ? true : false;

            funcdisabledeferbutton();
        }

        function getterm(term) {
            if (term === 0) {
                return "1st Term";
            }
            else if (term === 1) {
                return "2nd Term";
            }
        }

        function getTemplate(policy) {
            if (policy.policyNumber === vm.selectedPolicy.policyNumber)
                return 'edit';
            else
                return 'readOnly';
        };

        function reset() {
            vm.selectedPolicy = {};
        }

        function editPaymentDate(policyData) {
            vm.selectedPolicy = angular.copy(policyData);
            $scope.MinD = vm.selectedPolicy.minPaymentDate;
            $scope.MaxD = vm.selectedPolicy.maxPaymentDate;
            $scope.date = vm.selectedPolicy.paymentDate;
            vm.IsEditOn = true;
        }

        function gridPolicyShow() {
            if (vm.policyOptions.data !== null) {
                if (vm.policyOptions.data.length > 0) {
                    return true;
                }
                else {
                    return false;
                }
            }
        }

        function gridQuoteShow() {
            if (vm.quoteOptions.data !== null) {
                if (vm.quoteOptions.data.length > 0) {
                    return true;
                }
                else {
                    return false;
                }
            }
        }

        function savePaymentDate(index) {
            if (IsValidDate(vm.selectedPolicy.paymentDate, vm.selectedPolicy.minPaymentDate, vm.selectedPolicy.maxPaymentDate)) {
                vm.policyList[index] = angular.copy(vm.selectedPolicy);
                vm.IsEditOn = false;
                reset();
            }
            else {
                toastr.error(messageConstService.errPaymentDate);
            }
        }

        function IsValidDate(date, minDate, maxdate) {
            var effectiveDate = dateService.getMomentDateforDDMM(date);
            var minEffectiveDate = dateService.getMomentDateforDDMM(minDate);
            var maxEffectiveDate = dateService.getMomentDateforDDMM(maxdate);
            return (minEffectiveDate <= effectiveDate && effectiveDate <= maxEffectiveDate);
        }

        function getLink(item) {
            if (item === 1) {
                return '<div class="ui-grid-cell-contents"><a ng-if=\'row.entity.PolicyNumber !== null && row.entity.LineOfBusiness !== "SME - Commercial Package" && row.entity.LineOfBusiness !== "Commercial Motor" && row.entity.LineOfBusiness !== "Cyber"\' ng-click="grid.appScope.getParamEncrytion(1,row.entity.PolicyTransactionId)">{{row.entity.PolicyNumber}}</a>' +
                    '<a ng-if=\'row.entity.PolicyNumber !== null && row.entity.LineOfBusiness === "SME - Commercial Package"\' ng-click="grid.appScope.getParamEncrytion(4,row.entity.QuoteTransactionId)">{{row.entity.PolicyNumber}}</a>' +
                    '<a ng-if=\'row.entity.PolicyNumber !== null && row.entity.LineOfBusiness === "Commercial Motor"\' ng-click="grid.appScope.getParamEncrytion(6,row.entity.QuoteTransactionId)">{{row.entity.PolicyNumber}}</a>' +
                    '<a ng-if=\'row.entity.PolicyNumber !== null && row.entity.LineOfBusiness === "Cyber"\' ng-click="grid.appScope.getParamEncrytion(8,row.entity.QuoteTransactionId)">{{row.entity.PolicyNumber}}</a>' +
                    '</div>';
            }
            else {

                return '<div class="ui-grid-cell-contents"><a ng-if=\'row.entity.Status === "CANCELLATION" && row.entity.LineOfBusiness !== "SME - Commercial Package" && row.entity.QuoteNumber !== null\' ng-click="grid.appScope.getParamEncrytion(2,row.entity.QuoteTransactionId)"> {{row.entity.QuoteNumber}}</a>' +
                    '<a ng-if=\'row.entity.Status === "CANCELLATION" && row.entity.LineOfBusiness === "SME - Commercial Package" && row.entity.QuoteNumber !== null\' ng-click="grid.appScope.getParamEncrytion(5,row.entity.QuoteTransactionId)"> {{row.entity.QuoteNumber}}</a>' +
                    '<a ng-if=\'row.entity.Status !== "CANCELLATION" && row.entity.QuoteNumber == null && row.entity.QuoteStatus == "Declined"\' ng-click="grid.appScope.getParamEncrytion(3,row.entity.QuoteTransactionId)"> {{row.entity.QuoteNumber}}</a>' +
                    '<a ng-if=\'row.entity.Status !== "CANCELLATION" && row.entity.QuoteNumber !== null && row.entity.LineOfBusiness !== "SME - Commercial Package" && row.entity.LineOfBusiness !== "Commercial Motor" && row.entity.LineOfBusiness !== "Cyber" && row.entity.QuoteStatus !== "Draft"\' ng-click="grid.appScope.getParamEncrytion(3,row.entity.QuoteTransactionId)"> {{row.entity.QuoteNumber}}</a>' +
                    '<a ng-if=\'row.entity.Status !== "CANCELLATION" && row.entity.QuoteNumber !== null && row.entity.LineOfBusiness !== "SME - Commercial Package" && row.entity.LineOfBusiness === "Commercial Motor" && row.entity.LineOfBusiness !== "Cyber" && row.entity.QuoteStatus !== "Draft"\' ng-click="grid.appScope.getParamEncrytion(7,row.entity.QuoteTransactionId)"> {{row.entity.QuoteNumber}}</a>' + 
                    '<a ng-if=\'row.entity.Status !== "CANCELLATION" && row.entity.QuoteNumber !== null && row.entity.LineOfBusiness !== "SME - Commercial Package" && row.entity.LineOfBusiness !== "Commercial Motor" && row.entity.LineOfBusiness === "Cyber" && row.entity.QuoteStatus !== "Draft"\' ng-click="grid.appScope.getParamEncrytion(9,row.entity.QuoteTransactionId)"> {{row.entity.QuoteNumber}}</a>' + 
                    '<a ng-if=\'row.entity.Status !== "CANCELLATION" && row.entity.LineOfBusiness === "Home" && row.entity.QuoteStatus == "Draft"\' href  ng-click=\'grid.appScope.vm.validAndRedirect("UpdateHome",row.entity.LineOfBusiness,row.entity.CaseNumber)\'" > {{row.entity.QuoteNumber }}</a>' +
                    '<a ng-if=\'row.entity.Status !== "CANCELLATION" && row.entity.LineOfBusiness === "Motor" && row.entity.QuoteStatus == "Draft"\' href  ng-click=\'grid.appScope.vm.validAndRedirect("UpdateMotor",row.entity.LineOfBusiness,row.entity.CaseNumber)\'  > {{row.entity.QuoteNumber }}</a>' +
                    '<a ng-if=\'row.entity.Status !== "CANCELLATION" && row.entity.LineOfBusiness === "Landlord – Essentials" && row.entity.QuoteStatus == "Draft"\' href  ng-click=\'grid.appScope.vm.validAndRedirect("UpdateLandlordProtection",row.entity.LineOfBusiness,row.entity.CaseNumber)\' > {{row.entity.QuoteNumber }}</a>' +
                    '<a ng-if=\'row.entity.Status !== "CANCELLATION" && row.entity.LineOfBusiness === "Landlord – AD and LE" && row.entity.QuoteStatus == "Draft"\' href  ng-click=\'grid.appScope.vm.validAndRedirect("UpdateLandlordStandard",row.entity.LineOfBusiness,row.entity.CaseNumber)\' > {{row.entity.QuoteNumber }}</a>' +
                    '<a ng-if=\'row.entity.Status !== "CANCELLATION" && row.entity.QuoteNumber !== null && row.entity.LineOfBusiness === "SME - Commercial Package" && row.entity.QuoteStatus == "Quoted" ng-click="grid.appScope.getParamEncrytion(5,row.entity.QuoteTransactionId)"> {{row.entity.QuoteNumber}}</a>' +
                    '<a ng-if=\'row.entity.Status !== "CANCELLATION" && row.entity.QuoteNumber !== null && row.entity.LineOfBusiness === "SME - Commercial Package" && row.entity.QuoteStatus == "Referred" ng-click="grid.appScope.getParamEncrytion(5,row.entity.QuoteTransactionId)"> {{row.entity.QuoteNumber}}</a>' +

                    '<a ng-if=\'row.entity.Status !== "CANCELLATION" && row.entity.LineOfBusiness === "SME - Commercial Package" && row.entity.QuoteStatus == "Draft"\' href  ng-click=\'grid.appScope.vm.validAndRedirectSME(row.entity.QuoteTransactionId)\' > {{row.entity.CaseNumber }}</a>' +
                    '<a ng-if=\'row.entity.Status !== "CANCELLATION" && row.entity.QuoteNumber !== null && row.entity.LineOfBusiness === "Commercial Motor" && row.entity.QuoteStatus == "Quoted" ng-click="grid.appScope.getParamEncrytion(7,row.entity.QuoteTransactionId)">{{row.entity.QuoteNumber}}</a>' +
                    '<a ng-if=\'row.entity.Status !== "CANCELLATION" && row.entity.QuoteNumber !== null && row.entity.LineOfBusiness === "Commercial Motor" && row.entity.QuoteStatus == "Referred" ng-click="grid.appScope.getParamEncrytion(7,row.entity.QuoteTransactionId)"> {{row.entity.QuoteNumber}}</a>' +

                    '<a ng-if=\'row.entity.Status !== "CANCELLATION" && row.entity.QuoteNumber !== null && row.entity.LineOfBusiness === "Cyber" && row.entity.QuoteStatus == "Quoted" ng-click="grid.appScope.getParamEncrytion(9,row.entity.QuoteTransactionId)">{{row.entity.QuoteNumber}}</a>' +
                    '<a ng-if=\'row.entity.Status !== "CANCELLATION" && row.entity.QuoteNumber !== null && row.entity.LineOfBusiness === "Cyber" && row.entity.QuoteStatus == "Referred" ng-click="grid.appScope.getParamEncrytion(9,row.entity.QuoteTransactionId)"> {{row.entity.QuoteNumber}}</a>' +

                    '<a ng-if=\'row.entity.Status !== "CANCELLATION" && row.entity.LineOfBusiness === "Commercial Motor" && row.entity.QuoteStatus == "Draft"\' href  ng-click=\'grid.appScope.vm.validAndRedirectCommercialMotor(row.entity.QuoteTransactionId)\' > {{row.entity.CaseNumber }}</a>' +
                    '<a ng-if=\'row.entity.Status !== "CANCELLATION" && row.entity.LineOfBusiness === "Cyber" && row.entity.QuoteStatus == "Draft"\' href  ng-click=\'grid.appScope.vm.validAndRedirectCyber(row.entity.QuoteTransactionId)\' > {{row.entity.CaseNumber }}</a>' +
                    '</div>';
            }
        }

        function getParamEncrytion(mode, paramString) {
            vm.changePaymentSource();
            if (mode === 1) {
                var encryptedParam = sessionStorageService.getEncryption("id=" + paramString);
                $window.location.href = "/Bind?" + encryptedParam;
            }
            else if (mode === 2) {
                encryptedParam = sessionStorageService.getEncryption("qid=" + paramString);
                $window.location.href = "/Cancellation/Quote?" + encryptedParam;
            }
            else if (mode === 3) {
                encryptedParam = sessionStorageService.getEncryption("quoteTransactionId=" + paramString);
                $window.location.href = "/QuoteCase/Index?" + encryptedParam;
            }
            else if (mode === 4 || mode === 5) {
                encryptedParam = sessionStorageService.getEncryption("quoteTransactionId=" + paramString);
                var url = null;
                if (mode === 4) {
                    url = vm.SMEManagePackageActivePoliciesURL;
                }
                else {
                    url = vm.SMEManagePackageActiveQuotesURL;
                }
                portalV2Service.getV2Token().then(function (resp) {
                    portalV2Service.setKeyToLocalStorage(resp.data.data);
                    $window.location.href = window.location.protocol + '//' + window.location.host + url + '?' + encryptedParam;
                });
            }
            else if (mode === 6) {
                encryptedParam = sessionStorageService.getEncryption("quoteTransactionId=" + paramString + '&productId=' + keyConstService.CommercialMotorProductId);
                portalV2Service.getV2Token().then(function (resp) {
                    var redirectTo = vm.CommercialMotorManagePackageActivePoliciesURL + '/' + encryptedParam;
                    portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                });                
            }
            else if (mode === 7) {
                encryptedParam = sessionStorageService.getEncryption("quoteTransactionId=" + paramString + '&productId=' + keyConstService.CommercialMotorProductId);
                portalV2Service.getV2Token().then(function (resp) {
                    var redirectTo = vm.CommercialMotorManagePackageActiveQuotesURL + '/' + encryptedParam;
                    portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                });
            }
            else if (mode === 8) {
                encryptedParam = sessionStorageService.getEncryption("quoteTransactionId=" + paramString + '&productId=' + keyConstService.CyberProductId);
                portalV2Service.getV2Token().then(function (resp) {
                    var redirectTo = vm.CommercialMotorManagePackageActivePoliciesURL + '/' + encryptedParam;
                    portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                });
            }
            else if (mode === 9) {
                encryptedParam = sessionStorageService.getEncryption("quoteTransactionId=" + paramString + '&productId=' + keyConstService.CyberProductId);
                portalV2Service.getV2Token().then(function (resp) {
                    var redirectTo = vm.CommercialMotorManagePackageActiveQuotesURL + '/' + encryptedParam;
                    portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                });
            }
        }

        vm.validAndRedirect = function (producturl, product, casenumber) {
            sessionStorageService.set(keyConstService.isvalidquestionsback, true);
            $window.location.href = "/home/" + producturl + "?" + sessionStorageService.getEncryption("productName=" + product + "&&quoteCaseNumber=" + casenumber);
        };

        vm.validAndRedirectSME = function (quoteTransactionId) {
            sessionStorageService.set(keyConstService.isvalidquestionsback, true);
            portalV2Service.getV2Token().then(function (resp) {
                portalV2Service.setKeyToLocalStorage(resp.data.data);
                $window.location.href = window.location.protocol + '//' + window.location.host + vm.SMEManagePackageActiveQuotesURL + "?" + sessionStorageService.getEncryption("quoteTransactionId=" + quoteTransactionId);
            });
        };
        vm.validAndRedirectCommercialMotor = function (quoteTransactionId){
            sessionStorageService.set(keyConstService.isvalidquestionsback, true);
            portalV2Service.getV2Token().then(function (resp) {
                var redirectTo = keyConstService.CyberUrlPrefix + keyConstService.CyberEditQuote + sessionStorageService.getEncryption("quoteTransactionId=" + quoteTransactionId + '&productId=' + keyConstService.CommercialMotorProductId);
                portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
            });
        };
        vm.validAndRedirectCyber = function (quoteTransactionId) {
            sessionStorageService.set(keyConstService.isvalidquestionsback, true);
            portalV2Service.getV2Token().then(function (resp) {
                var redirectTo = keyConstService.CyberUrlPrefix + keyConstService.CyberEditQuote + sessionStorageService.getEncryption("quoteTransactionId=" + quoteTransactionId + '&productId=' + keyConstService.CyberProductId);
                portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
            });
        };

        function getTableStyle(paramValue) {
            var marginHeight = 15; // optional
            var length;
            if (paramValue === 1) {
                if (vm.policyOptions.data.length > 10) {
                    length = 10;
                }
                else {
                    length = vm.policyOptions.data.length;
                }
                // this is unique to my cellTemplate
                return {
                    height: ((length * vm.policyOptions.rowHeight + vm.policyOptions.headerRowHeight + marginHeight) - (length * 5)) + "px"
                };
            }
            else {
                if (vm.quoteOptions.data.length > 10) {
                    length = 10;
                }
                else {
                    length = vm.quoteOptions.data.length;
                }
                // this is unique to my cellTemplate
                return {
                    height: ((length * vm.quoteOptions.rowHeight + vm.quoteOptions.headerRowHeight + marginHeight) - (length * 5)) + "px"
                };
            }

        };


        function downloadDoc(packageNumber, templateName) {
            return $http
                ({
                    url: "/MediaProxy/PackageManager/GenerateDocumentPackageMang?packageNumberDoc=" + packageNumber + "&templateName=" + templateName + "&renewalCounter=" + vm.renewalCount,
                    method: "GET",
                    responseType: 'blob'
                })
                .then(function (result) {
                    var blob = new Blob([result.data], { type: [result.data.type] });
                    var ext = result.data.type === 'application/pdf' ? keyConstService.pdf : keyConstService.rtf;
                    isDynamic === true ? FileSaver.saveAs(blob, packageNumber + ext) : FileSaver.saveAs(blob, templateName + ext);
                    return result.data;
                },
                    function (data) {
                        toastr.error("System is currently not working. Please try after sometime.");
                        return;
                    });
        }

        function emailPackagedocs() {
            var documents = {
                packagenumber: vm.data.PackageNumber,
                docDetails: vm.packageDocument
            };
            return $http
                ({
                    url: "/MediaProxy/PackageManager/SendPackageDocument?" + "packagenumber=" + vm.data.PackageNumber + "&pdf=" + vm.packageDocument.pdf + "&rtf=" + vm.packageDocument.rtf + "&renewalCounter=" + vm.renewalCount,
                    method: "GET",
                    responseType: 'blob'
                })
                .then(function (result) {

                    var email = sessionStorageService.get('userEmail');
                    toastr.success("E-mail sent successfully to " + email.split('"')[1]);
                    return result.data.data;
                },
                    function (data) {
                        toastr.error("System is currently not working. Please try after sometime.");
                        return;
                    });
        }

        function changePaymentSource() {
            sessionStorageService.set('IsPackageManagerNavigationMode', true);
            sessionStorageService.set('PackageNumberInformation', vm.data.PackageNumber);
            sessionStorageService.set('RenewalCounter', vm.data.RenewalCounter);
            if (vm.policyOptions.data) {
                $window.location.href = webUrlConstService.paymentInfoUrl + "id=" + vm.policyOptions.data[0].PolicyTransactionId;
            }
        }

        function saveAnnualPackagePaymentDate() {
            for (var count = 0; count < vm.policyList.length; count++) {
                vm.policyList[count].minPaymentDate = null;
                vm.policyList[count].maxPaymentDate = null;
                vm.policyList[count].paymentDate = dateService.getDateDDMMtoMMDD(vm.policyList[count].paymentDate);
            }
            packageDetailService.saveAnnualPackagePaymentDate(vm.policyList).then(function (response) {
                $('#annual-change-payment-date').modal('hide');
                toastr.success("Update Successfull");
                vm.policyList = utilityService.toCamel(response.data);
                for (var count = 0; count < vm.policyList.length; count++) {
                    vm.policyList[count].minPaymentDate = new Date(vm.policyList[count].minPaymentDate);
                    vm.policyList[count].maxPaymentDate = new Date(vm.policyList[count].maxPaymentDate);
                    vm.policyList[count].paymentDate = new Date(vm.policyList[count].paymentDate);
                }
            }, function (error) {
                toastr.success("Update Failed");
            });
        };

        function saveMonthlyPackagePaymentDay() {
            var packageDateUpdateData = {
                "PackageId": vm.data.PackageId,
                "PaymentDay": vm.data.PaymentDay
            };
            packageDetailService.saveMonthlyPackagePaymentDay(packageDateUpdateData).then(function (response) {
                $('#monthly-change-payment-date').modal('hide');
                toastr.success("Update Successfull");
            }, function (error) {
                toastr.success("Update Failed");
            });
        };

        function DateDifferenceInDays(paymentDate, currentDate) {
            var diff = Date.parse(paymentDate) - Date.parse(currentDate);
            return Math.floor(diff / 86400000);
        }

        function updateExpirationInstallmentDate(date) {
            var packageDateUpdateData = {
                "PackageId": vm.data.PackageId,
                "PaymentMethod": vm.data.PaymentMethod,
                "ExpirationDate": dateService.getDateDDMMtoMMDD(vm.data.ExpirationDate),
                "PaymentDay": vm.data.PaymentDay
            };
            packageDetailService.updateExpirationInstallmentDate(packageDateUpdateData).then(function (response) {
                if (response.data === true)
                    toastr.success("Update Successfull");
            }, function (error) {
                toastr.success("Update Failed");
            });
        }

        function validateExpiration() {
            var effectiveDateM = dateService.getMomentDateforDDMM(new Date(vm.data.StartDate));
            var expirationDateM = dateService.getMomentDateforDDMM(vm.data.ExpirationDate);
            var expirationDateInMMDD = dateService.getDateDDMMtoMMDD(vm.data.ExpirationDate);
            //get the policy period based on the start date.
            var config = {
                params: { startDate: expirationDateInMMDD },
                headers: { 'Accept': 'application/json' }
            };
            $http.get(apiUrlConstService.lookupURL + 'GetPolicyPeriod', config)
                .then(function (result) {
                    if (result.data.status === true) {
                        vm.minimumPolicyDays = result.data.data.minimumPolicyPeriod;
                        vm.maximumPolicyDays = result.data.data.maximumPolicyPeriod;
                        if (!expirationDateM._isValid) {
                            vm.IsDateValid = false;
                            toastr.error(messageConstService.errDateInvalid);
                            return;
                        }
                        if (expirationDateM < effectiveDateM) {
                            vm.IsDateValid = false;
                            vm.expirationDate = "";
                            toastr.error(messageConstService.errMinExpirationDate);
                            return;
                        }

                        var dateRangeResponse = dateService.validateRange("days", vm.minimumPolicyDays, vm.maximumPolicyDays, vm.data.ExpirationDate, effectiveDateM, vm.data.ExpirationDate, null);
                        if (!dateRangeResponse.isValid) {
                            var message = "";
                            if (dateRangeResponse.errorMsg === "Date Below Range.") {
                                //reformat the message
                                message = stringService.stringFormat(messageConstService.errPolicyMinimumPeriod, vm.minimumPolicyDays);
                            }
                            if (dateRangeResponse.errorMsg === "Date Above Range.") {

                                message = stringService.stringFormat(messageConstService.errPolicyMaximumPeriod, vm.maximumPolicyDays);
                            }
                            toastr.error(message);
                            vm.IsDateValid = false;
                            vm.data.ExpirationDate = '';
                            return;
                        }
                        vm.IsDateValid = true;
                    }

                }, function (error) {
                    toastr.warning(messageConstService.errSelectAgain);
                });

        }

        /*view active quote*/
        vm.quoteView = function (grid, row) {
            sessionStorageService.set('IsPackageManagerNavigationMode', true);
            sessionStorageService.set('PackageNumberInformation', vm.data.PackageNumber);
            sessionStorageService.set('RenewalCounter', vm.data.RenewalCounter);

            if (row.entity.Status === "CANCELLATION") {
                $window.location.href = webUrlConstService.CancellationViewQuote + sessionStorageService.getEncryption("quoteId=" + row.entity.QuoteTransactionId);
            }
            else {
                if (row.entity.LineOfBusiness === "Home") {
                    sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                    location.href = "/Home/ViewHome?" + sessionStorageService.getEncryption("productName=" + row.entity.LineOfBusiness + "&&quoteCaseNumber=" + row.entity.CaseNumber);
                }
                else if (row.entity.LineOfBusiness === "Motor") {
                    sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                    location.href = "/Home/ViewMotor?" + sessionStorageService.getEncryption("productName=" + row.entity.LineOfBusiness + "&&quoteCaseNumber=" + row.entity.CaseNumber);
                }
                else if (row.entity.LineOfBusiness === "Landlord – Essentials") {
                    sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                    location.href = "/Home/ViewLandlordProtection?" + sessionStorageService.getEncryption("productName=" + row.entity.LineOfBusiness + "&&quoteCaseNumber=" + row.entity.CaseNumber);
                }
                else if (row.entity.LineOfBusiness === "Landlord – AD and LE") {
                    sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                    location.href = "/Home/ViewLandlordStandard?" + sessionStorageService.getEncryption("productName=" + row.entity.LineOfBusiness + "&&quoteCaseNumber=" + row.entity.CaseNumber);
                }
                else if (row.entity.LineOfBusiness === "Commercial Motor") {
                    sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                    portalV2Service.getV2Token().then(function (resp) {
                        var redirectTo = vm.CommercialMotorViewQuoteURL + '/' + sessionStorageService.getEncryption("quoteTransactionId=" + row.entity.QuoteTransactionId + '&productId=' + keyConstService.CommercialMotorProductId);
                        portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                    });
                }
                else if (row.entity.LineOfBusiness === keyConstService.CyberProductDescription) {
                    sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                    portalV2Service.getV2Token().then(function (resp) {
                        var redirectTo = keyConstService.CyberUrlPrefix + keyConstService.CyberViewQuote + sessionStorageService.getEncryption("quoteTransactionId=" + row.entity.QuoteTransactionId + '&productId=' + keyConstService.CyberProductId);
                        portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                    });
                }
            }

        };

        /*edit active quote*/
        vm.quoteEdit = function (grid, row) {
            sessionStorageService.set('IsPackageManagerNavigationMode', true);
            sessionStorageService.set('PackageNumberInformation', vm.data.PackageNumber);
            sessionStorageService.set('RenewalCounter', vm.data.RenewalCounter);

            packageManagerService.getQuoteStatus(row.entity.QuoteTransactionId).then(function (result) {
                if (result.data) {
                    if (result.data === "Declined" || result.data === "Referred" || result.data === "MoreInfo") {
                        toastr.error("Cannot edit Declined/Referred/MoreInfo quotes");
                    }
                    else {

                        if (row.entity.Status === "CANCELLATION") {
                            $window.location.href = webUrlConstService.CancellationViewQuote + sessionStorageService.getEncryption("quoteId=" + row.entity.QuoteTransactionId + "&&hasEdit=true");
                        }

                        else {

                            if (row.entity.LineOfBusiness === "Home") {
                                sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                                location.href = "/Home/UpdateHome?" + sessionStorageService.getEncryption("productName=" + row.entity.LineOfBusiness + "&&quoteCaseNumber=" + row.entity.CaseNumber + "&&startDate=" + row.entity.CreateDate);
                            }
                            else if (row.entity.LineOfBusiness === "Motor") {
                                sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                                location.href = "/Home/UpdateMotor?" + sessionStorageService.getEncryption("productName=" + row.entity.LineOfBusiness + "&&quoteCaseNumber=" + row.entity.CaseNumber);
                            }

                            else if (row.entity.LineOfBusiness === "Landlord – Essentials") {
                                sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                                location.href = "/Home/UpdateLandlordProtection?" + sessionStorageService.getEncryption("productName=" + row.entity.LineOfBusiness + "&&quoteCaseNumber=" + row.entity.CaseNumber);
                            }
                            else if (row.entity.LineOfBusiness === "Landlord – AD and LE") {
                                sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                                location.href = "/Home/UpdateLandlordStandard?" + sessionStorageService.getEncryption("productName=" + row.entity.LineOfBusiness + "&&quoteCaseNumber=" + row.entity.CaseNumber + "&&startDate=" + row.entity.CreateDate);
                            }
                            else if (row.entity.LineOfBusiness === "Commercial Motor") {
                                sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                                portalV2Service.getV2Token().then(function (resp) {
                                    var redirectTo = keyConstService.CommercialMotorUrlPrefix + keyConstService.CommercialMotorEditQuote + sessionStorageService.getEncryption("quoteTransactionId=" + row.entity.QuoteTransactionId + '&productId=' + keyConstService.CommercialMotorProductId);
                                    portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                                });                                
                            }
                            else if (row.entity.LineOfBusiness === keyConstService.CyberProductDescription) {
                                sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                                location.href = window.location.protocol + '//' + window.location.host + keyConstService.CyberUrlPrefix + keyConstService.CyberEditQuote + sessionStorageService.getEncryption("quoteTransactionId=" + row.entity.QuoteTransactionId + '&productId=' + keyConstService.CyberProductId);
                            }
                        }
                    }
                }
                else {
                    toastr.error(messageConstService.errServiceUnavailable);
                }
            },
                function (error) {
                    $log.error('error', error);
                    toastr.error(messageConstService.errServiceUnavailable);
                    vm.disableButtons = false;
                });


        };

        vm.confirmDiscardQuote = function (grid, row) {
            vm.quoteTransactionId = row.entity.QuoteTransactionId;
            vm.quoteNumber = row.entity.QuoteNumber;
        };

        /*discard active quote*/
        vm.discardQuote = function () {
            sessionStorageService.set('IsPackageManagerNavigationMode', true);
            sessionStorageService.set('PackageNumberInformation', vm.data.PackageNumber);
            sessionStorageService.set('RenewalCounter', vm.data.RenewalCounter);
            vm.packageNumber = sessionStorageService.get('PackageNumberInformation');
            vm.renewalCounter = sessionStorageService.get('RenewalCounter');
            vm.disableButtons = true;
            packageDetailService.discardQuote(vm.quoteNumber).then(function (result) {
                if (result.data) {
                    $window.location.href = webUrlConstService.getPackageInfo + sessionStorageService.getEncryption("packageNumber=" + JSON.parse(vm.packageNumber) + "&&renewalCounter=" + vm.renewalCounter);
                }
                else {
                    toastr.error(messageConstService.errServiceUnavailable);
                    vm.disableButtons = false;
                }
            },
                function (error) {
                    $log.error('error', error);
                    toastr.error(messageConstService.errServiceUnavailable);
                    vm.disableButtons = false;
                });
        };


        /*bind active quote*/
        vm.bindQuote = function (grid, row) {

            packageManagerService.getQuoteStatus(row.entity.QuoteTransactionId).then(function (result) {
                if (result.data) {
                    if (result.data === "Declined" || result.data === "Referred" || result.data === "MoreInfo" || result.data === "ReferralReturned") {
                        toastr.error("Cannot bind Declined/Referred/MoreInfo/ReferralReturned quotes");
                    }
                    else {
                        if (row.entity.Status === "CANCELLATION") {
                            $scope.getParamEncrytion(2, row.entity.QuoteTransactionId);
                        }
                        else {
                            sessionStorageService.set('IsPackageManagerNavigationMode', true);
                            sessionStorageService.set('PackageNumberInformation', vm.data.PackageNumber);
                            sessionStorageService.set('RenewalCounter', vm.data.RenewalCounter);
                            if (row.entity.LineOfBusiness === "Commercial Motor") {
                                portalV2Service.getV2Token().then(function (resp) {
                                    var redirectTo = keyConstService.CommercialMotorUrlPrefix + keyConstService.CommercialMotorQuoteSummary + sessionStorageService.getEncryption("quoteTransactionId=" + row.entity.QuoteTransactionId + '&productId=' + keyConstService.CommercialMotorProductId);
                                    portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                                });                                
                            }
                            if (row.entity.LineOfBusiness === keyConstService.CyberProductDescription) {
                                $window.location.href = window.location.protocol + '//' + window.location.host + vm.CommercialMotorManagePackageActiveQuotesURL + '/' + sessionStorageService.getEncryption("quoteTransactionId=" + row.entity.QuoteTransactionId + '&productId=' + keyConstService.CyberProductId);
                            }
                            else {
                                $window.location.href = webUrlConstService.bindQuote + sessionStorageService.getEncryption("quoteTransactionId=" + row.entity.QuoteTransactionId);
                            }
                           
                        }
                    }
                }
                else {
                    toastr.error(messageConstService.errServiceUnavailable);
                }
            },
                function (error) {
                    $log.error('error', error);
                    toastr.error(messageConstService.errServiceUnavailable);
                    vm.disableButtons = false;
                });
        };

        /*cancel active policy*/
        vm.policyCancellation = function (grid, row) {
            sessionStorageService.remove(keyConstService.ActionButtonEnable);
            if (row.entity.PolicyStatus === "CancellationPending" || row.entity.PolicyStatus === "EndorsementPending" || row.entity.PolicyStatus === "Cancelled") {
                toastr.error("Cannot cancel CancellationPending/EndorsementPending/Cancelled  policy");
            }
            else {
                sessionStorageService.set('IsPackageManagerNavigationMode', true);
                sessionStorageService.set('PackageNumberInformation', vm.data.PackageNumber);
                sessionStorageService.set('RenewalCounter', vm.data.RenewalCounter);
                //if (row.entity.LineOfBusiness === "Commercial Motor") {
                //    $window.location.href = window.location.protocol + '//' + window.location.host + vm.CommercialMotorManagePackageActivePoliciesURL + '/' + sessionStorageService.getEncryption("quoteTransactionId=" + row.entity.QuoteTransactionId);
                //}
                //else {
                //    $window.location.href = webUrlConstService.cancellationInitaiation + sessionStorageService.getEncryption("pid=" + row.entity.PolicyTransactionId);
                //}
                $window.location.href = webUrlConstService.cancellationInitaiation + sessionStorageService.getEncryption("pid=" + row.entity.PolicyTransactionId);
            }
        };


        /*Endorsement active policy*/
        vm.policyEndorsement = function (grid, row) {
            sessionStorageService.remove(keyConstService.ActionButtonEnable);
            if (row.entity.PolicyStatus === "CancellationPending" || row.entity.PolicyStatus === "EndorsementPending" || row.entity.PolicyStatus === "Cancelled") {
                toastr.error("Cannot endorse CancellationPending/EndorsementPending/Cancelled policy");
            }
            else {
                sessionStorageService.set('IsPackageManagerNavigationMode', true);
                sessionStorageService.set('PackageNumberInformation', vm.data.PackageNumber);
                sessionStorageService.set('RenewalCounter', vm.data.RenewalCounter);
                sessionStorageService.remove('IsNewEditTransaction');
                sessionStorageService.remove('endorsementRequestVM');
                sessionStorageService.remove('IsNewBusinessReadOnly');
                //if (row.entity.LineOfBusiness === "Commercial Motor") {
                //    $window.location.href = window.location.protocol + '//' + window.location.host + vm.CommercialMotorManagePackageActivePoliciesURL + '/' + sessionStorageService.getEncryption("quoteTransactionId=" + row.entity.QuoteTransactionId);
                //}
                //else {
                //    $window.location.href = webUrlConstService.endorsementRequest + sessionStorageService.getEncryption("quoteTransactionId=" + row.entity.QuoteTransactionId);
                //}
                $window.location.href = webUrlConstService.endorsementRequest + sessionStorageService.getEncryption("quoteTransactionId=" + row.entity.QuoteTransactionId);
            }
        };


        /*view active policy*/
        vm.viewPolicy = function (grid, row) {

            sessionStorageService.set('IsPackageManagerNavigationMode', true);
            sessionStorageService.set('PackageNumberInformation', vm.data.PackageNumber);
            sessionStorageService.set('RenewalCounter', vm.data.RenewalCounter);
            if (row.entity.LineOfBusiness === keyConstService.Home) {
                sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                location.href = webUrlConstService.viewPolicyHome + sessionStorageService.getEncryption("productName=Home&&quoteCaseNumber=" + row.entity.CaseNumber);
            }
            if (row.entity.LineOfBusiness === keyConstService.Motor) {
                sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                location.href = webUrlConstService.viewPolicyMotor + sessionStorageService.getEncryption("productName=Motor&&quoteCaseNumber=" + row.entity.CaseNumber);
            }
            if (row.entity.LineOfBusiness === keyConstService.LandlordADLE) {
                sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                location.href = webUrlConstService.viewLandlordStandard + sessionStorageService.getEncryption("productName=Landlord – AD and LE&&quoteCaseNumber=" + row.entity.CaseNumber);
            }

            if (row.entity.LineOfBusiness === keyConstService.LandlordEssentials) {
                sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
                location.href = webUrlConstService.viewLandlordProtection + sessionStorageService.getEncryption("productName=Landlord – Essentials&&quoteCaseNumber=" + row.entity.CaseNumber);
            }

            if (row.entity.LineOfBusiness === keyConstService.CommercialMotorProductDescription) {
                $window.location.href = window.location.protocol + '//' + window.location.host + vm.CommercialMotorViewQuoteURL + '/' + sessionStorageService.getEncryption("quoteTransactionId=" + row.entity.QuoteTransactionId + '&productId=' + keyConstService.CommercialMotorProductId);
            }

            if (row.entity.LineOfBusiness === keyConstService.CyberProductDescription) {
                $window.location.href = window.location.protocol + '//' + window.location.host + keyConstService.CyberUrlPrefix + keyConstService.CyberViewQuote + sessionStorageService.getEncryption("quoteTransactionId=" + row.entity.QuoteTransactionId + '&productId=' + keyConstService.CyberProductId);
            }
        };


        /*open active policy document*/
        vm.bindPolicyDocumentGrid = function (grid, row) {
            vm.showNBQuoteDocGrid = row.entity;

            bindService.bindPolicyDocumentGrid({
                CoverType: row.entity.CoverType,
                CoverageType: row.entity.CoverageType,
                PolicyTransactionId: row.entity.PolicyTransactionId
            })
                .then(function (result) {
                    if (result.status) {
                        vm.docDetail = result.data;
                        return result;
                    }
                    vm.showNBQuoteDocGrid = null;
                    toastr.error("System is currently not working. Please try after sometime.");
                });
        };


        /*download active policy document*/
        vm.GetPolicyDownloadSelected = function (value) {
            if (value === null) {
                return value;
            }
            var a = webUrlConstService.documentDownloadUrl;
            var flag = 0;
            vm.docDetail.forEach(function (trans) {
                if (trans.isChecked === true) {
                    flag++;
                    return $http
                        ({
                            url: webUrlConstService.documentDownloadUrl + value.PolicyTransactionId + "&policyDocumentId=" + trans.id,
                            method: "GET",
                            responseType: 'blob'
                        })
                        .then(function (result) {
                            var blob = new Blob([result.data], { type: [result.data.type] });
                            var ext = result.data.type === 'application/pdf' ? keyConstService.pdf : keyConstService.rtf;
                            trans.isDynamic === true ? FileSaver.saveAs(blob, utilityService.RemoveFilePostFix(trans.templateName) + '_' + value.PolicyNumber + ext) : FileSaver.saveAs(blob, trans.templateName + '_' + value.PolicyNumber + ext);
                            return result.data.data;

                        },
                            function (data) {
                                toastr.error("System is currently not working. Please try after sometime.");
                                return;
                            });

                }
            });
            if (flag === 0) {
                toastr.error("Please select atleast one document");
                return;
            }
        };


        /*send email for active policy document*/
        vm.GetPolicyEmailSelected = function (value) {
            var idChecked = [];
            var flag = 0;
            vm.docDetail.forEach(function (trans) {
                if (trans.isChecked === true) {
                    idChecked.push(trans.id);
                    flag++;
                }
            });
            if (flag === 0) {
                toastr.error("Please select atleast one document");
                return;
            } else {
                return $http
                    ({
                        url: webUrlConstService.documentSelectedDownloadUrl + value.PolicyTransactionId + "&documentDetail=" + JSON.stringify(idChecked),
                        method: "GET",
                        responseType: 'blob'
                    })
                    .then(function (result) {
                        var email = sessionStorageService.get('userEmail');
                        toastr.success("E-mail sent successfully to " + email.split('"')[1]);
                        return result.data.data;

                    },
                        function (data) {
                            toastr.error("System is currently not working. Please try after sometime.");
                            return;
                        });
            }
        };

        function redirectToSearchPkg() {
            $window.location.href = webUrlConstService.seachPackage;
        }

        function DownloadpaymentDoc(value) {
            if (vm.packageDocument.pdf === true) {
                vm.downloadDoc(vm.data.PackageNumber, 'PackageManagement schedule (PDF)');
            }
            if (vm.packageDocument.rtf === true) {
                vm.downloadDoc(vm.data.PackageNumber, 'PackageManagement schedule (RTF)');
            }
            if (vm.packageDocument.pdf !== true && vm.packageDocument.rtf !== true) {
                toastr.error("Please select Atleast one type of document to Download");
            }
        }

        function DownloadpaymentDocDisable() {
            if (vm.packageDocument.pdf !== true && vm.packageDocument.rtf !== true) {
                return true;
            }
            return false;
        }

        function nextinstallmentdate() {
            return $http
                ({
                    url: "/Proxy/packageManager/GetScheduleToPause?" + "packagenumber=" + vm.data.PackageNumber + "&callType=4" + "&renewalCounter=" + vm.renewalCount,
                    method: "GET"
                })
                .then(function (result) {
                    if (result.data.status) {
                        if (result.data && result.data.data[0].length !== 0) {
                            vm.nextInstallmentDate = moment(result.data.data[0][0].scheduleDate).format('DD-MM-YYYY');
                        }
                    }
                    else {
                        toastr.error("System is currently not working. Please try after sometime.");
                    }
                },
                    function (data) {
                        toastr.error("System is currently not working. Please try after sometime.");
                        return;
                    });

        }

        function deferinstallmentdate() {
            return $http
                ({
                    url: "/Proxy/packageManager/GetScheduleToPause?" + "packagenumber=" + vm.data.PackageNumber + "&callType=1" + "&renewalCounter=" + vm.renewalCount,
                    method: "GET"
                })
                .then(function (result) {
                    if (result.data.status) {
                        if (result.data.data[0][1]) {
                            vm.deferinstallmentdatelabel = moment(result.data.data[0][0].scheduleDate).format('DD-MM-YYYY');
                            vm.deferinstallmentdatelabel2 = moment(result.data.data[0][1].scheduleDate).format('DD-MM-YYYY');
                            vm.retryDate = moment(result.data.data[0][0].retryDate).format('DD-MM-YYYY');
                            if (vm.retryDate === "Invalid date") {
                                vm.retryDate = null;
                            }
                            vm.defererresult.errorMessage = "";
                            vm.defererresult.error = false;

                        }
                        else {
                            vm.defererresult.errorMessage = result.data.data[0][0].column1;
                            vm.defererresult.error = true;
                        }

                    }
                    else {
                        toastr.error("System is currently not working. Please try after sometime.");
                    }
                },
                    function (data) {
                        toastr.error("System is currently not working. Please try after sometime.");
                        return;
                    });

        }

        function deferinstallmentdateprocess() {
            return $http
                ({
                    url: "/Proxy/packageManager/GetScheduleToPause?" + "packagenumber=" + vm.data.PackageNumber + "&callType=2" + "&renewalCounter=" + vm.renewalCount,
                    method: "GET"
                })
                .then(function (result) {
                    if (result.data.status) {
                        vm.dataTableResult = result.data.data[0];
                        for (i = 0; i < vm.dataTableResult.length; i++) {
                            vm.dateFormat = moment(vm.dataTableResult[i].scheduleDate).format('DD MMMM YYYY');
                            vm.dataTableResult[i].scheduleDate = vm.dateFormat;
                        }
                        var total = 0.00;
                        var collected = 0.00;
                        var queued = 0.00;
                        for (var i = 0; i < result.data.data[0].length; i++) {
                            var product = result.data.data[0][i];
                            switch (product.paymentStatus) {
                                case "Paid":
                                    collected += parseFloat(product.totalAmount);
                                    break;
                                case "Unpaid":
                                    total += parseFloat(product.totalAmount);
                                    break;
                                case "Queued":
                                    queued += parseFloat(product.totalAmount);
                                    break;
                            }
                        }

                        vm.dataTableResultCollected = collected.toFixed(2);
                        vm.dataTableResultQueued = queued.toFixed(2);
                        vm.dataTableResultTotal = (total + collected + queued).toFixed(2);
                        vm.defererresult.message = "Instalment due on " + vm.deferinstallmentdatelabel + " is deferred successfully";
                        vm.nextInstallmentDate = vm.deferinstallmentdatelabel2;
                    }
                    else {
                        vm.defererresult.error = true;
                        toastr.error("System is currently not working. Please try after sometime.");
                        vm.defererresult.errorMessage = "System is currently not working. Please try after sometime";
                    }
                },
                    function (data) {
                        toastr.error("System is currently not working. Please try after sometime.");
                        return;
                    });
        }

        function funcdisabledeferbutton() {
            return $http
                ({
                    url: "/Proxy/packageManager/GetScheduleToPause?" + "packagenumber=" + vm.data.PackageNumber + "&callType=5" + "&renewalCounter=" + vm.renewalCount,
                    method: "GET"
                })
                .then(function (result) {
                    if (result.data.status) {
                        if (result.data.data.length > 0) {
                            vm.disabledeferbutton = JSON.parse(result.data.data[0][0].result);
                        }
                        else {
                            vm.disabledeferbutton = "false";
                        }
                    }
                    else {
                        toastr.error("System is currently not working. Please try after sometime.");
                    }
                },
                    function (data) {
                        toastr.error("System is currently not working. Please try after sometime.");
                        return;
                    });

        }

        function installmentschedule(calltype) {
            return $http
                ({
                    url: "/Proxy/packageManager/GetScheduleToPause?" + "packagenumber=" + vm.data.PackageNumber + "&callType=3" + "&renewalCounter=" + vm.renewalCount,
                    method: "GET"
                })
                .then(function (result) {
                    if (result.data.status) {
                        vm.dataTableResult = result.data.data[0];
                        for (i = 0; i < vm.dataTableResult.length; i++) {
                            vm.dateFormat = moment(vm.dataTableResult[i].scheduleDate).format('DD MMMM YYYY');
                            vm.dataTableResult[i].scheduleDate = vm.dateFormat;
                        }
                        var total = 0.00;
                        var collected = 0.00;
                        var queued = 0.00;
                        for (var i = 0; i < result.data.data[0].length; i++) {
                            var product = result.data.data[0][i];
                            switch (product.paymentStatus) {
                                case "Paid":
                                    collected += parseFloat(product.totalAmount);
                                    break;
                                case "Unpaid":
                                    total += parseFloat(product.totalAmount);
                                    break;
                                case "Queued":
                                    queued += parseFloat(product.totalAmount);
                                    break;
                            }
                        }

                        vm.dataTableResultCollected = collected.toFixed(2);
                        vm.dataTableResultQueued = queued.toFixed(2);
                        vm.dataTableResultTotal = (total + collected + queued).toFixed(2);
                    }
                    else {
                        toastr.error("System is currently not working. Please try after sometime.");
                    }

                },
                    function (data) {
                        toastr.error("System is currently not working. Please try after sometime.");
                        return;
                    });
        }


        function getPauseAttempts() {
            return $http
                ({
                    url: "/Proxy/packageManager/GetScheduleToPause?" + "packagenumber=" + vm.data.PackageNumber + "&callType=6" + "&renewalCounter=" + vm.renewalCount,
                    method: "GET"
                })
                .then(function (result) {
                    if (result.data.status) {
                        vm.dataTableResult = result.data;
                        if (result.data) {
                            vm.deferConfigure = JSON.parse(result.data.data[0][0].result);
                        }
                        else {
                            vm.deferConfigure = 1;
                        }
                    }
                    else {
                        toastr.error("System is currently not working. Please try after sometime.");
                    }

                },
                    function (data) {
                        toastr.error("System is currently not working. Please try after sometime.");
                        return;
                    });
        }

        function changeAnnualToInstallment()
        {
            return $http
                ({
                    url: "/Proxy/PackageManager/GetAnnualToInstallment?" + "packageNumber=" + vm.packageNo + "&renewalCounter=" + vm.renewalCount + "&instalmentDate=" + vm.newPaymentDay,
                    method: "GET"
                })
                .then(function (result) {
                    if (result.data.status) {
                        if (result.data.data[0][0].column1) {
                            vm.errorMessageAnnulToInst = result.data.data[0][0].column1; 
                        }
                        else { 
                        vm.dataTableResultSet = result.data.data[0];
                            for (var i = 0; i < vm.dataTableResultSet.length; i++) {
                                vm.dateFormat = moment(vm.dataTableResultSet[i].scheduleDate).format('DD MMMM YYYY');
                                vm.dataTableResultSet[i].scheduleDate = vm.dateFormat;
                            }
                       
                    }
                        return $http
                            ({
                                url: "/Proxy/PackageManager/GetPackageDetails?" + "packagenumber=" + vm.packageNo + "&renewalCounter=" + vm.renewalCount,
                                method: "GET"
                            })
                            .then(function (result) {
                                if (result.data.status) {
                                    init(utilityService.toPascal(result.data.data));
                                }

                            },
                                function (data) {
                                    toastr.error("System is currently not working. Please try after sometime.");
                                    return;
                                });
                    }

                },
                    function (data) {
                        toastr.error("System is currently not working. Please try after sometime.");
                        return;
                    });

           
        }

        function getAnnualToInstallmentTerms() {
            vm.newPaymentDay = - 1;
            return $http
                ({
                    url: "/Proxy/packageManager/GetScheduleToPause?" + "packagenumber=" + vm.data.PackageNumber + "&callType=7" + "&renewalCounter=" + vm.renewalCount,
                    method: "GET"
                })
                .then(function (result) {
                    if (result.data.status) {
                        if (result.data.data[0][0] && result.data.data[0][0].result) {
                            vm.packageErrorMessage = result.data.data[0][0].result;
                            $('#packageErrorMessage').modal('show');
                        }
                        else {
                            $('#enter-installment-date').modal('show');
                        }
                    }
                    else {
                        toastr.error("System is currently not working. Please try after sometime.");
                    }
                },
                    function (data) {
                        toastr.error("System is currently not working. Please try after sometime.");
                        return;
                    });

        }
        function GetCommonData(calltype, shortDescription) {
            return $http
                ({
                    url: "/Proxy/packageManager/GetCommonData?" + "callType=" + calltype + "&packagenumber=" + vm.data.PackageNumber + "&requestTypeValue=InstallmentDateChange&packageRenewalCount=" + vm.renewalCount + "&shortDescription=" + shortDescription+"&requestLevel=Package",
                    method: "GET"
                })
                .then(function (result) {
                    if (result.data.status) {
                        if (result.data.data.length > 0) {
                            return vm.disabledatechangebutton = JSON.parse(result.data.data[0][0].result);
                        }
                        else {
                            return "false";
                        }
                    }
                    else {
                        toastr.error("System is currently not working. Please try after sometime.");
                    }
                },
                    function (data) {
                        toastr.error("System is currently not working. Please try after sometime.");
                        return;
                    });
        }

        function ValidateInstalmentDateChange() {
            return $http
                ({
                    url: "/Proxy/packageManager/ValidateInstalmentDateChange?" + "packageNumber=" + vm.data.PackageNumber + "&packageRenewalCount=" + vm.renewalCount + "&instalmentDate=" + vm.newPaymentDay,
                    method: "GET"
                })
                .then(function (result) {
                    if (result.data.status && result.data.data) {
                        if (result.data.data.length > 0) {
                            if (result.data.data[0][0].column1) {
                                vm.packageErrorMessage = result.data.data[0][0].column1;
                                $('#packageErrorMessage').modal('show');
                            }
                        }
                        else {
                            $('#change-new-payment-type').modal('show');
                        }
                    }
                    else {
                        toastr.error("System is currently not working. Please try after sometime.");
                    }
                },
                    function (data) {
                        toastr.error("System is currently not working. Please try after sometime.");
                        return;
                    });
        }

        function changeinstallmentdate() {
            return $http
                ({
                    url: "/Proxy/packageManager/GetChangeInstalmentDate?" + "packagenumber=" + vm.data.PackageNumber + "&packageRenewalCount=" + vm.renewalCount + "&instalmentDate=" + vm.newPaymentDay ,
                    method: "GET"
                })
                .then(function (result) {
                    if (result.data.status && result.data.data) {
                        if (result.data.data[0][0].column1) {
                            vm.packageErrorMessage = result.data.data[0][0].column1;
                            $('#packageErrorMessage').modal('show');
                        }
                        else {
                            //// assign table value to display in the modal date-installment-schedule
                            vm.dataTableResultSet = result.data.data[0];
                            for (var i = 0; i < vm.dataTableResultSet.length; i++) {
                                vm.dateFormat = moment(vm.dataTableResultSet[i].scheduleDate).format('DD MMMM YYYY');
                                vm.dataTableResultSet[i].scheduleDate = vm.dateFormat;
                            }
                            $('#date-installment-schedule').modal('show');
                            //// reload manage package when received data for date change
                            packageDetailService.reloadManagePackage(vm.packageNo, vm.renewalCount).then(function (result) {
                                    if (result.status) {
                                        init(utilityService.toPascal(result.data));
                                    }

                                },
                                    function (data) {
                                        toastr.error("System is currently not working. Please try after sometime.");
                                        return;
                                    });
                        }
                        
                    }
                    else {
                        toastr.error("System is currently not working. Please try after sometime.");
                    }
                },
                    function (data) {
                        toastr.error("System is currently not working. Please try after sometime.");
                        return;
                    });
        }

        //// resest date for #date-installment-schedule popup
        function resetInstalmetDate() {
            vm.newPaymentDay = - 1;
        }
}

})();;
(function () {
    'use strict';

    angular.module('appUI')
        .service('packageDetailService', ['$rootScope', '$resource', '$q', '$http', '$log', 'apiUrlConstService', packageDetailService]);

    function packageDetailService($rootScope, $resource, $q, $http, $log, apiUrlConstService) {
        return {
            saveMonthlyPackagePaymentDay: saveMonthlyPackagePaymentDay,
            saveAnnualPackagePaymentDate: saveAnnualPackagePaymentDate,
            discardQuote: discardQuote,
            getPackageDetails: getPackageDetails,
            updateExpirationInstallmentDate: updateExpirationInstallmentDate,
            reloadManagePackage: reloadManagePackage
        };

        function saveMonthlyPackagePaymentDay(data) {
            var saveMonthlyPackagePaymentDayApi = $resource(apiUrlConstService.saveMonthlyPackagePaymentDay, {
                packageId: data.PackageId,
                paymentDay: data.PaymentDay
            }, { get: { method: 'POST', isArray: false } });
            return saveMonthlyPackagePaymentDayApi.save(data).$promise;
        };

        function saveAnnualPackagePaymentDate(data) {
            var saveAnnualPackagePaymentDateApi = $resource(apiUrlConstService.saveAnnualPackagePaymentDate, {
                packagePaymentDetails: JSON.stringify(data)
            }, { get: { method: 'POST', isArray: false } });
            return saveAnnualPackagePaymentDateApi.save(data).$promise;
        };

        function discardQuote(data) {
            var discardQuoteApi = $resource(apiUrlConstService.discardQuote, {
                quoteData: data
            }, { get: { method: 'POST', isArray: false } });
            return discardQuoteApi.save(data).$promise;
        };

        function getPackageDetails(data) {
            var getPackageDetailsApi = $resource(apiUrlConstService.getPackageDetails, {
                packageNumber: data
            }, { get: { method: 'GET', isArray: false } });
            return getPackageDetailsApi.get(data).$promise;
        };

        function updateExpirationInstallmentDate(packageData) {
            var PackageManagerApi = $resource(apiUrlConstService.updateExpirationInstallmentDate, {
                packageData: packageData
            }, { get: { method: 'POST', isArray: false } });
            return PackageManagerApi.save().$promise;
        };

        function reloadManagePackage(packageNumber, renewalCounter) {
            var packageUrl = $resource(apiUrlConstService.getPackageDetails, {
                packagenumber: packageNumber,
                renewalCounter: renewalCounter
            }, { get: { method: 'GET', isArray: false } });

            return packageUrl.get().$promise;
        }
    }
})();;
angular.module('appUI')
    .directive("clientView", function () {
        return {
            restrict: 'E',
            scope: {
                firstName: '=firstName',
                lastName: '=lastName',
                email: '=email',
                phoneNumber: '=phoneNumber',
                fax: '=fax'
            },
            templateUrl: 'app/pages/shared/clientView.html'
        }
    });;
/*global angular, moment */
/*jshint globalstrict: true*/
(function () {
    'use strict';

    angular.module('appUI')
        .directive('number', function () {
            return {
                require: 'ngModel',
                link: function (scope, element, attr, ngModelCtrl) {
                    function fromUser(text) {
                        if (text) {
                            var transformedInput = text.replace(/[^0-9]/g, '');

                            if (transformedInput !== text) {
                                ngModelCtrl.$setViewValue(transformedInput);
                                ngModelCtrl.$render();
                            }
                            return transformedInput;
                        }
                        return undefined;
                    }
                    ngModelCtrl.$parsers.push(fromUser);
                }
            };
        })




        .directive("effectiveDatePicker", function () {
            return {
                restrict: "A",
                require: "ngModel",
                scope: {
                    licenseAcquireDay: '=',
                    licenseAcquireMonth: '=',
                    licenseAcquireYear: '=',
                    minBackDays: '=',
                    maxBackDays: '=',
                },
                link: function (scope, elem, attrs, ngModelCtrl) {
                    scope.$watch('licenseAcquireDay', function () {
                        updateOptions(elem, scope);
                    });
                    scope.$watch('licenseAcquireMonth', function () {
                        updateOptions(elem, scope);
                    });
                    scope.$watch('licenseAcquireYear', function () {
                        updateOptions(elem, scope);
                    });

                    var updateModel = function (dateText) {
                        scope.$apply(function () {
                            ngModelCtrl.$setViewValue(dateText);
                            ngModelCtrl.$render();
                        });
                    };
                    var updateOptions = function (elem, scope) {
                        var date = new Date();
                        var currentMonth = date.getMonth();
                        var currentDate = date.getDate();
                        var currentYear = date.getFullYear();
                        var max = new Date(currentYear, currentMonth, currentDate + scope.maxBackDays);
                        //min date set according to the selected product
                        var licenseAcquireDate = new Date(scope.licenseAcquireYear, scope.licenseAcquireMonth - 1, scope.licenseAcquireDay);
                        var backDate = new Date(currentYear, currentMonth, currentDate + scope.minBackDays);
                        var min = "";
                        if (backDate < licenseAcquireDate) {
                            min = licenseAcquireDate;
                        }
                        else {
                            min = backDate;
                        }

                        var options = {
                            dateFormat: "dd/mm/yy",
                            changeMonth: true,
                            changeYear: true,
                            maxDate: max,
                            minDate: min
                        };
                        $(elem).datepicker('destroy');
                        $(elem).datepicker(options);
                    }
                    updateOptions(elem, scope);
                }


            }
        })

        .directive("dashboardDatePicker", function () {
            return {
                restrict: "A",
                require: "ngModel",
                scope: {
                    minBackDays: '=',
                    maxBackDays: '='
                },
                link: function (scope, elem, attrs, ngModelCtrl) {
                    var date = new Date();
                    var currentMonth = date.getMonth();
                    var currentDate = date.getDate();
                    var currentYear = date.getFullYear();
                    var max = new Date(currentYear, currentMonth, currentDate + 60);
                    var min = new Date(currentYear, currentMonth, currentDate - 90);;

                    var updateModel = function (dateText) {
                        scope.$apply(function () {
                            ngModelCtrl.$setViewValue(dateText);
                            ngModelCtrl.$render();
                        });
                    };
                    var options = {
                        dateFormat: "dd/mm/yy",
                        changeMonth: true,
                        changeYear: true,
                        maxDate: max,
                        minDate: min
                        //// defaultDate: "01/01/198",

                    };
                    $(elem).datepicker(options);
                }
            }
        })

        .directive("endorsementEffectiveDatePicker", function () {
            return {
                restrict: "A",
                require: "ngModel",
                link: function (scope, elem, attrs, ngModelCtrl) {
                    var endorsementVM = JSON.parse(attrs.endorsementEffectiveDatePicker);
                    var date = new Date();
                    var currentMonth = date.getMonth();
                    var currentDate = date.getDate();
                    var currentYear = date.getFullYear();
                    var max = new Date(currentYear, currentMonth, currentDate + endorsementVM.EndorsementWindowFromCurrent);
                    var updateModel = function (dateText) {
                        scope.$apply(function () {
                            ngModelCtrl.$setViewValue(dateText);
                            ngModelCtrl.$render();
                        });
                    };
                    var options = {
                        dateFormat: "dd/mm/yy",
                        changeMonth: true,
                        changeYear: true,
                        maxDate: new Date(max),
                        minDate: new Date(endorsementVM.PolicyEffectiveDate)
                        //// defaultDate: "01/01/198",

                    };
                    $(elem).datepicker(options);
                }
            }
        })


        .directive("allowPattern", function () {
            return {
                restrict: "A",
                compile: function (tElement, tAttrs) {
                    return function (scope, element, attrs) {
                        // I handle key events
                        element.bind("keypress", function (event) {
                            var keyCode = event.which || event.keyCode; // I safely get the keyCode pressed from the event.
                            var keyCodeChar = String.fromCharCode(keyCode); // I determine the char from the keyCode.

                            // If the keyCode char does not match the allowed Regex Pattern, then don't allow the input into the field.
                            if (!keyCodeChar.match(new RegExp(attrs.allowPattern, "i"))) {
                                event.preventDefault();
                                return false;
                            }

                        });
                    };
                }
            };
        })

        .directive("expirationDatePicker", function () {
            return {
                restrict: "A",
                require: "ngModel",
                scope: {
                    licenseAcquireDay: '=',
                    licenseAcquireMonth: '=',
                    licenseAcquireYear: '=',
                },
                link: function (scope, elem, attrs, ngModelCtrl) {
                    scope.$watch('licenseAcquireDay', function (newValue, oldValue) {
                        if (newValue !== oldValue)
                            updateOptions(elem, scope);
                    });

                    var updateModel = function (dateText) {
                        scope.$apply(function () {
                            ngModelCtrl.$setViewValue(dateText);
                            ngModelCtrl.$render();
                        });
                    };
                    var updateOptions = function (elem, scope) {
                        var date = new Date();
                        var currentMonth = date.getMonth();
                        var currentDate = date.getDate();
                        var currentYear = date.getFullYear();
                        var max = new Date(currentYear, currentMonth + 2095, currentDate);
                        //min date set according to the selected product
                        var licenseAcquireDate = new Date(scope.licenseAcquireYear, scope.licenseAcquireMonth - 1, scope.licenseAcquireDay);
                        var min = licenseAcquireDate;
                        var options = {
                            dateFormat: "dd/mm/yy",
                            changeMonth: true,
                            changeYear: true,
                            maxDate: max,
                            minDate: min
                        };
                        $(elem).datepicker('destroy');
                        $(elem).datepicker(options);
                    }
                    updateOptions(elem, scope);
                }


            }
        })

        .directive("dateClient", function () {

            return {

                restrict: "A",
                require: "ngModel",
                link: function (scope, elem, attrs, ngModelCtrl) {
                    var date = new Date();
                    var currentMonth = date.getMonth();
                    var currentDate = date.getDate();
                    var currentYear = date.getFullYear();
                    var max = new Date(currentYear, currentMonth, currentDate);
                    console.log(min);
                    var min = new Date(currentYear - 117, currentMonth, currentDate);
                    console.log(max);
                    var updateModel = function (dateText) {
                        scope.$apply(function () {
                            ngModelCtrl.$setViewValue(dateText);
                            ngModelCtrl.$render();
                        });
                    };
                    var options = {
                        dateFormat: "dd/mm/yy",
                        changeMonth: true,
                        changeYear: true,
                        yearRange: "-150:+150",
                        maxDate: max,
                        // defaultDate: "01/01/198",

                    };
                    $(elem).datepicker(options);
                }
            }
        })




        .directive("birthDatePicker", function () {
            return {
                restrict: "A",
                require: "ngModel",
                link: function (scope, elem, attrs, ngModelCtrl) {
                    var updateModel = function (dateText) {
                        scope.$apply(function () {
                            ngModelCtrl.$setViewValue(dateText);
                            ngModelCtrl.$render();
                        });
                    };
                    var options = {
                        dateFormat: "dd/mm/yy",
                        changeMonth: true,
                        changeYear: true,
                        yearRange: "-150:+0",
                        maxDate: new Date()
                        //   defaultDate: "01/01/1998",
                    };
                    //// ngModelCtrl.ctrl.$setViewValue(dateSet);
                    $(elem).datepicker(options);
                }
            }
        })


        .directive('card', function () {
            return {
                require: 'ngModel',
                scope: false,
                transclude: false,
                link: function (scope, elem, attrs, ctrl) {
                    ctrl.$parsers.unshift(function (value) {
                        scope.cctype =
                            (/^5[1-5][0-9]{14}$/.test(value)) ? "mastercard"
                                : (/^4[0-9]{12}(?:[0-9]{3})?$/.test(value)) ? "visa"
                                    : (/^3[47][0-9]{13}$/.test(value)) ? 'amex'
                                        : (/^6(?:011|5[0-9]{2})[0-9]{12}$/.test(value)) ? 'discover'
                                            : (/^3(?:0[0-5]|[68][0-9])[0-9]{11}$/.test(value)) ? 'diners'
                                                : undefined;
                        if (scope.cctype === 'amex' || scope.cctype === 'diners') {
                            ctrl.$setValidity('invalid', false);
                            return value;
                        }
                        ctrl.$setValidity('invalid', true);
                        return value;
                    });
                }
            };
        })
        .directive('cardExpiration', function () {
            return {
                require: 'ngModel', link: function (scope, elem, attrs, ctrl) {
                    scope.$watch('[expMonth,expYear]', function (value) {
                        ctrl.$setValidity('invalid', true);
                        var date = new moment();

                        if (scope.expYear === date.year() && scope.expMonth <= date.month()) {
                            ctrl.$setValidity('invalid', false);
                        }

                        return value;
                    }, true);
                }
            };
        })

        .directive('requiredField', function () {
            return {
                require: 'ngModel',
                link: function (scope, elem, attrs, ctrl) {
                    ctrl.$parsers.unshift(function (value) {
                        ctrl.$setValidity('required', true);
                        var regex = /^.+$/;
                        if (!regex.test(value)) {
                            ctrl.$setValidity('required', false);
                        }
                        return value;
                    });
                }
            };
        })

        .directive('cvv', function () {
            return {
                require: 'ngModel',
                link: function (scope, elem, attrs, ctrl) {
                    ctrl.$parsers.unshift(function (value) {
                        ctrl.$setValidity('required', true);
                        ctrl.$setValidity('cvv', true);

                        // required
                        var regexp1 = /^.+$/;
                        if (!regexp1.test(value)) {
                            ctrl.$setValidity('required', false);
                            return value;
                        }

                        var regexp2 = /^\d{4}$/;
                        if (!regexp2.test(value)) {
                            ctrl.$setValidity('cvv', false);
                            return value;
                        }

                        return value;
                    });
                }
            };
        })

        .directive('limitTo', function () {
            return {
                restrict: "A",
                link: function (scope, elem, attrs) {
                    var limit = parseInt(attrs.limitTo);
                    angular.element(elem).on("keypress", function (e) {
                        if (this.value.length == limit) e.preventDefault();
                    });
                }
            }
        })

        .directive('email', function () {
            return {
                require: 'ngModel',
                link: function (scope, elem, attrs, ctrl) {
                    ctrl.$parsers.unshift(function (value) {

                        ctrl.$setValidity('invalid', true);

                        if (value && value.trim().length > 0) {
                            var regexp2 = /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;

                            if (!regexp2.test(value)) {
                                ctrl.$setValidity('invalid', false);
                            }
                        }

                        return value;
                    });
                }
            };
        })

        .directive('validateSpecialCharacters', function () {
            return {
                require: 'ngModel',
                link: function (scope, elem, attrs, ctrl) {
                    ctrl.$parsers.unshift(function (value) {

                        ctrl.$setValidity('invalid', true);

                        if (value && value.trim().length > 0) {
                            var regexp2 = /^[^`~!@#$%\^*()_+={}|[\]\\:';"<>?,/]*$/;
                            var test = regexp2.test(value);
                            if (!regexp2.test(value)) {
                                ctrl.$setValidity('invalid', false);
                            }
                        }

                        return value;
                    });
                }
            };
        })

        .directive('mobile', function () {
            return {
                require: 'ngModel',
                link: function (scope, elem, attrs, ctrl) {
                    ctrl.$parsers.unshift(function (value) {
                        ctrl.$setValidity('validMobile', true);

                        var regexp2 = /04[\d]{8}/g;
                        if (value != "" && !regexp2.test(value)) {
                            ctrl.$setValidity('validMobile', false);
                            return value;
                        }

                        return value;
                    });
                }
            };
        })

        .directive("numbersOnly", function () {

            return {
                require: 'ngModel',
                link: function (scope, element, attrs, modelCtrl) {
                    modelCtrl.$parsers.push(function (inputValue) {
                        // this next if is necessary for when using ng-required on your input.
                        // In such cases, when a letter is typed first, this parser will be called
                        // again, and the 2nd time, the value will be undefined
                        if (inputValue === undefined) return ''
                        var transformedInput = inputValue.replace(/[^0-9]/g, '');
                        if (transformedInput !== inputValue) {
                            modelCtrl.$setViewValue(transformedInput);
                            modelCtrl.$render();
                        }

                        return transformedInput;
                    });
                }
            };
        })

        .directive("numbersWithHyphenOnly", function () {

            return {
                require: 'ngModel',
                link: function (scope, element, attrs, modelCtrl) {
                    modelCtrl.$parsers.push(function (inputValue) {
                        // this next if is necessary for when using ng-required on your input.
                        // In such cases, when a letter is typed first, this parser will be called
                        // again, and the 2nd time, the value will be undefined
                        if (inputValue === undefined) return ''
                        var transformedInput = inputValue.replace(/[^0-9-]/g, '');
                        if (transformedInput !== inputValue) {
                            modelCtrl.$setViewValue(transformedInput);
                            modelCtrl.$render();
                        }

                        return transformedInput;
                    });
                }
            };
        })


        .directive('validNumber', function () {
            return {
                require: '?ngModel',
                link: function (scope, element, attrs, ngModelCtrl) {

                    element.on('keydown', function (event) {
                        var keyCode = []
                        if (attrs.allowNegative == "true") {
                            keyCode = [8, 9, 36, 35, 37, 39, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 109, 110, 173, 190, 189];
                        }
                        else {
                            var keyCode = [8, 9, 36, 35, 37, 39, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 110, 173, 190];
                        }


                        if (attrs.allowDecimal == "false") {

                            var index = keyCode.indexOf(190);
                            if (index > -1) {
                                keyCode.splice(index, 1);
                            }

                        }

                        if ($.inArray(event.which, keyCode) == -1) event.preventDefault();
                        else {
                            var oVal = ngModelCtrl.$modelValue || '';
                            if ($.inArray(event.which, [109, 173]) > -1 && oVal.indexOf('-') > -1) event.preventDefault();
                            else if ($.inArray(event.which, [110, 190]) > -1 && oVal.indexOf('.') > -1) event.preventDefault();
                        }
                    })
                        .on('blur', function () {

                            if (element.val() == '' || parseFloat(element.val()) === 0.0 || element.val() == '-') {
                                ngModelCtrl.$setViewValue('0.00');
                            }
                            else if (attrs.allowDecimal === "false") {
                                ngModelCtrl.$setViewValue(element.val());
                            }
                            else {
                                if (attrs.decimalUpto) {
                                    var fixedValue = parseFloat(element.val()).toFixed(attrs.decimalUpto);
                                }
                                else { var fixedValue = parseFloat(element.val()).toFixed(2); }
                                ngModelCtrl.$setViewValue(fixedValue);
                            }



                            ngModelCtrl.$render();
                            scope.$apply();
                        });

                    ngModelCtrl.$parsers.push(function (text) {
                        var oVal = ngModelCtrl.$modelValue;
                        var nVal = ngModelCtrl.$viewValue;
                        console.log(nVal);
                        if (parseFloat(nVal) != nVal) {

                            if (nVal === null || nVal === undefined || nVal == '' || nVal == '-') oVal = nVal;

                            ngModelCtrl.$setViewValue(oVal);
                            ngModelCtrl.$render();
                            return oVal;
                        }
                        else {
                            var decimalCheck = nVal.split('.');
                            if (!angular.isUndefined(decimalCheck[1])) {
                                if (attrs.decimalUpto)
                                    decimalCheck[1] = decimalCheck[1].slice(0, attrs.decimalUpto);
                                else
                                    decimalCheck[1] = decimalCheck[1].slice(0, 2);
                                nVal = decimalCheck[0] + '.' + decimalCheck[1];
                            }

                            ngModelCtrl.$setViewValue(nVal);
                            ngModelCtrl.$render();
                            return nVal;
                        }
                    });

                    ngModelCtrl.$formatters.push(function (text) {
                        if (text === '0' || text === null && attrs.allowDecimal === "false") return '0';
                        else if (text === '0' || text === null && attrs.allowDecimal !== "false" && attrs.decimalUpto === undefined) return '0.00';
                        else if (text === '0' || text === null && attrs.allowDecimal !== "false" && attrs.decimalUpto !== undefined) return parseFloat(0).toFixed(attrs.decimalUpto);
                        else if (attrs.allowDecimal !== "false" && attrs.decimalUpto !== undefined) return parseFloat(text).toFixed(attrs.decimalUpto);
                        else return parseFloat(text).toFixed(2);
                    });
                }
            };
        })





        .directive('ngMin', function () {
            return {
                restrict: 'A',
                require: 'ngModel',
                link: function (scope, elem, attr, ctrl) {
                    scope.$watch(attr.ngMin, function () {
                        ctrl.$setViewValue(ctrl.$viewValue);
                    });
                    var minValidator = function (value) {
                        var min = scope.$eval(attr.ngMin) || 0;
                        if (!isEmpty(value) && value < min) {
                            ctrl.$setValidity('ngMin', false);
                            return undefined;
                        } else {
                            ctrl.$setValidity('ngMin', true);
                            return value;
                        }
                    };

                    ctrl.$parsers.push(minValidator);
                    ctrl.$formatters.push(minValidator);
                }
            };
        })

        .directive('ngMax', function () {
            return {
                restrict: 'A',
                require: 'ngModel',
                link: function (scope, elem, attr, ctrl) {
                    scope.$watch(attr.ngMax, function () {
                        ctrl.$setViewValue(ctrl.$viewValue);
                    });
                    var maxValidator = function (value) {
                        var max = scope.$eval(attr.ngMax) || Infinity;
                        if (!isEmpty(value) && value > max) {
                            ctrl.$setValidity('ngMax', false);
                            return undefined;
                        } else {
                            ctrl.$setValidity('ngMax', true);
                            return value;
                        }
                    };

                    ctrl.$parsers.push(maxValidator);
                    ctrl.$formatters.push(maxValidator);
                }
            };
        })

        .directive('numericOnly', function ($filter) {
            return {
                require: 'ngModel',
                link: function (scope, element, attrs, modelCtrl) {

                    element.bind('keyup', function (inputValue, e) {
                        var strinput = modelCtrl.$$rawModelValue;
                        //filter user input
                        var transformedInput = strinput ? strinput.replace(/[^,\d.-]/g, '') : null;
                        if (transformedInput === null) {
                            return;
                        }

                        //remove trailing 0
                        if (transformedInput.charAt(0) <= '0') {
                            transformedInput = null;
                            modelCtrl.$setViewValue(transformedInput);
                            modelCtrl.$render();
                        } else {
                            var decimalSplit = transformedInput.split(".");
                            var intPart = decimalSplit[0];
                            var decPart = decimalSplit[1];
                            //remove previously formated number
                            intPart = intPart.replace(/,/g, "");
                            //split whole number into array of 3 digits
                            if (intPart.length > 3) {
                                var intDiv = Math.floor(intPart.length / 3);
                                var strfraction = [];
                                var i = intDiv,
                                    j = 3;

                                while (intDiv > 0) {
                                    strfraction[intDiv] = intPart.slice(intPart.length - j, intPart.length - (j - 3));
                                    j = j + 3;
                                    intDiv--;
                                }
                                var k = j - 3;
                                if ((intPart.length - k) > 0) {
                                    strfraction[0] = intPart.slice(0, intPart.length - k);
                                }
                            }
                            //join arrays
                            if (strfraction == undefined) { return; }
                            var currencyformat = strfraction.join(',');
                            //check for leading comma
                            if (currencyformat.charAt(0) == ',') {
                                currencyformat = currencyformat.slice(1);
                            }

                            if (decPart == undefined) {
                                modelCtrl.$setViewValue(currencyformat);
                                modelCtrl.$render();
                                return;
                            } else {
                                currencyformat = currencyformat + "." + decPart.slice(0, 2);
                                modelCtrl.$setViewValue(currencyformat);
                                modelCtrl.$render();
                            }
                        }
                    });
                }
            };
        })

        .directive('currencyInput', ['$filter', '$browser', function ($filter, $browser) {
            return {
                require: 'ngModel',
                link: function ($scope, $element, $attrs, ngModelCtrl) {
                    var listener = function () {
                        var value = $element.val().replace(/,/g, '');
                        var inp = $filter('number')(value);
                        var limit = 9;
                        if (value != '' && value != '0') {
                            if (inp !== "") {
                                $element.val(inp);
                                ngModelCtrl.$setValidity('validcurrency', true);
                            }
                            else {
                                $element.val('');
                                ngModelCtrl.$setValidity('validcurrency', false);
                            }
                        }
                        else if (value == '0' || value === "") {
                            $element.val('');
                            ngModelCtrl.$setValidity('validcurrency', false);
                        }
                        else {
                            $element.val(value);
                        }

                        if (value.length > limit) {
                            $element.val('');
                            ngModelCtrl.$setValidity('validcurrency', false);
                        }

                    }

                    // This runs when we update the text field
                    ngModelCtrl.$parsers.push(function (viewValue) {
                        return viewValue.replace(/,/g, '');
                    })

                    // This runs when the model gets updated on the scope directly and keeps our view in sync
                    ngModelCtrl.$render = function () {

                        $element.val($filter('number')(ngModelCtrl.$viewValue))
                        ngModelCtrl.$setValidity('validcurrency', true);
                        if (ngModelCtrl.$modelValue == '0') {
                            $element.val('');
                            ngModelCtrl.$setValidity('validcurrency', false);

                        }

                    }

                    $element.bind('change', listener)
                    $element.bind('keydown', function (event) {
                        var key = event.keyCode
                        // If the keys include the CTRL, SHIFT, ALT, or META keys, or the arrow keys, do nothing.
                        // This lets us support copy and paste too
                        if (key == 91 || (15 < key && key < 19) || (37 <= key && key <= 40))
                            return
                        $browser.defer(listener) // Have to do this or changes don't get picked up properly
                    })

                    $element.bind('paste cut', function () {
                        $browser.defer(listener)
                    })
                }

            }
        }])

        .directive('buildingInput', ['$filter', '$browser', function ($filter, $browser) {
            return {
                require: 'ngModel',
                scope: {
                    buildingCover: '='
                },
                link: function (scope, $element, $attrs, ngModelCtrl) {
                    var listener = function () {
                        var value = $element.val().replace(/,/g, '');
                        var inp = $filter('number')(value);
                        var limit = 9;
                        if (inp === '' || inp === '0') {
                            $element.val('');
                            ngModelCtrl.$setValidity('validcurrency', false);
                        }
                        else {
                            $element.val(inp);
                            ngModelCtrl.viewValue = inp;
                            ngModelCtrl.$setValidity('validcurrency', true);
                        }
                        if (value.length > limit) {
                            $element.val('');
                            ngModelCtrl.$setValidity('validcurrency', false);
                        }
                    }

                    // This runs when we update the text field
                    ngModelCtrl.$parsers.push(function (viewValue) {
                        return viewValue.replace(/,/g, '');
                    })
                    // This runs when the model gets updated on the scope directly and keeps our view in sync
                    ngModelCtrl.$render = function () {
                        $element.val($filter('number')(ngModelCtrl.$viewValue))
                        ngModelCtrl.$setValidity('validcurrency', true);
                        if (scope.buildingCover) {
                            if (ngModelCtrl.$modelValue == '0') {
                                $element.val('');
                                ngModelCtrl.$setValidity('validcurrency', false);

                            }
                        }

                    }

                    $element.bind('change', listener)
                    $element.bind('keydown', function (event) {
                        var key = event.keyCode
                        // If the keys include the CTRL, SHIFT, ALT, or META keys, or the arrow keys, do nothing.
                        // This lets us support copy and paste too
                        if (key == 91 || (15 < key && key < 19) || (37 <= key && key <= 40))
                            return
                        //limiting the user to enter value greater than 999999999 for Building sum insured
                        $browser.defer(listener) // Have to do this or changes don't get picked up properly
                    })

                    $element.bind('paste cut', function () {
                        $browser.defer(listener)
                    })
                }

            }
        }])


        .directive('validAmount', ['$filter', '$browser', function ($filter, $browser) {
            return {
                require: 'ngModel',
                link: function ($scope, $element, $attrs, ngModelCtrl) {
                    var listener = function () {
                        var value = $element.val().replace(/,/g, '');
                        if (value != '' && value != '0') {
                            var inp = $filter('number')(value);
                            $element.val(inp);
                        }
                        else {
                            $element.val(value);
                        }


                    }

                    // This runs when we update the text field
                    ngModelCtrl.$parsers.push(function (viewValue) {
                        return viewValue.replace(/,/g, '');
                    })

                    // This runs when the model gets updated on the scope directly and keeps our view in sync
                    ngModelCtrl.$render = function () {

                        $element.val($filter('number')(ngModelCtrl.$viewValue))
                    }

                    $element.bind('change', listener)
                    $element.bind('keydown', function (event) {
                        var key = event.keyCode
                        // If the keys include the CTRL, SHIFT, ALT, or META keys, or the arrow keys, do nothing.
                        // This lets us support copy and paste too
                        if (key == 91 || (15 < key && key < 19) || (37 <= key && key <= 40))
                            return
                        $browser.defer(listener) // Have to do this or changes don't get picked up properly
                    })

                    $element.bind('paste cut', function () {
                        $browser.defer(listener)
                    })
                }

            }
        }])
        .directive('pasteMatch', function () {
            return {
                restrict: 'A',
                require: "ng-model",
                compile: function (tElement, tAttrs) {

                    return function (scope, element, attrs) {
                        element.bind('input', function () {
                            var res = /^[a-zA-Z0-9'\s]+$/.test(element.val());
                            if (!res) {
                                element.val(null);
                                element.trigger('change');
                            }
                        });
                    };
                }
            };
        })

        .directive("paymentDatePicker", function ($filter, $parse) {
            return {
                restrict: "A",
                require: "ngModel",
                scope: false,
                replace: true,
                transclude: true,
                template: '<input ng-transclude ui-mask="39/19/2999" ui-mask-raw="false" placeholder="DD/MM/YYYY"/>',
                link: function (scope, elem, attrs, ngModelCtrl) {
                    var max = scope.MaxD;
                    var min = scope.MinD;

                    //ngModelCtrl.$setViewValue(scope.date);
                    //ngModelCtrl.$render();

                    var updateModel = function (dateText) {
                        scope.$apply(function () {
                            ngModelCtrl.$setViewValue(dateText);
                            ngModelCtrl.$render();
                        });
                    };
                    var options = {
                        dateFormat: "dd/mm/yy",
                        changeMonth: true,
                        changeYear: true,
                        maxDate: max,
                        minDate: min,
                        defaultDate: scope.date,

                    };
                    $(elem).datepicker(options);

                    scope.limitToValidDate = limitToValidDate;
                    var dateFilter = $filter("date");
                    var today = new Date();
                    var date = {};

                    function isValidMonth(month) {
                        return month >= 0 && month < 12;
                    }

                    function isValidDay(day) {
                        return day > 0 && day < 32;
                    }

                    function isValidYear(year) {
                        return year > (today.getFullYear() - 115) && year < (today.getFullYear() + 115);
                    }

                    function isValidDate(inputDate) {
                        var formattedDate = formatDate(inputDate);
                        var mDate = moment(formattedDate, "DD/MM/YYYY");
                        if (!mDate._isValid) {
                            return false;
                        }
                        inputDate = mDate.toDate();
                        if (!angular.isDate(inputDate)) {
                            return false;
                        }
                        if (inputDate < new Date(2018, 4, 11)) {
                            return false;
                        }

                        date.month = inputDate.getMonth();
                        date.day = inputDate.getDate();
                        date.year = inputDate.getFullYear();
                        return (isValidMonth(date.month) && isValidDay(date.day) && isValidYear(date.year));
                    }

                    function formatDate(newDate) {
                        var modelDate = $parse(attrs.ngModel);
                        newDate = dateFilter(newDate, "dd/MM/yyyy");
                        modelDate.assign(scope, newDate);
                        return newDate;
                    }

                    ngModelCtrl.$validators.date = function (modelValue) {
                        return angular.isDefined(modelValue) && isValidDate(modelValue);
                    };

                    var pattern = "^(0[1-9]|[12][0-9]|3[01])(0[1-9]|1[012])(19|20)\\d\\d$" +
                        "|^(0[1-9]|[12][0-9]|3[01])(0[1-9]|1[012])(19|20)\\d$" +
                        "|^(0[1-9]|[12][0-9]|3[01])(0[1-9]|1[012])(19|20)$" +
                        "|^(0[1-9]|[12][0-9]|3[01])(0[1-9]|1[012])[12]$" +
                        "|^(0[1-9]|[12][0-9]|3[01])(0[1-9]|1[012])$" +
                        "|^(0[1-9]|[12][0-9]|3[01])([0-1])$" +
                        "|^(0[1-9]|[12][0-9]|3[01])$" +
                        "|^([0-3])$";
                    var regexp = new RegExp(pattern);

                    function limitToValidDate(event) {
                        var key = event.charCode ? event.charCode : event.keyCode;
                        if ((key >= 48 && key <= 57) || key === 9 || key === 46) {
                            var character = String.fromCharCode(event.which);
                            var start = element[0].selectionStart;
                            var end = element[0].selectionEnd;
                            var testValue = (element.val().slice(0, start) + character + element.val().slice(end)).replace(/\s|\//g, "");
                            //this code can be used in future if valid regex_pattern is made for validation of DD/MM/YYYY
                            //if (!(regexp.test(testValue))) {
                            //    event.preventDefault();
                            //}
                        }
                    }
                }
            }
        })

        .directive("cancellationEffectiveDatePicker", function ($filter, $parse) {
            return {
                restrict: "A",
                require: "ngModel",
                scope: false,
                replace: true,
                transclude: true,
                template: '<input ng-transclude ui-mask="39/19/2999" ui-mask-raw="false" placeholder="DD/MM/YYYY"/>',
                link: function (scope, elem, attrs, ngModelCtrl) {
                    var min = new Date(attrs['mincancellationdate']);
                    //ngModelCtrl.$setViewValue(scope.date);
                    //ngModelCtrl.$render();

                    var updateModel = function (dateText) {
                        scope.$apply(function () {
                            ngModelCtrl.$setViewValue(dateText);
                            ngModelCtrl.$render();
                        });
                    };
                    var options = {
                        dateFormat: "dd/mm/yy",
                        changeMonth: true,
                        changeYear: true,
                        minDate: min,
                        defaultDate: scope.date,

                    };
                    $(elem).datepicker(options);

                    scope.limitToValidDate = limitToValidDate;
                    var dateFilter = $filter("date");
                    var today = new Date();
                    var date = {};

                    function isValidMonth(month) {
                        return month >= 0 && month < 12;
                    }

                    function isValidDay(day) {
                        return day > 0 && day < 32;
                    }

                    function isValidYear(year) {
                        return year > (today.getFullYear() - 115) && year < (today.getFullYear() + 115);
                    }

                    function isValidDate(inputDate) {
                        var formattedDate = formatDate(inputDate);
                        var mDate = moment(formattedDate, "DD/MM/YYYY");
                        if (!mDate._isValid) {
                            return false;
                        }
                        inputDate = mDate.toDate();
                        if (!angular.isDate(inputDate)) {
                            return false;
                        }
                        if (inputDate < new Date(2018, 4, 11)) {
                            return false;
                        }

                        date.month = inputDate.getMonth();
                        date.day = inputDate.getDate();
                        date.year = inputDate.getFullYear();
                        return (isValidMonth(date.month) && isValidDay(date.day) && isValidYear(date.year));
                    }

                    function formatDate(newDate) {
                        var modelDate = $parse(attrs.ngModel);
                        newDate = dateFilter(newDate, "dd/MM/yyyy");
                        modelDate.assign(scope, newDate);
                        return newDate;
                    }

                    ngModelCtrl.$validators.date = function (modelValue) {
                        return angular.isDefined(modelValue) && isValidDate(modelValue);
                    };

                    var pattern = "^(0[1-9]|[12][0-9]|3[01])(0[1-9]|1[012])(19|20)\\d\\d$" +
                        "|^(0[1-9]|[12][0-9]|3[01])(0[1-9]|1[012])(19|20)\\d$" +
                        "|^(0[1-9]|[12][0-9]|3[01])(0[1-9]|1[012])(19|20)$" +
                        "|^(0[1-9]|[12][0-9]|3[01])(0[1-9]|1[012])[12]$" +
                        "|^(0[1-9]|[12][0-9]|3[01])(0[1-9]|1[012])$" +
                        "|^(0[1-9]|[12][0-9]|3[01])([0-1])$" +
                        "|^(0[1-9]|[12][0-9]|3[01])$" +
                        "|^([0-3])$";
                    var regexp = new RegExp(pattern);

                    function limitToValidDate(event) {
                        var key = event.charCode ? event.charCode : event.keyCode;
                        if ((key >= 48 && key <= 57) || key === 9 || key === 46) {
                            var character = String.fromCharCode(event.which);
                            var start = element[0].selectionStart;
                            var end = element[0].selectionEnd;
                            var testValue = (element.val().slice(0, start) + character + element.val().slice(end)).replace(/\s|\//g, "");
                            //this code can be used in future if valid regex_pattern is made for validation of DD/MM/YYYY
                            //if (!(regexp.test(testValue))) {
                            //    event.preventDefault();
                            //}
                        }
                    }
                }
            }
        })
        .directive("decimalNumberOnly", function () {
            return {
                require: 'ngModel',
                link: function (scope, element, attrs, modelCtrl) {
                    modelCtrl.$parsers.push(function (inputValue) {
                        // this next if is necessary for when using ng-required on your input.
                        // In such cases, when a letter is typed first, this parser will be called
                        // again, and the 2nd time, the value will be undefined
                        if (inputValue === undefined) return ''
                        var transformedInput = inputValue.replace(/[^0-9.]/g, '');
                        if (transformedInput !== inputValue) {
                            modelCtrl.$setViewValue(transformedInput);
                            modelCtrl.$render();
                        }

                        return transformedInput;
                    });
                }
            };
        })

        .directive("reportsDatePicker", function () {
            return {
                restrict: "A",
                require: "ngModel",
                scope: {
                    minBackDays: '=',
                    maxBackDays: '='
                },
                link: function (scope, elem, attrs, ngModelCtrl) {
                    var date = new Date();
                    var currentMonth = date.getMonth();
                    var currentDate = date.getDate();
                    var currentYear = date.getFullYear();
                    var max = new Date(currentYear, currentMonth, currentDate + 60);
                    var min = new Date("2019-03-01");

                    var updateModel = function (dateText) {
                        scope.$apply(function () {
                            ngModelCtrl.$setViewValue(dateText);
                            ngModelCtrl.$render();
                        });
                    };
                    var options = {
                        dateFormat: "dd/mm/yy",
                        maxDate: max,
                        minDate: min

                    };
                    $(elem).datepicker(options);
                }
            }
        })
        .directive("reportsCancellationDatePicker", function () {
            return {
                restrict: "A",
                require: "ngModel",
                scope: {
                    minBackDays: '=',
                    maxBackDays: '='
                },
                link: function (scope, elem, attrs, ngModelCtrl) {
                    var date = new Date();
                    var currentMonth = date.getMonth();
                    var currentDate = date.getDate();
                    var currentYear = date.getFullYear();
                    var max = new Date(currentYear, currentMonth, currentDate + 120);
                    var min = new Date("2018-01-01");

                    var updateModel = function (dateText) {
                        scope.$apply(function () {
                            ngModelCtrl.$setViewValue(dateText);
                            ngModelCtrl.$render();
                        });
                    };
                    var options = {
                        dateFormat: "dd/mm/yy",
                        maxDate: max,
                        minDate: min

                    };
                    $(elem).datepicker(options);
                }
            }
        })

        .directive("reportsUpcomingDueDatePicker", function () {
            return {
                restrict: "A",
                require: "ngModel",
                scope: {
                    minBackDays: '=',
                    maxBackDays: '='
                },
                link: function (scope, elem, attrs, ngModelCtrl) {
                    var date = new Date();
                    var currentMonth = date.getMonth();
                    var currentDate = date.getDate();
                    var currentYear = date.getFullYear();
                    var max = new Date(currentYear, currentMonth, currentDate + 150);
                    var min = new Date("2018-01-01");

                    var updateModel = function (dateText) {
                        scope.$apply(function () {
                            ngModelCtrl.$setViewValue(dateText);
                            ngModelCtrl.$render();
                        });
                    };
                    var options = {
                        dateFormat: "dd/mm/yy",
                        maxDate: max,
                        minDate: min

                    };
                    $(elem).datepicker(options);
                }
            }
        })

        //for version 2 Renovation END dates for home and LAndlord Standard

        .directive("anyDatePicker", function () {
            return {
                restrict: "A",
                require: "ngModel",
                scope: {
                    minBackDays: '=',
                    maxBackDays: '='
                },
                link: function (scope, elem, attrs, ngModelCtrl) {
                    var options = {
                        dateFormat: "dd/mm/yy"
                    };
                    $(elem).datepicker(options);
                }
            }
        })

        // for capital benefit cover of PA accepting 0 
        .directive('coverInput', ['$filter', '$browser', function ($filter, $browser) {
            return {
                require: 'ngModel',
                link: function ($scope, $element, $attrs, ngModelCtrl) {
                    var listener = function () {
                        var value = $element.val().replace(/,/g, '');
                        var inp = $filter('number')(value);
                        var limit = 9;
                        if (value != '' && value != '0') {
                            if (inp !== "") {
                                $element.val(inp);
                                ngModelCtrl.$setValidity('validcurrency', true);
                            }
                            else {
                                $element.val('');
                                ngModelCtrl.$setValidity('validcurrency', false);
                            }
                        }
                        else if (value === "") {
                            $element.val('');
                            ngModelCtrl.$setValidity('validcurrency', false);
                        }
                        else {
                            $element.val(value);
                        }

                        if (value.length > limit) {
                            $element.val('');
                            ngModelCtrl.$setValidity('validcurrency', false);
                        }

                    }

                    // This runs when we update the text field
                    ngModelCtrl.$parsers.push(function (viewValue) {
                        return viewValue.replace(/,/g, '');
                    })

                    // This runs when the model gets updated on the scope directly and keeps our view in sync
                    ngModelCtrl.$render = function () {

                        $element.val($filter('number')(ngModelCtrl.$viewValue))
                        ngModelCtrl.$setValidity('validcurrency', true);
                        

                       

                    }

                    $element.bind('change', listener)
                    $element.bind('keydown', function (event) {
                        var key = event.keyCode
                        // If the keys include the CTRL, SHIFT, ALT, or META keys, or the arrow keys, do nothing.
                        // This lets us support copy and paste too
                        if (key == 91 || (15 < key && key < 19) || (37 <= key && key <= 40))
                            return
                        $browser.defer(listener) // Have to do this or changes don't get picked up properly
                    })

                    $element.bind('paste cut', function () {
                        $browser.defer(listener)
                    })
                }

            }
        }])



    function isEmpty(value) {
        return angular.isUndefined(value) || value === '' || value === null || value !== value;
    }

}());;
(function () {
    'use strict';

    app.directive("bzGroup", bzGroup);


    function bzGroup() {
        return {
            restrict: "E",
            templateUrl: 'app/pages/questions/group.html',
            scope:
            {
                group: '=',
                curPage: '=?',
                broadcastHideShow: '=?'
            },
            link: function (scope) {
                scope.broadcastHideShow = broadcastHideShow;


                function broadcastHideShow(questionId,selectedData) {
                    console.log('bzGroup.In broadcastHideShow', this);
                    console.log('bzGroup.In broadcastHideShow: data', selectedData);
                    //console.log('In selected value:', scope.question.SelectedValue);
                    //create the event in name of the questionCode
                    var eventName = questionId + "HideShowEvent";
                    console.log('eventName to broadcast', eventName);
                    scope.$broadcast(eventName, selectedData);

                }
            }
        }
    }

})();;
(function () {
    'use strict';

    app.directive("bzQuestions", bzQuestion);


    function bzQuestion() {
        return {
            restrict: "E",
            templateUrl: 'app/pages/questions/question.html',
            scope:
            {
                question: '=',
                isHiddable: '=?',
                hideExpression: '=?',
                columnWidth: '=?',
                isHidden: '=?',
                broadcast: '&'
            },
            link: function (scope) {
                //console.log(scope.question);

                scope.isHidden = scope.question.IsHidden;
                scope.isHiddable = scope.question.IsHiddable;
                scope.hideExpression = scope.question.AngularHideExpressions;
                //scope.broadcastHideShow = broadcastHideShow;
                scope.InitializeListenHideShow = InitializeListenHideShow;

                //is question Hiddable the register the code for the listening the broadcast event of his parent/dependant question.
                if (scope.isHiddable) {
                    InitializeListenHideShow();
                }


                //listen only if question hiddenToggle happens...
                function InitializeListenHideShow() {
                    //parse the angular hideExpression in order to find the parent/dependant questionCode
                    console.log('InitializeListenHideShow linking scope.hideExpression value', scope.hideExpression);
                    var hideExpressionString = "";
                    hideExpressionString = scope.hideExpression;
                    hideExpressionString = hideExpressionString.trim();
                    if (hideExpressionString.includes('==')) {
                        var operands = hideExpressionString.split('==');

                        console.log('operands', operands);

                        var questionId = operands[0];
                        var questionSelectValue = operands[1];

                        //create the eventName in the name of question's ParentId
                        var eventName = questionId + "HideShowEvent";
                        //console.log('eventName to listen', eventName);

                        //register this question listen for the above event which will be broadcasted by parent
                        scope.$on(eventName, function (evt, data) {
                            console.log('listiningEvent', eventName, this, evt, data);
                            if (questionSelectValue == data.Label.toLowerCase()) {
                                //show this question
                                scope.isHidden = false;
                                scope.question.IsHidden = false;
                            }
                            else {
                                //hide this question
                                scope.isHidden = true;
                                scope.question.IsHidden = true;
                            }

                        });
                    }

                }

                //handle the desgin of question
                var singlecolumn = scope.question.SingleColumn;
                var doublecolumn = scope.question.DoubleColumn;
                var triplecolumn = scope.question.TripleColumn;

                if (singlecolumn == true) {
                    scope.columnWidth = "col-sm-12 col-md-12";
                }
                else if (doublecolumn == true) {
                    scope.columnWidth = "col-sm-6 col-md-6";
                }
                else if (triplecolumn == true) {
                    scope.columnWidth = "col-sm-4 col-md-4";
                }
            } //end Link
        }//end return
    }//end bzQuestion

})();;
(function () {
    'use strict';
    app.directive("bzSubgroup", bzSubGroup);

    function bzSubGroup() {
        return {
            restrict: "E",
            templateUrl: 'app/pages/questions/subGroup.html',
            scope:
            {
                subgroup: '=',
                initsubgroup:'='
            }
        }
    }
})();;
(function () {
    'use strict';

    app.directive("bzMatrix", bzMatrix);


    function bzMatrix() {
        return {
            restrict: "E",
            templateUrl: 'app/pages/questions/matrix.html',
            scope:
            {
                //questions: '=',
                question: '=',
                columnWidth: '=?',
            },
            link: function (scope) {
                var singlecolumn = scope.question.SingleColumn;
                var doublecolumn = scope.question.DoubleColumn;
                var triplecolumn = scope.question.TripleColumn;

                if (singlecolumn == true) {
                    scope.columnWidth = "col-sm-12 col-md-12";
                }
                else if (doublecolumn == true) {
                    scope.columnWidth = "col-sm-6 col-md-6";
                }
                else if (triplecolumn == true) {
                    scope.columnWidth = "col-sm-4 col-md-4";
                }
            }
        }
    }

})();;
angular.module('appUI')
    .directive("loader", function ($rootScope) {
        return function ($scope, element, attrs) {
            $scope.$on("loader_show", function () {
                return element.show();
            });
            return $scope.$on("loader_hide", function () {
                return element.hide();
            });
        };
    });;
(function () {
    'use strict';

    angular.module('appUI').controller('myController', myController).directive('manualDateMask', dateInput);
    angular.module('appUI').directive('manualEffectiveDateMask', manualEffectiveDateMask);

    myController.$inject = ['$scope'];
    function myController($scope) {
        $scope.date = "";
    }
    
    manualEffectiveDateMask.$inject = ["$filter", "$parse"];
    function manualEffectiveDateMask($filter, $parse) {
        return {
            restrict: 'A',
            require: 'ngModel',
            replace: true,
            transclude: true,
            template: '<input ng-transclude ui-mask="39/19/2999" ui-mask-raw="false" ng-keypress="limitToValidDate($event)" placeholder="DD/MM/YYYY"/>',
            link: function (scope, element, attrs, controller) {
                scope.limitToValidDate = limitToValidDate;
                var dateFilter = $filter("date");
                var today = new Date();
                var date = {};

                function isValidMonth(month) {
                    return month >= 0 && month < 12;
                }

                function isValidDay(day) {
                    return day > 0 && day < 32;
                }

                function isValidYear(year) {
                    return year > (today.getFullYear() - 115) && year < (today.getFullYear() + 115);
                }

                function isValidDate(inputDate) {
                    var formattedDate = formatDate(inputDate);
                    var mDate = moment(formattedDate, "DD/MM/YYYY");
                    if (!mDate._isValid) {
                        return false;
                    }
                    inputDate = mDate.toDate();
                    if (!angular.isDate(inputDate)) {
                        return false;
                    }
                    if (inputDate < new Date(2018, 4, 11)) {
                        return false;
                    }

                    date.month = inputDate.getMonth();
                    date.day = inputDate.getDate();
                    date.year = inputDate.getFullYear();
                    return (isValidMonth(date.month) && isValidDay(date.day) && isValidYear(date.year));
                }

                function formatDate(newDate) {
                    var modelDate = $parse(attrs.ngModel);
                    newDate = dateFilter(newDate, "dd/MM/yyyy");
                    modelDate.assign(scope, newDate);
                    return newDate;
                }

                controller.$validators.date = function (modelValue) {
                    return angular.isDefined(modelValue) && isValidDate(modelValue);
                };

                var pattern = "^(0[1-9]|[12][0-9]|3[01])(0[1-9]|1[012])(19|20)\\d\\d$" +
                    "|^(0[1-9]|[12][0-9]|3[01])(0[1-9]|1[012])(19|20)\\d$" +
                    "|^(0[1-9]|[12][0-9]|3[01])(0[1-9]|1[012])(19|20)$" +
                    "|^(0[1-9]|[12][0-9]|3[01])(0[1-9]|1[012])[12]$" +
                    "|^(0[1-9]|[12][0-9]|3[01])(0[1-9]|1[012])$" +
                    "|^(0[1-9]|[12][0-9]|3[01])([0-1])$" +
                    "|^(0[1-9]|[12][0-9]|3[01])$" +
                    "|^([0-3])$";
                var regexp = new RegExp(pattern);

                function limitToValidDate(event) {
                    var key = event.charCode ? event.charCode : event.keyCode;
                    if ((key >= 48 && key <= 57) || key === 9 || key === 46) {
                        var character = String.fromCharCode(event.which);
                        var start = element[0].selectionStart;
                        var end = element[0].selectionEnd;
                        var testValue = (element.val().slice(0, start) + character + element.val().slice(end)).replace(/\s|\//g, "");
                        //this code can be used in future if valid regex_pattern is made for validation of DD/MM/YYYY
                        //if (!(regexp.test(testValue))) {
                        //    event.preventDefault();
                        //}
                    }
                }
            }
        }
    }

    dateInput.$inject = ["$filter", "$parse"];
    function dateInput($filter, $parse) {
        return {
            restrict: 'A',
            require: 'ngModel',
            replace: true,
            transclude: true,
            template: '<input ng-transclude ui-mask="39/19/2999" ui-mask-raw="false" ng-keypress="limitToValidDate($event)" placeholder="DD/MM/YYYY"/>',
            link: function (scope, element, attrs, controller) {
                var isRequired = scope.$eval(attrs.isRequired);
                scope.limitToValidDate = limitToValidDate;
                var dateFilter = $filter("date");
                var today = new Date();
                var date = {};

                function isValidMonth(month) {
                    return month >= 0 && month < 12;
                }

                function isValidDay(day) {
                    return day > 0 && day < 32;
                }

                function isValidYear(year) {
                    return year > (today.getFullYear() - 115) && year < (today.getFullYear() + 115);
                }

                function isValidDate(inputDate) {
                    var formattedDate = formatDate(inputDate);
                    var mDate = moment(formattedDate, "DD/MM/YYYY");
                    if (!mDate._isValid) {
                        return false;
                    }
                    inputDate = mDate.toDate();
                    if (!angular.isDate(inputDate)) {
                        return false;
                    }

                    date.month = inputDate.getMonth();
                    date.day = inputDate.getDate();
                    date.year = inputDate.getFullYear();
                    return (isValidMonth(date.month) && isValidDay(date.day) && isValidYear(date.year));
                }

                function formatDate(newDate) {
                    var modelDate = $parse(attrs.ngModel);
                    newDate = dateFilter(newDate, "dd/MM/yyyy");
                    modelDate.assign(scope, newDate);
                    return newDate;
                }

                controller.$validators.date = function (modelValue) {
                    // in case, date is not mandatory , this directive set form to invalid because it return false, 
                    // so now if date is not required then we return true.
                    // In Edit, if Date of Esstablishment contain date then date does not convert into correct date so 
                    // i put model value check
                    if (isRequired === false && !modelValue) {
                        return true;
                    }
                    return angular.isDefined(modelValue) && isValidDate(modelValue);
                };

                var pattern = "^(0[1-9]|[12][0-9]|3[01])(0[1-9]|1[012])(19|20)\\d\\d$" +
                    "|^(0[1-9]|[12][0-9]|3[01])(0[1-9]|1[012])(19|20)\\d$" +
                    "|^(0[1-9]|[12][0-9]|3[01])(0[1-9]|1[012])(19|20)$" +
                    "|^(0[1-9]|[12][0-9]|3[01])(0[1-9]|1[012])[12]$" +
                    "|^(0[1-9]|[12][0-9]|3[01])(0[1-9]|1[012])$" +
                    "|^(0[1-9]|[12][0-9]|3[01])([0-1])$" +
                    "|^(0[1-9]|[12][0-9]|3[01])$" +
                    "|^([0-3])$";
                var regexp = new RegExp(pattern);

                function limitToValidDate(event) {
                    var key = event.charCode ? event.charCode : event.keyCode;
                    if ((key >= 48 && key <= 57) || key === 9 || key === 46) {
                        var character = String.fromCharCode(event.which);
                        var start = element[0].selectionStart;
                        var end = element[0].selectionEnd;
                        var testValue = (element.val().slice(0, start) + character + element.val().slice(end)).replace(/\s|\//g, "");
                        //this code can be used in future if valid regex_pattern is made for validation of DD/MM/YYYY
                        //if (!(regexp.test(testValue))) {
                        //    event.preventDefault();
                        //}
                    }
                }
            }
        }
    }

})();;
var app = angular.module('appUI');


app.directive('fileModel', ['$parse', function ($parse) {
    return {
        restrict: 'A',
        link: function (scope, element, attrs) {
            var model = $parse(attrs.ngModel);
            var modelSetter = model.assign;
            element.bind('change', function () {
                scope.$apply(function () {
                    model = element[0].files[0];
                    modelSetter(scope, model);
                });
            });
        }
    };
}]);;
(function () {
    'use strict';

    var appUI = angular.module('appUI');

    appUI.controller('reportsCtrl', ["$scope", "$rootScope", "$http", "$window", "Blob", "FileSaver", "uiGridConstants", "keyConstService", "dateService", "sessionStorageService", "reportsService", "apiUrlConstService", "cancellationService", 'portalV2Service', reportsCtrl]);

    function reportsCtrl($scope, $rootScope, $http, $window, Blob, FileSaver, uiGridConstants, keyConstService, dateService, sessionStorageService, reportsService, apiUrlConstService, cancellationService, portalV2Service) {

        var vm = this;
        var model = null;
        vm.scope = $rootScope;
        vm.data = null;

        vm.init = init;
        vm.activestatus = false;
        vm.activestatusCancellationPolicies = false;
        vm.activestatusClaimHistory = false;
        vm.toggleIcon = toggleIcon;
        vm.toggleIconCancellationPolicies = toggleIconCancellationPolicies;
        vm.toggleIconClaimHistory = toggleIconClaimHistory;
        vm.generateReport = generateReport;
        vm.generateDueAnnualPolicyReport = generateDueAnnualPolicyReport;
        vm.searchReport = searchReport;
        vm.generateClaimHistoryExcel = generateClaimHistoryExcel;
        vm.generateDueAnnualPolicyReport = generateDueAnnualPolicyReport;
        vm.searchUpcomingDue = searchUpcomingDue;
        vm.searchReportClaimHistory = searchReportClaimHistory;
        vm.showData = false;
        vm.showDataCancellationPolicies = false;
        vm.showDataClaimHistory = false;
        vm.dateQuery = dateQuery;
        vm.onSelectionChange = onSelectionChange;
        $scope.getParamEncrytion = getParamEncrytion;
        vm.FromDate = moment(new Date(new Date().setDate(new Date().getDate() - 60))).format("DD/MM/YYYY");
        vm.ToDate = moment(new Date(new Date().setDate(new Date().getDate() + 60))).format("DD/MM/YYYY");
        vm.Selection = "2";
        vm.activestatusUpcomingDue = false;
        vm.dateQueryCancellation = dateQueryCancellation;
        vm.showDataUpcomingDue = false;
        vm.toggleIconUpcomingDue = toggleIconUpcomingDue;
        vm.dateQueryUpcomingDue = dateQueryUpcomingDue;
        vm.downloadClaimHistoryDoc = downloadClaimHistoryDoc;
        $scope.renewal = {};
        vm.PolicyNumber = null;
        vm.ReportsData = {
            RR: { title: "Renewals/Replacements", isActive: true },
            CP: { title: "Cancelled policies (across all underwriters)", isActive: true },
            CH: { title: "Claims History", isActive: false },
            AP: { title: "Upcoming Due - Annual policies", isActive: false }            
        }
        vm.BrokerPortalV2Debugging = false;

        function init(data) {
            vm.BrokerPortalV2Debugging = false;
            sessionStorageService.remove(keyConstService.CopyQuoteOldTransactionId);
            sessionStorageService.remove(keyConstService.IsRenewalPolicy);
            sessionStorageService.remove(keyConstService.IsCopyQuote);
            for (let i = 0; i < data.length; i++) {
                let currentitem = data[i];
                switch (currentitem.code) {
                    case "RR":
                        vm.ReportsData.RR = {
                            title: currentitem.title,
                            isActive: ((currentitem.isBranchActive == null ? vm.ReportsData.RR.isActive : currentitem.isBranchActive)
                                && currentitem.isReportActive)
                        };
                        break;
                    case "AP":
                        vm.ReportsData.AP = {
                            title: currentitem.title,
                            isActive: ((currentitem.isBranchActive == null ? vm.ReportsData.AP.isActive : currentitem.isBranchActive)
                                && currentitem.isReportActive)
                        };
                        break;
                    case "CP":
                        vm.ReportsData.CP = {
                            title: currentitem.title,
                            isActive: ((currentitem.isBranchActive == null ? vm.ReportsData.CP.isActive : currentitem.isBranchActive)
                                && currentitem.isReportActive)
                        };
                        break;
                    case "CH":
                        vm.ReportsData.CH = {
                            title: currentitem.title,
                            isActive: ((currentitem.isBranchActive == null ? vm.ReportsData.CH.isActive : currentitem.isBranchActive)
                                && currentitem.isReportActive)
                        };
                        break;
                    default:
                        break;
                }
            }
        }

        function toggleIcon() {
            vm.Status = "4";
            $scope.renewalData = null;
            $scope.cancellationReportData = null;
            $scope.upcomingDueAnnualPoliciesData = null;
            $scope.claimHistoryData = null;
            vm.showData = false;
            vm.showDataCancellationPolicies = false;
            vm.showDataUpcomingDue = false;
            vm.activestatus = !vm.activestatus;
            vm.activestatusCancellationPolicies = false;
            vm.activestatusUpcomingDue = false;
            vm.showDataClaimHistory = false;
            vm.activestatusClaimHistory = false;
            vm.PolicyNumber = null;
            vm.FromDate = moment(new Date(new Date().setDate(new Date().getDate() - 60))).format("DD/MM/YYYY");
            vm.ToDate = moment(new Date(new Date().setDate(new Date().getDate() + 60))).format("DD/MM/YYYY");
            if (!$("#collapseCancellationPolicies").hasClass('collapse')) {
                $("#collapseCancellationPolicies").removeClass('in');
                $("#collapseCancellationPolicies").addClass('collapse');
            }
            if ($("#headingCancellationPolicies").hasClass('active')) {
                $("#headingCancellationPolicies").removeClass('active');
            }
            if (!$("#collapseUpcomingDue").hasClass('collapse')) {
                $("#collapseUpcomingDue").removeClass('in');
                $("#collapseUpcomingDue").addClass('collapse');
            }
            if ($("#headingUpcomingDue").hasClass('active')) {
                $("#headingUpcomingDue").removeClass('active');
            }
            if (!$("#collapseClaimHistory").hasClass('collapse')) {
                $("#collapseClaimHistory").removeClass('in');
                $("#collapseClaimHistory").addClass('collapse');
            }
            if ($("#headingClaimHistory").hasClass('active')) {
                $("#headingClaimHistory").removeClass('active');
            }
        }

        function toggleIconCancellationPolicies() {
            $scope.renewalData = null;
            $scope.cancellationReportData = null;
            $scope.upcomingDueAnnualPoliciesData = null;
            $scope.claimHistoryData = null;
            vm.Status = null;
            vm.showData = false;
            vm.showDataCancellationPolicies = false;
            vm.showDataUpcomingDue = false;
            vm.activestatusCancellationPolicies = !vm.activestatusCancellationPolicies;
            vm.activestatus = false;
            vm.activestatusUpcomingDue = false;
            vm.showDataClaimHistory = false;
            vm.activestatusClaimHistory = false;
            vm.PolicyNumber = null;
            vm.FromDate = moment(new Date(new Date().setDate(new Date().getDate() - 60))).format("DD/MM/YYYY");
            vm.ToDate = moment(new Date(new Date().setDate(new Date().getDate() + 60))).format("DD/MM/YYYY");
            if (!$("#collapse").hasClass('collapse')) {
                $("#collapse").removeClass('in');
                $("#collapse").addClass('collapse');
            }
            if ($("#heading").hasClass('active')) {
                $("#heading").removeClass('active');
            }
            if (!$("#collapseUpcomingDue").hasClass('collapse')) {
                $("#collapseUpcomingDue").removeClass('in');
                $("#collapseUpcomingDue").addClass('collapse');
            }
            if ($("#headingUpcomingDue").hasClass('active')) {
                $("#headingUpcomingDue").removeClass('active');
            }
            if (!$("#collapseClaimHistory").hasClass('collapse')) {
                $("#collapseClaimHistory").removeClass('in');
                $("#collapseClaimHistory").addClass('collapse');
            }
            if ($("#headingClaimHistory").hasClass('active')) {
                $("#headingClaimHistory").removeClass('active');
            }

        }

        function toggleIconUpcomingDue() {
            $scope.renewalData = null;
            $scope.cancellationReportData = null;
            $scope.upcomingDueAnnualPoliciesData = null;
            vm.Status = null;
            vm.showData = false;
            vm.showDataCancellationPolicies = false;
            vm.showDataUpcomingDue = false;
            vm.activestatusUpcomingDue = !vm.activestatusUpcomingDue;
            vm.activestatusCancellationPolicies = false;
            vm.activestatus = false;
            $scope.claimHistoryData = null;
            vm.showDataClaimHistory = false;
            vm.activestatusClaimHistory = false;
            vm.PolicyNumber = null;
            vm.FromDate = moment(new Date(new Date().setDate(new Date().getDate() - 60))).format("DD/MM/YYYY");
            vm.ToDate = moment(new Date(new Date().setDate(new Date().getDate() + 60))).format("DD/MM/YYYY");
            if (!$("#collapse").hasClass('collapse')) {
                $("#collapse").removeClass('in');
                $("#collapse").addClass('collapse');
            }
            if ($("#heading").hasClass('active')) {
                $("#heading").removeClass('active');
            }
            if (!$("#collapseCancellationPolicies").hasClass('collapse')) {
                $("#collapseCancellationPolicies").removeClass('in');
                $("#collapseCancellationPolicies").addClass('collapse');
            }
            if ($("#headingCancellationPolicies").hasClass('active')) {
                $("#headingCancellationPolicies").removeClass('active');
            }
            if (!$("#collapseClaimHistory").hasClass('collapse')) {
                $("#collapseClaimHistory").removeClass('in');
                $("#collapseClaimHistory").addClass('collapse');
            }
            if ($("#headingClaimHistory").hasClass('active')) {
                $("#headingClaimHistory").removeClass('active');
            }
        }

        function toggleIconClaimHistory() {
            $scope.renewalData = null;
            $scope.cancellationReportData = null;
            $scope.upcomingDueAnnualPoliciesData = null;
            $scope.claimHistoryData = null;
            vm.Status = null;
            vm.showData = false;
            vm.showDataCancellationPolicies = false;
            vm.showDataUpcomingDue = false;
            vm.activestatusUpcomingDue = false;
            vm.activestatusCancellationPolicies = false;
            vm.activestatus = false;
            vm.showDataClaimHistory = false;
            vm.PolicyNumber = null;
            vm.activestatusClaimHistory = !vm.activestatusClaimHistory;
            if (!$("#collapse").hasClass('collapse')) {
                $("#collapse").removeClass('in');
                $("#collapse").addClass('collapse');
            }
            if ($("#heading").hasClass('active')) {
                $("#heading").removeClass('active');
            }
            if (!$("#collapseCancellationPolicies").hasClass('collapse')) {
                $("#collapseCancellationPolicies").removeClass('in');
                $("#collapseCancellationPolicies").addClass('collapse');
            }
            if ($("#headingCancellationPolicies").hasClass('active')) {
                $("#headingCancellationPolicies").removeClass('active');
            }
            if (!$("#collapseUpcomingDue").hasClass('collapse')) {
                $("#collapseUpcomingDue").removeClass('in');
                $("#collapseUpcomingDue").addClass('collapse');
            }
            if ($("#headingUpcomingDue").hasClass('active')) {
                $("#headingUpcomingDue").removeClass('active');
            }
        }

        //add this functionality for sorting date(cancellationEffectiveDate, effectiveDate, expirationDate) in ui-grid
        $scope.links = {
            sortFun: function (firstDate, secondDate) {
                if (firstDate != null && secondDate != null) {
                    var pattern = /(\d{2})\/(\d{2})\/(\d{4})/;
                    var getFirstDateType = new Date(firstDate.replace(pattern, '$3-$2-$1'));
                    var getSeondDateType = new Date(secondDate.replace(pattern, '$3-$2-$1'));
                    return getFirstDateType - getSeondDateType;
                }
            }
        };
        $scope.gridUpcomingDue = {
            paginationPageSize: 15,
            enablePagination: true,
            paginationPageSizes: [15, 20, 30],
            enableSorting: true,
            rowHeight: 55,
            enableFiltering: false,
            enableRowHeaderSelection: false,
            enableColumnMenus: false,
            gridMenuShowHideColumns: false,
            enableHiding: false,
            data: null,
            columnDefs: [
                { name: 'packageNumber', width: "225" },
                { name: 'policyNumber', field: 'policyNumber', width: "225" },
                { name: 'insuredName', width: "195" },
                {
                    name: 'effectiveDate', field: 'effectiveDate', width: "230",
                    'sortingAlgorithm': $scope.links.sortFun
                },
                { name: 'processName', cellClass: 'text-left', width: "230" },
                { name: 'branchName', cellClass: 'text-left', width: "230" },
                { name: 'product', cellClass: 'text-left', width: "230" },
                { name: 'totalPremiumDue', field: 'totalPremiumDue', width: "230" },
                { name: 'totalReceived', field: 'totalReceived', width: "230" },
                { name: 'brokerName', cellClass: 'text-left', width: "230" },
                { name: 'brokerEmailId', cellClass: 'text-left', width: "230" }
                ],
        };

        $scope.gridClaimHistory = {
            paginationPageSize: 15,
            enablePagination: true,
            paginationPageSizes: [15, 20, 30],
            enableSorting: true,
            rowHeight: 55,
            enableFiltering: false,
            enableRowHeaderSelection: false,
            enableColumnMenus: false,
            gridMenuShowHideColumns: false,
            enableHiding: false,
            data: null,
            columnDefs: [
                { name: 'policyNumber', width: "185" },
                { name: 'packageNumber', width: "185" },
                { name: 'insuredName', width: "185" },
                { name: 'startDate', width: "185", cellFilter: 'date:\'dd-MM-yyyy\'' },
                { name: 'endDate', width: "185", cellFilter: 'date:\'dd-MM-yyyy\'' },
                {
                    name: 'action', cellClass: 'text-left', width: "175", cellTemplate: getDownloadDocumentLink()}
            ],
        };

        function getDownloadDocumentLink() {
            return '<div class="ui-grid-cell-contents"><a ng-click="grid.appScope.vm.downloadClaimHistoryDoc(row.entity.policyNumber)">Download Document</a></div>';
        }

        function downloadClaimHistoryDoc(policyNumber) {
            return $http
                ({
                    url: "/MediaProxy/Report/GenerateClaimHistoryDocument?policyNumber=" + policyNumber,
                    method: "GET",
                    responseType: 'blob'
                })
                .then(function (result) {
                    var blob = new Blob([result.data], { type: [result.data.type] });
                    var fileName;
                    fileName = "Claims_History_" +policyNumber + ".pdf";
                    console.log(fileName);
                    FileSaver.saveAs(blob, fileName);
                    return result.data;
                },
                    function (data) {
                        toastr.error("System is currently not working. Please try after sometime.");
                        return;
                    });
        }

        $scope.gridCancellationPolicies = {
            paginationPageSize: 15,
            enablePagination: true,
            paginationPageSizes: [15, 20, 30],
            enableSorting: true,
            rowHeight: 55,
            enableFiltering: false,
            enableRowHeaderSelection: false,
            enableColumnMenus: false,
            gridMenuShowHideColumns: false,
            enableHiding: false,
            data: null,
            columnDefs: [
                { name: 'packageNumber', width: "225" },
                { name: 'insuredName', width: "195" },
                { name: 'policyNumber', field: 'policyNumber', width: "225" },
                {
                    name: 'cancellationEffectiveDate', field: 'cancellationEffectiveDate', width: "230",
                    'sortingAlgorithm': $scope.links.sortFun
                },
                { name: 'status', width: "200" },
                { name: 'policyTerm', field: 'policyTerm', width: "180" },
                { name: 'product', cellClass: 'text-left', width: "230" },
                { name: 'paymentType', width: "200" },
                { name: 'brokerManagedPayment', width: "225" },
                { name: 'brokerName', cellClass: 'text-left', width: "230" },
                { name: 'brokerEmailId', cellClass: 'text-left', width: "230" },
                { name: 'cancellationReason', cellClass: 'text-left', width: "350" }

            ],
        };

        $scope.gridOptions = {
            paginationPageSize: 15,
            enablePagination: true,
            paginationPageSizes: [15, 20, 30],
            enableSorting: true,
            rowHeight: 55,
            enableFiltering: false,
            enableRowHeaderSelection: false,
            enableColumnMenus: false,
            gridMenuShowHideColumns: false,
            enableHiding: false,
            data: null,
            columnDefs: [
                { name: 'packageNumber', width: "225" },
                { name: 'policyNumber', field: 'policyNumber', width: "225" },
                { name: 'insuredName', width: "195" },
                { name: 'quoteNumber', cellTemplate: getQuoteLink(), width: "225" },
                {
                    name: 'effectiveDate', field: 'effectiveDate', width: "200",
                    'sortingAlgorithm': $scope.links.sortFun
                },
                { name: 'renewal/ replacement Status', width: "300", field: 'renewalStatus' },
                { name: 'renewal/ replacement Quote Status', width: "300", field: 'renewalQuoteStatus' },
                { name: 'policyTerm', field: 'policyTerm', width: "180" },
                { name: 'product', cellClass: 'text-left', width: "230" },
                { name: 'brokerName', cellClass: 'text-left', width: "230" },
                { name: 'brokerEmailId', cellClass: 'text-left', width: "230" },
                {
                    name: 'expirationDate', field: 'expirationDate', cellClass: 'text-left', width: "230",
                    'sortingAlgorithm': $scope.links.sortFun
                },
                { name: 'caseNumber', field: 'caseNumber', visible: false },
                { name: 'quoteStatus', field: 'quoteStatus', visible: false }
            ],
            actionList: [
                { label: "View", icon: "glyphicon-eye-open", href: 'policies/view/{{row.policyNumber}}' }
            ]

        };

        function getQuoteLink() {
            return '<div class="ui-grid-cell-contents"><a ng-if=\'row.entity.processType === "CANCELLATION" && row.entity.quoteNumber !== null\' ng-click="grid.appScope.getParamEncrytion(1,row.entity.quoteTransactionId)"> {{row.entity.quoteNumber}}</a>' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.quoteNumber == null && row.entity.product !== "SME - Commercial Package" && row.entity.quoteStatus == "Declined"\' ng-click="grid.appScope.getParamEncrytion(2,row.entity.quoteTransactionId)"> {{row.entity.quoteNumber}}</a>' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.quoteNumber !== null  && row.entity.product !== "SME - Commercial Package" && row.entity.quoteStatus !== "Draft"\' ng-click="grid.appScope.getParamEncrytion(2,row.entity.quoteTransactionId)"> {{row.entity.quoteNumber}}</a>' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.product === "Home" && row.entity.quoteStatus == "Draft"\' href  ng-click=\'grid.appScope.vm.validAndRedirect("UpdateHome",row.entity.product,row.entity.caseNumber)\'" > {{row.entity.quoteNumber }}</a>' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.product === "Motor" && row.entity.quoteStatus == "Draft"\' href  ng-click=\'grid.appScope.vm.validAndRedirect("UpdateMotor",row.entity.product,row.entity.caseNumber)\'  > {{row.entity.quoteNumber }}</a>' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.product === "Landlord – Essentials" && row.entity.quoteStatus == "Draft"\' href  ng-click=\'grid.appScope.vm.validAndRedirect("UpdateLandlordProtection",row.entity.product,row.entity.caseNumber)\' > {{row.entity.quoteNumber }}</a>' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.product === "Landlord – AD and LE" && row.entity.quoteStatus == "Draft"\' href  ng-click=\'grid.appScope.vm.validAndRedirect("UpdateLandlordStandard",row.entity.product,row.entity.caseNumber)\' > {{row.entity.quoteNumber }}</a>' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.quoteNumber !== null && row.entity.product === "SME - Commercial Package" && row.entity.quoteStatus == "Quoted"\' ng-click="grid.appScope.getParamEncrytion(3,row.entity.quoteTransactionId)"> {{row.entity.quoteNumber}}</a>' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.quoteNumber !== null && row.entity.product === "SME - Commercial Package" && row.entity.quoteStatus == "Referred"\' ng-click="grid.appScope.getParamEncrytion(3,row.entity.quoteTransactionId)"> {{row.entity.quoteNumber}}</a>' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.quoteNumber !== null  && row.entity.product === "SME - Commercial Package" && row.entity.quoteStatus !== "Draft"\' ng-click="grid.appScope.getParamEncrytion(3,row.entity.quoteTransactionId)"> {{row.entity.quoteNumber}}</a>' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.quoteNumber == null && row.entity.product === "SME - Commercial Package" && row.entity.quoteStatus == "Declined"\' ng-click="grid.appScope.getParamEncrytion(3,row.entity.quoteTransactionId)"> {{row.entity.quoteNumber}}</a>' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.product === "SME - Commercial Package" && row.entity.quoteStatus == "Draft"\' href  ng-click=\'grid.appScope.vm.validAndRedirectSME(row.entity.quoteTransactionId)\' >{{row.entity.quoteNumber}}</a></div >' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.quoteNumber !== null && row.entity.product === "Commercial Motor" && row.entity.quoteStatus == "Quoted"\' ng-click="grid.appScope.getParamEncrytion(4,row.entity.quoteTransactionId)"> {{row.entity.quoteNumber}}</a>' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.quoteNumber !== null && row.entity.product === "Commercial Motor" && row.entity.quoteStatus == "Referred"\' ng-click="grid.appScope.getParamEncrytion(4,row.entity.quoteTransactionId)"> {{row.entity.quoteNumber}}</a>' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.quoteNumber !== null  && row.entity.product === "Commercial Motor" && row.entity.quoteStatus !== "Draft"\' ng-click="grid.appScope.getParamEncrytion(4,row.entity.quoteTransactionId)"> {{row.entity.quoteNumber}}</a>' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.quoteNumber == null && row.entity.product === "Commercial Motor" && row.entity.quoteStatus == "Declined"\' ng-click="grid.appScope.getParamEncrytion(4,row.entity.quoteTransactionId)"> {{row.entity.quoteNumber}}</a>' +
                '<a ng-if=\'row.entity.processType !== "CANCELLATION" && row.entity.product === "Commercial Motor" && row.entity.quoteStatus == "Draft"\' href  ng-click=\'grid.appScope.vm.validAndRedirectCommotor(row.entity.quoteTransactionId)\' >{{row.entity.quoteNumber}}</a></div >';
        }

        function getParamEncrytion(mode, paramString) {
            if (mode === 1) {
                var encryptedParam = sessionStorageService.getEncryption("qid=" + paramString);
                $window.location.href = "/Cancellation/Quote?" + encryptedParam;
            }
            else if (mode === 2) {
                encryptedParam = sessionStorageService.getEncryption("quoteTransactionId=" + paramString);
                $window.location.href = apiUrlConstService.quoteIndexUrl + encryptedParam;
            }
            else if (mode === 3) {
                encryptedParam = sessionStorageService.getEncryption("id=" + paramString);
                $window.location.href = apiUrlConstService.bindIndexUrl + encryptedParam;
            }
            else if (mode === 4) {
                portalV2Service.getV2Token().then(function (resp) {
                    var redirectTo = vm.CommercialMotorSearchQuoteURL + '/' + sessionStorageService.getEncryption("quoteTransactionId=" + paramString + '&productId=' + keyConstService.CommercialMotorProductId);
                    portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
                }); 
            }
            else if (mode === 5 || mode === 6) {
                encryptedParam = sessionStorageService.getEncryption("quoteTransactionId=" + paramString);
                var url = null;
                if (mode === 5) {
                    url = vm.SMEHomePageQuoteListURL
                }
                else {
                    url = vm.SMEHomePagePolicyListURL
                }
                portalV2Service.getV2Token().then(function (resp) {
                    portalV2Service.setKeyToLocalStorage(resp.data.data);
                    $window.location.href = window.location.protocol + '//' + window.location.host + url + '?' + encryptedParam;
                });
            }
        }
        vm.validAndRedirect = function (productUrl, product, caseNumber) {
            sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
            $window.location.href = "/Home/" + productUrl + "?" + sessionStorageService.getEncryption("productName=" + product + "&&quoteCaseNumber=" + caseNumber);
        };

        vm.validAndRedirectSME = function (quoteTransactionId) {
            sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
            portalV2Service.getV2Token().then(function (resp) {
                portalV2Service.setKeyToLocalStorage(resp.data.data);
                $window.location.href = window.location.protocol + '//' + window.location.host + rootModel.SMESearchQuoteURL + '?' + sessionStorageService.getEncryption("quoteTransactionId=" + quoteTransactionId);
            });
        };

        vm.validAndRedirectCommotor = function (quoteTransactionId) {
            sessionStorageService.set(keyConstService.IsValidQuestionsBack, true);
            portalV2Service.getV2Token().then(function (resp) {
                var redirectTo = rootModel.CommercialMotorSearchQuoteURL + '/' + sessionStorageService.getEncryption("quoteTransactionId=" + quoteTransactionId + '&productId=' + keyConstService.CommercialMotorProductId);
                portalV2Service.preserveTokenAndRedirectTo(resp.data.data, redirectTo, vm.BrokerPortalV2Debugging);
            }); 
        }

        function searchUpcomingDue() {
            vm.FromDate = vm.FromDate;
            vm.ToDate = vm.ToDate;
            vm.Branchlevel = parseInt(vm.Selection);

            $scope.renewalData = null;
            $scope.cancellationReportData = null;
            $scope.UpcomingDueReportData = null;
            $scope.gridUpcomingDue.data = $scope.UpcomingDueReportData;
            $scope.gridUpcomingDue.paginationCurrentPage = 1;
            $scope.gridUpcomingDue.paginationPageSize = 15;
            $scope.gridOptions.data = $scope.renewalData;
            $scope.gridOptions.paginationCurrentPage = 1;
            $scope.gridOptions.paginationPageSize = 15;
            $scope.gridCancellationPolicies.data = $scope.cancellationReportData;
            $scope.gridCancellationPolicies.paginationCurrentPage = 1;
            $scope.gridCancellationPolicies.paginationPageSize = 15;
            $scope.claimHistoryData = null;
            $scope.gridClaimHistory.data = $scope.claimHistoryData;
            $scope.gridClaimHistory.paginationCurrentPage = 1;
            $scope.gridClaimHistory.paginationPageSize = 15;
            vm.showDataClaimHistory = false;
            vm.showData = false;
            vm.showDataCancellationPolicies = false;
            vm.showDataUpcomingDue = false;

            reportsService.getUpcomingDuePolicies(vm.FromDate, vm.ToDate, vm.Branchlevel).then(function (data) {
                if (data.data !== null && data.data.length > 0) {
                    vm.showDataUpcomingDue = true;
                }
                if (data.status == false) {
                    toastr.error("Data not found for the search.");
                    $scope.UpcomingDueReportData = null;
                }

                $scope.UpcomingDueReportData = data.data;
                $scope.gridUpcomingDue.data = $scope.UpcomingDueReportData;

            });


        }

        function searchReport() {
            vm.FromDate = vm.FromDate;
            vm.ToDate = vm.ToDate;
            vm.Branchlevel = parseInt(vm.Selection);
            vm.Status = vm.Status;

            $scope.renewalData = null;
            $scope.cancellationReportData = null;
            $scope.gridOptions.data = $scope.renewalData;
            $scope.gridOptions.paginationCurrentPage = 1;
            $scope.gridOptions.paginationPageSize = 15;
            $scope.gridCancellationPolicies.data = $scope.cancellationReportData;
            $scope.gridCancellationPolicies.paginationCurrentPage = 1;
            $scope.gridCancellationPolicies.paginationPageSize = 15;
            $scope.UpcomingDueReportData = null;
            $scope.gridUpcomingDue.data = $scope.UpcomingDueReportData;
            $scope.gridUpcomingDue.paginationCurrentPage = 1;
            $scope.gridUpcomingDue.paginationPageSize = 15;
            $scope.claimHistoryData = null;
            $scope.gridClaimHistory.data = $scope.claimHistoryData;
            $scope.gridClaimHistory.paginationCurrentPage = 1;
            $scope.gridClaimHistory.paginationPageSize = 15;
            vm.showDataClaimHistory = false;
            vm.showData = false;
            vm.showDataCancellationPolicies = false;
            vm.showDataUpcomingDue = false;

            if (vm.Status != null) {
                reportsService.getRenewals(vm.FromDate, vm.ToDate, vm.Branchlevel, vm.Status).then(function (data) {
                    if (data.data!==null && data.data.length > 0) {
                        vm.showData = true;

                    }
                    if (data.status == false) {
                        toastr.error("Data not found for the search.");
                        $scope.renewalData = null;

                    }
                    var newdata = data.data;
                    $scope.renewalData = data.data;
                    $scope.gridOptions.data = $scope.renewalData;

                });
            } else {

                cancellationService.getCancellationReport(vm.FromDate, vm.ToDate, vm.Branchlevel).then(function (data) {
                    if (data.data !== null && data.data.length > 0) {
                        vm.showDataCancellationPolicies = true;
                    }
                    if (data.status == false) {
                        toastr.error("Data not found for the search.");
                        $scope.cancellationReportData = null;
                    }

                    $scope.cancellationReportData = data.data;
                    $scope.gridCancellationPolicies.data = $scope.cancellationReportData;

                });
            }
        }

        function searchReportClaimHistory() {
            vm.PolicyNumber = vm.PolicyNumber;
            $scope.renewalData = null;
            $scope.cancellationReportData = null;
            $scope.gridOptions.data = $scope.renewalData;
            $scope.gridOptions.paginationCurrentPage = 1;
            $scope.gridOptions.paginationPageSize = 15;
            $scope.gridCancellationPolicies.data = $scope.cancellationReportData;
            $scope.gridCancellationPolicies.paginationCurrentPage = 1;
            $scope.gridCancellationPolicies.paginationPageSize = 15;
            $scope.UpcomingDueReportData = null;
            $scope.gridUpcomingDue.data = $scope.UpcomingDueReportData;
            $scope.gridUpcomingDue.paginationCurrentPage = 1;
            $scope.gridUpcomingDue.paginationPageSize = 15;
            $scope.claimHistoryData = null;
            $scope.gridClaimHistory.data = $scope.claimHistoryData;
            $scope.gridClaimHistory.paginationCurrentPage = 1;
            $scope.gridClaimHistory.paginationPageSize = 15;
            vm.showDataClaimHistory = false;
            vm.showData = false;
            vm.showDataCancellationPolicies = false;
            vm.showDataUpcomingDue = false;
            
            reportsService.getClaimHistory(vm.PolicyNumber).then(function (data) {
                if (data.data !== null && data.data.length > 0) {
                    $scope.claimHistoryData = data.data.slice(0, 1);
                    $scope.gridClaimHistory.data = $scope.claimHistoryData;
                    vm.showDataClaimHistory = true;
                }

                if (data.status == false) {
                    toastr.error("Data not found for the search.");
                    $scope.claimHistoryData = null;
                    $scope.gridClaimHistory.data = $scope.claimHistoryData;
                    vm.PolicyNumber = '';
                }
            });          
        }

        function onSelectionChange() {
            $scope.renewalData = null;
            vm.showData = false;
            $scope.cancellationReportData = null;
            vm.showDataCancellationPolicies = false;
            $scope.UpcomingDueReportData = null;
            vm.showDataUpcomingDue = false;
            vm.showDataClaimHistory = false;
            $scope.claimHistoryData = null;
        }

        function generateReport(isPdf,isExcel) {
            var config = { headers: { 'Content-Type': undefined } };
            var format;
            if (isPdf === true) {
                format = "Pdf";
            }
            else {
                format = "Excel";
            }
            if (vm.Status != null) {
                var reportVM = {
                    "FromDate": vm.FromDate,
                    "ToDate": vm.ToDate,
                    "Branchlevel": parseInt(vm.Selection),
                    "Status": vm.Status
                };
            
                return $http
                    ({
                        url: "/mediaProxy/Renewal/GenerateRenewalsReport",
                        method: "POST",
                        data: reportVM,
                        params: { reportVM, format },
                        responseType: "blob"
                    })
                    .then(function (result) {

                        var blob = new Blob([result.data], { type: [result.data.type] });
                        var fileName;
                        if ((parseInt(vm.Selection)) === 1) {
                            if (isPdf === true) {
                                fileName = "MyPolicies(RenewalQuotes).pdf";
                            }
                            else {
                                fileName = "MyPolicies(RenewalQuotes).xlsx";
                            }
                        }
                        else {
                            if (isExcel === true) {
                                fileName = "MyBranchPolicies(RenewalQuotes).xlsx";
                            }
                            else {

                                fileName = "MyBranchPolicies(RenewalQuotes).pdf";

                            }
                        }
                        FileSaver.saveAs(blob, fileName);
                        return result.data.data;

                    },
                        function (data) {
                            toastr.error("System is currently not working or There is no data present ");
                            return;
                        });
            }
            else {
                var reportVM = {
                    "FromDate": vm.FromDate,
                    "ToDate": vm.ToDate,
                    "Branchlevel": parseInt(vm.Selection)
                };

                return $http
                    ({
                        url: "/mediaProxy/Cancellation/GenerateCancellationReport",
                        method: "POST",
                        data: reportVM,
                        responseType: "blob"
                    })
                    .then(function (result) {

                        var blob = new Blob([result.data], { type: [result.data.type] });
                        var fileName;
                        if ((parseInt(vm.Selection)) === 1) {
                            fileName = "MyPolicies(CancelledPolicies).xlsx";
                        }
                        else {
                            fileName = "MyBranchPolicies(CancelledPolicies).xlsx";
                        }
                        FileSaver.saveAs(blob, fileName);
                        return result.data.data;

                    },
                        function (data) {
                            toastr.error("System is currently not working or There is no data present ");
                            return;
                        });
            }
        }

        function generateDueAnnualPolicyReport() {
            var config = { headers: { 'Content-Type': undefined } };
                var reportVM = {
                    "FromDate": vm.FromDate,
                    "ToDate": vm.ToDate,
                    "Branchlevel": parseInt(vm.Selection)
                };
                return $http
                    ({
                        url: "/mediaProxy/Report/GenerateDueAnnualPolicy",
                        method: "POST",
                        data: reportVM,
                        responseType: "blob"
                    })
                    .then(function (result) {
                        var blob = new Blob([result.data], { type: [result.data.type] });
                        var fileName;
                        if ((parseInt(vm.Selection)) === 1) {
                            fileName = "MyPolicies(UpcomingDuePolicies).xlsx";
                        }
                        else {
                            fileName = "MyBranchPolicies(UpcomingDuePolicies).xlsx";
                        }
                        FileSaver.saveAs(blob, fileName);
                        return result.data.data;
                    },
                        function (data) {
                            toastr.error("System is currently not working or There is no data present ");
                            return;
                        });
        }

        function generateClaimHistoryExcel() {
            var config = { headers: { 'Content-Type': undefined } };
            var policyNumber = vm.PolicyNumber;
            return $http
                ({
                    url: "/mediaProxy/Report/GenerateClaimHistoryExcel?policyNumber=" + policyNumber,
                    method: "POST",
                    responseType: "blob"
                })
                .then(function (result) {
                    var blob = new Blob([result.data], { type: [result.data.type] });
                    var fileName;
                    fileName = "Claims_History_" + policyNumber + ".xlsx";;
                    FileSaver.saveAs(blob, fileName);
                    return result.data.data;
                },
                    function (data) {
                        toastr.error("System is currently not working or There is no data present ");
                        return;
                    });

        }

        function dateQuery(dateToValidate, isFrom) {
            var mFromDate = moment(vm.FromDate, 'DD/MM/YYYY').toDate();
            var mToDate = moment(vm.ToDate, 'DD/MM/YYYY').toDate();
            if ($scope.gridOptions.data) {
                $scope.renewalData = null;
                vm.showData = false;
            }
            else if ($scope.gridCancellationPolicies.data) {
                $scope.cancellationReportData = null;
                vm.showDataCancellationPolicies = false;
            }
            else if ($scope.gridUpcomingDue.data) {
                $scope.UpcomingDueReportData = null;
                vm.showDataUpcomingDue = false;
            }
            if ((mFromDate > mToDate) && dateToValidate) {
                toastr.warning("Please enter a valid range.");
                vm.FromDate = '';
                vm.ToDate = '';
                vm.Status = "4";
                return;
            }
            var currentDate = new Date();
            var minDate = new Date(keyConstService.StartRenewal);
            var maxDate = new Date();
            maxDate.setDate(maxDate.getDate() + 60);
            var dateRangeResponse = dateService.validateDateRange(dateToValidate, minDate, maxDate);
            if (!dateRangeResponse.isValid && dateToValidate) {
                toastr.warning("Date not allowed!");
                if (isFrom) {
                    vm.FromDate = '';
                }
                else {
                    vm.ToDate = '';
                }
                return;
            }
            if (!dateToValidate && typeof (isFrom) !== 'undefined') {
                return;
            }
        }

        function dateQueryCancellation(dateToValidate, isFrom) {
            var mFromDate = moment(vm.FromDate, 'DD/MM/YYYY').toDate();
            var mToDate = moment(vm.ToDate, 'DD/MM/YYYY').toDate();
            if ($scope.gridOptions.data) {
                $scope.renewalData = null;
                vm.showData = false;
            }
            else if ($scope.gridCancellationPolicies.data) {
                $scope.cancellationReportData = null;
                vm.showDataCancellationPolicies = false;
            }
            else if ($scope.gridUpcomingDue.data) {
                $scope.UpcomingDueReportData = null;
                vm.showDataUpcomingDue = false;
            }
            if ((mFromDate > mToDate) && dateToValidate) {
                toastr.warning("Please enter a valid range.");
                vm.FromDate = '';
                vm.ToDate = '';
                return;
            }
            var currentDate = new Date();
            var minDate = new Date(keyConstService.searchCancelledPolicyDate);
            var maxDate = new Date();
            maxDate.setDate(maxDate.getDate() + 120);
            var dateRangeResponse = dateService.validateDateRange(dateToValidate, minDate, maxDate);
            if (!dateRangeResponse.isValid && dateToValidate) {
                toastr.warning("Date not allowed!");
                if (isFrom) {
                    vm.FromDate = '';
                }
                else {
                    vm.ToDate = '';
                }
                return;
            }
            if (!dateToValidate && typeof (isFrom) !== 'undefined') {
                return;
            }
        }

        function dateQueryUpcomingDue(dateToValidate, isFrom) {
            var mFromDate = moment(vm.FromDate, 'DD/MM/YYYY').toDate();
            var mToDate = moment(vm.ToDate, 'DD/MM/YYYY').toDate();
            if ($scope.gridOptions.data) {
                $scope.renewalData = null;
                vm.showData = false;
            }
            else if ($scope.gridCancellationPolicies.data) {
                $scope.cancellationReportData = null;
                vm.showDataCancellationPolicies = false;
            }
            else if ($scope.gridUpcomingDue.data) {
                $scope.UpcomingDueReportData = null;
                vm.showDataUpcomingDue = false;
            }
            if ((mFromDate > mToDate) && dateToValidate) {
                toastr.warning("Please enter a valid range.");
                vm.FromDate = '';
                vm.ToDate = '';
                return;
            }
            var currentDate = new Date();
            var minDate = new Date(keyConstService.searchCancelledPolicyDate);
            var maxDate = new Date();
            maxDate.setDate(maxDate.getDate() + 150 );
            var dateRangeResponse = dateService.validateDateRange(dateToValidate, minDate, maxDate);
            if (!dateRangeResponse.isValid && dateToValidate) {
                toastr.warning("Date not allowed!");
                if (isFrom) {
                    vm.FromDate = '';
                }
                else {
                    vm.ToDate = '';
                }
                return;
            }
            if (!dateToValidate && typeof (isFrom) !== 'undefined') {
                return;
            }
        }

    }
})();;
(function () {
    'use strict';

    angular.module('appUI')
        .service('reportsService', ['$rootScope', '$resource', '$q', 'apiUrlConstService', reportsService]);

    function reportsService($rootScope, $resource, $q, apiUrlConstService) {
        return {
            getRenewals: getRenewals,
            getUpcomingDuePolicies: getUpcomingDuePolicies,
            getClaimHistory: getClaimHistory
        };

        function getRenewals(FromDate,ToDate,Branchlevel,Status) {            
            var renewalApi = $resource(apiUrlConstService.getRenewalData, {
                dateFrom: FromDate,
                dateTo: ToDate,
                branchLevel: Branchlevel,
                status: Status
                },
                { get: { method: 'GET', isArray: false } });

            return renewalApi.get().$promise;
        }
        function getUpcomingDuePolicies(FromDate, ToDate, Branchlevel) {
            var upcomingDuePoliciesApi = $resource(apiUrlConstService.getUpcomingDuePoliciesData, {
                dateFrom: FromDate,
                dateTo: ToDate,
                branchLevel: Branchlevel
            },
                { get: { method: 'GET', isArray: false } });

            return upcomingDuePoliciesApi.get().$promise;
        }

        function getClaimHistory(PolicyNumber) {
            var claimHistoryApi = $resource(apiUrlConstService.getClaimHistoryData, {
                policyNumber: PolicyNumber
            },
                { get: { method: 'GET', isArray: false } });

            return claimHistoryApi.get().$promise;
        }
    }
        
})();
;
(function () {
    'use strict';
    app.directive("bzSection", bzSection);

    function bzSection() {
        return {
            restrict: "E",
            templateUrl: 'app/pages/questions/section.html',
            scope:
            {
                section: '=',
                sectionquestion: '=?'
            },
            link: function (scope, element, attrs) {


                scope.sectionquestion = [];

                if (scope.section.counter == 0)
                {
                    //first run
                    console.log('first run');
                    scope.section.InitState.forEach(function (item, index) {
                        scope.sectionquestion.push(item);
                    });
                    scope.section.counter = 1;
                }
                else
                {
                    //subsequent run
                    console.log('second run');
                    scope.section.QuestionVM.forEach(function (item, index) {
                        scope.sectionquestion.push(item);
                    });
                }

                scope.addRow = function () {
                    //add the question from the initial state 
                    scope.section.InitState.forEach(function (item, index) {
                        scope.sectionquestion.push(item);
                        scope.section.QuestionVM.push(item);
                    });
                }

                console.log(scope.section.QuestionVM);
                console.log(scope.sectionquestion);
            }
        }
    }
})();;
(function () {
    'use strict';

    var appUI = angular.module('appUI');

    appUI.controller('personalAccidentCtrl', ['$rootScope', '$q', '$window', '$filter', 'responsiveService', 'quotesService', 'sessionStorageService', 'apiUrlConstService', 'webUrlConstService', 'dateService', 'disclaimerService', '$http', '$log', 'messageConstService', 'keyConstService', '$scope', '$mdDialog', '$timeout', 'clientService', 'utilityService', personalAccidentCtrl]);

    function personalAccidentCtrl($rootScope, $q, $window, $filter, responsiveService, quotesService, sessionStorageService, apiUrlConstService, webUrlConstService, dateService, disclaimerService, $http, $log, messageConstService, keyConstService, $scope, $mdDialog, $timeout, clientService, utilityService) {
        var vm = this;
        vm.CaseNumber = null;
        vm.disableButtons = false;
        vm.IsEndorsement = false;
        vm.showManagePkg = false;
        vm.EffectiveDate = null;
        vm.ExpirationDate = null;
        vm.StartDate = null;
        vm.OccupationListData = [];
        vm.ExcessListData = [];
        vm.PreviousInsurerListData = [];
        vm.BenefitPeriodListData = [];
        vm.disableAddOccupation = false;
        vm.invalidWeeklyBenefitAmount = false;
        vm.isvalidWeeklyBenefitAmount = false;
        vm.notesrequired = false;
        vm.minWeelyBenefitValue = 0;
        vm.minCapitalCoverValue = 0;
        vm.maxCapitalCoverValue = 0;
        var caseId = null;
        vm.transactionId = null;
        vm.getTransactionIdWithoutSaving = null;
        vm.ReadOnly = false;
        vm.showBrokerFee = true;
        vm.endorsementVM = null;
        vm.IsAccidentOnly = true;
        vm.IsAccidentAndSickness = true;
        var newBusinessCaseData = null;
        var newBusinessCaseDetail = null;
        var startDate= null;
        var productId = null;
        var isPackageManagerMode = null;
        var renewalCounter = null;
        var isNewEditTransaction = null;
        var IsNewBusinessEdit = false;
        var endorsementstate = null;
        vm.EndorsementCoverage = null;
        vm.selectedOccupation = true;
        vm.message = null;
        vm.getTransactionIdfromSession = null;
        vm.otherInsuredAddress = null;
        vm.ClientDetail = {};
        vm.otherreadonly = false;
        vm.OtherInsuredName = null;
        vm.help_text_for_Endorsement = keyConstService.help_text_for_Endorsement;
        vm.tempPrimaryInsured;
        vm.checkAgreedValue = false;
        vm.init = function (personalAccidentData) {
            isPackageManagerMode = sessionStorageService.get('IsPackageManagerNavigationMode');
            if (sessionStorageService.get(keyConstService.getTransactionIdWithoutSaving) !== null) {
                vm.getTransactionIdWithoutSaving = JSON.parse(sessionStorageService.get(keyConstService.getTransactionIdWithoutSaving));
            }
            vm.getTransactionIdfromSession = sessionStorageService.get(keyConstService.quoteTransactionId);
            vm.getParsedQuestionSetWithoutSaving = JSON.parse(sessionStorageService.get(keyConstService.getQuestionSetWithoutSaving));
            renewalCounter = sessionStorageService.get('RenewalCounter');
            
            // get all the drop down list values populated
            vm.ExcessListData = personalAccidentData.PersonalAccidentListData.ExcessList;
            vm.PreviousInsurerListData = personalAccidentData.PersonalAccidentListData.PreviousInsuredList;
            vm.BenefitPeriodListData = personalAccidentData.PersonalAccidentListData.BenefitPeriodList;
            vm.OccupationListData = personalAccidentData.PersonalAccidentListData.OccupationList;

            if (isPackageManagerMode === "true" || renewalCounter !== null) {
                vm.showManagePkg = true;
            }          
            var IsValidQuestionsBack = JSON.parse(sessionStorageService.get(keyConstService.IsValidQuestionsBack));
            vm.endorsementVM = JSON.parse(sessionStorageService.get(keyConstService.endorsementRequestVM));
            if (personalAccidentData.IsEndorsement) {
                vm.IsEndorsement = personalAccidentData.IsEndorsement;
                 vm.PolicyNumber = personalAccidentData.PolicyNumber;
            }
            if (personalAccidentData.PersonalAccidentQuestion && personalAccidentData.PersonalAccidentQuestion.PaymentFrequency.BrokerManagedPayment !== null) {
                vm.brokerManagedPayment = personalAccidentData.PersonalAccidentQuestion.PaymentFrequency.BrokerManagedPayment;
            }
            else {
                vm.brokerManagedPayment = personalAccidentData.PackageDetail.BrokerManagedPayment;
            }

            // hide brokerfee on endorsement
            if (vm.IsEndorsement) {
                vm.showBrokerFee = false;
            }
            else {
                vm.showBrokerFee = true;
            }   
            
            vm.personalAccidentData = personalAccidentData;
            vm.activatePayment = vm.personalAccidentData.ActivatePayment;
            if (vm.personalAccidentData) {
                if (vm.personalAccidentData.IsPolicyBound) {
                    vm.enablePopUp = true;
                    toastr.error(messageConstService.errMessagePolicyBound);
                }
                if (vm.personalAccidentData.QuoteTransactionId !== null && vm.personalAccidentData.QuoteCase !== null) {
                    vm.transactionId = vm.personalAccidentData.QuoteTransactionId;
                    vm.caseNumber = vm.personalAccidentData.QuoteCase.CaseNumber;
                }
            }

            // getting thershold values from server and if not found then from key const service
            if (personalAccidentData.ThresholdValuesPa) {
               
                vm.minWeelyBenefitValue = personalAccidentData.ThresholdValuesPa.WeeklyBenefitThreshold;
                vm.minCapitalCoverValue = personalAccidentData.ThresholdValuesPa.MinCapitalBenefitThreshold;
                vm.maxCapitalCoverValue = personalAccidentData.ThresholdValuesPa.MaxCapitalBenefitThreshold;
                vm.maxweeklyBenefitValue = personalAccidentData.ThresholdValuesPa.MaxWeeklyBenefitThershold;
            }

            if (vm.minWeelyBenefitValue === 0) {
                
                vm.minWeelyBenefitValue = keyConstService.WeeklyBenefitThreshold;
            }
            if (vm.minCapitalCoverValue === 0) {
                vm.minCapitalCoverValue = keyConstService.MinCapitalCoverThreshold;
            }
            if (vm.maxCapitalCoverValue === 0) {
                vm.maxCapitalCoverValue = keyConstService.MaxCapitalCoverThreshold;
            }
            // For first new business Transaction i.e when get quote is not clicked
            if (!personalAccidentData.PersonalAccidentQuestion) {
                caseId = sessionStorageService.get(keyConstService.caseId);
                sessionStorageService.set(keyConstService.IsNewEditTransaction, isNewEditTransaction);
                vm.CaseNumber = JSON.parse(sessionStorageService.get('caseNumber'));   
                vm.state = quotesService.loadQuoteData(null, keyConstService.PersonalAccidentProductId, personalAccidentData.PersonalAccidentListData);
                // by default Keeping all the check boxes false                
                vm.state.CoverageInfo.IsAgreedValue = false;
                vm.state.CoverageInfo.IncludeSpecificCondition = false;
                vm.state.CoverageInfo.ExcludeSpecificCondition = false;
                // Update Package Detail in QuotePolicyInfo
                if (personalAccidentData.PackageDetail !== null) {
                    vm.state.QuotePolicyInfo.PackageRenewalCounter = personalAccidentData.PackageDetail.RenewalCounter;
                    vm.state.QuotePolicyInfo.PackageId = personalAccidentData.PackageDetail.Id;
                    vm.state.QuotePolicyInfo.PackageNumber = personalAccidentData.PackageDetail.PackageNumber;
                }
                if (personalAccidentData.ProductDetails) {
                    vm.state.QuotePolicyInfo.ProductId = personalAccidentData.ProductDetails.Id;
                    vm.state.QuotePolicyInfo.ProductCode = personalAccidentData.ProductDetails.ProductCode;
                    vm.state.QuotePolicyInfo.LineOfBusinessId = personalAccidentData.ProductDetails.LineOfBusinessId;
                }
                newBusinessCaseData = sessionStorageService.get(keyConstService.newBusinessCaseData);
                newBusinessCaseDetail = JSON.parse(newBusinessCaseData);
                startDate = newBusinessCaseDetail.data.EffectiveDate;
                productId = newBusinessCaseDetail.data.ProductId;

                // update the state of the page to the last stage before hitting previus and the next
                if (vm.getParsedQuestionSetWithoutSaving !== null && newBusinessCaseDetail) {
                    vm.state = vm.getParsedQuestionSetWithoutSaving;
                    vm.state.PaymentFrequency.ModeOfPayment = newBusinessCaseDetail.data.ModeOfPayment;
                    vm.state.PaymentFrequency.InstallmentDate = newBusinessCaseDetail.data.InstallmentDate;
                    if (vm.getParsedQuestionSetWithoutSaving.RiskInformation.AddressDetails.IsManualAddress) {
                        vm.selectedMannualAddress = vm.getParsedQuestionSetWithoutSaving.RiskInformation.AddressDetails.AddressText;
                    }
                    else {
                        vm.selectedAddress = angular.copy(vm.getParsedQuestionSetWithoutSaving.RiskInformation.AddressDetails.AddressText);
                    }
                    vm.addressValue = vm.getParsedQuestionSetWithoutSaving.RiskInformation.AddressDetails.AddressValue;
                    // check for valid entry in fields
                    vm.checkBrkerCommissionLimit();
                    vm.checkWeeklyBenefitValue();
                    vm.checkWeeklyCapitalCoverValue();
                    vm.isDuplicateExcess();
                }

                var brokerCommissionRequest = quotesService.getBrokerCommission({
                    EffectiveDate: startDate,
                    ProductId: productId,
                    ProductName: null
                })
                    .then(function (result) {
                        if (result.data) {
                            vm.data = result.data.brokerBranchCommissionFeeVM;
                        }
                        if (vm.data) {
                            for (var i = 0; i < vm.data.length; i++) {
                                if (vm.data[i].coverCode.toLowerCase() === keyConstService.personalAccidentCover.toLowerCase()) {
                                    if (!vm.getParsedQuestionSetWithoutSaving) {
                                        vm.state.BrokerRemuneration.BrokerCommissionPercentage = vm.data[i].brokerCommissionFee;
                                    }
                                    vm.maxbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMax;
                                    vm.minbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMin;
                                    vm.checkBrkerCommissionLimit();
                                }
                            }
                        }
                        else {
                            toastr.error("Broker Commission not available");
                        }
                    });

               
                quotesService.getInsuredNameList(caseId).then(function (ResponseData) {
                        if (ResponseData.data !== null) {
                            var newDate = new Date(ResponseData.data.policyHolder.dateOfBirthApp);
                            vm.state.PolicyHolder.DateOfBirthApp = newDate;
                            ResponseData.data.policyHolder.insuredNameList = ResponseData.data.policyHolder.insuredNameList
                            .filter(function (item) {return item.insuredType !== "Business";});                                                        
                            vm.state.PolicyHolder.InsuredNameList = ResponseData.data.policyHolder.insuredNameList;
                            vm.state.PolicyHolder.InsuredClientId = ResponseData.data.policyHolder.insuredClientId;
                            vm.ClientDetail = ResponseData.data.clientDetail;
                            vm.addSecondaryClient = ResponseData.data.clientDetail.secondaryInsuredClientVM;
                            vm.otherInsuredAddress = ResponseData.data.clientDetail.addressLogVM;
                            vm.state.PolicyHolder.InsuredName = ResponseData.data.policyHolder.insuredName;
                            if (vm.state.RiskInformation.AddressDetails.AddressText == null) {
                                vm.state.RiskInformation.AddressDetails.AddressText = ResponseData.data.buildingInfo.addressText;
                                vm.state.RiskInformation.AddressDetails.AddressValue = ResponseData.data.buildingInfo.addressValue;
                                vm.state.RiskInformation.AddressDetails.Postcode = ResponseData.data.buildingInfo.postCode;
                                vm.state.RiskInformation.AddressDetails.AddressLine1 = ResponseData.data.buildingInfo.addressLine1;
                                vm.state.RiskInformation.AddressDetails.IsManualAddress = ResponseData.data.buildingInfo.isManualAddress
                            }
                            vm.otherInsuredAddress = ResponseData.data.clientDetail.addressLogVM;
                            vm.PropertyDetail = angular.copy(ResponseData.data.buildingInfo);

                            if (!vm.state.RiskInformation.AddressDetails.IsManualAddress) {
                                vm.selectedAddress = { postCode: vm.state.RiskInformation.AddressDetails.Postcode, text: vm.state.RiskInformation.AddressDetails.AddressText, value: vm.state.RiskInformation.AddressDetails.AddressValue };

                            }
                            else if (vm.state.RiskInformation.AddressDetails.IsManualAddress){
                                vm.selectedMannualAddress = { postCode: vm.state.RiskInformation.AddressDetails.Postcode, text: vm.state.RiskInformation.AddressDetails.AddressText, addressLine1: vm.state.RiskInformation.AddressDetails.AddressLine1, value: vm.state.RiskInformation.AddressDetails.AddressValue, isManualAddress: vm.state.RiskInformation.AddressDetails.IsManualAddress };
                                
                            }
                                
                            
                            vm.tempPrimaryInsured = vm.state.PolicyHolder.InsuredName;

                        }                      
                    });
                    
                // removing questionset from session for valid newbusiness quote
                if (!vm.getParsedQuestionSetWithoutSaving) {
                    sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
                }
            }

            // for edit endorsement and view (needs to modified)
            else {
                if (personalAccidentData.QuoteCase !== null) {
                    vm.CaseNumber = personalAccidentData.QuoteCase.CaseNumber;
                }
                vm.brokerFeeGST = personalAccidentData.PersonalAccidentQuestion.BrokerRemuneration.BrokerFee;

                // if true determines full term endorsement
                vm.IsEndorsementPolicyEffectiveDate = personalAccidentData.IsEndorsementPolicyEffectiveDate;
                vm.IsEndorsement = personalAccidentData.IsEndorsement;
                vm.state = personalAccidentData.PersonalAccidentQuestion;
                // Update Package Detail in QuotePolicyInfo
                if (personalAccidentData.PackageDetail !== null) {
                    vm.state.QuotePolicyInfo.RenewalCounter = personalAccidentData.PackageDetail.RenewalCounter;
                    vm.state.QuotePolicyInfo.PackageId = personalAccidentData.PackageDetail.Id;
                    vm.state.QuotePolicyInfo.PackageNumber = personalAccidentData.PackageDetail.PackageNumber;
                }
                
                vm.dataState = personalAccidentData;
                vm.rowVersion = personalAccidentData.RowVersion;
                vm.transactionStatus = personalAccidentData.Status;
                vm.isSecondaryDisabled = false;
                vm.policyTransactionId = personalAccidentData.PolicyTransactionId;
                sessionStorageService.remove(keyConstService.IsNewBusinessReadOnly);
                sessionStorageService.set(keyConstService.IsPackageEditable, vm.dataState.IsPackageEditable);
                vm.ReadOnly = personalAccidentData.IsReadOnly;
                var newBusinessdata = JSON.parse(sessionStorageService.get(keyConstService.newBusinessCaseData));
                if (vm.getParsedQuestionSetWithoutSaving) {
                    if (vm.getTransactionIdfromSession === vm.getTransactionIdWithoutSaving) {
                        vm.state = vm.getParsedQuestionSetWithoutSaving;
                        vm.policyHolderDateOfBirthApp = angular.copy(vm.getParsedQuestionSetWithoutSaving.PolicyHolder.DateOfBirthApp);
                        if (newBusinessdata) {
                            vm.state.PaymentFrequency.ModeOfPayment = newBusinessdata.data.PaymentFrequency;
                            vm.state.PaymentFrequency.InstallmentDate = newBusinessdata.data.InstallmentDate;
                        }

                        //Code to enable disable state when policyeffectivedate = endorsementeffectivedate
                        if (vm.getParsedQuestionSetWithoutSaving.RiskInformation.AddressDetails.IsManualAddress) {
                            vm.state.RiskInformation.AddressDetails.AddressLine1 = vm.getParsedQuestionSetWithoutSaving.RiskInformation.AddressDetails.AddressLine1;
                            vm.selectedMannualAddress = vm.getParsedQuestionSetWithoutSaving.RiskInformation.AddressDetails.AddressText;

                        }
                        else if (!vm.getParsedQuestionSetWithoutSaving.RiskInformation.AddressDetails.IsManualAddress && vm.getParsedQuestionSetWithoutSaving.RiskInformation.AddressDetails.AddressText !== null) {
                            vm.state.RiskInformation.AddressDetails.AddressText = vm.getParsedQuestionSetWithoutSaving.RiskInformation.AddressDetails.AddressText;
                            vm.selectedAddress = { postCode: vm.getParsedQuestionSetWithoutSaving.RiskInformation.AddressDetails.Postcode, text: vm.getParsedQuestionSetWithoutSaving.RiskInformation.AddressDetails.AddressText, value: vm.getParsedQuestionSetWithoutSaving.RiskInformation.AddressDetails.AddressValue };
                            vm.selectedAddress = angular.copy(vm.getParsedQuestionSetWithoutSaving.RiskInformation.AddressDetails.AddressText);
                        } 
                    }
                }

                else {

                    if (vm.personalAccidentData.PersonalAccidentQuestion.RiskInformation.AddressDetails.IsManualAddress) {
                        vm.selectedMannualAddress = vm.personalAccidentData.PersonalAccidentQuestion.RiskInformation.AddressDetails.AddressText;
                        vm.state.RiskInformation.AddressDetails.AddressLine1 = vm.personalAccidentData.PersonalAccidentQuestion.RiskInformation.AddressDetails.AddressLine1;
                    }
                    else {
                        vm.selectedAddress = vm.personalAccidentData.PersonalAccidentQuestion.RiskInformation.AddressDetails.AddressText;
                    }
                }
                
                if (vm.endorsementVM) {
                    endorsementstate = angular.copy(vm.state);
                    vm.state.BrokerRemuneration.BrokerFee = 0;
                    vm.state.BrokerRemuneration.BrokerFeeGST = 0;
                    vm.transactionId = personalAccidentData.QuoteTransactionId;
                    if (vm.state.RiskInformation.AddressDetails.IsManualAddress === false) {
                        vm.state.RiskInformation.AddressDetails.AddressLine1 = null;
                        vm.selectedMannualAddress = null;
                    }  
                    var endorsementDataVM = JSON.parse(sessionStorageService.get(keyConstService.endorsementRequestVM));
                    {
                        if (endorsementDataVM) {
                            vm.policyEffectiveDate = moment(endorsementDataVM.StartDate).format('MM/DD/YYYY');
                            vm.endorsementEffectiveDate = endorsementDataVM.EndorsementEffectiveDate;
                            if (vm.policyEffectiveDate === vm.endorsementEffectiveDate) {
                            // full term endorsement
                                vm.IsEndorsementPolicyEffectiveDate = true;
                                var isEndorsementEdit = JSON.parse(sessionStorageService.get(keyConstService.IsNewEditTransaction));
                                if (isEndorsementEdit) {
                                    if (vm.getParsedQuestionSetWithoutSaving) {
                                        vm.state.UnderwritingCriteria.HasInsuredInLast3Years = vm.getParsedQuestionSetWithoutSaving.UnderwritingCriteria.HasInsuredInLast3Years;
                                        vm.state.UnderwritingCriteria.InsuredInLast3YearsData = vm.getParsedQuestionSetWithoutSaving.UnderwritingCriteria.InsuredInLast3YearsData;
                                    }
                                }
                            }
                            else {
                                // mid term endorsement
                                vm.IsEndorsementPolicyEffectiveDate = false;
                                var newBusinessQuestionsForEndorsement = quotesService.getQuestionSetForPolicy(personalAccidentData.PolicyId)
                                    .then(function (result) {
                                        var questionsSet = JSON.parse(result.data.requestContent);
                                        vm.state.UnderwritingCriteria.HasInsuredInLast3Years = questionsSet.UnderwritingCriteria.HasInsuredInLast3Years;
                                        vm.state.UnderwritingCriteria.InsuredInLast3YearsData = questionsSet.UnderwritingCriteria.InsuredInLast3YearsData;
                                    });
                            }
                        }
                    }
                }
          
                if (vm.ReadOnly === true) {
                    sessionStorageService.set(keyConstService.IsNewBusinessReadOnly, vm.personalAccidentData.IsReadOnly);
                }
                vm.StartDate = vm.personalAccidentData.StartDate;
                if (sessionStorageService.get(keyConstService.newBusinessCaseData) !== null) {
                    newBusinessCaseDetail = JSON.parse(sessionStorageService.get(keyConstService.newBusinessCaseData));
                    vm.state.QuotePolicyInfo.EffectiveDate = newBusinessCaseDetail.data.EffectiveDate;
                    vm.state.QuotePolicyInfo.ExpirationDate = newBusinessCaseDetail.data.ExpirationDate;
                    vm.state.QuotePolicyInfo.StartDate = newBusinessCaseDetail.data.EffectiveDate;
                }
                else {
                    vm.state.QuotePolicyInfo.EffectiveDate = vm.personalAccidentData.EffectiveDate;
                    vm.state.QuotePolicyInfo.ExpirationDate = vm.personalAccidentData.ExpirationDate;
                    vm.state.QuotePolicyInfo.StartDate = vm.personalAccidentData.EffectiveDate;
                }

                if (!sessionStorageService.get(keyConstService.IsNewEditTransaction)) {
                    var isEdit = JSON.parse(sessionStorageService.get(keyConstService.IsNewEditTransaction));
                    if (isEdit !== false) {
                        isNewEditTransaction = true;
                        sessionStorageService.set(keyConstService.IsNewEditTransaction, isNewEditTransaction);
                    }
                }
                sessionStorageService.set(keyConstService.rowVersion, personalAccidentData.RowVersion);
                sessionStorageService.set(keyConstService.caseId, personalAccidentData.QuoteCase.Id);
                caseId = sessionStorageService.get(keyConstService.caseId);

                sessionStorageService.set(keyConstService.caseNumber, vm.CaseNumber);
                vm.getNewBusinessCaseData = JSON.parse(sessionStorageService.get(keyConstService.newBusinessCaseData));
                sessionStorageService.set(keyConstService.newBusinessData, vm.getNewBusinessCaseData);
                IsNewBusinessEdit = sessionStorageService.get(keyConstService.IsNewBusinessEdit);
                sessionStorageService.remove(keyConstService.quoteTransactionId);
                sessionStorageService.set(keyConstService.quoteTransactionId, personalAccidentData.QuoteTransactionId);

                if (vm.state.RiskInformation.AddressDetails.AddressText !== null && !vm.state.RiskInformation.AddressDetails.IsManualAddress && vm.getTransactionIdfromSession !== vm.getTransactionIdWithoutSaving) {
                    vm.selectedAddress = vm.state.RiskInformation.AddressDetails.AddressText;
                    vm.selectAddress = vm.state.RiskInformation.AddressDetails.AddressValue;
                }
                else if (vm.state.RiskInformation.AddressDetails.AddressText !== null && vm.state.RiskInformation.AddressDetails.IsManualAddress) {
                    vm.selectedMannualAddress = vm.state.RiskInformation.AddressDetails.AddressText;
                    vm.selectMannualAddress = vm.state.RiskInformation.AddressDetails.AddressValue;
                }

                if (vm.IsEndorsement) {
                    var CoverageOnEndorsement = vm.EndorsementCoverage = vm.personalAccidentData.PersonalAccidentQuestion.CoverageInfo.CoverageOnEndorsement;
                    if (CoverageOnEndorsement === keyConstService.paAccidentOnlyCoverageKey) {
                        vm.IsAccidentOnly = true;
                        vm.IsAccidentAndSickness = false;
                    }
                    else {
                        vm.IsAccidentOnly = false;
                        vm.IsAccidentAndSickness = true;
                    }
                }

                var productName = personalAccidentData.LOB;
                if (productName == undefined || productName==null) {
                    productName = "Personal Accident";
                }
                startDate = personalAccidentData.EffectiveDate;
                if (!vm.IsEndorsement) {
                    var brokerCommissionRequestOnEdit = quotesService.getBrokerCommissiononEdit({
                        EffectiveDate: startDate,
                        ProductName: productName,
                        ProductId: null
                    })
                        .then(function (result) {
                            vm.data = result.data.brokerBranchCommissionFeeVM;
                            if (vm.data) {
                                for (var i = 0; i < vm.data.length; i++) {
                                    if (vm.data[i].coverCode.toLowerCase() === keyConstService.personalAccidentCover.toLowerCase()) {
                                        vm.maxbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMax;
                                        vm.minbrokerCommissionPercentage = vm.data[i].brokerCommissionFeeMin;
                                    }
                                    if (!vm.ReadOnly && !vm.IsEndorsement) {
                                        vm.checkBrkerCommissionLimit();
                                    }
                                }
                                if (vm.getTransactionIdfromSession === vm.getTransactionIdWithoutSaving && vm.getTransactionIdWithoutSaving !== null && getQuoteTransactionId !== null) {
                                    vm.state.PolicyHolder.DateOfBirthApp = vm.policyHolderDateOfBirthApp;
                                }
                            }
                        });
                }

                vm.checkAgreedValue = true;
                // check for valid entry in fields
                vm.checkBrkerCommissionLimit();
                vm.checkWeeklyBenefitValue();
                vm.checkWeeklyCapitalCoverValue();
                vm.isDuplicateExcess();
                getInsuredNameList(true);
                getSecondaryInsuredList(personalAccidentData.PersonalAccidentQuestion.PolicyHolder.DateOfBirthApp);
                // removing questionset from session for valid newbusiness quote
                if (!vm.getParsedQuestionSetWithoutSaving) {
                    sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
                }
            
                if (!IsNewBusinessEdit) {
                    sessionStorageService.remove(keyConstService.newBusinessCaseData);
                }
                else if (vm.getNewBusinessCaseData) {
                    vm.personalAccidentData.PackageDetail.PaymentFrequency = vm.getNewBusinessCaseData.data.PaymentFrequency;
                    vm.personalAccidentData.PackageDetail.InstallmentDate = vm.getNewBusinessCaseData.data.InstallmentDate;
                }
                // removing questionset from session for valid newbusiness quote
                if (!vm.getParsedQuestionSetWithoutSaving) {
                    sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
                }
            }
            vm.state.PaymentFrequency.ModeOfPayment = vm.personalAccidentData.PackageDetail.PaymentFrequency;
            vm.state.PaymentFrequency.DayofInstallment = 0;
            if (vm.state.PaymentFrequency.ModeOfPayment === 'Monthly') {
                vm.state.PaymentFrequency.DayofInstallment = vm.personalAccidentData.PackageDetail.InstallmentDate;
            }
        };

        vm.getQuote = function () {
            vm.isDisabled = true;
            vm.getConvertedDate();
            vm.state.CoverageInfo.CapitalCover = vm.state.CoverageInfo.CapitalCover === null ? 0 : vm.state.CoverageInfo.CapitalCover;
                        if (vm.transactionStatus === "Draft") {
                isNewEditTransaction = false;
            }
            else {
                isNewEditTransaction = sessionStorageService.get(keyConstService.IsNewEditTransaction);
            }
            vm.rowVersion = JSON.parse(sessionStorageService.get(keyConstService.rowVersion));
            var automaticPayment = -1;
            if (vm.endorsementVM !== null) {
                vm.state.QuotePolicyInfo.EffectiveDate = vm.endorsementVM.EndorsementEffectiveDate;
                vm.state.QuotePolicyInfo.ExpirationDate = vm.endorsementVM.ExpirationDate;
                vm.state.QuotePolicyInfo.StartDate = vm.endorsementVM.StartDate;
                sessionStorageService.remove(keyConstService.endorsementRequestVM);
                sessionStorageService.remove(keyConstService.IsEndorsementEdit);

            }
            else {
                //var newBusinessData = JSON.parse(sessionStorageService.get(keyConstService.newBusinessCaseData));
                if (newBusinessCaseDetail && newBusinessCaseDetail.data) {
                    vm.state.QuotePolicyInfo.EffectiveDate = newBusinessCaseDetail.data.EffectiveDate;
                    vm.state.QuotePolicyInfo.ExpirationDate = newBusinessCaseDetail.data.ExpirationDate;
                    vm.state.QuotePolicyInfo.StartDate = newBusinessCaseDetail.data.StartDate;
                    automaticPayment = newBusinessCaseDetail.data.BrokerManagedPayment;
                }
            }
            // update the model for 
            if (automaticPayment === -1) {
                automaticPayment = vm.brokerManagedPayment;
            }
            vm.state.PaymentFrequency.BrokerManagedPayment = automaticPayment;
            sessionStorageService.set(keyConstService.quoteState, vm.state);
            var data = sessionStorageService.get(keyConstService.quoteState);
            if (sessionStorageService.get(keyConstService.IsCopyQuote) === "true")
                isNewEditTransaction = false;
            var transactionId = JSON.parse(sessionStorageService.get(keyConstService.quoteTransactionId));
            var finalData = { SaveContent: data, EffectiveDate: vm.state.QuotePolicyInfo.EffectiveDate, ExpirationDate: vm.state.QuotePolicyInfo.ExpirationDate, TransactionId: transactionId, NewEditTransaction: isNewEditTransaction, RowVersion: vm.rowVersion, PaymentFrequency: vm.state.PaymentFrequency.ModeOfPayment, InstallmentDate: vm.personalAccidentData.PackageDetail.InstallmentDate, BrokerManagedPayment: automaticPayment };
            vm.disableButtons = true;
            sessionStorageService.remove(keyConstService.getTransactionIdWithoutSaving);
            sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
            sessionStorageService.remove(keyConstService.resetNonRegoData);
            sessionStorageService.set(keyConstService.sessionStorageState, false);
            quotesService.generateQuote(quotesService.generateRequest(finalData, "PersonalAccident"), "PersonalAccident").then(function (data) {
                var handledResponse = quotesService.handleResponse(data, "PersonalAccident");
                if (handledResponse.status) {
                    sessionStorageService.remove(keyConstService.IsNewEditTransaction);
                    sessionStorageService.remove(keyConstService.IsCopyQuote);
                    vm.rowVersion = handledResponse.data.rowVersion;
                    sessionStorageService.set(keyConstService.quoteTransactionId, handledResponse.data.transactionId);
                    //Remove PrimaryClientInsuredId
                    sessionStorageService.remove(keyConstService.PrimaryInsuredId);
                    if (handledResponse.data.error !== null) {
                        if (handledResponse.data.error.number === 401 || handledResponse.data.error.number === 402) {
                            if (handledResponse.data.error.number === 401) {
                                toastr.error(messageConstService.errServiceUnavailable);
                                vm.disableButtons = false;
                            }
                            $timeout(function () {
                                $window.location.href = webUrlConstService.homeIndex;
                            }, 1000);
                            return;
                        }
                    }
                    if (handledResponse.data.decisionResult) {
                        //
                        if (handledResponse.data.decisionResult.isDeclined || handledResponse.data.decisionResult.isReferral || handledResponse.data.ratingResult) {
                            var quoteTransactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
                            $window.location.href = webUrlConstService.quoteCaseIndex + '?' + sessionStorageService.getEncryption("quoteTransactionId=" + quoteTransactionId);

                        }
                        else {
                            toastr.error(messageConstService.errRatingService);
                            vm.disableButtons = false;
                        }

                    } else {
                        toastr.error(messageConstService.errDecisionService);
                        vm.disableButtons = false;
                    }

                }
                else {
                    toastr.error(messageConstService.errServiceUnavailable);
                    vm.disableButtons = false;
                }

            }, function (e) {
                var myJSON = JSON.stringify(e);
                $log.log('error myJSON', myJSON);
                //toastr.error(myJSON);
                toastr.error(messageConstService.errMessageWhenDuplicateEntryIssue);
                //vm.disableButtons = false;
            });
        };

        vm.saveQuote = function () {
            vm.disableButtons = true;            
            sessionStorageService.remove(keyConstService.getTransactionIdWithoutSaving);
            sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
            sessionStorageService.remove(keyConstService.resetNonRegoData);
            sessionStorageService.set(keyConstService.sessionStorageState, false);
            var transactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
            vm.rowVersion = JSON.parse(sessionStorageService.get(keyConstService.rowVersion));
            var automaticPayment = -1;
            if (vm.transactionStatus === "Draft") {
                isNewEditTransaction = false;
            }
            else {
                isNewEditTransaction = sessionStorageService.get(keyConstService.IsNewEditTransaction);
            }
            if (vm.endorsementVM !== null) {
                vm.state.QuotePolicyInfo.EffectiveDate = vm.endorsementVM.EndorsementEffectiveDate;
                vm.state.QuotePolicyInfo.ExpirationDate = vm.endorsementVM.ExpirationDate;
                vm.state.QuotePolicyInfo.StartDate = vm.endorsementVM.StartDate;
                sessionStorageService.set(keyConstService.endorsementRequestVM, vm.endorsementVM);
            }
            else {
                //var newBusinessData = JSON.parse(sessionStorageService.get(keyConstService.newBusinessCaseData));
                if (newBusinessCaseDetail && newBusinessCaseDetail.data) {
                    vm.state.QuotePolicyInfo.EffectiveDate = newBusinessCaseDetail.data.EffectiveDate;
                    vm.state.QuotePolicyInfo.ExpirationDate = newBusinessCaseDetail.data.ExpirationDate;
                    vm.state.QuotePolicyInfo.StartDate = newBusinessCaseDetail.data.StartDate;
                    automaticPayment = newBusinessCaseDetail.data.BrokerManagedPayment;
                }
            }
            if (automaticPayment === -1) {
                automaticPayment = vm.brokerManagedPayment;
            }
            vm.state.PaymentFrequency.BrokerManagedPayment = automaticPayment;
            var data = JSON.stringify(vm.state);
            var finalData = { SaveContent: data, EffectiveDate: vm.state.QuotePolicyInfo.EffectiveDate, ExpirationDate: vm.state.QuotePolicyInfo.ExpirationDate, TransactionId: transactionId, NewEditTransaction: isNewEditTransaction, RowVersion: vm.rowVersion, PaymentFrequency: vm.state.PaymentFrequency.ModeOfPayment, InstallmentDate: vm.personalAccidentData.PackageDetail.InstallmentDate, BrokerManagedPayment: automaticPayment };
            var quoteRequest = quotesService.generateRequest(finalData, "PersonalAccident");
            quotesService.saveQuote(quoteRequest, "PersonalAccident").then(function (data) {
                if (data !== null && data.data !== null && data.data.error !== null && data.data.error.number === 402) {
                    $timeout(function () {
                        $window.location.href = webUrlConstService.homeIndex;
                    }, 1000);
                    return;
                }
                if (data && data.status === false) {
                    toastr.error(messageConstService.errRecordUpdated);
                    vm.disableButtons = false;
                }
                else if (data && data.status === true) {
                    toastr.success("Saved!");
                    //Remove PrimaryClientInsuredId
                    sessionStorageService.remove(keyConstService.PrimaryInsuredId);
                    vm.rowVersion = data.data.quoteTransaction.rowVersion;
                    isNewEditTransaction = false;
                    sessionStorageService.set(keyConstService.IsNewEditTransaction, isNewEditTransaction);
                    sessionStorageService.set(keyConstService.rowVersion, vm.rowVersion);
                    sessionStorageService.set(keyConstService.quoteTransactionId, data.data.quoteTransaction.id);
                    sessionStorageService.set(keyConstService.newBusinessCaseData.status, data.data.quoteTransaction.status);
                    var handledResponse = quotesService.handleResponse(data, "PersonalAccident");
                    vm.disableButtons = false;
                }
            }, function (e) {
                var myJSON = JSON.stringify(e);
                $log.error('error myJSON', myJSON);
                vm.disableButtons = false;
            });
        };

        vm.continueOrNavigateBackToPackageManager = function () {
            var packageNumber = sessionStorageService.get('PackageNumberInformation');
            sessionStorageService.remove('IsPackageManagerNavigationMode');
            sessionStorageService.remove('PackageNumberInformation');
            sessionStorageService.remove('RenewalCounter');
            if (renewalCounter !== null && packageNumber !== null) {
                $window.location.href = webUrlConstService.getPackageInfo + sessionStorageService.getEncryption("packageNumber=" + JSON.parse(packageNumber) + "&&renewalCounter=" + renewalCounter);
            }
        };

        vm.Cancel = function () {
            vm.disableButtons = true;
            if (vm.IsEndorsement) {
                quotesService.quoteDiscardRequest(sessionStorageService.get(keyConstService.quoteTransactionId)).then(function (result) {
                    if (result.data) {
                        if (vm.showManagePkg) {
                            vm.packageNumber = sessionStorageService.get('PackageNumberInformation');
                            vm.renewalCounter = sessionStorageService.get('RenewalCounter');
                            sessionStorageService.remove('IsPackageManagerNavigationMode');
                            sessionStorageService.remove('PackageNumberInformation');
                            sessionStorageService.remove('RenewalCounter');
                            $window.location.href = webUrlConstService.getPackageInfo + sessionStorageService.getEncryption("packageNumber=" + JSON.parse(vm.packageNumber) + "&&renewalCounter=" + vm.renewalCounter);
                        }
                        else {
                            $timeout(function () {
                                var Id = vm.dataState.PolicyId;
                                window.location = "/Bind?" + sessionStorageService.getEncryption("id=" + Id);
                            }, 1000);
                        }
                    } else {
                        toastr.error(messageConstService.errServiceUnavailable);
                        vm.disableButtons = false;
                    }
                },
                    function (error) {
                        $log.error('error', error);
                        toastr.error(messageConstService.errServiceUnavailable);
                        vm.disableButtons = false;
                    });
            }
            else {
                $window.location = webUrlConstService.homeIndex;
            }
        };

        vm.showManualAddressOption = function () {
            vm.state.RiskInformation.AddressDetails.IsManualAddress = true;
            vm.searchText = null;
            vm.resetAddressData();
        };
       
        vm.resetSearchText = function () {
            vm.state.RiskInformation.AddressDetails.IsManualAddress = false;
            vm.resetAddressData();
        };

        vm.showManualAddressOtherInsured = function () {
            vm.otherInsuredAddress.isManualAddress = true;
            vm.searchText1 = null;
            resetAddress();
        };

        vm.resetSearchTextOtherInsured = function () {
            vm.otherInsuredAddress.isManualAddress = false;
            resetAddress();
        };

        

        vm.checkBrkerCommissionLimit = function () {
            vm.brokerCommissionLimitMessage = false;
            var regexp = /^[0-9]+(\.[0-9]{1,2})?$/;
            if (!regexp.test(vm.state.BrokerRemuneration.BrokerCommissionPercentage)) {
                vm.state.BrokerRemuneration.BrokerCommissionPercentage = null;
                vm.brokerCommissionLimitMessage = true;
            }

            if (vm.state.BrokerRemuneration.BrokerCommissionPercentage > vm.maxbrokerCommissionPercentage || vm.state.BrokerRemuneration.BrokerCommissionPercentage < vm.minbrokerCommissionPercentage)
                vm.brokerCommissionLimitMessage = true;
        };

        vm.Back = function () {      
            if (isPackageManagerMode === "true") {
                sessionStorageService.set(keyConstService.IsPackageManagerNavigationMode, "preTrue");
            }
            vm.disableButtons = true;
            //if (vm.IsEndorsement) {
            //    if (vm.state.RiskInformation.AddressDetails.IsManualAddress === false) {
            //        vm.selectedMannualAddress = null;
            //        vm.state.RiskInformation.AddressDetails.AddressLine1 = null;
            //    }
            //    sessionStorageService.set(keyConstService.AddressValue, vm.state.RiskInformation.AddressDetails.AddressValue);
            //}
            var currentTransactionId = sessionStorageService.get(keyConstService.quoteTransactionId);
            sessionStorageService.remove(keyConstService.resetNonRegoData);
            sessionStorageService.remove(keyConstService.getQuestionSetWithoutSaving);
            sessionStorageService.remove(keyConstService.isManualRegoEnabled);
            sessionStorageService.set(keyConstService.getQuestionSetWithoutSaving, vm.state);
            sessionStorageService.set(keyConstService.sessionStorageState, true);
            sessionStorageService.set(keyConstService.getTransactionIdWithoutSaving,currentTransactionId);

            if (vm.IsEndorsement && currentTransactionId !== null) {
                window.location = webUrlConstService.endorsementRequest + sessionStorageService.getEncryption("quoteTransactionId=" + currentTransactionId);
            }
            else {
                if (sessionStorageService.get(keyConstService.IsNewEditTransaction) !== "true") {
                    sessionStorageService.set(keyConstService.IsNewEditTransaction, isNewEditTransaction);
                }
                if (currentTransactionId !== null) {
                    window.location = webUrlConstService.newBusinessIndex + sessionStorageService.getEncryption("transactionId=" + currentTransactionId);
                }
            }
        };

        vm.EnableDisableButton = function (form1) {
            if ((vm.selectedAddress === null && !vm.state.RiskInformation.AddressDetails.IsManualAddress) ||
                form1.$invalid ||
                vm.ReadOnly ||                
                vm.brokerCommissionLimitMessage ||
                vm.invalidCapitalBenefitAmount ||
                vm.invalidWeeklyBenefitAmount ||
                vm.message !== null
                //!vm.validDOBOtherInsurer ||
                //!vm.policyHolderNameExists()
                ) {
                return true;
            } else {
                return false;
            }
        };

        vm.nextPremium = function () {
            if (vm.policyTransactionId) {
                $window.location.href = webUrlConstService.bindIndex + sessionStorageService.getEncryption('id=' + vm.policyTransactionId);
            }
            else {
                window.location = webUrlConstService.quoteCasePremiumURL + sessionStorageService.getEncryption('quoteTransactionId=' + vm.transactionId);
            }
        };

        vm.addressSearch = function (query) {
            return $http.get(apiUrlConstService.addressURL + 'IntechAddressListAsync?address=' + query, { skipInterceptor: true })
                .then(function (result) {
                    let obj = {
                        text: messageConstService.manualAddressList,
                        value: 'N/A',
                        postCode: null
                    };

                    let resultantdata = result.data.data;
                    if (resultantdata.length > 0) {
                        resultantdata.push(obj);
                    }
                    return resultantdata;
                });
        };

        vm.mannualAddressSearch = function (query) {
            return $http.get(apiUrlConstService.addressURL + 'MannualAddressList?searchAddress=' + query, { skipInterceptor: true })
                .then(function (result) {
                    return result.data.data;
                });
        };

        //Check Is Address is valid or not
        vm.checkValidManualAddress = function (field) {
            if (vm.mannualSearchText) {
                if (!vm.selectedMannualAddress) {
                    field.$setValidity('invalid', false);
                }
                else {
                    field.$setValidity('invalid', true);
                }
            }
        };

        vm.addressMapped = function addressMapped(address) {
            if (!address) {
                vm.state.RiskInformation.AddressDetails.AddressText = null;
            }

            if (address && address.value == 'N/A') {
                address = null;
                vm.selectedAddress = null;
                vm.showManualAddressOption();
            }

            if (address) {
                if (!address.text) {
                    vm.state.RiskInformation.AddressDetails.AddressText = address;
                }
                if (address.text) {
                    vm.state.RiskInformation.AddressDetails.AddressText = address.text;
                    if (address.value) {
                        vm.state.RiskInformation.AddressDetails.AddressValue = address.value;
                        vm.state.RiskInformation.AddressDetails.postcode = address.postCode === null ? null : address.postCode;
                        var splitSate = address.value.split('|');
                        vm.AddressState = splitSate[0];

                    }
                }
            }
        };

        vm.resetAddressData = function () { 
            if (!vm.IsEndorsement) {
                if (vm.state.RiskInformation.AddressDetails.IsManualAddress) {
                    vm.previousAddress = [{
                        postcode: vm.state.RiskInformation.AddressDetails.Postcode,
                        text: vm.state.RiskInformation.AddressDetails.AddressText,
                        value: vm.state.RiskInformation.AddressDetails.AddressValue
                    }];
                     
                    vm.previousSelectedAddress = vm.state.RiskInformation.AddressDetails.AddressText;
                    vm.state.RiskInformation.AddressDetails.Address = null;
                    vm.selectedMannualAddress = null;
                    vm.mannualSearchText = null;
                    vm.state.RiskInformation.AddressDetails.AddressLine1 = null;
                    vm.state.RiskInformation.AddressDetails.AddressText = null;
                } else {
                    //restore the address
                    vm.state.RiskInformation.AddressDetails.AddressText = vm.previousSelectedAddress;
                    if (vm.previousAddress && vm.previousAddress[0].text) {
                        vm.selectedAddress = vm.previousAddress[0];
                    }
                }
            }
            else {
                if (endorsementstate !== null && endorsementstate.RiskInformation.AddressDetails.IsManualAddress) {
                    if (!vm.state.RiskInformation.AddressDetails.IsManualAddress) {
                        if (vm.state.RiskInformation.AddressDetails.AddressLine1 !== null) {
                            vm.previousAddressLine1 = vm.state.RiskInformation.AddressDetails.AddressLine1;
                            vm.manualAddressText = vm.state.RiskInformation.AddressDetails.AddressText;
                        }
                        vm.state.RiskInformation.AddressDetails.AddressLine1 = null;
                        vm.state.RiskInformation.AddressDetails.AddressText = null;
                        vm.selectedMannualAddress = null;
                        vm.selectedAddress = null;
                    }
                    else {
                        vm.state.RiskInformation.AddressDetails.AddressLine1 = vm.previousAddressLine1;
                        vm.state.RiskInformation.AddressDetails.AddressText = vm.manualAddressText;
                        vm.selectedMannualAddress = vm.manualAddressText;
                    }
                }
                else {
                    if (!vm.state.RiskInformation.AddressDetails.IsManualAddress) {
                        vm.selectedAddress = vm.previousSelectedAddress;
                        vm.state.RiskInformation.AddressDetails.AddressValue = vm.previousAddressValue;
                    }
                    else {
                        vm.previousAddress = vm.state.RiskInformation.AddressDetails.AddressText;
                        vm.previousAddressValue = vm.state.RiskInformation.AddressDetails.AddressValue;
                        vm.previousSelectedAddress = vm.selectedAddress;
                        vm.mannualSearchText = null;
                        vm.state.RiskInformation.AddressDetails.AddressText = null;
                        vm.state.RiskInformation.AddressDetails.AddressLine1 = null;
                        vm.selectedAddress = null;
                        vm.selectedMannualAddress = null;
                    }
                }
            }

        };

        vm.ResetHasInsuredInLast3YearsSection = function () {
            if (!vm.state.UnderwritingCriteria.HasInsuredInLast3Years) {
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsEverInsuranceDeclined = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.ReasonEverInsuranceDeclined = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsBankrupt = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.ReasonBankrupt = null;
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsIncarcerated = null;
            }
            else {
                if (vm.IsEndorsement && endorsementstate) {
                    vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsEverInsuranceDeclined = endorsementstate.UnderwritingCriteria.InsuredInLast3YearsData.IsEverInsuranceDeclined;
                    vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsBankrupt = endorsementstate.UnderwritingCriteria.InsuredInLast3YearsData.IsBankrupt;
                    vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsIncarcerated = endorsementstate.UnderwritingCriteria.InsuredInLast3YearsData.IsIncarcerated;
                    vm.state.UnderwritingCriteria.InsuredInLast3YearsData.ReasonBankrupt = endorsementstate.UnderwritingCriteria.InsuredInLast3YearsData.ReasonBankrupt;
                    vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsIncarcerated = endorsementstate.UnderwritingCriteria.InsuredInLast3YearsData.IsIncarcerated;
                }
            }
        };

        vm.ResetDeclineSection = function () {
            if (vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsEverInsuranceDeclined === false &&
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsBankrupt === false &&
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsIncarcerated === false) {
                document.getElementById('openUnableToQuoteUW').click();
            }
            if (!vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsEverInsuranceDeclined) {
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.ReasonEverInsuranceDeclined = null;
            }
            else if (vm.IsEndorsement && vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsEverInsuranceDeclined && endorsementstate) {
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.ReasonEverInsuranceDeclined = endorsementstate.UnderwritingCriteria.InsuredInLast3YearsData.ReasonEverInsuranceDeclined;
            }
            if (!vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsBankrupt) {
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.ReasonBankrupt = null;
            }
            else if (vm.IsEndorsement && vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsBankrupt && endorsementstate) {
                vm.state.UnderwritingCriteria.InsuredInLast3YearsData.ReasonBankrupt = endorsementstate.UnderwritingCriteria.InsuredInLast3YearsData.ReasonBankrupt;
            }
        };

        vm.RevertUW = function () {
            vm.state.UnderwritingCriteria.HasInsuredInLast3Years = false;
            vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsEverInsuranceDeclined = null;
            vm.state.UnderwritingCriteria.InsuredInLast3YearsData.ReasonEverInsuranceDeclined = null;
            vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsBankrupt = null;
            vm.state.UnderwritingCriteria.InsuredInLast3YearsData.ReasonBankrupt = null;
            vm.state.UnderwritingCriteria.InsuredInLast3YearsData.IsIncarcerated = null;
          
        };
        vm.changeNotesPrintable = function (currentNote) {
            if (vm.state.Notes.length > 1) {
                var currentIndex = vm.state.Notes.indexOf(currentNote);
                var index = 1 - currentIndex;
                vm.state.Notes[index].IsPrintable = !currentNote.IsPrintable;
            }
        };

        vm.removeNote = function (item) {
            vm.state.Notes.splice(vm.state.Notes.indexOf(item), 1);
        };

        vm.addNote = function (currentNote) {
            var newNote = {
                Note: null,
                IsPrintable: !currentNote.IsPrintable
            };
            if (vm.state.Notes.length < 2) {
                vm.state.Notes.push(newNote);
            }
        };

        vm.isDuplicateExcess = function () {
            vm.message = null;
            if (!vm.IsEndorsement) {
                if (!vm.state.Excess.AccidentOnlyExcess2) {
                    vm.message = "Please select accident only option 2";
                    return;
                }
                if (vm.state.Excess.AccidentOnlyExcess3 === null || vm.state.Excess.AccidentOnlyExcess3 === "") {
                    vm.message = "Please select accident only option 3";
                    return;
                }
                if (vm.state.Excess.AccidentOnlyExcess1 === null || vm.state.Excess.AccidentOnlyExcess1 === "") {
                    vm.message = "Please select accident only option 1";
                    return;
                }

                if (vm.state.Excess.AccidentSicknessExcess2 === null || vm.state.Excess.AccidentSicknessExcess2 === "") {
                    vm.message = "Please select accident and sickness option 2";
                    return;
                }
                if (vm.state.Excess.AccidentSicknessExcess3 === null || vm.state.Excess.AccidentSicknessExcess3 === "") {
                    vm.message = "Please select accident and sickness option 3";
                    return;
                }
                if (vm.state.Excess.AccidentSicknessExcess1 === null || vm.state.Excess.AccidentSicknessExcess1 === "") {
                    vm.message = "Please select accident and sickness option 1";
                    return;
                }

                if (vm.state.Excess.AccidentOnlyExcess1 === vm.state.Excess.AccidentOnlyExcess2 || vm.state.Excess.AccidentOnlyExcess1 === vm.state.Excess.AccidentOnlyExcess3 || vm.state.Excess.AccidentOnlyExcess3 === vm.state.Excess.AccidentOnlyExcess2) {
                    vm.message = "Excess value cannot be same";
                    return;
                }
                if (vm.state.Excess.AccidentSicknessExcess1 === vm.state.Excess.AccidentSicknessExcess2 || vm.state.Excess.AccidentSicknessExcess1 === vm.state.Excess.AccidentSicknessExcess3 || vm.state.Excess.AccidentSicknessExcess3 === vm.state.Excess.AccidentSicknessExcess2) {
                    vm.message = "Excess value cannot be same";
                    return;
                }
            }

        };

        vm.checkWeeklyBenefitValue = function () {
            vm.invalidWeeklyBenefitAmount = false;
            if (!vm.checkAgreedValue) {
                vm.state.CoverageInfo.IsAgreedValue = false;
            }
            if (vm.state.CoverageInfo.WeeklyBenefit && vm.state.CoverageInfo.WeeklyBenefit <= vm.minWeelyBenefitValue) {
                vm.invalidWeeklyBenefitAmount = true;
            }
           
            if (vm.state.CoverageInfo.WeeklyBenefit <= keyConstService.AgreedValueThreshold && vm.state.CoverageInfo.WeeklyBenefit > vm.minWeelyBenefitValue) {
                vm.isvalidWeeklyBenefitAmount = false;
                vm.state.CoverageInfo.IsAgreedValue = true;
            }
            else if (vm.state.CoverageInfo.WeeklyBenefit > keyConstService.AgreedValueThreshold && vm.state.CoverageInfo.WeeklyBenefit <= vm.maxweeklyBenefitValue) {
                vm.isvalidWeeklyBenefitAmount = true;
            }                    
            else {
                vm.isvalidWeeklyBenefitAmount = false;
                vm.state.CoverageInfo.IsAgreedValue = false;
            }          

            vm.checkAgreedValue = false;
        };

        vm.checkvalidWeeklyBenefitAmount = function () {
        
}

     

        vm.checkWeeklyCapitalCoverValue = function () {
            vm.invalidCapitalBenefitAmount = false;
            
            if (vm.state.CoverageInfo.CapitalCover === "") {
                vm.state.CoverageInfo.CapitalCover = null;
            }
            else if (vm.state.CoverageInfo.CapitalCover > vm.maxCapitalCoverValue) {
                vm.invalidCapitalBenefitAmount = true;
            }
            else if (vm.state.CoverageInfo.CapitalCover == null ) {
                vm.invalidCapitalBenefitAmount = false;
            }
        };

        // occupation list related functions
        vm.addOccupation = function () {
            if (vm.state.RiskInformation.OccupationList !== null && vm.state.RiskInformation.OccupationList.length < 10) {
                vm.state.RiskInformation.OccupationList.push({ OccupationName: null, OccupationClass: null, OccupationKey: null, AnzicCode: null, SearchText : null });
            }
            else {
                vm.disableAddOccupation = true;
            }
        };

        vm.removeOccupation = function (occupation) {
            // Enable add button
            vm.disableAddOccupation = false;

            var index = vm.state.RiskInformation.OccupationList.indexOf(occupation);
            vm.state.RiskInformation.OccupationList.splice(index, 1);
        };

        vm.occupationSearch = function (searchQuery) {
            searchQuery = searchQuery.toLowerCase();
            //var otherOccupationObject = {OccupationName:'Other'}
            var results = [];
            var occupations = [];
            var otherOccupation = null;
            if (vm.OccupationListData) {
                angular.forEach(vm.OccupationListData, function (item, key) {
                    if (occupations.indexOf(item.OccupationName.toLowerCase()) === -1 && item.OccupationName.toLowerCase().indexOf(searchQuery) > -1 && item.OccupationName.toLowerCase() !== 'other') {
                        results.push(item);
                        occupations.push(item.OccupationName.toLowerCase());
                    }
                    if (item.OccupationName.toLowerCase() === 'other') {
                        otherOccupation = item;
                        //results.splice(item);
                    }
                });
                if (otherOccupation !== null) {
                    results.push(otherOccupation);
                }
            }
            return results;
        };

        vm.OccupationMapped = function (selectedOccupation, index) {
            //vm.state.RiskInformation.OccupationList.splice(index, 1);
            if (!selectedOccupation) {
                vm.state.RiskInformation.OccupationList[index].OccupationName = null;
                vm.state.RiskInformation.OccupationList[index].OccupationKey = null;
                vm.state.RiskInformation.OccupationList[index].OccupationClass = null;
                vm.state.RiskInformation.OccupationList[index].AnzicCode = null;
                vm.state.RiskInformation.OccupationList[index].SearchText = null;
                //vm.selectedOccupation = false;
            }

            if (selectedOccupation) {
                if (selectedOccupation.OccupationName !== 'Other') {
                    vm.state.RiskInformation.OccupationList[index].OccupationName = selectedOccupation.OccupationName;
                    vm.state.RiskInformation.OccupationList[index].OccupationKey = selectedOccupation.OccupationKey;
                    vm.state.RiskInformation.OccupationList[index].OccupationClass = selectedOccupation.OccupationClass;
                    vm.state.RiskInformation.OccupationList[index].AnzicCode = selectedOccupation.AnzicCode;
                }
                else {
                    vm.state.RiskInformation.OccupationList[index].OccupationName = null;
                    vm.state.RiskInformation.OccupationList[index].OccupationKey = selectedOccupation.OccupationKey;
                    vm.state.RiskInformation.OccupationList[index].OccupationClass = selectedOccupation.OccupationClass;
                    vm.state.RiskInformation.OccupationList[index].AnzicCode = selectedOccupation.AnzicCode;
                }

                for (var i = 0; i < vm.state.RiskInformation.OccupationList.length; i++)
                {
                    if (i !== index) {
                        if (vm.state.RiskInformation.OccupationList[i] && vm.state.RiskInformation.OccupationList[i].OccupationName === selectedOccupation.OccupationName) {
                            vm.state.RiskInformation.OccupationList[index].OccupationName = null;
                            vm.state.RiskInformation.OccupationList[index].OccupationKey = null;
                            vm.state.RiskInformation.OccupationList[index].OccupationClass = null;
                            vm.state.RiskInformation.OccupationList[index].AnzicCode = null;
                            vm.state.RiskInformation.OccupationList[index].SearchText = null;
                        }
                    }
                }
                //vm.selectedOccupation = true;
            }
        };

        vm.addOtherOccupation = function (otheroccupation, index) {
            vm.state.RiskInformation.OccupationList[index].OccupationName = otheroccupation.OccupationName;
        };

        // secondary insured lis
        vm.secondaryListChange = function (DOBFlag, DOBonEdit) {
            for (var i = 0; i < vm.state.PolicyHolder.InsuredNameList.length; i++) {
                if (vm.state.PolicyHolder.InsuredNameList !== null && vm.state.PolicyHolder.InsuredNameList[i].value === vm.state.PolicyHolder.InsuredName && vm.state.PolicyHolder.InsuredName !== 'Other' && vm.state.PolicyHolder.InsuredName !== 'OtherInsured') {
                    var index = vm.state.PolicyHolder.InsuredNameList.indexOf(vm.state.PolicyHolder.InsuredNameList[i]);
                    var temporarylist = angular.copy(vm.state.PolicyHolder.InsuredNameList);
                    // commented as per bug 7095
                    //vm.state.PolicyHolder.OtherInsuredName = null;
                    if (DOBFlag) {
                        if (vm.state.PolicyHolder.InsuredNameList[i].dateOfBirth !== null) {
                            vm.state.PolicyHolder.DateOfBirthApp = dateService.convertDatetoDDMMYYYFormat(vm.state.PolicyHolder.InsuredNameList[i].dateOfBirth);
                        }
                        else {
                            vm.state.PolicyHolder.InsuredNameList[i].dateOfBirth = "2000-01-01T00:00:00";
                        }
                    }
                    if (!DOBFlag) {
                        vm.state.PolicyHolder.DateOfBirthApp = DOBonEdit;
                    }
                    vm.state.PolicyHolder.SecondaryInsuredsList = temporarylist;
                    vm.state.PolicyHolder.InsuredClientId = !vm.state.PolicyHolder.InsuredNameList[i].Id ? vm.state.PolicyHolder.InsuredNameList[i].id : vm.state.PolicyHolder.InsuredNameList[i].Id;
                    vm.state.PolicyHolder.SecondaryInsuredsList.splice(index, 1);
                    vm.state.PolicyHolder.SecondaryInsuredsList = vm.state.PolicyHolder.SecondaryInsuredsList;

                    if (vm.state.PolicyHolder.SecondaryInsuredsList !== null) {
                        var secondaryInsuredOtherPos = vm.state.PolicyHolder.SecondaryInsuredsList.findIndex(p => p.value === "Other");
                        if (secondaryInsuredOtherPos !== -1) {
                            vm.state.PolicyHolder.SecondaryInsuredsList.splice(secondaryInsuredOtherPos, 1);
                        }
                    }
                    
                    // Changes Related to SME, update Primary Insured Id
                    sessionStorageService.set(keyConstService.PrimaryInsuredId, vm.state.PolicyHolder.InsuredClientId);
                }
                //else if (vm.state.PolicyHolder.InsuredName === 'Other') {
                //    angular.element('#add-insured').modal('show');
                //}

                ////else if (vm.state.PolicyHolder.InsuredName === 'Other') {
                ////    vm.state.PolicyHolder.InsuredClientId = null;
                ////    temporarylist = angular.copy(vm.state.PolicyHolder.InsuredNameList);
                ////    vm.state.PolicyHolder.SecondaryInsuredsList = temporarylist;
                ////    if (DOBFlag) {
                ////        vm.state.PolicyHolder.DateOfBirthApp = null;
                ////    }

                ////}
            }

            if (vm.state.PolicyHolder.InsuredName != "OtherInsured") {
                vm.tempPrimaryInsured = vm.state.PolicyHolder.InsuredName;
            } else if (vm.state.PolicyHolder.InsuredName === 'OtherInsured') {
                angular.element('#add-insured').modal('show');
            }
        };

        vm.changeOtherInsuredName = function () {
            if (form1 && form1.OtherInsuredName) {
                if (form1.OtherInsuredName.value.length > 100) {
                    vm.showMessageGrt100OtherInsuredName = true;
                    form1.OtherInsuredName.value = form1.OtherInsuredName.value.substring(0, 100);
                } else {
                    vm.showMessageGrt100OtherInsuredName = false;
                }
            }
        };

        vm.getConvertedDate = function () {
            var dateofBirth = vm.state.PolicyHolder.DateOfBirthApp;
            if (dateofBirth) {
                var response = dateService.validateBirthDDMMYYYY(dateofBirth, 150);

                if (!response.isValid) {
                    vm.state.PolicyHolder.DateOfBirth = '';
                    vm.state.PolicyHolder.DateOfBirthApp = '';
                    toastr.warning(response.errorMsg);
                    return;
                }

                vm.state.PolicyHolder.DateOfBirth = response.date;
            }

        };
        // back to package manager funciton
        vm.continueOrNavigateBackToPackageManager = function () {
            var packageNumber = sessionStorageService.get('PackageNumberInformation');
            var renewalCounter = sessionStorageService.get('RenewalCounter');
            sessionStorageService.remove('IsPackageManagerNavigationMode');
            sessionStorageService.remove('PackageNumberInformation');
            sessionStorageService.remove('RenewalCounter');
            $window.location.href = webUrlConstService.getPackageInfo + sessionStorageService.getEncryption("packageNumber=" + JSON.parse(packageNumber) + "&&renewalCounter=" + renewalCounter);
        };

        vm.CoverageChange = function (value) {
            if (value === keyConstService.paAccidentOnlyCoverageKey) {
                vm.state.CoverageInfo.CoverageOnEndorsement = keyConstService.paAccidentOnlyCoverageKey;
                vm.IsAccidentOnly = true;
                vm.IsAccidentAndSickness = false;
                vm.state.Excess.AccidentSicknessExcess1 = null;
                if (endorsementstate && endorsementstate.CoverageInfo.CoverageOnEndorsement === keyConstService.paAccidentOnlyCoverageKey) {
                    vm.state.Excess.AccidentOnlyExcess1 = endorsementstate.Excess.AccidentOnlyExcess1;
                }
                else {
                    vm.state.Excess.AccidentOnlyExcess1 = '7';
                }
            }
            else {
                vm.state.CoverageInfo.CoverageOnEndorsement = keyConstService.paAccidnetAndSicknessCoverageKey;
                vm.IsAccidentOnly = false;
                vm.IsAccidentAndSickness = true;
                vm.state.Excess.AccidentOnlyExcess1 = null;
                if (endorsementstate && endorsementstate.CoverageInfo.CoverageOnEndorsement === keyConstService.paAccidnetAndSicknessCoverageKey) {
                    vm.state.Excess.AccidentSicknessExcess1 = endorsementstate.Excess.AccidentSicknessExcess1;
                }
                else {
                    vm.state.Excess.AccidentSicknessExcess1 = '7';
                }
            }
        };

        function getInsuredNameList(isEdit) {
            caseId = sessionStorageService.get(keyConstService.caseId);

            quotesService.getInsuredNameList(caseId).then(function (ResponseData) {
                if (ResponseData.data !== null) {
                    if (!isEdit) {
                        vm.state.PolicyHolder.InsuredNameList=ResponseData.data.policyHolder.insuredNameList
                            .filter(function (item) { return item.insuredType !== "Business"; });
                        //vm.state.PolicyHolder.InsuredNameList = ResponseData.data.policyHolder.insuredNameList;
                        //vm.state.PolicyHolder.SecondaryInsuredsList = ResponseData.data.policyHolder.secondaryInsuredsList;
                        vm.state.PolicyHolder.InsuredClientId = ResponseData.data.policyHolder.insuredClientId;
                        vm.ClientDetail = ResponseData.data.clientDetail;
                        vm.addSecondaryClient = ResponseData.data.clientDetail.secondaryInsuredClientVM;
                        vm.otherInsuredAddress = ResponseData.data.clientDetail.addressLogVM;
                        vm.PropertyDetail = angular.copy(ResponseData.data.buildingInfo);
                        
                        //vm.state.PolicyHolder.InsuredName = ResponseData.data.policyHolder.insuredName;
                        if (!vm.selectedAddress) {
                            ResponseData.data.buildingInfo.addressText = null;
                            ResponseData.data.buildingInfo.addressValue = null;
                        }

                        // Commented as per bug 7567
                        //if (vm.selectedAddress) {
                        //    vm.state.RiskInformation.AddressDetails.AddressText = ResponseData.data.buildingInfo.addressText;
                        //    vm.state.RiskInformation.AddressDetails.AddressValue = ResponseData.data.buildingInfo.addressValue;
                        //}

                        //vm.checkRentalAmount();
                        //vm.checkSumInsuredValue();
                        //vm.checkClaims();


                        if (vm.getTransactionIdfromSession !== vm.getTransactionIdWithoutSaving) {
                            var newDate = new Date(ResponseData.data.policyHolder.dateOfBirthApp);
                            vm.state.PolicyHolder.DateOfBirthApp = newDate;
                        }
                        for (var i = 0; i < ResponseData.data.policyHolder.secondaryInsuredsList.length; i++) {
                            if (ResponseData.data.policyHolder.secondaryInsuredsList[i].value === vm.state.PolicyHolder.InsuredName && ResponseData.data.policyHolder.secondaryInsuredsList[i].id === vm.state.PolicyHolder.InsuredClientId) {
                                var index = ResponseData.data.policyHolder.secondaryInsuredsList.indexOf(ResponseData.data.policyHolder.secondaryInsuredsList[i]);
                                ResponseData.data.policyHolder.secondaryInsuredsList.splice(index, 1);
                                vm.state.PolicyHolder.SecondaryInsuredsList = ResponseData.data.policyHolder.secondaryInsuredsList;

                                if (vm.getTransactionIdfromSession === vm.getTransactionIdWithoutSaving) {
                                    vm.getQuestionSetWithoutSavingData = JSON.parse(sessionStorageService.get(keyConstService.getQuestionSetWithoutSaving));
                                    if (vm.getQuestionSetWithoutSavingData) {
                                        if (vm.getQuestionSetWithoutSavingData.PolicyHolder.InsuredName === "Other") {
                                            vm.state.PolicyHolder.InsuredName = vm.getQuestionSetWithoutSavingData.PolicyHolder.InsuredName;
                                            vm.state.PolicyHolder.OtherInsuredName = vm.getQuestionSetWithoutSavingData.PolicyHolder.OtherInsuredName;
                                            for (var j = 0; j < vm.getQuestionSetWithoutSavingData.PolicyHolder.SecondaryInsuredsList.length; j++) {
                                                vm.state.PolicyHolder.SecondaryInsuredsList[j] = vm.getQuestionSetWithoutSavingData.PolicyHolder.SecondaryInsuredsList[j];
                                            }
                                        }
                                    }
                                }
                                //else {
                                //    if (vm.state.PolicyHolder.InsuredName) {
                                //        vm.state.PolicyHolder.InsuredName = ResponseData.data.policyHolder.insuredName;
                                //    }
                                //}
                            }
                            //else {
                            //    if (vm.state.PolicyHolder.InsuredName) {
                            //        vm.state.PolicyHolder.InsuredName = ResponseData.data.policyHolder.insuredName;
                            //    }
                            //}
                        }
                    }
                    else {
                        vm.ClientDetail = ResponseData.data.clientDetail;
                        vm.addSecondaryClient = ResponseData.data.clientDetail.secondaryInsuredClientVM;
                        vm.otherInsuredAddress = ResponseData.data.clientDetail.addressLogVM;
                        vm.PropertyDetail = angular.copy(ResponseData.data.buildingInfo);
                        ResponseData.data.policyHolder.insuredNameList = ResponseData.data.policyHolder.insuredNameList
                            .filter(function (item) { return item.insuredType !== "Business"; });                                                        
                        vm.state.PolicyHolder.InsuredNameList = ResponseData.data.policyHolder.insuredNameList;
                    }
                    vm.tempPrimaryInsured = vm.state.PolicyHolder.InsuredName;
                }
            });
            if (!isEdit) {
                resetAddress();
            }

        }

        function getSecondaryInsuredList(DOBonEdit) {
            var caseid = vm.CaseNumber;
            vm.state.PolicyHolder.InsuredNameList = [];
            vm.state.PolicyHolder.SecondaryInsuredsList = [];
            var secondaryInsuredListOnEdit = clientService.getSecondaryInmsured(
                caseid)
                .then(function (result) {
                    if (result) {
                        vm.data = result.data.policyHolder;
                        for (var i = 0; i < result.data.policyHolder.insuredNameList.length; i++) {

                            vm.state.PolicyHolder.InsuredNameList.push(result.data.policyHolder.insuredNameList[i]);
                            vm.state.PolicyHolder.SecondaryInsuredsList.push(result.data.policyHolder.insuredNameList[i]);
                            vm.secondaryListChange(vm.DOBFlag, DOBonEdit);
                        }

                        // for additional insured
                        //checkAdditionalInsuredInList();
                    }
                });
        }

        vm.storeOtherInsuredAddress = function (address) {
            if (address && address.value == 'N/A') {
                address = null;
                vm.selectedAddress1 = null;
                vm.showManualAddressOtherInsured();
            }


            if (address !== null && address !== undefined) {
                if (address.value) {
                    vm.addSecondaryClient[0].IsStampDutyExempted = false;
                    var splitSate = address.value.split('|');
                    var AddressState = splitSate[0];
                    vm.addSecondaryClient[0].IsStampDutyExempted = false;
                    if (AddressState === "NSW") {
                        vm.addSecondaryClient[0].showStampDuty = true;
                    }
                    else {
                        vm.addSecondaryClient[0].showStampDuty = false;
                    }

                    if (vm.addSecondaryClient[0].IsSameAsPrimaryAddress && vm.otherInsuredAddress && vm.PropertyDetail.addressText !== address.text) {
                        vm.addSecondaryClient[0].IsSameAsPrimaryAddress = false;
                    }

                    if (vm.otherInsuredAddress) {
                        vm.otherInsuredAddress.Address = address.text;
                        vm.otherInsuredAddress.DelimeterAddress = address.value;
                        vm.otherInsuredAddress.PostCode = address.postCode === null ? null : address.postCode;
                        if (address.isManualAddress) {
                            vm.selectedOtherMannualItem = vm.selectedOtherMannualAddress.text;
                            vm.otherInsuredAddress.AddressLine1 = vm.selectedOtherMannualAddress.addressLine1;
                        }
                    }
                    else {
                        vm.otherInsuredAddress = {
                            Address: address.text,
                            DelimeterAddress: address.value,
                            PostCode: address.postCode === null ? null : address.postCode
                        };
                    }
                }
            }
        };

        vm.checkSameAsPrimary = function () {
            if (vm.addSecondaryClient[0].IsSameAsPrimaryAddress) {

                if (!vm.PropertyDetail.isManualAddress) {
                    vm.selectedAddress1 = { postCode: vm.PropertyDetail.postcode, text: vm.PropertyDetail.addressText, value: vm.PropertyDetail.addressValue };
                    vm.storeOtherInsuredAddress(vm.selectedAddress1);
                }
                else {
                    vm.selectedOtherMannualAddress = { postCode: vm.PropertyDetail.postcode, text: vm.PropertyDetail.addressText, addressLine1: vm.PropertyDetail.addressLine1, value: vm.PropertyDetail.addressValue, isManualAddress: vm.PropertyDetail.isManualAddress };
                    vm.storeOtherInsuredAddress(vm.selectedOtherMannualAddress);
                }
                vm.otherInsuredAddress.isManualAddress = vm.PropertyDetail.isManualAddress;
                if (vm.otherInsuredAddress.isManualAddress === false) {
                    vm.otherInsuredAddress.AddressLine1 = null;
                    vm.mannualOtherSearchText = null;
                    vm.selectedOtherMannualItem = null;
                }
            }
        };


        function resetAddress() {
            vm.selectedAddress1 = null;
            vm.otherInsuredAddress.Address = null;
            vm.otherInsuredAddress.DelimeterAddress = null;
            vm.otherInsuredAddress.PostCode = null;
            vm.showStampDuty = false;
            if (vm.addSecondaryClient.length > 0) {
                vm.addSecondaryClient[0].IsStampDutyExempted = false;
                vm.addSecondaryClient[0].IsSameAsPrimaryAddress = false;
            }
           
            if (vm.otherInsuredAddress.isManualAddress === false) {
                vm.otherInsuredAddress.AddressLine1 = null;
                vm.mannualOtherSearchText = null;
                vm.selectedOtherMannualItem = null;
            }
        }

        vm.cancelOtherInsured = function (type) {
            if (vm.addSecondaryClient.length > 0) {
                vm.addSecondaryClient[0].FirstName = null;
                vm.addSecondaryClient[0].LastName = null;
                vm.addSecondaryClient[0].DateOfBirthStringAsDDMMYYYY = null;
                vm.addSecondaryClient[0].OrganisationName = null;
                vm.addSecondaryClient[0].TradingName = null;
                vm.searchText1 = null;
                if (type === 'cancelButton') {
                    vm.addSecondaryClient[0].ClientType = null;
                }
            }
            if (type.$name === 'otherInsuredForm' && vm.otherInsuredAddress.isManualAddress === false) {
                type.otherAutocompleteAddress.$invalid = true;
                type.otherAutocompleteAddress.$touched = false;
            }

            if (type === 'cancelButton') {
               vm.state.PolicyHolder.InsuredName = vm.tempPrimaryInsured;
            }

            // Commentd by Ankur as per us 6829
            //vm.tempPrimaryInsured = vm.state.PolicyHolder.InsuredNameList.filter(function (e) { return e.clientType === 'Primary' })
            //vm.state.PolicyHolder.InsuredName = vm.tempPrimaryInsured[0].name;

            vm.otherInsuredAddress.isManualAddress = false;
            resetAddress();
        };

        vm.OtherSubmitEnabled = function (otherInsuredForm) {
            if (otherInsuredForm.$invalid || (vm.selectedAddress1 === null && !vm.otherInsuredAddress.isManualAddress)) {
                return true;
            }
            else {
                return false;
            }
        };

        vm.checkValidOtherManualAddress = function (field) {
            if (vm.mannualOtherSearchText) {
                if (!vm.selectedOtherMannualItem) {
                    field.$setValidity('invalid', false);
                }
                else {
                    field.$setValidity('invalid', true);
                }
            }
        };

        vm.addOtherInsured = function () {
            vm.ClientDetail.SecondaryInsuredClientVM = vm.addSecondaryClient;
            vm.ClientDetail.SecondaryInsuredClientVM[0].AddressLogVM = vm.otherInsuredAddress;

            var client = {
                ClientViewModel: vm.ClientDetail.clientViewModel !== null ? vm.ClientDetail.clientViewModel : null,
                SecondaryInsuredClientVM: vm.ClientDetail.SecondaryInsuredClientVM
            };

            var request = clientService.updateClientData({
                client: client
            });
            request.then(function success(response) {
                if (vm.ClientDetail.SecondaryInsuredClientVM[0].ClientType == 'Individual') {
                    vm.state.PolicyHolder.InsuredName = vm.ClientDetail.SecondaryInsuredClientVM[0].FirstName + " " + vm.ClientDetail.SecondaryInsuredClientVM[0].LastName;
                } else {                    
                   vm.state.PolicyHolder.InsuredName = vm.ClientDetail.SecondaryInsuredClientVM[0].OrganisationName;
                }
                return getInsuredNameList(false);
            });
        };
    }
})();;
(function () {
    'use strict';

    angular.module('appUI')
        .service('portalV2Service', ['$rootScope', '$resource', '$q', '$http', '$log', '$window', 'apiUrlConstService', 'keyConstService', 'sessionStorageService', portalV2Service]);

    function portalV2Service($rootScope, $resource, $q, $http, $log, $window, apiUrlConstService, keyConstService, sessionStorageService) {
        return {
            getV2Token: getV2Token,
            setKeyToLocalStorage: setKeyToLocalStorage,
            preserveTokenAndRedirectTo: preserveTokenAndRedirectTo
        };

        function getV2Token() {
            var portalV2API = $resource(apiUrlConstService.getV2Token, {}, 
                { request: { method: 'POST', isArray: false } });
            var retVal = portalV2API.request().$promise;
            return retVal;
        }

        //Function to set encrypted key in the local storage for SME product
        function setKeyToLocalStorage(token) {
            var  encryptedtkn = sessionStorageService.getEncryption(token);
                $window.localStorage.setItem(keyConstService.V2Auth, encryptedtkn);
        }

        //Function to set encrypted key in the session storage for Portal V2 and redirectAccordingly
        function preserveTokenAndRedirectTo(token, redirectTo, isDebuggingActive) {
            var encryptedtkn = sessionStorageService.getEncryption(token);
            sessionStorage.setItem(keyConstService.V2Auth, encryptedtkn);
            var host = window.location.protocol + '//' + window.location.host;
            if (isDebuggingActive) {
                var date = new Date();
                date.setTime(date.getTime() + (2 * 60 * 60 * 1000));
                var expires = "; expires=" + date.toUTCString();
                document.cookie = keyConstService.V2Auth + "=" + encryptedtkn + expires + "; path=/";
                host = keyConstService.PortalV2DebuggingHost;
            }
           $window.location.href = host + redirectTo;
        }
    }

})();;
