payservedb 3.4.9 → 3.5.0

package/package.json

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

package/src/models/levy.js

@@ -60,4 +60,4 @@ const levySchema = new mongoose.Schema(
 // Compile the model from the schema
 const Levy = mongoose.model("Levy", levySchema);
 
-module.exports = Levy;
+module.exports = Levy;

package/src/models/reminder.js

@@ -1,4 +1,5 @@
 const mongoose = require("mongoose");
+const moment = require("moment-timezone");
 
 // Define the schema for Reminder
 const reminderSchema = new mongoose.Schema(
@@ -10,28 +11,57 @@ const reminderSchema = new mongoose.Schema(
     },
     type: {
       type: String,
-      enum: ['onetime', 'recurring'], 
       required: true,
+      enum: ['standard', 'custom'], 
+      default: 'standard'
     },
-    frequency: {
-      type: String,
-      enum: ['daily', 'weekly', 'biweekly', 'monthly'], 
-      required: function() { return this.type === 'recurring'; }, 
-    },
-    scheduledDate: {
-      type: Date,
-      required: function() { return this.type === 'onetime'; }, 
-    },
-    time: {
+    module: {
       type: String,
       required: true,
+      enum: ['levy', 'lease'], 
+      default: 'levy'
     },
-    day: {
-      type: String,
+    remindOn: {
+      invoiceDate: {
+        type: Boolean,
+        default: true,
+      },
+      dueDate: {
+        type: Boolean,
+        default: false,
+      },
+      afterOverdue: {
+        enabled: {
+          type: Boolean,
+          default: false,
+        },
+        days: {
+          type: [Number],
+          validate: {
+            validator: function (value) {
+              // If afterOverdue is not enabled, any value is valid
+              if (!this.remindOn.afterOverdue.enabled) return true;
+
+              // When enabled, days must be 1, 3, or 7
+              return Array.isArray(value) &&
+                value.length > 0 &&
+                value.every(day => [1, 3, 7].includes(day));
+            },
+            message: 'When overdue reminders are enabled, days can only be 1, 3, or 7'
+          }
+        }
+      }
     },
-    module: {
+    time: {
       type: String,
       required: true,
+      default: "09:00",
+      validate: {
+        validator: function (value) {
+          return /^([0-1]?[0-9]|2[0-3]):[0-5][0-9]$/.test(value);
+        },
+        message: 'Time must be in HH:mm format'
+      }
     },
     isActive: {
       type: Boolean,
@@ -41,22 +71,104 @@ const reminderSchema = new mongoose.Schema(
     processed: {
       type: Boolean,
       required: true,
-      default: false, 
+      default: false,
+    },
+    lastProcessed: {
+      type: Date,
+    },
+    notificationTypes: {
+      type: [String],
+      required: true,
+      validate: {
+        validator: function (value) {
+          return value.length > 0 &&
+            value.every(type => ['SMS', 'EMAIL'].includes(type.toUpperCase()));
+        },
+        message: 'At least one valid notification type is required'
+      }
+    },
+    message: {
+      type: String,
+      maxLength: [500, 'Message cannot exceed 500 characters']
+    },
+    levyId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Levy",
+      required: true,
     },
-    notificationTypes: [String], 
-    message: String, 
-    levyId: String, 
     facilityId: {
       type: mongoose.Schema.Types.ObjectId,
       ref: "Facility",
       required: true,
+      index: true
     },
+    timezone: {
+      type: String,
+      required: true,
+      default: 'UTC',
+      validate: {
+        validator: function (value) {
+          return moment.tz.names().includes(value);
+        },
+        message: 'Invalid timezone'
+      }
+    }
   },
   {
     timestamps: true,
+    // Add indexes for frequently queried fields
+    indexes: [
+      { facilityId: 1, isActive: 1 },
+      { facilityId: 1, isActive: 1, 'remindOn.invoiceDate': 1 },
+      { facilityId: 1, isActive: 1, 'remindOn.dueDate': 1 },
+      { facilityId: 1, isActive: 1, 'remindOn.afterOverdue.enabled': 1 },
+      { levyId: 1, isActive: 1 },
+      { facilityId: 1, lastProcessed: 1 }
+    ]
   }
 );
 
+// Add method to check if reminder should be processed
+reminderSchema.methods.shouldProcess = function (currentTime, invoice) {
+  if (!this.isActive || !invoice) return false;
+
+  const now = moment(currentTime);
+  const invoiceDate = moment(invoice.createdAt);
+  const dueDate = moment(invoice.dueDate);
+  const today = moment().startOf('day');
+
+  // Check if we should process based on time
+  if (!this.isTimeToProcess(now)) return false;
+
+  // Check invoice date reminder
+  if (this.remindOn.invoiceDate && invoiceDate.isSame(today, 'day')) {
+    return true;
+  }
+
+  // Check due date reminder
+  if (this.remindOn.dueDate && dueDate.isSame(today, 'day')) {
+    return true;
+  }
+
+  // Check overdue reminders
+  if (this.remindOn.afterOverdue.enabled && dueDate.isBefore(today, 'day')) {
+    const daysOverdue = today.diff(dueDate, 'days');
+    return this.remindOn.afterOverdue.days.includes(daysOverdue);
+  }
+
+  return false;
+};
+
+// Helper method to check if current time matches reminder time
+reminderSchema.methods.isTimeToProcess = function (currentTime) {
+  const reminderMoment = moment(this.time, 'HH:mm');
+  const currentMoment = moment(currentTime).format('HH:mm');
+  const diffMinutes = moment(currentMoment, 'HH:mm').diff(reminderMoment, 'minutes');
+
+  // Allow processing within 5-minute window
+  return Math.abs(diffMinutes) <= 5;
+};
+
 const Reminder = mongoose.model("Reminder", reminderSchema);
 
-module.exports = Reminder;
+module.exports = Reminder;