payservedb 5.6.3 → 5.6.5

package/src/models/purchase_request.js

@@ -1,111 +1,111 @@
-const mongoose = require('mongoose');
-
-const purchaseRequestSchema = new mongoose.Schema({
-    facilityId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Facility',
-        required: true,
-        index: true
-    },
-    items: [{
-        itemDescription: {
-            type: String,
-            required: true,
-            trim: true
-        },
-        quantity: {
-            type: Number,
-            required: true
-        },
-        unitOfMeasure: {
-            type: String,
-            required: true,
-            trim: true
-        },
-        remarksSpecification: {
-            type: String,
-            trim: true
-        }
-    }],
-    from: {
-        type: String,
-        trim: true
-    },
-    date: {
-        type: Date,
-        required: true,
-        default: Date.now
-    },
-    irfNumber: {
-        type: String,
-        required: true,
-        trim: true,
-        index: true
-    },
-    department: {
-        type: String,
-        trim: true
-    },
-    status: {
-        type: String,
-        default: 'pending',
-        index: true
-    },
-    poStatus: {
-        type: String,
-        enum: ['PO Raised', 'pending'],
-        default: 'pending',
-        index: true
-    },
-    approvalWorkflowId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'ApprovalWorkflow',
-        required: true
-      },
-      approvalStatus: {
-        type: String,
-        enum: ['pending', 'in_progress', 'approved', 'rejected'],
-        default: 'pending',
-        index: true
-      },
-      currentStep: {
-        type: Number,
-        default: 1,
-        min: 1
-      },
-      approvals: [{
-        stepNumber: {
-          type: Number,
-          required: true
-        },
-        stepName: {
-          type: String,
-          required: true
-        },
-        approvers: [{
-          userId: {
-            type: mongoose.Schema.Types.ObjectId,
-            ref: 'User',
-            required: true
-          },
-          status: {
-            type: String,
-            enum: ['pending', 'approved', 'rejected'],
-            default: 'pending'
-          },
-          actionDate: {
-            type: Date
-          },
-          comments: {
-            type: String,
-            trim: true
-          }
-        }]
-      }]
-    }, {
-      timestamps: true
-    });
-
-const PurchaseRequest = mongoose.model('PurchaseRequest', purchaseRequestSchema);
-
+const mongoose = require('mongoose');
+
+const purchaseRequestSchema = new mongoose.Schema({
+    facilityId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Facility',
+        required: true,
+        index: true
+    },
+    items: [{
+        itemDescription: {
+            type: String,
+            required: true,
+            trim: true
+        },
+        quantity: {
+            type: Number,
+            required: true
+        },
+        unitOfMeasure: {
+            type: String,
+            required: true,
+            trim: true
+        },
+        remarksSpecification: {
+            type: String,
+            trim: true
+        }
+    }],
+    from: {
+        type: String,
+        trim: true
+    },
+    date: {
+        type: Date,
+        required: true,
+        default: Date.now
+    },
+    irfNumber: {
+        type: String,
+        required: true,
+        trim: true,
+        index: true
+    },
+    department: {
+        type: String,
+        trim: true
+    },
+    status: {
+        type: String,
+        default: 'pending',
+        index: true
+    },
+    poStatus: {
+        type: String,
+        enum: ['PO Raised', 'pending'],
+        default: 'pending',
+        index: true
+    },
+    approvalWorkflowId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'ApprovalWorkflow',
+        required: true
+      },
+      approvalStatus: {
+        type: String,
+        enum: ['pending', 'in_progress', 'approved', 'rejected'],
+        default: 'pending',
+        index: true
+      },
+      currentStep: {
+        type: Number,
+        default: 1,
+        min: 1
+      },
+      approvals: [{
+        stepNumber: {
+          type: Number,
+          required: true
+        },
+        stepName: {
+          type: String,
+          required: true
+        },
+        approvers: [{
+          userId: {
+            type: mongoose.Schema.Types.ObjectId,
+            ref: 'User',
+            required: true
+          },
+          status: {
+            type: String,
+            enum: ['pending', 'approved', 'rejected'],
+            default: 'pending'
+          },
+          actionDate: {
+            type: Date
+          },
+          comments: {
+            type: String,
+            trim: true
+          }
+        }]
+      }]
+    }, {
+      timestamps: true
+    });
+
+const PurchaseRequest = mongoose.model('PurchaseRequest', purchaseRequestSchema);
+
 module.exports = PurchaseRequest;

package/src/models/refresh_token.js

@@ -1,23 +1,23 @@
-const mongoose = require('mongoose');
-
-const refreshTokenSchema = new mongoose.Schema({
-    userId: {
-        type: String,
-        required: true,
-        index: true, // Index for faster lookup by userId
-    },
-    token: {
-        type: String,
-        required: true,
-    },
-    createdAt: {
-        type: Date,
-        required: true,
-        default: Date.now,
-        expires: '30d', // Example: Token expires after 30 days
-    },
-},{timestamps: true});
-
-const RefreshToken = mongoose.model('RefreshToken', refreshTokenSchema);
-
-module.exports = RefreshToken;
+const mongoose = require('mongoose');
+
+const refreshTokenSchema = new mongoose.Schema({
+    userId: {
+        type: String,
+        required: true,
+        index: true, // Index for faster lookup by userId
+    },
+    token: {
+        type: String,
+        required: true,
+    },
+    createdAt: {
+        type: Date,
+        required: true,
+        default: Date.now,
+        expires: '30d', // Example: Token expires after 30 days
+    },
+},{timestamps: true});
+
+const RefreshToken = mongoose.model('RefreshToken', refreshTokenSchema);
+
+module.exports = RefreshToken;

package/src/models/reminder.js

@@ -1,198 +1,198 @@
-const mongoose = require("mongoose");
-const moment = require("moment-timezone");
-
-const reminderSchema = new mongoose.Schema(
-  {
-    name: {
-      type: String,
-      required: true,
-      trim: true,
-    },
-    type: {
-      type: String,
-      required: true,
-      enum: ['standard', 'custom'],
-      default: 'standard'
-    },
-    module: {
-      type: String,
-      required: true,
-      enum: ['levy', 'lease', 'utility'],
-      default: 'levy'
-    },
-    moduleId: {
-      type: mongoose.Schema.Types.ObjectId,
-      required: true,
-      refPath: 'module'
-    },
-    remindOn: {
-      invoiceDate: {
-        type: Boolean,
-        default: true,
-      },
-      dueDate: {
-        type: Boolean,
-        default: false,
-      },
-      afterOverdue: {
-        enabled: {
-          type: Boolean,
-          default: false,
-        },
-        daily: {
-          type: Boolean,
-          default: false,
-        },
-        days: {
-          type: [Number],
-          validate: {
-            validator: function (value) {
-              // If daily reminders are enabled, no need to validate days
-              if (this.remindOn?.afterOverdue?.daily === true) return true;
-
-              // If overdue reminders are disabled, no validation needed
-              if (!this.remindOn?.afterOverdue?.enabled) return true;
-
-              // If overdue is enabled but daily is false, then validate days array
-              return Array.isArray(value) &&
-                value.length > 0 &&
-                value.every(day => [1, 3, 7].includes(day));
-            },
-            message: 'When overdue reminders are enabled (and daily is false), days must include only values of 1, 3, or 7'
-          }
-        }
-      }
-    },
-    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,
-      required: true,
-      default: true,
-    },
-    processed: {
-      type: Boolean,
-      required: true,
-      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']
-    },
-    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,
-    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 },
-      { facilityId: 1, isActive: 1, 'remindOn.afterOverdue.daily': 1 },
-      { moduleId: 1, isActive: 1 },
-      { facilityId: 1, lastProcessed: 1 }
-    ]
-  }
-);
-
-// Helper 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 current time matches reminder time
-  if (!this.isTimeToProcess(now)) return false;
-
-  // Check for invoice date reminder
-  if (this.remindOn.invoiceDate && invoiceDate.isSame(today, 'day')) {
-    return true;
-  }
-
-  // Check for due date reminder
-  if (this.remindOn.dueDate && dueDate.isSame(today, 'day')) {
-    return true;
-  }
-
-  // Check for overdue reminder
-  if (this.remindOn.afterOverdue.enabled && dueDate.isBefore(today, 'day')) {
-    // If daily reminders are enabled, send reminder every day after due date
-    if (this.remindOn.afterOverdue.daily) {
-      return true;
-    }
-
-    // Otherwise, check if today is one of the specific days after due date
-    const daysOverdue = today.diff(dueDate, 'days');
-    return this.remindOn.afterOverdue.days.includes(daysOverdue);
-  }
-
-  return false;
-};
-
-// Helper to check if current time is close to scheduled reminder time
-reminderSchema.methods.isTimeToProcess = function (currentTime) {
-  const reminderTime = moment(this.time, 'HH:mm');
-  const currentMoment = moment(currentTime).format('HH:mm');
-  const diffMinutes = Math.abs(
-    moment(currentMoment, 'HH:mm').diff(reminderTime, 'minutes')
-  );
-
-  // Allow processing within 5 minutes of scheduled time
-  return diffMinutes <= 5;
-};
-
-// Method to check if reminder has been processed today
-reminderSchema.methods.hasBeenProcessedToday = function () {
-  if (!this.lastProcessed) return false;
-
-  const today = moment().startOf('day');
-  const processedDate = moment(this.lastProcessed).startOf('day');
-
-  return processedDate.isSame(today, 'day');
-};
-
-const Reminder = mongoose.model("Reminder", reminderSchema);
-
+const mongoose = require("mongoose");
+const moment = require("moment-timezone");
+
+const reminderSchema = new mongoose.Schema(
+  {
+    name: {
+      type: String,
+      required: true,
+      trim: true,
+    },
+    type: {
+      type: String,
+      required: true,
+      enum: ['standard', 'custom'],
+      default: 'standard'
+    },
+    module: {
+      type: String,
+      required: true,
+      enum: ['levy', 'lease', 'utility'],
+      default: 'levy'
+    },
+    moduleId: {
+      type: mongoose.Schema.Types.ObjectId,
+      required: true,
+      refPath: 'module'
+    },
+    remindOn: {
+      invoiceDate: {
+        type: Boolean,
+        default: true,
+      },
+      dueDate: {
+        type: Boolean,
+        default: false,
+      },
+      afterOverdue: {
+        enabled: {
+          type: Boolean,
+          default: false,
+        },
+        daily: {
+          type: Boolean,
+          default: false,
+        },
+        days: {
+          type: [Number],
+          validate: {
+            validator: function (value) {
+              // If daily reminders are enabled, no need to validate days
+              if (this.remindOn?.afterOverdue?.daily === true) return true;
+
+              // If overdue reminders are disabled, no validation needed
+              if (!this.remindOn?.afterOverdue?.enabled) return true;
+
+              // If overdue is enabled but daily is false, then validate days array
+              return Array.isArray(value) &&
+                value.length > 0 &&
+                value.every(day => [1, 3, 7].includes(day));
+            },
+            message: 'When overdue reminders are enabled (and daily is false), days must include only values of 1, 3, or 7'
+          }
+        }
+      }
+    },
+    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,
+      required: true,
+      default: true,
+    },
+    processed: {
+      type: Boolean,
+      required: true,
+      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']
+    },
+    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,
+    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 },
+      { facilityId: 1, isActive: 1, 'remindOn.afterOverdue.daily': 1 },
+      { moduleId: 1, isActive: 1 },
+      { facilityId: 1, lastProcessed: 1 }
+    ]
+  }
+);
+
+// Helper 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 current time matches reminder time
+  if (!this.isTimeToProcess(now)) return false;
+
+  // Check for invoice date reminder
+  if (this.remindOn.invoiceDate && invoiceDate.isSame(today, 'day')) {
+    return true;
+  }
+
+  // Check for due date reminder
+  if (this.remindOn.dueDate && dueDate.isSame(today, 'day')) {
+    return true;
+  }
+
+  // Check for overdue reminder
+  if (this.remindOn.afterOverdue.enabled && dueDate.isBefore(today, 'day')) {
+    // If daily reminders are enabled, send reminder every day after due date
+    if (this.remindOn.afterOverdue.daily) {
+      return true;
+    }
+
+    // Otherwise, check if today is one of the specific days after due date
+    const daysOverdue = today.diff(dueDate, 'days');
+    return this.remindOn.afterOverdue.days.includes(daysOverdue);
+  }
+
+  return false;
+};
+
+// Helper to check if current time is close to scheduled reminder time
+reminderSchema.methods.isTimeToProcess = function (currentTime) {
+  const reminderTime = moment(this.time, 'HH:mm');
+  const currentMoment = moment(currentTime).format('HH:mm');
+  const diffMinutes = Math.abs(
+    moment(currentMoment, 'HH:mm').diff(reminderTime, 'minutes')
+  );
+
+  // Allow processing within 5 minutes of scheduled time
+  return diffMinutes <= 5;
+};
+
+// Method to check if reminder has been processed today
+reminderSchema.methods.hasBeenProcessedToday = function () {
+  if (!this.lastProcessed) return false;
+
+  const today = moment().startOf('day');
+  const processedDate = moment(this.lastProcessed).startOf('day');
+
+  return processedDate.isSame(today, 'day');
+};
+
+const Reminder = mongoose.model("Reminder", reminderSchema);
+
 module.exports = Reminder;