payservedb 9.2.6 → 9.2.8

package/src/models/water_meter_concentrator.js

@@ -1,71 +1,71 @@
-const mongoose = require('mongoose');
-const concentratorSchema = new mongoose.Schema({
-    serialNumber: {
-        type: String,
-        required: true,
-        trim: true,
-        unique: true
-    },
-    manufacturer: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'MeterManufacturer',
-    },
-    range: {
-        type: Number,
-        min: 0
-    },
-    isInstalled: {
-        type: Boolean,
-        default: false
-    },
-    isFaulty: {
-        type: Boolean,
-        default: false
-    },
-    inStock: {
-        type: Boolean,
-        default: true
-    },
-    status: {
-        type: String,
-        required: true,
-        enum: ['online', 'offline', 'maintenance'],
-        default: 'offline'
-    },
-    ipAddress: {
-        type: String,
-        trim: true
-    },
-    meter_fails: {
-        type: Number,
-        min: 0
-    },
-    facilityId: [{
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Facility',
-    }],
-    location: {
-        city: {
-            type: String,
-            trim: true
-        },
-        latitude: {
-            type: Number,
-            min: -90,
-            max: 90
-        },
-        longitude: {
-            type: Number,
-            min: -180,
-            max: 180
-        }
-    },
-    lastUpdated: {
-        type: String
-    }
-}, {
-    timestamps: true
-});
-
-const Concentrator = mongoose.model('Concentrator', concentratorSchema);
+const mongoose = require('mongoose');
+const concentratorSchema = new mongoose.Schema({
+    serialNumber: {
+        type: String,
+        required: true,
+        trim: true,
+        unique: true
+    },
+    manufacturer: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'MeterManufacturer',
+    },
+    range: {
+        type: Number,
+        min: 0
+    },
+    isInstalled: {
+        type: Boolean,
+        default: false
+    },
+    isFaulty: {
+        type: Boolean,
+        default: false
+    },
+    inStock: {
+        type: Boolean,
+        default: true
+    },
+    status: {
+        type: String,
+        required: true,
+        enum: ['online', 'offline', 'maintenance'],
+        default: 'offline'
+    },
+    ipAddress: {
+        type: String,
+        trim: true
+    },
+    meter_fails: {
+        type: Number,
+        min: 0
+    },
+    facilityId: [{
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Facility',
+    }],
+    location: {
+        city: {
+            type: String,
+            trim: true
+        },
+        latitude: {
+            type: Number,
+            min: -90,
+            max: 90
+        },
+        longitude: {
+            type: Number,
+            min: -180,
+            max: 180
+        }
+    },
+    lastUpdated: {
+        type: String
+    }
+}, {
+    timestamps: true
+});
+
+const Concentrator = mongoose.model('Concentrator', concentratorSchema);
 module.exports = Concentrator;

package/src/models/water_meter_daily_history.js

@@ -1,33 +1,33 @@
-const mongoose = require('mongoose');
-
-const dailyWaterMeterHistorySchema = new mongoose.Schema({
-    meterId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'WaterMeter',
-        required: true,
-        index: true
-    },
-    date: {
-        type: Date,
-        required: true,
-        index: true
-    },
-    reading: {
-        type: Number,
-        required: true,
-        min: 0
-    },
-    status: {
-        type: String,
-        enum: ['opened', 'closed', 'maintenance', 'faulty'],
-        default: 'opened',
-    }
-}, {
-    timestamps: true
-});
-
-dailyWaterMeterHistorySchema.index({ meterId: 1, date: 1 });
-
-const DailyWaterMeterHistory = mongoose.model('DailyWaterMeterHistory', dailyWaterMeterHistorySchema);
-
+const mongoose = require('mongoose');
+
+const dailyWaterMeterHistorySchema = new mongoose.Schema({
+    meterId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'WaterMeter',
+        required: true,
+        index: true
+    },
+    date: {
+        type: Date,
+        required: true,
+        index: true
+    },
+    reading: {
+        type: Number,
+        required: true,
+        min: 0
+    },
+    status: {
+        type: String,
+        enum: ['opened', 'closed', 'maintenance', 'faulty'],
+        default: 'opened',
+    }
+}, {
+    timestamps: true
+});
+
+dailyWaterMeterHistorySchema.index({ meterId: 1, date: 1 });
+
+const DailyWaterMeterHistory = mongoose.model('DailyWaterMeterHistory', dailyWaterMeterHistorySchema);
+
 module.exports = DailyWaterMeterHistory;

package/src/models/water_meter_high_risk.js

@@ -1,37 +1,37 @@
-const mongoose = require('mongoose');
-
-const highRiskMeterSchema = new mongoose.Schema({
-    meterNumber: {
-        type: String,
-        required: true,
-        unique: true,
-        trim: true,
-        index: true
-    },
-    concentratorSerialNumber: {
-        type: String,
-        required: true,
-        trim: true
-    },
-    customerName: {
-        type: String,
-        required: true,
-        trim: true
-    },
-    facilityName: {
-        type: String,
-        required: true,
-        trim: true
-    },
-    unitName: {
-        type: String,
-        required: true,
-        trim: true
-    }
-}, {
-    timestamps: true
-});
-
-const HighRiskMeter = mongoose.model('HighRiskMeter', highRiskMeterSchema);
-
+const mongoose = require('mongoose');
+
+const highRiskMeterSchema = new mongoose.Schema({
+    meterNumber: {
+        type: String,
+        required: true,
+        unique: true,
+        trim: true,
+        index: true
+    },
+    concentratorSerialNumber: {
+        type: String,
+        required: true,
+        trim: true
+    },
+    customerName: {
+        type: String,
+        required: true,
+        trim: true
+    },
+    facilityName: {
+        type: String,
+        required: true,
+        trim: true
+    },
+    unitName: {
+        type: String,
+        required: true,
+        trim: true
+    }
+}, {
+    timestamps: true
+});
+
+const HighRiskMeter = mongoose.model('HighRiskMeter', highRiskMeterSchema);
+
 module.exports = HighRiskMeter;

package/src/models/water_meter_iot_cards.js

@@ -1,35 +1,35 @@
-const mongoose = require('mongoose');
-
-const iotCardSchema = new mongoose.Schema({
-    serialNumber: {
-        type: String,
-        required: true,
-        unique: true,
-        trim: true
-    },
-    provider: {
-        type: String,
-        required: true,
-        trim: true
-    },
-    concentrator: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Concentrator'
-    },
-    location: {
-        type: String,
-        trim: true
-    },
-    status: {
-        type: String,
-        required: true,
-        enum: ['active', 'inactive', 'suspended'],
-        default: 'inactive'
-    }
-}, {
-    timestamps: true
-});
-
-const MeterIotCard = mongoose.model('MeterIotCard', iotCardSchema);
-
+const mongoose = require('mongoose');
+
+const iotCardSchema = new mongoose.Schema({
+    serialNumber: {
+        type: String,
+        required: true,
+        unique: true,
+        trim: true
+    },
+    provider: {
+        type: String,
+        required: true,
+        trim: true
+    },
+    concentrator: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Concentrator'
+    },
+    location: {
+        type: String,
+        trim: true
+    },
+    status: {
+        type: String,
+        required: true,
+        enum: ['active', 'inactive', 'suspended'],
+        default: 'inactive'
+    }
+}, {
+    timestamps: true
+});
+
+const MeterIotCard = mongoose.model('MeterIotCard', iotCardSchema);
+
 module.exports = MeterIotCard;

package/src/models/water_meter_loan_deduction.js

@@ -1,135 +1,135 @@
-const mongoose = require('mongoose');
-
-const waterMeterLoanDeductionSchema = new mongoose.Schema({
-  customerId: {
-    type: mongoose.Schema.Types.ObjectId,
-    ref: 'Customer',
-    required: true,
-    index: true
-  },
-  accountId: {
-    type: mongoose.Schema.Types.ObjectId,
-    ref: 'WaterMeterAccount',
-    required: true,
-    index: true
-  },
-  meterId: {
-    type: mongoose.Schema.Types.ObjectId,
-    ref: 'WaterMeter',
-    required: true,
-    index: true
-  },
-  amount: {
-    type: Number,
-    required: true,
-    min: 0
-  },
-  yearMonth: {
-    type: String,
-    required: true,
-    index: true,
-    // Format: YYYY-MM (e.g., "2026-01")
-    validate: {
-      validator: function(v) {
-        return /^\d{4}-(0[1-9]|1[0-2])$/.test(v);
-      },
-      message: "yearMonth must be in YYYY-MM format"
-    }
-  },
-  deductionDate: {
-    type: Date,
-    required: true,
-    default: Date.now
-  },
-  status: {
-    type: String,
-    enum: ['pending', 'completed', 'insufficient_balance'],
-    required: true,
-    default: 'pending',
-    index: true
-  },
-  debitRecordId: {
-    type: mongoose.Schema.Types.ObjectId,
-    ref: 'WaterPrepaidDebit',
-    // Will be populated when deduction is completed
-  },
-  balanceAtAttempt: {
-    type: Number,
-    // Store balance when deduction was attempted
-  },
-  attempts: {
-    type: Number,
-    default: 0,
-    min: 0
-  },
-  lastAttemptDate: {
-    type: Date
-  },
-  completedDate: {
-    type: Date
-  },
-  notes: {
-    type: String,
-    trim: true
-  }
-}, {
-  timestamps: true
-});
-
-// Compound index to ensure one deduction per customer per month
-waterMeterLoanDeductionSchema.index(
-  { customerId: 1, yearMonth: 1 }, 
-  { unique: true }
-);
-
-// Index for finding pending deductions
-waterMeterLoanDeductionSchema.index({ status: 1, yearMonth: 1 });
-
-// Index for finding deductions by account
-waterMeterLoanDeductionSchema.index({ accountId: 1, yearMonth: 1 });
-
-// Static method to check if deduction exists for a customer in a given month
-waterMeterLoanDeductionSchema.statics.deductionExists = async function(customerId, yearMonth) {
-  const count = await this.countDocuments({ customerId, yearMonth });
-  return count > 0;
-};
-
-// Static method to get pending deductions
-waterMeterLoanDeductionSchema.statics.getPendingDeductions = async function() {
-  return this.find({ status: 'pending' })
-    .populate('accountId')
-    .populate('meterId')
-    .sort({ createdAt: 1 });
-};
-
-// Static method to get pending deductions for a specific month
-waterMeterLoanDeductionSchema.statics.getPendingDeductionsForMonth = async function(yearMonth) {
-  return this.find({ 
-    status: 'pending',
-    yearMonth: yearMonth 
-  })
-    .populate('accountId')
-    .populate('meterId')
-    .sort({ createdAt: 1 });
-};
-
-// Instance method to mark as completed
-waterMeterLoanDeductionSchema.methods.markCompleted = async function(debitRecordId) {
-  this.status = 'completed';
-  this.debitRecordId = debitRecordId;
-  this.completedDate = new Date();
-  return this.save();
-};
-
-// Instance method to mark as insufficient balance
-waterMeterLoanDeductionSchema.methods.markInsufficientBalance = async function(balance) {
-  this.status = 'insufficient_balance';
-  this.balanceAtAttempt = balance;
-  this.attempts += 1;
-  this.lastAttemptDate = new Date();
-  return this.save();
-};
-
-const WaterMeterLoanDeduction = mongoose.model('WaterMeterLoanDeduction', waterMeterLoanDeductionSchema);
-
+const mongoose = require('mongoose');
+
+const waterMeterLoanDeductionSchema = new mongoose.Schema({
+  customerId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Customer',
+    required: true,
+    index: true
+  },
+  accountId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'WaterMeterAccount',
+    required: true,
+    index: true
+  },
+  meterId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'WaterMeter',
+    required: true,
+    index: true
+  },
+  amount: {
+    type: Number,
+    required: true,
+    min: 0
+  },
+  yearMonth: {
+    type: String,
+    required: true,
+    index: true,
+    // Format: YYYY-MM (e.g., "2026-01")
+    validate: {
+      validator: function(v) {
+        return /^\d{4}-(0[1-9]|1[0-2])$/.test(v);
+      },
+      message: "yearMonth must be in YYYY-MM format"
+    }
+  },
+  deductionDate: {
+    type: Date,
+    required: true,
+    default: Date.now
+  },
+  status: {
+    type: String,
+    enum: ['pending', 'completed', 'insufficient_balance'],
+    required: true,
+    default: 'pending',
+    index: true
+  },
+  debitRecordId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'WaterPrepaidDebit',
+    // Will be populated when deduction is completed
+  },
+  balanceAtAttempt: {
+    type: Number,
+    // Store balance when deduction was attempted
+  },
+  attempts: {
+    type: Number,
+    default: 0,
+    min: 0
+  },
+  lastAttemptDate: {
+    type: Date
+  },
+  completedDate: {
+    type: Date
+  },
+  notes: {
+    type: String,
+    trim: true
+  }
+}, {
+  timestamps: true
+});
+
+// Compound index to ensure one deduction per customer per month
+waterMeterLoanDeductionSchema.index(
+  { customerId: 1, yearMonth: 1 }, 
+  { unique: true }
+);
+
+// Index for finding pending deductions
+waterMeterLoanDeductionSchema.index({ status: 1, yearMonth: 1 });
+
+// Index for finding deductions by account
+waterMeterLoanDeductionSchema.index({ accountId: 1, yearMonth: 1 });
+
+// Static method to check if deduction exists for a customer in a given month
+waterMeterLoanDeductionSchema.statics.deductionExists = async function(customerId, yearMonth) {
+  const count = await this.countDocuments({ customerId, yearMonth });
+  return count > 0;
+};
+
+// Static method to get pending deductions
+waterMeterLoanDeductionSchema.statics.getPendingDeductions = async function() {
+  return this.find({ status: 'pending' })
+    .populate('accountId')
+    .populate('meterId')
+    .sort({ createdAt: 1 });
+};
+
+// Static method to get pending deductions for a specific month
+waterMeterLoanDeductionSchema.statics.getPendingDeductionsForMonth = async function(yearMonth) {
+  return this.find({ 
+    status: 'pending',
+    yearMonth: yearMonth 
+  })
+    .populate('accountId')
+    .populate('meterId')
+    .sort({ createdAt: 1 });
+};
+
+// Instance method to mark as completed
+waterMeterLoanDeductionSchema.methods.markCompleted = async function(debitRecordId) {
+  this.status = 'completed';
+  this.debitRecordId = debitRecordId;
+  this.completedDate = new Date();
+  return this.save();
+};
+
+// Instance method to mark as insufficient balance
+waterMeterLoanDeductionSchema.methods.markInsufficientBalance = async function(balance) {
+  this.status = 'insufficient_balance';
+  this.balanceAtAttempt = balance;
+  this.attempts += 1;
+  this.lastAttemptDate = new Date();
+  return this.save();
+};
+
+const WaterMeterLoanDeduction = mongoose.model('WaterMeterLoanDeduction', waterMeterLoanDeductionSchema);
+
 module.exports = WaterMeterLoanDeduction;