payservedb 6.1.0 → 6.1.2

package/index.js

@@ -206,9 +206,90 @@ async function getModelFromDB(dbConnection, modelName, schema) {
   return dbConnection.models[modelName]; // Return existing model if already registered
 }
 
+// Function to initialize service with specific models
+function initializeService(modelNames = []) {
+  const serviceModels = {};
+  let currentConnection = null;
+  
+  // Enhanced connect function that also registers models
+  async function connectWithModels(dbName, secured, username, password, url, port) {
+    await connectToMongoDB(dbName, secured, username, password, url, port);
+    currentConnection = mongoose.connection;
+    
+    // Register models with the current connection
+    modelNames.forEach(modelName => {
+      if (models[modelName] && !currentConnection.models[modelName]) {
+        serviceModels[modelName] = currentConnection.model(modelName, models[modelName]);
+      } else if (currentConnection.models[modelName]) {
+        serviceModels[modelName] = currentConnection.models[modelName];
+      }
+    });
+    
+    return serviceModels;
+  }
+  
+  // Enhanced switchDB function that also registers models
+  async function switchDBWithModels(dbName) {
+    const dbConnection = await switchDB(dbName);
+    currentConnection = dbConnection;
+    
+    // Register models with the new connection
+    const dbModels = {};
+    modelNames.forEach(modelName => {
+      if (models[modelName]) {
+        if (!dbConnection.models[modelName]) {
+          dbModels[modelName] = dbConnection.model(modelName, models[modelName]);
+        } else {
+          dbModels[modelName] = dbConnection.models[modelName];
+        }
+      }
+    });
+    
+    return { connection: dbConnection, models: dbModels };
+  }
+  
+  // Function to get models for the current connection
+  function getModels() {
+    if (!currentConnection) {
+      throw new Error('No active database connection. Please connect first.');
+    }
+    
+    const connectionModels = {};
+    modelNames.forEach(modelName => {
+      if (currentConnection.models[modelName]) {
+        connectionModels[modelName] = currentConnection.models[modelName];
+      }
+    });
+    
+    return connectionModels;
+  }
+  
+  // Function to get a specific model
+  function getModel(modelName) {
+    if (!currentConnection) {
+      throw new Error('No active database connection. Please connect first.');
+    }
+    
+    if (!modelNames.includes(modelName)) {
+      throw new Error(`Model ${modelName} not initialized in this service`);
+    }
+    
+    return currentConnection.models[modelName];
+  }
+  
+  return {
+    connectToMongoDB: connectWithModels,
+    switchDB: switchDBWithModels,
+    getModels,
+    getModel,
+    getCurrentConnection: () => currentConnection
+  };
+}
+
 module.exports = {
   connectToMongoDB,
   switchDB,
   getModelFromDB,
+  initializeService,
   ...models, // Spread operator to export all models
-};
+};

package/package.json

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

package/src/models/powerMeterPowerCharges.js

@@ -6,6 +6,10 @@ const powerMeterPowerChargeSchema = new mongoose.Schema({
         ref: 'Facility',
         required: true
     },
+    yearMonth: {
+        type: String,
+        required: true
+    },
     // KPLC Power Charges
     fuelCostCharge: {
         type: Number,

package/src/models/propertyManagerContract.js

@@ -67,6 +67,10 @@ const PropertyManagerContractSchema = new Schema(
             type: Boolean, 
             default: false 
         },
+        balanceBroughtForward: {
+            type: Number,
+            default: 0
+        },
         // Management fee
         managementFee: {
             type: {
@@ -90,7 +94,7 @@ const PropertyManagerContractSchema = new Schema(
                 }
             }
         },
-        // GL Account configurations
+        // GL Account configurations - updated to match sample data structure
         invoiceDoubleEntryAccount: {
             type: mongoose.Schema.Types.ObjectId,
             ref: 'GLAccountDoubleEntries'
@@ -130,10 +134,26 @@ const PropertyManagerContractSchema = new Schema(
         createdBy: {
             type: mongoose.Schema.Types.ObjectId,
             ref: 'User' // References global User collection
+        },
+        // Additional fields for contract lifecycle management
+        suspensionReason: {
+            type: String
+        },
+        terminationReason: {
+            type: String
+        },
+        terminationDate: {
+            type: Date
+        },
+        completionDate: {
+            type: Date
         }
     },
     {
-        timestamps: true
+        timestamps: true,
+        // Ensure virtual fields are included in JSON output
+        toJSON: { virtuals: true },
+        toObject: { virtuals: true }
     }
 );
 
@@ -202,10 +222,11 @@ PropertyManagerContractSchema.pre('save', function (next) {
 PropertyManagerContractSchema.methods.syncWithLeaseData = async function(leaseData) {
     if (!leaseData) return;
     
-    // Update contract fields from lease data (removed balanceBroughtForward)
+    // Update contract fields from lease data
     this.startDate = leaseData.leaseTerms?.startDate || this.startDate;
     this.endDate = leaseData.leaseTerms?.endDate || this.endDate;
     this.paymentDueDate = leaseData.financialTerms?.paymentDueDate || this.paymentDueDate;
+    this.balanceBroughtForward = leaseData.financialTerms?.balanceBroughtForward || this.balanceBroughtForward;
     this.frequency = leaseData.billingCycle?.frequency || this.frequency;
     this.autoSend = leaseData.billingCycle?.autoSend !== undefined ? leaseData.billingCycle.autoSend : this.autoSend;
     this.nextInvoiceDate = leaseData.billingCycle?.nextInvoiceDate || this.nextInvoiceDate;
@@ -241,6 +262,7 @@ PropertyManagerContractSchema.virtual('durationInDays').get(function() {
     const diffTime = Math.abs(this.endDate - this.startDate);
     return Math.ceil(diffTime / (1000 * 60 * 60 * 24));
 });
+
 // Virtual for contract remaining days
 PropertyManagerContractSchema.virtual('remainingDays').get(function() {
     if (!this.endDate) return null;
@@ -250,6 +272,17 @@ PropertyManagerContractSchema.virtual('remainingDays').get(function() {
     return Math.ceil(diffTime / (1000 * 60 * 60 * 24));
 });
 
+// Virtual for management fee display
+PropertyManagerContractSchema.virtual('managementFeeDisplay').get(function() {
+    if (!this.managementFee) return null;
+    
+    if (this.managementFee.type === 'percentage') {
+        return `${this.managementFee.value}%`;
+    } else {
+        return `$${this.managementFee.value.toLocaleString()}`;
+    }
+});
+
 // Indexes for better query performance
 PropertyManagerContractSchema.index({ customerId: 1, status: 1 });
 PropertyManagerContractSchema.index({ facilityId: 1, status: 1 });
@@ -330,6 +363,32 @@ PropertyManagerContractSchema.statics.findContractsRequiringInvoicing = function
       .populate('customerId', 'firstName lastName email');
 };
 
+PropertyManagerContractSchema.statics.findContractsByFeeType = function(facilityId, feeType) {
+    return this.find({
+        facilityId: facilityId,
+        'managementFee.type': feeType
+    }).populate('propertyManager', 'fullName email')
+      .populate('units', 'name unitType')
+      .populate('customerId', 'firstName lastName email')
+      .sort({ 'managementFee.value': -1 });
+};
+
+PropertyManagerContractSchema.statics.getContractStatistics = function(facilityId) {
+    return this.aggregate([
+        {
+            $match: { facilityId: mongoose.Types.ObjectId(facilityId) }
+        },
+        {
+            $group: {
+                _id: '$status',
+                count: { $sum: 1 },
+                totalFeeValue: { $sum: '$managementFee.value' },
+                avgFeeValue: { $avg: '$managementFee.value' }
+            }
+        }
+    ]);
+};
+
 // Instance methods for contract management
 PropertyManagerContractSchema.methods.calculateNextInvoiceDate = function() {
     if (!this.lastInvoiceDate && !this.startDate) return null;
@@ -401,6 +460,32 @@ PropertyManagerContractSchema.methods.completeContract = async function() {
     return this.save();
 };
 
+// Method to calculate management fee for a given amount
+PropertyManagerContractSchema.methods.calculateManagementFee = function(baseAmount) {
+    if (!this.managementFee) return 0;
+    
+    if (this.managementFee.type === 'percentage') {
+        return (baseAmount * this.managementFee.value) / 100;
+    } else {
+        return this.managementFee.value;
+    }
+};
+
+// Method to get contract summary
+PropertyManagerContractSchema.methods.getContractSummary = function() {
+    return {
+        id: this._id,
+        contractName: this.contractName,
+        status: this.status,
+        duration: this.durationInDays,
+        remainingDays: this.remainingDays,
+        managementFee: this.managementFeeDisplay,
+        frequency: this.frequency,
+        nextInvoiceDate: this.nextInvoiceDate,
+        isComplete: this.isComplete
+    };
+};
+
 // Pre-findOneAndUpdate middleware to maintain data integrity
 PropertyManagerContractSchema.pre(['findOneAndUpdate', 'updateOne', 'updateMany'], function() {
     const update = this.getUpdate();
@@ -431,6 +516,11 @@ PropertyManagerContractSchema.post('save', function(doc) {
         console.log(`Contract status changed to: ${doc.status}`);
         // Add notification logic here
     }
+    
+    // Log invoice date updates
+    if (this.isModified('nextInvoiceDate') || this.isModified('lastInvoiceDate')) {
+        console.log(`Invoice dates updated for contract: ${doc.contractName}`);
+    }
 });
 
 // Error handling for validation errors
@@ -453,6 +543,8 @@ PropertyManagerContractSchema.methods.toJSON = function() {
     contract.missingRequiredFields = this.getMissingRequiredFields();
     contract.durationInDays = this.durationInDays;
     contract.remainingDays = this.remainingDays;
+    contract.managementFeeDisplay = this.managementFeeDisplay;
+    contract.contractSummary = this.getContractSummary();
     
     return contract;
 };
@@ -461,4 +553,4 @@ PropertyManagerContractSchema.methods.toJSON = function() {
 module.exports = {
     schema: PropertyManagerContractSchema,
     name: 'PropertyManagerContract'
-};
+};

package/src/models/water_meter_concentrator.js

@@ -29,8 +29,8 @@ const concentratorSchema = new mongoose.Schema({
     status: {
         type: String,
         required: true,
-        enum: ['Online', 'Offline', 'Maintenance'],
-        default: 'Offline'
+        enum: ['online', 'offline', 'maintenance'],
+        default: '0ffline'
     },
     meter_fails: {
         type: Number,
@@ -55,6 +55,9 @@ const concentratorSchema = new mongoose.Schema({
             min: -180,
             max: 180
         }
+    },
+    lastUpdated: {
+        type: String
     }
 }, {
     timestamps: true