payservedb 7.0.1 → 7.0.3

package/src/models/water_prepaid_debit.js

@@ -1,50 +1,50 @@
-const mongoose = require('mongoose');
-
-const waterPrepaidDebitSchema = new mongoose.Schema({
-    accountId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'WaterMeterAccount',
-        required: true,
-    },
-    meterId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'WaterMeter',
-        required: true,
-    },
-    prev_reading: {
-        type: Number,
-        required: true,
-    },
-    current_reading: {
-        type: Number,
-        required: true,
-        default: 0
-    },
-    consumption: {
-        type: Number,
-        required: true,
-    },
-    rate: {
-        type: String,
-        required: true,
-    },
-    totalAmount: {
-        type: Number,
-        required: true,
-    },
-    date: {
-        type: String,
-        required: true
-    },
-    time: {
-        type: String,
-        required: true
-    },
-
-}, {
-    timestamps: true
-});
-
-const WaterPrepaidDebit = mongoose.model('WaterPrepaidDebit', waterPrepaidDebitSchema);
-
-module.exports = WaterPrepaidDebit;
+const mongoose = require('mongoose');
+
+const waterPrepaidDebitSchema = new mongoose.Schema({
+    accountId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'WaterMeterAccount',
+        required: true,
+    },
+    meterId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'WaterMeter',
+        required: true,
+    },
+    prev_reading: {
+        type: Number,
+        required: true,
+    },
+    current_reading: {
+        type: Number,
+        required: true,
+        default: 0
+    },
+    consumption: {
+        type: Number,
+        required: true,
+    },
+    rate: {
+        type: String,
+        required: true,
+    },
+    totalAmount: {
+        type: Number,
+        required: true,
+    },
+    date: {
+        type: String,
+        required: true
+    },
+    time: {
+        type: String,
+        required: true
+    },
+
+}, {
+    timestamps: true
+});
+
+const WaterPrepaidDebit = mongoose.model('WaterPrepaidDebit', waterPrepaidDebitSchema);
+
+module.exports = WaterPrepaidDebit;

package/src/models/workorder.js

@@ -1,49 +1,49 @@
-const mongoose = require('mongoose');
-
-const workOrderSchema = new mongoose.Schema({
-  facilityId: {
-    type: mongoose.Schema.Types.ObjectId,
-    ref: 'Facility',
-    required: true,
-  },
-  requester: {
-    type: mongoose.Schema.Types.ObjectId,
-    ref: 'User', 
-    required: true,
-  },
-  assigneeName: {
-    type: String,
-    trim: true,
-  },
-  description: {
-    type: String,
-    required: true,
-    trim: true,
-  },
-  pricing: {
-    type: Number,
-    required: true,
-    min: 0,
-  },
-  status: {
-    type: String,
-    enum: ['in progress', 'completed', 'suspended', 'pending', 'cancelled'],
-    default: 'pending',
-  },
-  type: {
-    type: String,
-    enum: ['scheduled', 'unscheduled'],
-    required: true,
-  },
-  orderNumber: {
-    type: Number,
-    unique: true,
-    required: true,
-  },
-}, {
-  timestamps: true, 
-});
-
-const WorkOrder = mongoose.model('WorkOrder', workOrderSchema);
-
-module.exports = WorkOrder;
+const mongoose = require('mongoose');
+
+const workOrderSchema = new mongoose.Schema({
+  facilityId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Facility',
+    required: true,
+  },
+  requester: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User', 
+    required: true,
+  },
+  assigneeName: {
+    type: String,
+    trim: true,
+  },
+  description: {
+    type: String,
+    required: true,
+    trim: true,
+  },
+  pricing: {
+    type: Number,
+    required: true,
+    min: 0,
+  },
+  status: {
+    type: String,
+    enum: ['in progress', 'completed', 'suspended', 'pending', 'cancelled'],
+    default: 'pending',
+  },
+  type: {
+    type: String,
+    enum: ['scheduled', 'unscheduled'],
+    required: true,
+  },
+  orderNumber: {
+    type: Number,
+    unique: true,
+    required: true,
+  },
+}, {
+  timestamps: true, 
+});
+
+const WorkOrder = mongoose.model('WorkOrder', workOrderSchema);
+
+module.exports = WorkOrder;

package/src/models/facilityContractPricing.js

@@ -1,51 +0,0 @@
-const mongoose = require("mongoose");
-
-const FacilityContractPricingSchema = new mongoose.Schema(
-  {
-    name: {
-      type: String,
-      required: true,
-    },
-    powerMetersPrice: {
-      type: Number,
-      required: true,
-      min: [0, "Power meters price cannot be negative"],
-      default: 0,
-    },
-    hotWaterMetersPrice: {
-      type: Number,
-      required: true,
-      min: [0, "Hot water meters price cannot be negative"],
-      default: 0,
-    },
-    coldWaterMetersPrice: {
-      type: Number,
-      required: true,
-      min: [0, "Cold water meters price cannot be negative"],
-      default: 0,
-    },
-    unitsPrice: {
-      type: Number,
-      required: true,
-      min: [0, "Units price cannot be negative"],
-      default: 0,
-    },
-    licensePrice: {
-      type: Number,
-      required: true,
-      min: [0, "License price cannot be negative"],
-      default: 0,
-    },
-  },
-
-  {
-    timestamps: true,
-  },
-);
-
-const FacilityContractPricing = mongoose.model(
-  "FacilityContractPricing",
-  FacilityContractPricingSchema,
-);
-
-module.exports = FacilityContractPricing;

package/src/models/facilityInvoiceContract.js

@@ -1,268 +0,0 @@
-const mongoose = require("mongoose");
-
-const facilityInvoiceContractSchema = new mongoose.Schema(
-  {
-    facility: {
-      type: mongoose.Schema.Types.ObjectId,
-      ref: "Facility",
-      required: true,
-    },
-    pricing: {
-      type: mongoose.Schema.Types.ObjectId,
-      ref: "FacilityContractPricing",
-      required: true,
-    },
-    name: {
-      type: String,
-      required: true,
-      trim: true,
-    },
-    phone: {
-      type: String,
-      required: true,
-      trim: true,
-    },
-    email: {
-      type: String,
-      required: true,
-      trim: true,
-      lowercase: true,
-      match: [/^\S+@\S+\.\S+$/, "Please enter a valid email address"],
-    },
-    paymentInterval: {
-      type: String,
-      enum: ["monthly", "quarterly", "yearly"],
-      default: "monthly",
-    },
-    paymentType: {
-      type: String,
-      enum: ["prepaid", "postpaid", "cash"],
-      default: "cash",
-    },
-    invoiceDueAfterDays: {
-      type: Number,
-      required: true,
-      min: [0, "Invoice due days cannot be negative"],
-    },
-    overdueAfterDays: {
-      type: Number,
-      required: true,
-      min: [0, "Overdue days cannot be negative"],
-      default: 7,
-    },
-    prorate: {
-      type: Boolean,
-      default: false,
-    },
-    items: [
-      {
-        itemType: {
-          type: String,
-          required: true,
-          enum: [
-            "unit",
-            "license",
-            "powerMeters",
-            "hotWaterMeters",
-            "coldWaterMeters",
-          ],
-          trim: true,
-        },
-        name: {
-          type: String,
-          required: true,
-          trim: true,
-        },
-        description: {
-          type: String,
-          required: true,
-          trim: true,
-        },
-        price: {
-          type: Number,
-          required: true,
-          min: [0, "Price cannot be negative"],
-        },
-        quantity: {
-          type: Number,
-          required: true,
-          min: [1, "Quantity must be at least 1"],
-        },
-      },
-    ],
-    reminders: [
-      {
-        frequency: {
-          type: String,
-          required: true,
-          enum: ["daily", "custom"],
-          default: "daily",
-        },
-        customDays: {
-          type: Number,
-          required: function () {
-            return this.frequency === "custom";
-          },
-          min: [1, "Custom days must be at least 1"],
-          default: null,
-        },
-        startDate: {
-          type: Date,
-          required: true,
-        },
-        status: {
-          type: String,
-          enum: ["sent", "pending"],
-          default: "pending",
-        },
-      },
-    ],
-    dates: {
-      startDate: {
-        type: Date,
-        required: true,
-      },
-      endDate: {
-        type: Date,
-        required: true,
-      },
-      invoiceGeneratedDate: {
-        type: Date,
-        required: true,
-      },
-      invoiceDueDate: {
-        type: Date,
-        required: true,
-      },
-    },
-    signedContractDocument: {
-      type: String,
-      required: false, // Changed from required: true
-      default: null, // Added default value
-    },
-    status: {
-      type: String,
-      enum: ["pending", "signed", "rejected"],
-      default: "pending",
-    },
-    active: {
-      type: Boolean,
-      default: false, // Changed default to false since contracts start inactive
-    },
-    header: {
-      companyName: {
-        type: String,
-        required: true,
-        trim: true,
-      },
-      companyAddress: {
-        type: String,
-        required: true,
-        trim: true,
-      },
-      companyPhone: {
-        type: String,
-        trim: true,
-      },
-      companyEmail: {
-        type: String,
-        trim: true,
-        lowercase: true,
-        match: [/^\S+@\S+\.\S+$/, "Please enter a valid email address"],
-      },
-      companyWebsite: {
-        type: String,
-        trim: true,
-        match: [/^https?:\/\/[^\s$.?#].[^\s]*$/, "Please enter a valid URL"],
-      },
-      taxNumber: {
-        type: String,
-        trim: true,
-      },
-      logo: {
-        type: String,
-        default: null,
-      },
-    },
-    footer: {
-      bankName: {
-        type: String,
-        trim: true,
-      },
-      accountName: {
-        type: String,
-        trim: true,
-      },
-      accountNumber: {
-        type: String,
-        trim: true,
-      },
-      swiftCode: {
-        type: String,
-        trim: true,
-      },
-      paymentTerms: {
-        type: String,
-        trim: true,
-        default: "Net 30 days",
-      },
-      latePaymentFee: {
-        type: String,
-        trim: true,
-      },
-      taxRate: {
-        type: String,
-        trim: true,
-      },
-      additionalNotes: {
-        type: String,
-        trim: true,
-      },
-      supportEmail: {
-        type: String,
-        trim: true,
-        lowercase: true,
-        match: [/^\S+@\S+\.\S+$/, "Please enter a valid email address"],
-      },
-      supportPhone: {
-        type: String,
-        trim: true,
-      },
-      termsAndConditions: {
-        type: String,
-        trim: true,
-      },
-    },
-    createdAt: {
-      type: Date,
-      default: Date.now,
-    },
-    updatedAt: {
-      type: Date,
-      default: Date.now,
-    },
-  },
-  {
-    timestamps: true,
-  },
-);
-
-// Add validation middleware to ensure signed contracts have documents
-facilityInvoiceContractSchema.pre("save", function (next) {
-  if (this.status === "signed" && !this.signedContractDocument) {
-    return next(
-      new Error("Signed contracts must have a signed contract document"),
-    );
-  }
-  if (this.active === true && this.status !== "signed") {
-    return next(new Error("Only signed contracts can be active"));
-  }
-  next();
-});
-
-const FacilityInvoiceContract = mongoose.model(
-  "FacilityInvoiceContract",
-  facilityInvoiceContractSchema,
-);
-
-module.exports = FacilityInvoiceContract;

package/src/models/power_meter_command_queue.js

@@ -1,33 +0,0 @@
-const mongoose = require('mongoose');
-
-const powerCommandQueueSchema = new mongoose.Schema({
-    deviceId: {
-        type: String,
-        required: true
-    },
-    gatewayId: {
-        type: String,
-        required: true
-    },
-    commandType: {
-        type: String,
-        enum: ['On', 'Off', 'Read'],
-        required: true
-    },
-    status: {
-        type: String,
-        enum: ['pending', 'sent', 'acknowledged', 'failed'],
-        default: 'pending'
-    },
-    retryCount: {
-        type: Number,
-        default: 0
-    },
-    sentAt: {
-        type: Date
-    }
-}, { timestamps: true });
-
-const PowerCommandQueue = mongoose.model('PowerCommandQueue', powerCommandQueueSchema);
-
-module.exports = PowerCommandQueue;

package/src/models/power_meter_negative_balance.js

@@ -1,44 +0,0 @@
-const mongoose = require('mongoose');
-
-const powerNegativeBalanceSchema = new mongoose.Schema({
-    customerId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Customer',
-        required: true
-    },
-    accountId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'PowerMeterCustomerAccount',
-        required: true
-    },
-    customerName: {
-        type: String,
-        required: true,
-        trim: true
-    },
-    meterNumber: {
-        type: String,
-        required: true,
-        trim: true
-    },
-    amount: {
-        type: Number,
-        required: true
-    },
-    type: {  
-        type: String,
-        enum: ['Credit', 'Debit'],
-        required: true
-    },
-    dateRecorded: {
-        type: Date,
-        required: true,
-        default: Date.now
-    }
-}, {
-    timestamps: true
-});
-
-const PowerNegativeBalance = mongoose.model('PowerNegativeBalance', powerNegativeBalanceSchema);
-
-module.exports = PowerNegativeBalance;

package/src/models/power_prepaid_credits.js

@@ -1,47 +0,0 @@
-const mongoose = require('mongoose');
-
-const powerPrepaidCreditSchema = new mongoose.Schema({
-    accountId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'PowerMeterCustomerAccount',
-        required: true,
-    },
-    meterId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'PowerMeters',
-        required: true,
-    },
-    ref: {
-        type: String,
-        required: true,
-    },
-    amount: {
-        type: Number,
-        required: true,
-        default: 0
-    },
-    time: {
-        type: String,
-        required: true,
-    },
-    addedOn: {
-        type: String,
-        required: true,
-    },
-    reason: {
-        type: String,
-        required: true,
-    },
-    type: {
-        type: String,
-        enum: ['Mobile Money', 'Bank', 'Manual'],
-        required: true
-    },
-
-}, {
-    timestamps: true
-});
-
-const PowerPrepaidCredit = mongoose.model('PowerPrepaidCredit', powerPrepaidCreditSchema);
-
-module.exports = PowerPrepaidCredit;

package/src/models/water_meter_high_risk.js

@@ -1,37 +0,0 @@
-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;