payservedb 5.6.0 → 5.6.2

package/index.js

@@ -171,7 +171,8 @@ const models = {
     GLAccountDoubleEntries: require('./src/models/gl_account_double_entries'),
     PendingCredential: require('./src/models/pendingCredentials'),
     UnitManagementTemplate: require('./src/models/unitManagementTemplate'),
-    PropertyManagerRevenue: require('./src/models/propertyManagerRevenue')
+    PropertyManagerRevenue: require('./src/models/propertyManagerRevenue'),
+    PropertyManagerContract: require('./src/models/propertyManagerContract')
 };
 
 // Function to get models dynamically from a specific database connection

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "payservedb",
-  "version": "5.6.0",
+  "version": "5.6.2",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"

package/src/models/levy.js

@@ -37,7 +37,14 @@ const levySchema = new mongoose.Schema(
       type: String,
       required: true,
     },
-    // New fields added from levy contract
+    // New billing type field
+    billingType: {
+      type: String,
+      enum: ['Prepaid', 'Postpaid'],
+      required: true,
+      default: 'Postpaid'
+    },
+    // Fields from levy contract
     currency: {
       type: mongoose.Schema.Types.ObjectId,
       ref: "Currency",
@@ -52,6 +59,67 @@ const levySchema = new mongoose.Schema(
       type: mongoose.Schema.Types.ObjectId,
       required: false,
     },
+    // New bank payment field
+    bankPayment: {
+      type: Boolean,
+      default: false,
+      required: false,
+    },
+    // Bank details for bank payment
+    bankDetails: {
+      bankName: {
+        type: String,
+        required: false,
+        trim: true,
+      },
+      accountName: {
+        type: String,
+        required: false,
+        trim: true,
+      },
+      accountNumber: {
+        type: String,
+        required: false,
+        trim: true,
+      },
+      branch: {
+        type: String,
+        required: false,
+        trim: true,
+      },
+      swiftCode: {
+        type: String,
+        required: false,
+        trim: true,
+      }
+    },
+    // GL Account Configuration (moved from levy contract)
+    glAccounts: {
+      invoice: {
+        debit: {
+          type: mongoose.Schema.Types.ObjectId,
+          ref: "GLAccount",
+          required: false,
+        },
+        credit: {
+          type: mongoose.Schema.Types.ObjectId,
+          ref: "GLAccount",
+          required: false,
+        }
+      },
+      payment: {
+        debit: {
+          type: mongoose.Schema.Types.ObjectId,
+          ref: "GLAccount",
+          required: false,
+        },
+        credit: {
+          type: mongoose.Schema.Types.ObjectId,
+          ref: "GLAccount",
+          required: false,
+        }
+      }
+    },
     disabled: {
       type: Boolean,
       required: false,

package/src/models/levycontract.js

@@ -41,17 +41,6 @@ const LevyContractSchema = new Schema(
             default: 'Active',
             required: [true, 'Status is required']
         },
-        // Replace single doubleEntryAccount with two separate accounts
-        invoiceDoubleEntryAccount: {
-            type: mongoose.Schema.Types.ObjectId,
-            ref: 'GLAccountDoubleEntries',
-            required: [true, 'Invoice double entry account is required']
-        },
-        paymentDoubleEntryAccount: {
-            type: mongoose.Schema.Types.ObjectId,
-            ref: 'GLAccountDoubleEntries',
-            required: [true, 'Payment double entry account is required']
-        },
         balanceBroughtForward: {
             type: Number,
             default: 0
@@ -109,22 +98,6 @@ LevyContractSchema.virtual('unit', {
     justOne: true
 });
 
-// Virtual populate for invoice double entry account
-LevyContractSchema.virtual('invoiceDoubleEntry', {
-    ref: 'GLAccountDoubleEntries',
-    localField: 'invoiceDoubleEntryAccount',
-    foreignField: '_id',
-    justOne: true
-});
-
-// Virtual populate for payment double entry account
-LevyContractSchema.virtual('paymentDoubleEntry', {
-    ref: 'GLAccountDoubleEntries',
-    localField: 'paymentDoubleEntryAccount',
-    foreignField: '_id',
-    justOne: true
-});
-
 // Pre-save middleware to ensure endDate is after startDate
 LevyContractSchema.pre('save', function (next) {
     if (this.startDate && this.endDate && this.startDate >= this.endDate) {
@@ -134,24 +107,10 @@ LevyContractSchema.pre('save', function (next) {
     }
 });
 
-// Pre-save middleware to maintain backward compatibility during migration
-LevyContractSchema.pre('save', function (next) {
-    // If we have the old doubleEntryAccount but not the new ones, 
-    // use the old one for both new fields during the transition
-    if (this.doubleEntryAccount &&
-        (!this.invoiceDoubleEntryAccount || !this.paymentDoubleEntryAccount)) {
-        this.invoiceDoubleEntryAccount = this.doubleEntryAccount;
-        this.paymentDoubleEntryAccount = this.doubleEntryAccount;
-    }
-    next();
-});
-
 // Index for efficient queries
 LevyContractSchema.index({ levyId: 1, unitId: 1, status: 1 });
 LevyContractSchema.index({ facilityId: 1 });
 LevyContractSchema.index({ customerId: 1 });
-LevyContractSchema.index({ invoiceDoubleEntryAccount: 1 });
-LevyContractSchema.index({ paymentDoubleEntryAccount: 1 });
 
 module.exports = {
     schema: LevyContractSchema,

package/src/models/propertyManagerContract.js

@@ -0,0 +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);
+
+module.exports = PropertyManagerContract;

package/src/models/units.js

@@ -50,14 +50,13 @@ const unitSchema = new mongoose.Schema({
         type: Boolean,
         default: false
     },
-    propertyManagementFee: {
-        type: Number,
-        required: function () {
+    propertyManagerName: {
+        type: String,
+        required: function() {
             return this.isManagedByPropertyManager === true;
-        },
-        min: [0, "Property management fee must be at least 0"],
-        max: [100, "Property management fee cannot exceed 100%"]
+        }
     },
+    
     occupants: [
         {
             customerId: { type: mongoose.Schema.Types.ObjectId, ref: 'Customer' },
@@ -95,17 +94,18 @@ const unitSchema = new mongoose.Schema({
     timestamps: true // Automatically add createdAt and updatedAt fields
 });
 
-// Add pre-save middleware to handle propertyManagementFee
+// Add pre-save middleware to handle property management fields
 unitSchema.pre('save', function (next) {
-    // Clear propertyManagementFee if not managed by property manager
+    // Clear property management fields if not managed by property manager
     if (!this.isManagedByPropertyManager) {
-        this.propertyManagementFee = null;
+        this.propertyManagerName = null;
     }
     next();
 });
 
 // Indexes for improved performance
 unitSchema.index({ name: 1 });
+unitSchema.index({ isManagedByPropertyManager: 1 });
 
 // Compile the model from the schema
 const Unit = mongoose.model('Unit', unitSchema);