@dynamatix/gb-schemas 2.0.67 → 2.3.4

package/dist/applicants/applicant-welcome-call.model.js

@@ -0,0 +1,709 @@
+import mongoose from "mongoose";
+import { applyWorkflowPlugin } from "../shared/workflow.plugin";
+import { applyAuditMiddleware } from "@dynamatix/cat-shared/middlewares";
+// Welcome Call Schema
+const welcomeCallSchema = new mongoose.Schema({
+    applicantId: { type: mongoose.Schema.Types.ObjectId, ref: "Applicant", required: true },
+    applicationId: { type: mongoose.Schema.Types.ObjectId, ref: "Application", required: false },
+    bepReference: {
+        type: String,
+        description: "BEP reference",
+        default: null
+    },
+    applicantName: {
+        type: String,
+        description: "Applicant Name",
+        default: null
+    },
+    firstCallAttemptDate: {
+        type: String,
+        description: "Call Started Date",
+        default: null
+    },
+    scheduledCallTime: {
+        type: String,
+        description: "Scheduled Call Time",
+        default: null
+    },
+    callCompletedDate: {
+        type: String,
+        description: "Call Completed Date / Welcome call end date",
+        default: null
+    },
+    failedCallReason: {
+        type: String,
+        description: "Failed Call Reason",
+        default: null,
+    },
+    idvStatus: {
+        type: String,
+        description: "IDV Status",
+        default: null
+    },
+    customerFullNameStatusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup" },
+    customerDOBStatusLid: {
+        type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null
+    },
+    residentialAddressStatusLid: {
+        type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null
+    },
+    contactNumberStatusLid: {
+        type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null
+    },
+    emailAddressStatusLid: {
+        type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null
+    },
+    financePaymentTypeStatusLid: {
+        type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null
+    },
+    amountOfFinanceStatusLid: {
+        type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null
+    },
+    otherApplicantDetailsStatusLid: {
+        type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null
+    },
+    employerNameStatusLid: {
+        type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null
+    },
+    securityPropertyPurchasePriceLid: {
+        type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null,
+        description: "security property purchase price/estimated value"
+    },
+    idvPassedStatusLid: {
+        type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null
+    },
+    highRiskCountryStatusLid: {
+        type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null,
+        description: "applicant you are speaking is residing in high risk country"
+    },
+    securityPropertyAddressStatusLid: {
+        type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null,
+        description: "applicant to confirm the security property address"
+    },
+    monthlyFinancePaymentStatusLid: {
+        type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null
+    },
+    propertyResidents: {
+        type: String,
+        description: "Who will reside in the property? N.B. This should align with the finance type and other application details",
+        default: null
+    },
+    propertyTypeStatusLid: {
+        type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null,
+        description: "applicant to confirm type of property"
+    },
+    productFixedPeriodStatusLid: {
+        type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null,
+        description: "customer to confirm the length of product fixed period"
+    },
+    fullFinanceTermStatusLid: {
+        type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null,
+        description: "customer to confirm the length of finance term"
+    },
+    productRentalRateStatusLid: {
+        type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null
+    },
+    underwritingQuestions: {
+        type: String,
+        description: "Underwriting questions",
+        default: null
+    },
+    vulnerabilityImpact: {
+        type: String,
+        description: "Is there anything you feel the Bank should be aware of that could impact your finances or your ability to deal with your account either now or in the future?",
+        default: null
+    },
+    vulnerabilityIndicatorsStatusLid: {
+        type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null
+    },
+    vulnerabilityResponseStatusLid: {
+        type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null,
+        description: "vulnerability response to previous question"
+    },
+    isVulnerableCustomer: {
+        type: Boolean,
+        default: false,
+        description: "vulnerable customer SOP/TEXAS model"
+    },
+    isInformCustomerStatus: {
+        type: Boolean, default: false,
+        description: "inform customer if changes at any point in the future"
+    },
+    financeSummaryStatusLid: {
+        type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null,
+        desription: "customer to explain  summary of finance details"
+    },
+    ShahriahFinanceSummaryStatusLid: {
+        type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null,
+        description: "customer to summarize the understanding of shahriah finance details and how differ from mortgage"
+    },
+    isNextStepsStatus: {
+        type: Boolean, default: false,
+        description: "explain next step in application journey"
+    },
+    purchaseTypeLid: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: "Lookup",
+        required: false
+    },
+    lendingTypeLid: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: "Lookup",
+        required: false
+    },
+    customerEnglishabilityStatusLid: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: "Lookup",
+        required: false,
+        description: "Customer's levele of English speaking ability"
+    },
+    brokerNameStatusLid: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: "Lookup",
+        required: false,
+        description: "ask applicant to confirm the broker name"
+    },
+    accountHolderNameStatusLid: {
+        type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null,
+        description: "Ask the applicant to confirm the account holder and name of bank"
+    },
+    repaymentAmountStatusLid: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: "Lookup",
+        default: null,
+        description: "Ask the applicant to confirm the monthly repayment amount",
+    },
+    propertyReside: {
+        type: String,
+        description: "Customer to confirm who will reside in the property",
+        default: null
+    },
+    FinanceTypeStatusLid: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: "Lookup",
+        default: null,
+        description: "applicant response matched with application detail and finance type",
+    },
+    customerSufficientStatusLid: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: "Lookup",
+        required: false,
+        description: "customer sufficiently aware of application details",
+    },
+    knowledgeOfApplicationStatusLid: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: "Lookup",
+        required: false,
+        description: "applicant knowledge of application details",
+    },
+    customerQuestions: {
+        type: String,
+        description: "Ask the customer if they have any questions",
+        default: null
+    },
+    underwriterName: {
+        type: String,
+        description: "Name of underwriter",
+        default: null
+    },
+    failedCallDate: {
+        type: String,
+        description: "Failed Call Date",
+        default: null
+    },
+    isAlgbraAccountRequested: {
+        type: Boolean,
+        default: false,
+        description: "if Algbra bank account has been requested"
+    },
+    isActive: {
+        type: Boolean,
+        default: true,
+        description: "Welcome call active"
+    }
+}, {
+    timestamps: true,
+    toJSON: { virtuals: true },
+    toObject: { virtuals: true }
+});
+// virtual property for full name
+welcomeCallSchema.virtual('fullName').get(function () {
+    if (this.applicantId && typeof this.applicantId === 'object') {
+        const applicant = this.applicantId;
+        const firstName = applicant.firstName || '';
+        const lastName = applicant.lastName || '';
+        return `${firstName} ${lastName}`.trim();
+    }
+    return null;
+});
+// Virtual property for current address
+welcomeCallSchema.virtual('customerCurrentResidentialAddress').get(function () {
+    if (this.applicantId && typeof this.applicantId === 'object') {
+        const applicant = this.applicantId;
+        // Use only regular address fields (addressLine1, addressLine2, addressLine3)
+        if (applicant.addressLine1) {
+            // Get country name from populated addressCountryLid
+            let countryName = '';
+            if (applicant.addressCountryLid && typeof applicant.addressCountryLid === 'object') {
+                countryName = applicant.addressCountryLid.name || '';
+            }
+            const addressParts = [
+                applicant.addressLine1,
+                applicant.addressLine2,
+                applicant.addressLine3,
+                applicant.addressCity,
+                applicant.addressPostCode,
+                countryName
+            ].filter(part => part && part.trim() !== '');
+            return addressParts.join(', ');
+        }
+    }
+    return null;
+});
+// Virtual property for applicant employer/business name based on income settings
+welcomeCallSchema.virtual('applicantEmployerBusinessName').get(function () {
+    if (this.applicantId && typeof this.applicantId === 'object') {
+        const applicant = this.applicantId;
+        // Check if applicant has income settings
+        if (applicant.incomeSourceId && typeof applicant.incomeSourceId === 'object') {
+            const incomeSettings = applicant.incomeSourceId;
+            // If incomeFromEmployment is false, return N/A
+            if (!incomeSettings.incomeFromEmployment)
+                return 'N/A';
+            // Check employment status to determine if employed or self-employed
+            if (incomeSettings.employmentStatusLid && typeof incomeSettings.employmentStatusLid === 'object') {
+                const employmentStatus = incomeSettings.employmentStatusLid;
+                const statusName = employmentStatus.name;
+                // Check if it's employed status - compare by name for stability
+                if (statusName === 'Employee with no shareholding' ||
+                    statusName === 'A non-equity partner in a partnership' ||
+                    statusName === 'A shareholder with less than 25% shares') {
+                    // Check employment information
+                    if (applicant.employmentInformationId && typeof applicant.employmentInformationId === 'object') {
+                        const employment = applicant.employmentInformationId;
+                        // If field exists, return the value (or empty string if null/empty)
+                        if (employment.employerName && employment.employerName.trim() !== '') {
+                            return employment.employerName;
+                        }
+                        else {
+                            return '';
+                        }
+                        // Field exists but no data - return empty string
+                        return '';
+                    }
+                }
+                // Check if it's self-employed or solo trader status - compare by name for stability
+                else if (statusName === 'A shareholder with 25% or more shares' ||
+                    statusName === 'An equity partner in a partnership' ||
+                    statusName === 'Sole Trader') {
+                    // Check self-employment information
+                    if (applicant.selfEmployedInformationId && typeof applicant.selfEmployedInformationId === 'object') {
+                        const selfEmployment = applicant.selfEmployedInformationId;
+                        // If field exists, return the value (or empty string if null/empty)
+                        if (selfEmployment.nameOfBusiness && selfEmployment.nameOfBusiness.trim() !== '') {
+                            return selfEmployment.nameOfBusiness;
+                        }
+                        else {
+                            return '';
+                        }
+                        // Field exists but no data - return empty string
+                        return '';
+                    }
+                }
+            }
+            else {
+                console.log('No employment status found');
+            }
+        }
+    }
+    return 'N/A';
+});
+// Virtual property for Customer's Contact Numbers (Phone and Mobile)
+welcomeCallSchema.virtual('customerContactNumbers').get(function () {
+    if (this.applicantId && typeof this.applicantId === 'object') {
+        const phoneNumber = this.applicantId.phoneNumber;
+        const mobileNumber = this.applicantId.mobileNumber;
+        if (phoneNumber && mobileNumber) {
+            return `${phoneNumber}/${mobileNumber}`;
+        }
+        else if (phoneNumber) {
+            return phoneNumber;
+        }
+        else if (mobileNumber) {
+            return mobileNumber;
+        }
+    }
+    return null;
+});
+// Virtual property for other applicants name and DOB in the requested format
+welcomeCallSchema.virtual('otherApplicantsNameAndDOB').get(function () {
+    let application = null;
+    if (this.applicantId && typeof this.applicantId === 'object' && !(typeof this.applicantId.toHexString === 'function') && this.applicantId.applicationId) {
+        application = this.applicantId.applicationId;
+    }
+    else if (this.applicationId && typeof this.applicationId === 'object') {
+        application = this.applicationId;
+    }
+    else {
+        return 'N/A';
+    }
+    if (application) {
+        // Get all applicants from the application (field name is 'applicants')
+        if (application.applicants && Array.isArray(application.applicants) && application.applicants.length > 0) {
+            // Get current applicant ID for comparison
+            const currentApplicantId = this.applicantId?._id || this.applicantId;
+            // Filter out the current applicant to get only OTHER applicants
+            const otherApplicants = application.applicants.filter((applicant) => {
+                const applicantId = applicant._id || applicant;
+                return applicantId.toString() !== currentApplicantId.toString();
+            });
+            // If no other applicants, return "N/A" (single applicant case)
+            if (otherApplicants.length === 0) {
+                return 'N/A';
+            }
+            // Format each other applicant as: "First and middle names, last name, Date of birth"
+            const formattedApplicants = otherApplicants.map((applicant, index) => {
+                // Check if applicant is an ObjectId (not populated)
+                if (typeof applicant === 'string' || (applicant.constructor && applicant.constructor.name === 'ObjectId')) {
+                    return null; // Skip unpopulated references
+                }
+                const firstName = applicant.firstName || '';
+                const middleName = applicant.middleName || '';
+                const lastName = applicant.lastName || '';
+                // Combine first and middle names with space
+                const fullFirstName = middleName ? `${firstName} ${middleName}` : firstName;
+                // Format date of birth to dd/mm/yyyy
+                let formattedDOB = '';
+                if (applicant.dateOfBirth) {
+                    // Check if dateOfBirth is already a formatted string (DD/MM/YYYY)
+                    if (typeof applicant.dateOfBirth === 'string' && /^\d{2}\/\d{2}\/\d{4}$/.test(applicant.dateOfBirth)) {
+                        // Already in DD/MM/YYYY format
+                        formattedDOB = applicant.dateOfBirth;
+                    }
+                    else {
+                        // Try to parse as Date object or ISO string
+                        try {
+                            const date = new Date(applicant.dateOfBirth);
+                            // Check if date is valid
+                            if (!isNaN(date.getTime())) {
+                                const day = String(date.getDate()).padStart(2, '0');
+                                const month = String(date.getMonth() + 1).padStart(2, '0');
+                                const year = date.getFullYear();
+                                formattedDOB = `${day}/${month}/${year}`;
+                            }
+                        }
+                        catch (e) {
+                            // Date parsing failed, try to use as-is if it's a string
+                            if (typeof applicant.dateOfBirth === 'string') {
+                                formattedDOB = applicant.dateOfBirth;
+                            }
+                        }
+                    }
+                }
+                const isLast = index === otherApplicants.length - 1;
+                const comma = isLast ? '' : ',';
+                // Format as an HTML line (with bold labels and inline values)
+                return `
+            <div class="applicant-line">
+                <span class="readonly-data">${fullFirstName}, ${lastName}, ${formattedDOB}${comma}</span>
+            </div>
+        `;
+            }).filter((line) => line && line.trim() !== '');
+            // Join all applicants as HTML (no \n needed)
+            return formattedApplicants.join('');
+        }
+    }
+    // If application not populated or no applicants, return "N/A"
+    return 'N/A';
+});
+// Virtual property for broker name and firm 
+welcomeCallSchema.virtual('brokerNameAndFirm').get(function () {
+    // Access application from welcome call directly
+    if (this.applicationId && typeof this.applicationId === 'object') {
+        const application = this.applicationId;
+        let brokerName = '';
+        let tradingName = '';
+        // Get broker information
+        if (application.brokerId && typeof application.brokerId === 'object') {
+            const broker = application.brokerId;
+            // Get broker name
+            if (broker.firstName && broker.lastName) {
+                brokerName = `${broker.firstName} ${broker.lastName}`;
+            }
+            // Get trading name (try both lowercase and uppercase)
+            if (broker.tradingName) {
+                tradingName = broker.tradingName;
+            }
+            else if (broker.TradingName) {
+                tradingName = broker.TradingName;
+            }
+        }
+        // Combine in format "Broker name / Trading Name"
+        if (brokerName && tradingName) {
+            return `${brokerName} / ${tradingName}`;
+        }
+        else if (brokerName) {
+            return brokerName;
+        }
+        else if (tradingName) {
+            return tradingName;
+        }
+    }
+    return null;
+});
+// Virtual property for  account holder and Bank 
+welcomeCallSchema.virtual('accountHolderAndBank').get(function () {
+    if (this.applicantId && typeof this.applicantId === 'object' && this.applicantId.applicationId) {
+        const application = this.applicantId.applicationId;
+        let accountHolderName = '';
+        let institutionName = '';
+        // Get direct debit information
+        if (application && application.directDebitId && typeof application.directDebitId === 'object') {
+            const directDebit = application.directDebitId;
+            if (directDebit.nameOfAccountHolder) {
+                accountHolderName = directDebit.nameOfAccountHolder;
+            }
+            if (directDebit.institution) {
+                institutionName = directDebit.institution;
+            }
+        }
+        // Combine in format "account holder / institution"
+        if (accountHolderName && institutionName) {
+            return `${accountHolderName} / ${institutionName}`;
+        }
+        else if (accountHolderName) {
+            return accountHolderName;
+        }
+        else if (institutionName) {
+            return institutionName;
+        }
+    }
+    return null;
+});
+// virtual property for property address
+welcomeCallSchema.virtual('customerPropertyAddress').get(function () {
+    // Get property address from application's security reference
+    if (this.applicationId && typeof this.applicationId === 'object') {
+        const application = this.applicationId;
+        // Access security details through securityId
+        if (application.securityId && typeof application.securityId === 'object') {
+            const security = application.securityId;
+            // Use property address fields from security model
+            if (security.propertyAddressLine1) {
+                const addressParts = [
+                    security.propertyAddressLine1,
+                    security.propertyAddressLine2,
+                    security.propertyAddressLine3,
+                    security.propertyAddressCity,
+                    security.propertyAddressPostCode
+                ].filter(part => part && part.trim() !== '')
+                    .map(part => `${part},`);
+                return addressParts.join('\n');
+            }
+        }
+    }
+    return null;
+});
+// Virtual property for applicant employer information
+welcomeCallSchema.virtual('applicantEmployer').get(function () {
+    if (this.applicantId && typeof this.applicantId === 'object') {
+        const applicant = this.applicantId;
+        // Check if applicant has employment information
+        if (applicant.employmentId && typeof applicant.employmentId === 'object') {
+            const employment = applicant.employmentId;
+            // Priority: employerName first, then natureOfBusiness
+            if (employment.employerName && employment.employerName.trim() !== '') {
+                return employment.employerName;
+            }
+            else if (employment.natureOfBusiness && employment.natureOfBusiness.trim() !== '') {
+                return employment.natureOfBusiness;
+            }
+        }
+    }
+    return null;
+});
+// Virtual property for product name
+welcomeCallSchema.virtual('productName').get(function () {
+    // Get product from application
+    if (this.applicationId && typeof this.applicationId === 'object') {
+        const application = this.applicationId;
+        // First check if selectedProduct is on the application directly
+        let selectedProduct = application.selectedProduct;
+        // If not found on application, check productId
+        if (!selectedProduct || selectedProduct.trim() === '') {
+            if (application.productId && typeof application.productId === 'object') {
+                selectedProduct = application.productId.selectedProduct;
+            }
+        }
+        // Extract text before parentheses if selectedProduct has a value
+        if (selectedProduct && typeof selectedProduct === 'string' && selectedProduct.trim() !== '') {
+            // Extract text before opening parenthesis and trim whitespace
+            const match = selectedProduct.match(/^([^(]+)/);
+            if (match && match[1]) {
+                let productName = match[1].trim();
+                // Remove product type words like "Fixed", "Variable", "Tracker", etc.
+                // Split by common product type keywords and return only the first part
+                const productTypeKeywords = ['Fixed', 'Variable', 'Tracker', 'Discount', 'Capped'];
+                for (const keyword of productTypeKeywords) {
+                    if (productName.includes(keyword)) {
+                        productName = productName.split(keyword)[0].trim();
+                        break;
+                    }
+                }
+                return productName;
+            }
+            // If no parentheses found, return the whole string trimmed
+            return selectedProduct.trim();
+        }
+    }
+    return null;
+});
+// Virtual property for initial rate percentage
+welcomeCallSchema.virtual('initialRatePercentage').get(function () {
+    // Get product features from application
+    if (this.applicationId && typeof this.applicationId === 'object') {
+        const application = this.applicationId;
+        // Check if product features are available
+        if (application.productFeatures && typeof application.productFeatures === 'object') {
+            const productFeatures = application.productFeatures;
+            // Get initialRate value
+            if (productFeatures.initialRate !== undefined && productFeatures.initialRate !== null) {
+                const initialRate = productFeatures.initialRate;
+                // Convert to number
+                const rateValue = typeof initialRate === 'string' ? parseFloat(initialRate) : initialRate;
+                // Check if valid number
+                if (!isNaN(rateValue)) {
+                    // If value is less than 1, it's likely stored as decimal (e.g., 0.0599)
+                    // Multiply by 100 to get percentage
+                    // If value is greater than or equal to 1, it's likely already in percentage form (e.g., 5.99)
+                    // Divide by 100 as requested by user
+                    const percentageValue = rateValue >= 1 ? rateValue / 100 : rateValue * 100;
+                    // Format to 2 decimal places and add % sign
+                    return `${percentageValue.toFixed(2)}%`;
+                }
+            }
+        }
+    }
+    return null;
+});
+// Virtual property for finance summary HTML
+welcomeCallSchema.virtual('financeSummaryHtml').get(async function () {
+    let application = null;
+    if (this.applicantId && typeof this.applicantId === 'object' && !(typeof this.applicantId.toHexString === 'function') && this.applicantId.applicationId) {
+        application = this.applicantId.applicationId;
+    }
+    else if (this.applicationId && typeof this.applicationId === 'object') {
+        application = this.applicationId;
+    }
+    else {
+        return '-';
+    }
+    if (application) {
+        // Initialize summary data
+        let product = '';
+        let financeTerm = '';
+        let monthlyRepayment = '';
+        let rentalIncome = '';
+        let occupancy = '';
+        // Get product information (first 3 characters)
+        if (application.selectedProduct && typeof application.selectedProduct === 'string') {
+            const extracted = application.selectedProduct.split('(')[0].trim();
+            product = `${extracted} product`;
+        }
+        else if (application.productId && typeof application.productId === 'object' && application.productId.selectedProduct) {
+            const extracted = application.productId.selectedProduct.split('(')[0].trim();
+            product = `${extracted} product`;
+        }
+        else {
+            product = '-';
+        }
+        // Get finance term from productId if available
+        if (application.productId && typeof application.productId === 'object') {
+            if (application.productId.numberOfYearsToRepay !== undefined && application.productId.numberOfYearsToRepay !== null) {
+                financeTerm = `${application.productId.numberOfYearsToRepay} year finance term`;
+            }
+        }
+        else {
+            financeTerm = '-';
+        }
+        // Get rental income from mortgage - mortgageId is at application level
+        let mortgage = null;
+        if (application.mortgageId && typeof application.mortgageId === 'object') {
+            mortgage = application.mortgageId;
+        }
+        if (mortgage) {
+            // Helper function to format currency with commas
+            const formatCurrency = (value) => {
+                if (isNaN(value) || value === null || value === undefined) {
+                    return '0.00';
+                }
+                return value.toLocaleString('en-GB', {
+                    minimumFractionDigits: 2,
+                    maximumFractionDigits: 2
+                });
+            };
+            // Get rental income - check if it exists (even if 0)
+            if (mortgage.monthlyRentalIncome !== undefined && mortgage.monthlyRentalIncome !== null) {
+                // Convert to number first, then format
+                const numericValue = Number(mortgage.monthlyRentalIncome);
+                const rentalValue = isNaN(numericValue) ? '0.00' : formatCurrency(numericValue);
+                rentalIncome = `£${rentalValue}`;
+            }
+            // Get monthly repayment amount from productFeatures collection
+            try {
+                const ApplicationProductFeatures = mongoose.model('ApplicationProductFeatures');
+                const productFeatures = await ApplicationProductFeatures.findOne({
+                    applicationId: application
+                });
+                if (productFeatures && productFeatures.repayment !== undefined && productFeatures.repayment !== null) {
+                    const numericValue = Number(productFeatures.repayment);
+                    const repaymentValue = isNaN(numericValue) ? '0.00' : formatCurrency(numericValue);
+                    monthlyRepayment = `£${repaymentValue}`;
+                }
+                else {
+                    monthlyRepayment = '-';
+                }
+            }
+            catch (error) {
+                console.log('Error fetching product features:', error);
+                monthlyRepayment = '-';
+            }
+            // Get occupancy information from mortgage
+            if (mortgage.proposedTenantsLids && Array.isArray(mortgage.proposedTenantsLids) && mortgage.proposedTenantsLids.length > 0) {
+                // Get the first proposed tenant type
+                const firstTenant = mortgage.proposedTenantsLids[0];
+                if (firstTenant && typeof firstTenant === 'object' && firstTenant.name) {
+                    occupancy = firstTenant.name;
+                }
+            }
+            else {
+                occupancy = '-';
+            }
+        }
+        // Check if lending type is BTL to show rental income and occupancy
+        const isBTL = application.lendingTypeLid &&
+            typeof application.lendingTypeLid === 'object' &&
+            application.lendingTypeLid.name === 'BTL';
+        const monthlyRepaymentClass = isBTL ? 'mb-2' : '';
+        // Create HTML content
+        let summaryContent = `
+         <div class="flex align-items-center mb-2"><p class="text-bold m-0 readonly-data">Product:</p> <span class="readonly-data ml-2">${product}</span></div>
+         <div class="flex align-items-center mb-2"><p class="text-bold m-0 readonly-data">Finance Term:</p> <span class="readonly-data ml-2">${financeTerm}</span></div>
+         <div class="flex align-items-center ${monthlyRepaymentClass}"><p class="text-bold m-0 readonly-data">Monthly Repayment:</p> <span class="readonly-data ml-2">${monthlyRepayment}</span></div>`;
+        // Only show rental income and occupancy for BTL applications
+        if (isBTL) {
+            summaryContent += `
+        <div class="flex align-items-center mb-2"><p class="text-bold m-0 readonly-data">Rental Income:</p> <span class="readonly-data ml-2">${rentalIncome}</span></div>
+        <div class="flex align-items-center"><p class="text-bold m-0 readonly-data">Occupancy:</p> <span class="readonly-data ml-2">${occupancy}</span></div>`;
+        }
+        return summaryContent;
+    }
+    return '-';
+});
+applyAuditMiddleware(welcomeCallSchema, "ApplicantWelcomeCall");
+// Apply workflow plugin to the schema
+applyWorkflowPlugin(welcomeCallSchema, 'applicantwelcomecall');
+// Index for query optimization
+welcomeCallSchema.index({ applicantId: 1, isActive: 1 }); // Compound index for getWelcomeCallByApplicantId and softDeleteByApplicantId queries
+const WelcomeCallModel = mongoose.model('ApplicantWelcomeCall', welcomeCallSchema);
+export default WelcomeCallModel;