payservedb 5.6.1 → 5.6.3

package/index.js

@@ -171,7 +171,9 @@ 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'),
+    BillerAddress: require('./src/models/billerAddress')
 };
 
 // Function to get models dynamically from a specific database connection

package/package.json

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

package/src/models/billerAddress.js

@@ -0,0 +1,117 @@
+const mongoose = require("mongoose");
+
+// Define the schema for Biller Address
+const billerAddressSchema = new mongoose.Schema(
+  {
+    name: {
+      type: String,
+      required: [true, "Address name is required"],
+      trim: true,
+      minlength: [1, "Address name must be at least 1 character long"],
+    },
+    companyName: {
+      type: String,
+      required: [true, "Company name is required"],
+      trim: true,
+    },
+    website: {
+      type: String,
+      trim: true,
+      validate: {
+        validator: function (v) {
+          if (!v) return true; // Optional field
+          return /^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-])\/?$/.test(v);
+        },
+        message: "Please enter a valid website URL"
+      }
+    },
+    email: {
+      type: String,
+      required: [true, "Email is required"],
+      trim: true,
+      lowercase: true,
+      validate: {
+        validator: function (v) {
+          return /^\w+([\.-]?\w+)@\w+([\.-]?\w+)(\.\w{2,3})+$/.test(v);
+        },
+        message: "Please enter a valid email address"
+      }
+    },
+    phone: {
+      type: String,
+      trim: true,
+    },
+    address: {
+      type: String,
+      required: [true, "Address is required"],
+      trim: true,
+    },
+    city: {
+      type: String,
+      required: [true, "City is required"],
+      trim: true,
+    },
+    state: {
+      type: String,
+      trim: true,
+    },
+    country: {
+      type: String,
+      required: [true, "Country is required"],
+      trim: true,
+      default: "Kenya"
+    },
+    postalCode: {
+      type: String,
+      trim: true,
+    },
+    logo: {
+      type: String, // Will store the file path/URL of the uploaded logo
+      required: false,
+    },
+    isDefault: {
+      type: Boolean,
+      default: false,
+    },
+    facilityId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Facility",
+      required: true,
+    },
+    createdBy: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "User",
+    },
+    updatedBy: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "User",
+    }
+  },
+  {
+    timestamps: true,
+  }
+);
+
+// Index for efficient queries
+billerAddressSchema.index({ facilityId: 1 });
+billerAddressSchema.index({ facilityId: 1, isDefault: 1 });
+
+// Pre-save middleware to ensure only one default address per facility
+billerAddressSchema.pre('save', async function (next) {
+  if (this.isDefault && this.isModified('isDefault')) {
+    // If this address is being set as default, unset all other defaults for this facility
+    await this.constructor.updateMany(
+      {
+        facilityId: this.facilityId,
+        _id: { $ne: this._id }
+      },
+      { $set: { isDefault: false } }
+    );
+  }
+  next();
+});
+
+// Compile the model from the schema
+const BillerAddress = mongoose.model("BillerAddress", billerAddressSchema);
+
+module.exports = BillerAddress;

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);