payservedb 6.4.4 → 6.4.6

package/index.js

@@ -203,6 +203,7 @@ const models = {
   NegativeBalance: require("./src/models/water_meter_negative_amounts"),
   MasterWorkplan: require("./src/models/master_workplan"),
   MasterWorkplanChild: require("./src/models/master_workplan_child"),
+  DutyRosterChecklist: require("./src/models/dutyRoasterChecklist"),
 };
 
 // Function to get models dynamically from a specific database connection

package/package.json

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

package/src/models/dutyRoasterChecklist.js

@@ -0,0 +1,250 @@
+const mongoose = require("mongoose");
+
+const DutyRosterChecklistSchema = new mongoose.Schema(
+  {
+    dutyRosterId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "DutyRoster",
+      required: true,
+    },
+    facilityId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Facility",
+      required: true,
+    },
+    staffId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "User",
+      required: true,
+    },
+    masterWorkplanId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "MasterWorkplan",
+      required: true,
+    },
+    // Array of tasks with their individual dates and status
+    tasks: [
+      {
+        childWorkplanId: {
+          type: mongoose.Schema.Types.ObjectId,
+          ref: "ChildWorkplan",
+          required: true,
+        },
+        // Each task can have multiple scheduled dates
+        scheduledDates: [
+          {
+            date: {
+              type: Date,
+              required: true,
+            },
+            status: {
+              type: String,
+              enum: [
+                "pending",
+                "completed",
+                "missed",
+                "cancelled",
+                "in-progress",
+              ],
+              default: "pending",
+              required: true,
+            },
+            completedAt: {
+              type: Date,
+            },
+            completedBy: {
+              type: mongoose.Schema.Types.ObjectId,
+              ref: "User",
+            },
+            notes: {
+              type: String,
+              maxlength: 500,
+            },
+            // Time tracking
+            startTime: String,
+            endTime: String,
+            actualDuration: Number, // in minutes
+          },
+        ],
+        // Task metadata
+        priority: {
+          type: String,
+          enum: ["low", "medium", "high", "critical"],
+          default: "medium",
+        },
+        estimatedDuration: Number, // in minutes
+        isRecurring: {
+          type: Boolean,
+          default: false,
+        },
+        recurringPattern: {
+          type: String,
+          enum: ["daily", "weekly", "monthly", "custom"],
+        },
+      },
+    ],
+    // Overall checklist metadata
+    period: {
+      startDate: {
+        type: Date,
+        required: true,
+      },
+      endDate: {
+        type: Date,
+        required: true,
+      },
+    },
+    // Summary statistics
+    summary: {
+      totalTasks: {
+        type: Number,
+        default: 0,
+      },
+      completedTasks: {
+        type: Number,
+        default: 0,
+      },
+      pendingTasks: {
+        type: Number,
+        default: 0,
+      },
+      missedTasks: {
+        type: Number,
+        default: 0,
+      },
+      completionPercentage: {
+        type: Number,
+        default: 0,
+        min: 0,
+        max: 100,
+      },
+    },
+    status: {
+      type: String,
+      enum: ["active", "completed", "expired", "cancelled"],
+      default: "active",
+    },
+  },
+  {
+    timestamps: true,
+  },
+);
+
+// Pre-save middleware to update summary statistics
+DutyRosterChecklistSchema.pre("save", function (next) {
+  // Validate period dates
+  if (this.period.startDate >= this.period.endDate) {
+    return next(new Error("End date must be after start date"));
+  }
+
+  // Calculate summary statistics
+  let totalScheduledDates = 0;
+  let completedScheduledDates = 0;
+  let pendingScheduledDates = 0;
+  let missedScheduledDates = 0;
+
+  this.tasks.forEach((task) => {
+    task.scheduledDates.forEach((scheduledDate) => {
+      totalScheduledDates++;
+      switch (scheduledDate.status) {
+        case "completed":
+          completedScheduledDates++;
+          break;
+        case "pending":
+        case "in-progress":
+          pendingScheduledDates++;
+          break;
+        case "missed":
+          missedScheduledDates++;
+          break;
+      }
+    });
+  });
+
+  this.summary.totalTasks = totalScheduledDates;
+  this.summary.completedTasks = completedScheduledDates;
+  this.summary.pendingTasks = pendingScheduledDates;
+  this.summary.missedTasks = missedScheduledDates;
+  this.summary.completionPercentage =
+    totalScheduledDates > 0
+      ? Math.round((completedScheduledDates / totalScheduledDates) * 100)
+      : 0;
+
+  next();
+});
+
+// Static method to generate dates between start and end date
+DutyRosterChecklistSchema.statics.generateDateRange = function (
+  startDate,
+  endDate,
+  frequency = "daily",
+) {
+  const dates = [];
+  const current = new Date(startDate);
+  const end = new Date(endDate);
+
+  while (current <= end) {
+    dates.push(new Date(current));
+
+    switch (frequency) {
+      case "daily":
+        current.setDate(current.getDate() + 1);
+        break;
+      case "weekly":
+        current.setDate(current.getDate() + 7);
+        break;
+      case "monthly":
+        current.setMonth(current.getMonth() + 1);
+        break;
+      default:
+        current.setDate(current.getDate() + 1);
+    }
+  }
+
+  return dates;
+};
+
+// Instance method to update task status
+DutyRosterChecklistSchema.methods.updateTaskStatus = function (
+  taskId,
+  dateId,
+  status,
+  completedBy,
+  notes,
+) {
+  const task = this.tasks.id(taskId);
+  if (!task) {
+    throw new Error("Task not found");
+  }
+
+  const scheduledDate = task.scheduledDates.id(dateId);
+  if (!scheduledDate) {
+    throw new Error("Scheduled date not found");
+  }
+
+  scheduledDate.status = status;
+  if (status === "completed") {
+    scheduledDate.completedAt = new Date();
+    scheduledDate.completedBy = completedBy;
+  }
+  if (notes) {
+    scheduledDate.notes = notes;
+  }
+
+  return this.save();
+};
+
+// Add indexes for efficient queries
+DutyRosterChecklistSchema.index({ dutyRosterId: 1 });
+DutyRosterChecklistSchema.index({ facilityId: 1, staffId: 1 });
+DutyRosterChecklistSchema.index({ masterWorkplanId: 1 });
+DutyRosterChecklistSchema.index({ "period.startDate": 1, "period.endDate": 1 });
+DutyRosterChecklistSchema.index({ "tasks.scheduledDates.date": 1 });
+DutyRosterChecklistSchema.index({ status: 1 });
+
+const DutyRosterChecklist = mongoose.model(
+  "DutyRosterChecklist",
+  DutyRosterChecklistSchema,
+);
+
+module.exports = DutyRosterChecklist;

package/src/models/dutyroster.js

@@ -36,8 +36,14 @@ const dutyRosterSchema = new mongoose.Schema(
       ref: "MasterWorkplanAssignment",
       required: true,
     },
-
-    // Regular weekly schedule - now array of time slots for each day
+    startDate: {
+      type: Date,
+      required: true,
+    },
+    endDate: {
+      type: Date,
+      required: true,
+    },
     weeklySchedule: {
       monday: [timeSlotSchema],
       tuesday: [timeSlotSchema],
@@ -47,7 +53,6 @@ const dutyRosterSchema = new mongoose.Schema(
       saturday: [timeSlotSchema],
       sunday: [timeSlotSchema],
     },
-
     // For exceptions to the regular schedule
     exceptions: [
       {
@@ -65,7 +70,6 @@ const dutyRosterSchema = new mongoose.Schema(
         reason: String,
       },
     ],
-
     // Metadata
     metadata: {
       period: {
@@ -79,21 +83,14 @@ const dutyRosterSchema = new mongoose.Schema(
   },
 );
 
-// Status code definitions
-dutyRosterSchema.statics.STATUS_CODES = {
-  ON: "On Duty",
-  OFF: "Off Duty",
-  AL: "Annual Leave",
-  CL: "Casual Leave",
-  "ML/PL": "Medical/Paternity Leave",
-  PH: "Public Holiday",
-  UI: "Unplanned Issues",
-};
-
-// Pre-save middleware to handle backward compatibility with old format
+// Add validation to ensure endDate is after startDate
 dutyRosterSchema.pre("save", function (next) {
-  const schedule = this.weeklySchedule;
+  // Validate date range
+  if (this.startDate && this.endDate && this.startDate >= this.endDate) {
+    return next(new Error("End date must be after start date"));
+  }
 
+  const schedule = this.weeklySchedule;
   // Convert any day that's not an array to an array with a single element
   for (const day of [
     "monday",
@@ -107,7 +104,6 @@ dutyRosterSchema.pre("save", function (next) {
     if (schedule[day] && !Array.isArray(schedule[day])) {
       schedule[day] = [schedule[day]];
     }
-
     // Ensure each day has at least one time slot
     if (!schedule[day] || schedule[day].length === 0) {
       schedule[day] = [
@@ -119,8 +115,22 @@ dutyRosterSchema.pre("save", function (next) {
       ];
     }
   }
-
   next();
 });
 
+// Status code definitions
+dutyRosterSchema.statics.STATUS_CODES = {
+  ON: "On Duty",
+  OFF: "Off Duty",
+  AL: "Annual Leave",
+  CL: "Casual Leave",
+  "ML/PL": "Medical/Paternity Leave",
+  PH: "Public Holiday",
+  UI: "Unplanned Issues",
+};
+
+// Add index for efficient date range queries
+dutyRosterSchema.index({ startDate: 1, endDate: 1 });
+dutyRosterSchema.index({ facilityId: 1, startDate: 1, endDate: 1 });
+
 module.exports = mongoose.model("DutyRoster", dutyRosterSchema);

package/src/models/leaseagreement.js

@@ -26,6 +26,13 @@ const leaseAgreementSchema = new mongoose.Schema({
         ref: 'Customer',
         required: true
     },
+    
+    // *** NEW FIELD: Add billing address support ***
+    billerAddressId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'BillerAddress'
+    },
+    
     // GL Account configurations
     invoiceDoubleEntryAccount: {
         type: mongoose.Schema.Types.ObjectId,
@@ -92,6 +99,28 @@ const leaseAgreementSchema = new mongoose.Schema({
             type: mongoose.Schema.Types.ObjectId,
             ref: 'Penalty'
         },
+        
+        // *** ENHANCED: Add payment configuration flags ***
+        bankPayment: {
+            type: Boolean,
+            default: false
+        },
+        mobilePayment: {
+            type: Boolean,
+            default: false
+        },
+        
+        // *** ENHANCED: Add structured payment method references ***
+        bankAccountId: {
+            type: mongoose.Schema.Types.ObjectId,
+            ref: 'BankAccount'
+        },
+        paymentMethodId: {
+            type: mongoose.Schema.Types.ObjectId,
+            ref: 'PaymentMethod'
+        },
+        
+        // Existing M-Pesa fields (keep for backward compatibility)
         mpesaEnabled: {
             type: Boolean,
             default: false
@@ -101,6 +130,7 @@ const leaseAgreementSchema = new mongoose.Schema({
             accountNumber: String,
             phoneNumber: String
         },
+        
         escalations: [{
             _id: { type: mongoose.Schema.Types.ObjectId, auto: true },
             effectiveDate: { type: Date, required: true },
@@ -219,4 +249,4 @@ leaseAgreementSchema.index({ facilityId: 1 });
 
 const LeaseAgreement = mongoose.model('LeaseAgreement', leaseAgreementSchema);
 
-module.exports = LeaseAgreement;
+module.exports = LeaseAgreement;

package/src/models/master_workplan.js

@@ -9,6 +9,7 @@ const masterWorkplanSchema = new mongoose.Schema({
   title: {
     type: String,
     required: true,
+    unique: true,
   },
   description: {
     type: String,

package/src/models/water_meter_billing.js

@@ -44,7 +44,7 @@ const analogBillingSchema = new mongoose.Schema({
     },
     status: {
         type: String,
-        enum: ['pending', 'reviewed', 'billed'],
+        enum: ['pending', 'reviewed', 'billed', 'failed'],
         default: 'pending',
     },
 }, {