payservedb 5.6.4 → 5.6.6

package/src/models/propertyManagerContract.js

@@ -1,359 +1,359 @@
-const mongoose = require('mongoose');
-const Schema = mongoose.Schema;
-
-const PropertyManagerContractSchema = new Schema(
-    {
-        contractName: {
-            type: String,
-            required: [true, 'Contract name is required']
-        },
-        propertyManager: {
-            type: mongoose.Schema.Types.ObjectId,
-            ref: 'User',
-            required: [true, 'Property manager is required']
-        },
-        units: [{
-            type: mongoose.Schema.Types.ObjectId,
-            ref: 'Unit',
-            required: [true, 'At least one unit is required']
-        }],
-        customerId: {
-            type: mongoose.Schema.Types.ObjectId,
-            ref: 'Customer',
-            required: [true, 'Customer ID is required']
-        },
-        // Optional fields - only required when status is "Active"
-        startDate: {
-            type: Date,
-            required: function() {
-                return this.status === 'Active';
-            }
-        },
-        endDate: {
-            type: Date,
-            required: function() {
-                return this.status === 'Active';
-            }
-        },
-        invoiceDay: {
-            type: Number,
-            required: function() {
-                return this.status === 'Active';
-            },
-            min: [1, 'Invoice day must be between 1 and 31'],
-            max: [31, 'Invoice day must be between 1 and 31']
-        },
-        dueDate: {
-            type: String, // Store as string like "5th", "10th", etc.
-            required: function() {
-                return this.status === 'Active';
-            }
-        },
-        balanceBroughtForward: {
-            type: Number,
-            default: 0
-        },
-        collectionFrequency: {
-            type: String,
-            enum: ['Daily', 'Weekly', 'Bi-Weekly', 'Monthly', 'Quarterly', 'Semi-Annually', 'Annually'],
-            default: 'Monthly',
-            required: function() {
-                return this.status === 'Active';
-            }
-        },
-        // Always required fields regardless of status
-        managementFee: {
-            type: {
-                type: String,
-                enum: ['percentage', 'amount'],
-                required: [true, 'Management fee type is required']
-            },
-            value: {
-                type: Number,
-                required: [true, 'Management fee value is required'],
-                min: [0, 'Management fee value cannot be negative']
-            }
-        },
-        // GL Account configurations - matching LeaseAgreement pattern
-        invoiceDoubleEntryAccount: {
-            type: mongoose.Schema.Types.ObjectId,
-            ref: 'GLAccountDoubleEntries'
-        },
-        paymentDoubleEntryAccount: {
-            type: mongoose.Schema.Types.ObjectId,
-            ref: 'GLAccountDoubleEntries'
-        },
-        // GL Account direct configurations (used when creating double entry records)
-        glAccounts: {
-            invoice: {
-                debit: {
-                    type: mongoose.Schema.Types.ObjectId,
-                    ref: 'GLAccount'
-                },
-                credit: {
-                    type: mongoose.Schema.Types.ObjectId,
-                    ref: 'GLAccount'
-                }
-            },
-            payment: {
-                debit: {
-                    type: mongoose.Schema.Types.ObjectId,
-                    ref: 'GLAccount'
-                },
-                credit: {
-                    type: mongoose.Schema.Types.ObjectId,
-                    ref: 'GLAccount'
-                }
-            }
-        },
-        status: {
-            type: String,
-            enum: ['Active', 'Inactive', 'Completed', 'Suspended', 'Terminated'],
-            default: 'Inactive',
-            required: [true, 'Status is required']
-        },
-        facilityId: {
-            type: mongoose.Schema.Types.ObjectId,
-            ref: 'Facility',
-            required: [true, 'Facility ID is required']
-        },
-        lastInvoiceDate: {
-            type: Date
-        },
-        nextInvoiceDate: {
-            type: Date
-        },
-        autoSend: {
-            type: Boolean,
-            default: false
-        },
-        // Track data source and sync information
-        leaseDataSource: {
-            type: String,
-            enum: ['lease', 'manual'],
-            default: 'manual'
-        },
-        lastSyncedAt: {
-            type: Date
-        },
-        // Track which units have lease agreements
-        unitsWithLeases: [{
-            unitId: {
-                type: mongoose.Schema.Types.ObjectId,
-                ref: 'Unit'
-            },
-            leaseId: {
-                type: mongoose.Schema.Types.ObjectId,
-                ref: 'LeaseAgreement'
-            },
-            syncedAt: {
-                type: Date,
-                default: Date.now
-            }
-        }],
-        createdBy: {
-            type: mongoose.Schema.Types.ObjectId,
-            ref: 'User'
-        },
-        updatedBy: {
-            type: mongoose.Schema.Types.ObjectId,
-            ref: 'User'
-        },
-        // Track contract edit history
-        editHistory: [{
-            editedBy: {
-                type: mongoose.Schema.Types.Mixed,
-                ref: 'User'
-            },
-            editedAt: { 
-                type: Date, 
-                default: Date.now 
-            },
-            reason: { 
-                type: String, 
-                required: true 
-            },
-            changes: { 
-                type: Object 
-            }
-        }]
-    },
-    {
-        timestamps: true,
-        toJSON: { virtuals: true },
-        toObject: { virtuals: true }
-    }
-);
-
-// Virtual populate for Property Manager details
-PropertyManagerContractSchema.virtual('propertyManagerDetails', {
-    ref: 'User',
-    localField: 'propertyManager',
-    foreignField: '_id',
-    justOne: true
-});
-
-// Virtual populate for Customer details
-PropertyManagerContractSchema.virtual('customer', {
-    ref: 'Customer',
-    localField: 'customerId',
-    foreignField: '_id',
-    justOne: true
-});
-
-// Virtual populate for Units details
-PropertyManagerContractSchema.virtual('unitDetails', {
-    ref: 'Unit',
-    localField: 'units',
-    foreignField: '_id'
-});
-
-// Virtual populate for invoice double entry account
-PropertyManagerContractSchema.virtual('invoiceDoubleEntry', {
-    ref: 'GLAccountDoubleEntries',
-    localField: 'invoiceDoubleEntryAccount',
-    foreignField: '_id',
-    justOne: true
-});
-
-// Virtual populate for payment double entry account
-PropertyManagerContractSchema.virtual('paymentDoubleEntry', {
-    ref: 'GLAccountDoubleEntries',
-    localField: 'paymentDoubleEntryAccount',
-    foreignField: '_id',
-    justOne: true
-});
-
-// Virtual populate for Facility details
-PropertyManagerContractSchema.virtual('facility', {
-    ref: 'Facility',
-    localField: 'facilityId',
-    foreignField: '_id',
-    justOne: true
-});
-
-// Virtual to check if contract is complete (has all lease-dependent fields)
-PropertyManagerContractSchema.virtual('isComplete').get(function() {
-    return this.startDate && this.endDate && this.invoiceDay && this.dueDate && this.collectionFrequency;
-});
-
-// Virtual to get completion percentage
-PropertyManagerContractSchema.virtual('completionPercentage').get(function() {
-    const requiredFields = ['startDate', 'endDate', 'invoiceDay', 'dueDate', 'collectionFrequency'];
-    const completedFields = requiredFields.filter(field => this[field] != null).length;
-    return Math.round((completedFields / requiredFields.length) * 100);
-});
-
-// Pre-save middleware to ensure endDate is after startDate (only when both exist)
-PropertyManagerContractSchema.pre('save', function (next) {
-    if (this.startDate && this.endDate && this.startDate >= this.endDate) {
-        next(new Error('End date must be after start date'));
-    } else {
-        next();
-    }
-});
-
-// Pre-save middleware to validate units array is not empty
-PropertyManagerContractSchema.pre('save', function (next) {
-    if (!this.units || this.units.length === 0) {
-        next(new Error('At least one unit must be specified'));
-    } else {
-        next();
-    }
-});
-
-// Pre-save middleware to validate management fee
-PropertyManagerContractSchema.pre('save', function (next) {
-    if (this.managementFee.type === 'percentage' && this.managementFee.value > 100) {
-        next(new Error('Management fee percentage cannot exceed 100%'));
-    } else {
-        next();
-    }
-});
-
-// Pre-save middleware to auto-update status based on completion
-PropertyManagerContractSchema.pre('save', function (next) {
-    // If contract has all required lease fields and is currently Inactive, make it Active
-    if (this.status === 'Inactive' && this.isComplete) {
-        this.status = 'Active';
-        this.leaseDataSource = 'lease';
-        this.lastSyncedAt = new Date();
-    }
-    
-    // If contract is missing required fields and is currently Active, make it Inactive
-    if (this.status === 'Active' && !this.isComplete) {
-        this.status = 'Inactive';
-    }
-    
-    next();
-});
-
-// Pre-save middleware to set next invoice date based on collection frequency (only for active contracts)
-PropertyManagerContractSchema.pre('save', function (next) {
-    if (this.isNew && this.status === 'Active' && this.startDate && this.invoiceDay && !this.nextInvoiceDate) {
-        const baseDate = new Date(this.startDate);
-        baseDate.setDate(this.invoiceDay);
-        
-        // If the invoice day has passed this month, set for next month
-        if (baseDate < this.startDate) {
-            baseDate.setMonth(baseDate.getMonth() + 1);
-        }
-        
-        this.nextInvoiceDate = baseDate;
-    }
-    next();
-});
-
-// Method to sync with lease data
-PropertyManagerContractSchema.methods.syncWithLeaseData = async function(leaseData) {
-    if (!leaseData) return;
-    
-    this.startDate = leaseData.leaseTerms?.startDate || this.startDate;
-    this.endDate = leaseData.leaseTerms?.endDate || this.endDate;
-    this.invoiceDay = leaseData.financialTerms?.paymentDueDate || this.invoiceDay;
-    this.balanceBroughtForward = leaseData.financialTerms?.balanceBroughtForward || this.balanceBroughtForward;
-    this.collectionFrequency = leaseData.billingCycle?.frequency || this.collectionFrequency;
-    this.autoSend = leaseData.billingCycle?.autoSend !== undefined ? leaseData.billingCycle.autoSend : this.autoSend;
-    
-    // Copy GL accounts if available
-    if (leaseData.glAccounts) {
-        this.glAccounts = leaseData.glAccounts;
-    }
-    if (leaseData.invoiceDoubleEntryAccount) {
-        this.invoiceDoubleEntryAccount = leaseData.invoiceDoubleEntryAccount;
-    }
-    if (leaseData.paymentDoubleEntryAccount) {
-        this.paymentDoubleEntryAccount = leaseData.paymentDoubleEntryAccount;
-    }
-    
-    this.leaseDataSource = 'lease';
-    this.lastSyncedAt = new Date();
-    
-    // Auto-calculate due date from payment due date if not set
-    if (this.invoiceDay && !this.dueDate) {
-        const dueDateMap = {
-            1: "1st", 5: "5th", 10: "10th", 15: "15th"
-        };
-        this.dueDate = dueDateMap[this.invoiceDay] || `${this.invoiceDay}th`;
-    }
-    
-    return this.save();
-};
-
-// Indexes for efficient queries
-PropertyManagerContractSchema.index({ customerId: 1, status: 1 });
-PropertyManagerContractSchema.index({ facilityId: 1 });
-PropertyManagerContractSchema.index({ units: 1 });
-PropertyManagerContractSchema.index({ propertyManager: 1 }); // New index for property manager
-PropertyManagerContractSchema.index({ invoiceDoubleEntryAccount: 1 });
-PropertyManagerContractSchema.index({ paymentDoubleEntryAccount: 1 });
-PropertyManagerContractSchema.index({ startDate: 1, endDate: 1 });
-PropertyManagerContractSchema.index({ nextInvoiceDate: 1, status: 1 });
-PropertyManagerContractSchema.index({ leaseDataSource: 1 });
-PropertyManagerContractSchema.index({ 'unitsWithLeases.unitId': 1 });
-
-
-// Compile the model from the schema
-const PropertyManagerContract = mongoose.model("PropertyManagerContract", PropertyManagerContractSchema);
-
+const mongoose = require('mongoose');
+const Schema = mongoose.Schema;
+
+const PropertyManagerContractSchema = new Schema(
+    {
+        contractName: {
+            type: String,
+            required: [true, 'Contract name is required']
+        },
+        propertyManager: {
+            type: mongoose.Schema.Types.ObjectId,
+            ref: 'User',
+            required: [true, 'Property manager is required']
+        },
+        units: [{
+            type: mongoose.Schema.Types.ObjectId,
+            ref: 'Unit',
+            required: [true, 'At least one unit is required']
+        }],
+        customerId: {
+            type: mongoose.Schema.Types.ObjectId,
+            ref: 'Customer',
+            required: [true, 'Customer ID is required']
+        },
+        // Optional fields - only required when status is "Active"
+        startDate: {
+            type: Date,
+            required: function() {
+                return this.status === 'Active';
+            }
+        },
+        endDate: {
+            type: Date,
+            required: function() {
+                return this.status === 'Active';
+            }
+        },
+        invoiceDay: {
+            type: Number,
+            required: function() {
+                return this.status === 'Active';
+            },
+            min: [1, 'Invoice day must be between 1 and 31'],
+            max: [31, 'Invoice day must be between 1 and 31']
+        },
+        dueDate: {
+            type: String, // Store as string like "5th", "10th", etc.
+            required: function() {
+                return this.status === 'Active';
+            }
+        },
+        balanceBroughtForward: {
+            type: Number,
+            default: 0
+        },
+        collectionFrequency: {
+            type: String,
+            enum: ['Daily', 'Weekly', 'Bi-Weekly', 'Monthly', 'Quarterly', 'Semi-Annually', 'Annually'],
+            default: 'Monthly',
+            required: function() {
+                return this.status === 'Active';
+            }
+        },
+        // Always required fields regardless of status
+        managementFee: {
+            type: {
+                type: String,
+                enum: ['percentage', 'amount'],
+                required: [true, 'Management fee type is required']
+            },
+            value: {
+                type: Number,
+                required: [true, 'Management fee value is required'],
+                min: [0, 'Management fee value cannot be negative']
+            }
+        },
+        // GL Account configurations - matching LeaseAgreement pattern
+        invoiceDoubleEntryAccount: {
+            type: mongoose.Schema.Types.ObjectId,
+            ref: 'GLAccountDoubleEntries'
+        },
+        paymentDoubleEntryAccount: {
+            type: mongoose.Schema.Types.ObjectId,
+            ref: 'GLAccountDoubleEntries'
+        },
+        // GL Account direct configurations (used when creating double entry records)
+        glAccounts: {
+            invoice: {
+                debit: {
+                    type: mongoose.Schema.Types.ObjectId,
+                    ref: 'GLAccount'
+                },
+                credit: {
+                    type: mongoose.Schema.Types.ObjectId,
+                    ref: 'GLAccount'
+                }
+            },
+            payment: {
+                debit: {
+                    type: mongoose.Schema.Types.ObjectId,
+                    ref: 'GLAccount'
+                },
+                credit: {
+                    type: mongoose.Schema.Types.ObjectId,
+                    ref: 'GLAccount'
+                }
+            }
+        },
+        status: {
+            type: String,
+            enum: ['Active', 'Inactive', 'Completed', 'Suspended', 'Terminated'],
+            default: 'Inactive',
+            required: [true, 'Status is required']
+        },
+        facilityId: {
+            type: mongoose.Schema.Types.ObjectId,
+            ref: 'Facility',
+            required: [true, 'Facility ID is required']
+        },
+        lastInvoiceDate: {
+            type: Date
+        },
+        nextInvoiceDate: {
+            type: Date
+        },
+        autoSend: {
+            type: Boolean,
+            default: false
+        },
+        // Track data source and sync information
+        leaseDataSource: {
+            type: String,
+            enum: ['lease', 'manual'],
+            default: 'manual'
+        },
+        lastSyncedAt: {
+            type: Date
+        },
+        // Track which units have lease agreements
+        unitsWithLeases: [{
+            unitId: {
+                type: mongoose.Schema.Types.ObjectId,
+                ref: 'Unit'
+            },
+            leaseId: {
+                type: mongoose.Schema.Types.ObjectId,
+                ref: 'LeaseAgreement'
+            },
+            syncedAt: {
+                type: Date,
+                default: Date.now
+            }
+        }],
+        createdBy: {
+            type: mongoose.Schema.Types.ObjectId,
+            ref: 'User'
+        },
+        updatedBy: {
+            type: mongoose.Schema.Types.ObjectId,
+            ref: 'User'
+        },
+        // Track contract edit history
+        editHistory: [{
+            editedBy: {
+                type: mongoose.Schema.Types.Mixed,
+                ref: 'User'
+            },
+            editedAt: { 
+                type: Date, 
+                default: Date.now 
+            },
+            reason: { 
+                type: String, 
+                required: true 
+            },
+            changes: { 
+                type: Object 
+            }
+        }]
+    },
+    {
+        timestamps: true,
+        toJSON: { virtuals: true },
+        toObject: { virtuals: true }
+    }
+);
+
+// Virtual populate for Property Manager details
+PropertyManagerContractSchema.virtual('propertyManagerDetails', {
+    ref: 'User',
+    localField: 'propertyManager',
+    foreignField: '_id',
+    justOne: true
+});
+
+// Virtual populate for Customer details
+PropertyManagerContractSchema.virtual('customer', {
+    ref: 'Customer',
+    localField: 'customerId',
+    foreignField: '_id',
+    justOne: true
+});
+
+// Virtual populate for Units details
+PropertyManagerContractSchema.virtual('unitDetails', {
+    ref: 'Unit',
+    localField: 'units',
+    foreignField: '_id'
+});
+
+// Virtual populate for invoice double entry account
+PropertyManagerContractSchema.virtual('invoiceDoubleEntry', {
+    ref: 'GLAccountDoubleEntries',
+    localField: 'invoiceDoubleEntryAccount',
+    foreignField: '_id',
+    justOne: true
+});
+
+// Virtual populate for payment double entry account
+PropertyManagerContractSchema.virtual('paymentDoubleEntry', {
+    ref: 'GLAccountDoubleEntries',
+    localField: 'paymentDoubleEntryAccount',
+    foreignField: '_id',
+    justOne: true
+});
+
+// Virtual populate for Facility details
+PropertyManagerContractSchema.virtual('facility', {
+    ref: 'Facility',
+    localField: 'facilityId',
+    foreignField: '_id',
+    justOne: true
+});
+
+// Virtual to check if contract is complete (has all lease-dependent fields)
+PropertyManagerContractSchema.virtual('isComplete').get(function() {
+    return this.startDate && this.endDate && this.invoiceDay && this.dueDate && this.collectionFrequency;
+});
+
+// Virtual to get completion percentage
+PropertyManagerContractSchema.virtual('completionPercentage').get(function() {
+    const requiredFields = ['startDate', 'endDate', 'invoiceDay', 'dueDate', 'collectionFrequency'];
+    const completedFields = requiredFields.filter(field => this[field] != null).length;
+    return Math.round((completedFields / requiredFields.length) * 100);
+});
+
+// Pre-save middleware to ensure endDate is after startDate (only when both exist)
+PropertyManagerContractSchema.pre('save', function (next) {
+    if (this.startDate && this.endDate && this.startDate >= this.endDate) {
+        next(new Error('End date must be after start date'));
+    } else {
+        next();
+    }
+});
+
+// Pre-save middleware to validate units array is not empty
+PropertyManagerContractSchema.pre('save', function (next) {
+    if (!this.units || this.units.length === 0) {
+        next(new Error('At least one unit must be specified'));
+    } else {
+        next();
+    }
+});
+
+// Pre-save middleware to validate management fee
+PropertyManagerContractSchema.pre('save', function (next) {
+    if (this.managementFee.type === 'percentage' && this.managementFee.value > 100) {
+        next(new Error('Management fee percentage cannot exceed 100%'));
+    } else {
+        next();
+    }
+});
+
+// Pre-save middleware to auto-update status based on completion
+PropertyManagerContractSchema.pre('save', function (next) {
+    // If contract has all required lease fields and is currently Inactive, make it Active
+    if (this.status === 'Inactive' && this.isComplete) {
+        this.status = 'Active';
+        this.leaseDataSource = 'lease';
+        this.lastSyncedAt = new Date();
+    }
+    
+    // If contract is missing required fields and is currently Active, make it Inactive
+    if (this.status === 'Active' && !this.isComplete) {
+        this.status = 'Inactive';
+    }
+    
+    next();
+});
+
+// Pre-save middleware to set next invoice date based on collection frequency (only for active contracts)
+PropertyManagerContractSchema.pre('save', function (next) {
+    if (this.isNew && this.status === 'Active' && this.startDate && this.invoiceDay && !this.nextInvoiceDate) {
+        const baseDate = new Date(this.startDate);
+        baseDate.setDate(this.invoiceDay);
+        
+        // If the invoice day has passed this month, set for next month
+        if (baseDate < this.startDate) {
+            baseDate.setMonth(baseDate.getMonth() + 1);
+        }
+        
+        this.nextInvoiceDate = baseDate;
+    }
+    next();
+});
+
+// Method to sync with lease data
+PropertyManagerContractSchema.methods.syncWithLeaseData = async function(leaseData) {
+    if (!leaseData) return;
+    
+    this.startDate = leaseData.leaseTerms?.startDate || this.startDate;
+    this.endDate = leaseData.leaseTerms?.endDate || this.endDate;
+    this.invoiceDay = leaseData.financialTerms?.paymentDueDate || this.invoiceDay;
+    this.balanceBroughtForward = leaseData.financialTerms?.balanceBroughtForward || this.balanceBroughtForward;
+    this.collectionFrequency = leaseData.billingCycle?.frequency || this.collectionFrequency;
+    this.autoSend = leaseData.billingCycle?.autoSend !== undefined ? leaseData.billingCycle.autoSend : this.autoSend;
+    
+    // Copy GL accounts if available
+    if (leaseData.glAccounts) {
+        this.glAccounts = leaseData.glAccounts;
+    }
+    if (leaseData.invoiceDoubleEntryAccount) {
+        this.invoiceDoubleEntryAccount = leaseData.invoiceDoubleEntryAccount;
+    }
+    if (leaseData.paymentDoubleEntryAccount) {
+        this.paymentDoubleEntryAccount = leaseData.paymentDoubleEntryAccount;
+    }
+    
+    this.leaseDataSource = 'lease';
+    this.lastSyncedAt = new Date();
+    
+    // Auto-calculate due date from payment due date if not set
+    if (this.invoiceDay && !this.dueDate) {
+        const dueDateMap = {
+            1: "1st", 5: "5th", 10: "10th", 15: "15th"
+        };
+        this.dueDate = dueDateMap[this.invoiceDay] || `${this.invoiceDay}th`;
+    }
+    
+    return this.save();
+};
+
+// Indexes for efficient queries
+PropertyManagerContractSchema.index({ customerId: 1, status: 1 });
+PropertyManagerContractSchema.index({ facilityId: 1 });
+PropertyManagerContractSchema.index({ units: 1 });
+PropertyManagerContractSchema.index({ propertyManager: 1 }); // New index for property manager
+PropertyManagerContractSchema.index({ invoiceDoubleEntryAccount: 1 });
+PropertyManagerContractSchema.index({ paymentDoubleEntryAccount: 1 });
+PropertyManagerContractSchema.index({ startDate: 1, endDate: 1 });
+PropertyManagerContractSchema.index({ nextInvoiceDate: 1, status: 1 });
+PropertyManagerContractSchema.index({ leaseDataSource: 1 });
+PropertyManagerContractSchema.index({ 'unitsWithLeases.unitId': 1 });
+
+
+// Compile the model from the schema
+const PropertyManagerContract = mongoose.model("PropertyManagerContract", PropertyManagerContractSchema);
+
 module.exports = PropertyManagerContract;