payservedb 5.7.4 → 5.7.6

package/package.json

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

package/src/models/propertyManagerContract.js

@@ -22,7 +22,12 @@ const PropertyManagerContractSchema = new Schema(
             ref: 'Customer',
             required: [true, 'Customer ID is required']
         },
-        // Optional fields - only required when status is "Active"
+        facilityId: {
+            type: mongoose.Schema.Types.ObjectId,
+            ref: 'Facility',
+            required: [true, 'Facility ID is required']
+        },
+        // Lease term details
         startDate: {
             type: Date,
             required: function() {
@@ -35,33 +40,38 @@ const PropertyManagerContractSchema = new Schema(
                 return this.status === 'Active';
             }
         },
-        invoiceDay: {
+        // Payment details - aligned with LeaseAgreement
+        paymentDueDate: {
             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']
+            min: [1, 'Payment due date must be between 1 and 31'],
+            max: [31, 'Payment due date must be between 1 and 31']
         },
-        dueDate: {
-            type: String, // Store as string like "5th", "10th", etc.
+        frequency: {
+            type: String,
+            enum: ['Monthly', 'Quarterly', 'Annually'],
+            default: 'Monthly',
             required: function() {
                 return this.status === 'Active';
             }
         },
+        nextInvoiceDate: { 
+            type: Date 
+        },
+        lastInvoiceDate: { 
+            type: Date 
+        },
+        autoSend: { 
+            type: Boolean, 
+            default: false 
+        },
         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
+        // Management fee
         managementFee: {
             type: {
                 type: String,
@@ -74,7 +84,7 @@ const PropertyManagerContractSchema = new Schema(
                 min: [0, 'Management fee value cannot be negative']
             }
         },
-        // GL Account configurations - matching LeaseAgreement pattern
+        // GL Account configurations
         invoiceDoubleEntryAccount: {
             type: mongoose.Schema.Types.ObjectId,
             ref: 'GLAccountDoubleEntries'
@@ -83,7 +93,6 @@ const PropertyManagerContractSchema = new Schema(
             type: mongoose.Schema.Types.ObjectId,
             ref: 'GLAccountDoubleEntries'
         },
-        // GL Account direct configurations (used when creating double entry records)
         glAccounts: {
             invoice: {
                 debit: {
@@ -112,248 +121,52 @@ const PropertyManagerContractSchema = new Schema(
             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 }
+        timestamps: 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)
+// Basic validation
 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) {
+    } else 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) {
+    } else 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
+// 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.paymentDueDate = leaseData.financialTerms?.paymentDueDate || this.paymentDueDate;
     this.balanceBroughtForward = leaseData.financialTerms?.balanceBroughtForward || this.balanceBroughtForward;
-    this.collectionFrequency = leaseData.billingCycle?.frequency || this.collectionFrequency;
+    this.frequency = leaseData.billingCycle?.frequency || this.frequency;
     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`;
-    }
+    this.nextInvoiceDate = leaseData.billingCycle?.nextInvoiceDate || this.nextInvoiceDate;
+    this.lastInvoiceDate = leaseData.billingCycle?.lastInvoiceDate || this.lastInvoiceDate;
     
     return this.save();
 };
 
-// Indexes for efficient queries
+// Basic indexes
 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({ propertyManager: 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;
+module.exports = {
+    schema: PropertyManagerContractSchema,
+    name: 'PropertyManagerContract'
+};

package/src/models/purchase_order.js

@@ -21,6 +21,12 @@ const purchaseOrderSchema = new mongoose.Schema({
         index: true,
         ref: 'PurchaseRequest'
     },
+    rfqNumber: {
+        type: String,
+        trim: true,
+        index: true,
+        ref: 'RFQDetails'
+    },
     supplier: {
         type: mongoose.Schema.Types.ObjectId,
         ref: 'Supplier',
@@ -52,7 +58,9 @@ const purchaseOrderSchema = new mongoose.Schema({
     },
     budget: {
         type: String,
-        trim: true
+        trim: true,
+        index: true,
+        ref: 'Budget'
     },
     status: {
         type: String,

package/src/models/rfq_response.js

@@ -47,6 +47,14 @@ const rfqResponseSchema = new mongoose.Schema({
       default: '',
     }
   }],
+  
+  vatAmount: {
+    type: Number,
+    required: false,
+    min: 0,
+    default: 0,
+  },
+  
   deliveryDays: {
     type: Number,
     required: true,
@@ -100,7 +108,4 @@ const rfqResponseSchema = new mongoose.Schema({
   timestamps: true,
 });
 
-// Unique response per supplier per RFQ
-rfqResponseSchema.index({ rfqId: 1, supplierId: 1 }, { unique: true });
-
 module.exports = mongoose.model('RFQResponse', rfqResponseSchema);