payservedb 6.6.0 → 6.6.2

package/package.json

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

package/src/models/auditTrail.js

@@ -40,7 +40,7 @@ const userDetailsSchema = new mongoose.Schema(
       required: false,
     },
   },
-  { _id: false }
+  { _id: false },
 );
 
 // Main audit trail schema
@@ -125,6 +125,14 @@ const auditTrailSchema = new mongoose.Schema(
       required: true,
     },
 
+    // response status
+    response_status: {
+      type: String,
+      required: true,
+      enum: ["success", "error", "unknown"],
+      default: "unknown",
+    },
+
     // Method-specific data
     previous_data: {
       type: mongoose.Schema.Types.Mixed,
@@ -149,7 +157,7 @@ const auditTrailSchema = new mongoose.Schema(
   },
   {
     timestamps: true,
-  }
+  },
 );
 
 // Pre-save middleware for data validation and cleanup
@@ -202,7 +210,11 @@ auditTrailSchema.statics.findByActivity = function (activity, limit = 100) {
     .limit(limit);
 };
 
-auditTrailSchema.statics.findByFacility = function (facilityId, startDate, endDate) {
+auditTrailSchema.statics.findByFacility = function (
+  facilityId,
+  startDate,
+  endDate,
+) {
   const query = { "route_params.facilityId": facilityId };
   if (startDate || endDate) {
     query.timestamp = {};
@@ -252,10 +264,12 @@ auditTrailSchema.methods.getActivityType = function () {
 };
 
 auditTrailSchema.methods.isSuccessful = function () {
-  return this.activity.includes("Success") || 
-         (!this.activity.includes("Failed") && 
-          !this.activity.includes("Error") && 
-          !this.activity.includes("Not Found"));
+  return (
+    this.activity.includes("Success") ||
+    (!this.activity.includes("Failed") &&
+      !this.activity.includes("Error") &&
+      !this.activity.includes("Not Found"))
+  );
 };
 
 auditTrailSchema.methods.hasDataChanges = function () {
@@ -277,9 +291,21 @@ auditTrailSchema.index({ device_type: 1, timestamp: -1 }); // Device type querie
 auditTrailSchema.index({ browser: 1, timestamp: -1 }); // Browser-based queries
 
 // Compound indexes for common query patterns
-auditTrailSchema.index({ "user_details.userId": 1, activity: 1, timestamp: -1 }); // User + activity
-auditTrailSchema.index({ "route_params.facilityId": 1, method: 1, timestamp: -1 }); // Facility + method
-auditTrailSchema.index({ ip_address: 1, "user_details.userId": 1, timestamp: -1 }); // IP + user correlation
+auditTrailSchema.index({
+  "user_details.userId": 1,
+  activity: 1,
+  timestamp: -1,
+}); // User + activity
+auditTrailSchema.index({
+  "route_params.facilityId": 1,
+  method: 1,
+  timestamp: -1,
+}); // Facility + method
+auditTrailSchema.index({
+  ip_address: 1,
+  "user_details.userId": 1,
+  timestamp: -1,
+}); // IP + user correlation
 
 // Text search index for searching activities and user details
 auditTrailSchema.index({
@@ -292,7 +318,7 @@ auditTrailSchema.index({
 // Activity type constants
 auditTrailSchema.statics.ACTIVITY_TYPES = {
   CREATE: "CREATE",
-  UPDATE: "UPDATE", 
+  UPDATE: "UPDATE",
   DELETE: "DELETE",
   AUTH: "AUTH",
   OTHER: "OTHER",
@@ -317,4 +343,4 @@ auditTrailSchema.statics.DEVICE_TYPES = {
   UNKNOWN: "unknown",
 };
 
-module.exports = mongoose.model("AuditTrail", auditTrailSchema);
+module.exports = mongoose.model("AuditTrail", auditTrailSchema);

package/src/models/dailyChecklist.js

@@ -1,7 +1,7 @@
 const mongoose = require("mongoose");
 
-// Child property schema with date
-const childPropertySchema = new mongoose.Schema(
+// Reading entry schema - each individual reading with metadata
+const readingEntrySchema = new mongoose.Schema(
   {
     value: {
       type: mongoose.Schema.Types.Mixed, // String, Boolean, or Number
@@ -11,8 +11,47 @@ const childPropertySchema = new mongoose.Schema(
       type: Date,
       required: true,
     },
+    recordedBy: {
+      type: String,
+      required: false, // User ID who recorded this reading
+    },
+    notes: {
+      type: String,
+      required: false, // Optional notes for this reading
+    },
+    isActive: {
+      type: Boolean,
+      default: true, // Allow soft deletion of readings
+    },
+  },
+  { _id: true, timestamps: true }, // Keep _id for individual readings and timestamps
+);
+
+// Child property schema with historical readings
+const childPropertySchema = new mongoose.Schema(
+  {
+    name: {
+      type: String,
+      required: true, // Child property name (e.g., "fuel_level")
+    },
+    currentValue: {
+      type: mongoose.Schema.Types.Mixed, // Latest value for quick access
+      required: false,
+    },
+    currentDate: {
+      type: Date,
+      required: false, // Date of latest reading
+    },
+    unit: {
+      type: String,
+      required: false, // Unit of measurement (e.g., "%", "°C", "bar")
+    },
+    readings: {
+      type: [readingEntrySchema], // Array of all historical readings
+      default: [],
+    },
   },
-  { _id: false },
+  { _id: true },
 );
 
 // Main facilities monitoring schema
@@ -22,15 +61,11 @@ const dailyChecklistSchema = new mongoose.Schema(
       type: String,
       required: true,
     },
-
-    // Dynamic parent-child structure with dates
-    // Parent_name -> child_name -> { value, date }
+    // Dynamic parent-child structure with historical readings
+    // Parent_name -> [child_properties with readings]
     data: {
       type: Map,
-      of: {
-        type: Map,
-        of: childPropertySchema,
-      },
+      of: [childPropertySchema], // Array of child properties for each parent
       default: new Map(),
     },
   },
@@ -40,43 +75,158 @@ const dailyChecklistSchema = new mongoose.Schema(
 );
 
 // Helper methods
-dailyChecklistSchema.methods.setValue = function (
+dailyChecklistSchema.methods.addReading = function (
   parentName,
   childName,
   value,
   date = new Date(),
+  metadata = {},
 ) {
   if (!this.data.has(parentName)) {
-    this.data.set(parentName, new Map());
+    this.data.set(parentName, []);
   }
 
-  this.data.get(parentName).set(childName, { value, date });
+  const parent = this.data.get(parentName);
+  let childProperty = parent.find((child) => child.name === childName);
+
+  if (!childProperty) {
+    // Create new child property
+    childProperty = {
+      name: childName,
+      currentValue: value,
+      currentDate: date,
+      unit: metadata.unit || null,
+      readings: [],
+    };
+    parent.push(childProperty);
+  }
+
+  // Add new reading
+  const newReading = {
+    value: value,
+    date: date,
+    recordedBy: metadata.recordedBy || null,
+    notes: metadata.notes || null,
+    isActive: true,
+  };
+
+  childProperty.readings.push(newReading);
+
+  // Update current values
+  childProperty.currentValue = value;
+  childProperty.currentDate = date;
+
+  // Sort readings by date (newest first)
+  childProperty.readings.sort((a, b) => new Date(b.date) - new Date(a.date));
+
   this.markModified("data");
 };
 
-dailyChecklistSchema.methods.getValue = function (parentName, childName) {
+dailyChecklistSchema.methods.getCurrentValue = function (
+  parentName,
+  childName,
+) {
   const parent = this.data.get(parentName);
   if (parent) {
-    const child = parent.get(childName);
-    return child ? child.value : null;
+    const child = parent.find((c) => c.name === childName);
+    return child ? child.currentValue : null;
   }
   return null;
 };
 
-dailyChecklistSchema.methods.getChildWithDate = function (
+dailyChecklistSchema.methods.getReadingHistory = function (
   parentName,
   childName,
+  limit = null,
 ) {
   const parent = this.data.get(parentName);
   if (parent) {
-    return parent.get(childName) || null;
+    const child = parent.find((c) => c.name === childName);
+    if (child) {
+      const activeReadings = child.readings.filter((r) => r.isActive);
+      return limit ? activeReadings.slice(0, limit) : activeReadings;
+    }
+  }
+  return [];
+};
+
+dailyChecklistSchema.methods.getLatestReading = function (
+  parentName,
+  childName,
+) {
+  const parent = this.data.get(parentName);
+  if (parent) {
+    const child = parent.find((c) => c.name === childName);
+    if (child && child.readings.length > 0) {
+      return child.readings.find((r) => r.isActive) || null;
+    }
   }
   return null;
 };
 
+dailyChecklistSchema.methods.updateReading = function (
+  parentName,
+  childName,
+  readingId,
+  updates,
+) {
+  const parent = this.data.get(parentName);
+  if (parent) {
+    const child = parent.find((c) => c.name === childName);
+    if (child) {
+      const reading = child.readings.id(readingId);
+      if (reading) {
+        Object.assign(reading, updates);
+
+        // If this was the latest reading, update current values
+        const latestReading = child.readings.find((r) => r.isActive);
+        if (latestReading && latestReading._id.equals(readingId)) {
+          child.currentValue = reading.value;
+          child.currentDate = reading.date;
+        }
+
+        this.markModified("data");
+        return true;
+      }
+    }
+  }
+  return false;
+};
+
+dailyChecklistSchema.methods.deleteReading = function (
+  parentName,
+  childName,
+  readingId,
+) {
+  const parent = this.data.get(parentName);
+  if (parent) {
+    const child = parent.find((c) => c.name === childName);
+    if (child) {
+      const reading = child.readings.id(readingId);
+      if (reading) {
+        reading.isActive = false; // Soft delete
+
+        // Update current values to next active reading
+        const latestActiveReading = child.readings.find((r) => r.isActive);
+        if (latestActiveReading) {
+          child.currentValue = latestActiveReading.value;
+          child.currentDate = latestActiveReading.date;
+        } else {
+          child.currentValue = null;
+          child.currentDate = null;
+        }
+
+        this.markModified("data");
+        return true;
+      }
+    }
+  }
+  return false;
+};
+
 dailyChecklistSchema.methods.createParent = function (parentName) {
   if (!this.data.has(parentName)) {
-    this.data.set(parentName, new Map());
+    this.data.set(parentName, []);
     this.markModified("data");
   }
 };
@@ -91,7 +241,72 @@ dailyChecklistSchema.methods.getParentNames = function () {
 
 dailyChecklistSchema.methods.getChildNames = function (parentName) {
   const parent = this.data.get(parentName);
-  return parent ? Array.from(parent.keys()) : [];
+  return parent ? parent.map((child) => child.name) : [];
+};
+
+dailyChecklistSchema.methods.getChildProperty = function (
+  parentName,
+  childName,
+) {
+  const parent = this.data.get(parentName);
+  if (parent) {
+    return parent.find((child) => child.name === childName) || null;
+  }
+  return null;
+};
+
+// Get readings within a date range
+dailyChecklistSchema.methods.getReadingsByDateRange = function (
+  parentName,
+  childName,
+  startDate,
+  endDate,
+) {
+  const parent = this.data.get(parentName);
+  if (parent) {
+    const child = parent.find((c) => c.name === childName);
+    if (child) {
+      return child.readings.filter((reading) => {
+        const readingDate = new Date(reading.date);
+        return (
+          reading.isActive &&
+          readingDate >= new Date(startDate) &&
+          readingDate <= new Date(endDate)
+        );
+      });
+    }
+  }
+  return [];
+};
+
+// Get statistics for a child property
+dailyChecklistSchema.methods.getChildStatistics = function (
+  parentName,
+  childName,
+) {
+  const readings = this.getReadingHistory(parentName, childName);
+  if (readings.length === 0) return null;
+
+  const numericReadings = readings
+    .map((r) => r.value)
+    .filter((v) => typeof v === "number");
+
+  if (numericReadings.length === 0) {
+    return {
+      totalReadings: readings.length,
+      type: "non-numeric",
+    };
+  }
+
+  return {
+    totalReadings: readings.length,
+    type: "numeric",
+    min: Math.min(...numericReadings),
+    max: Math.max(...numericReadings),
+    average:
+      numericReadings.reduce((a, b) => a + b, 0) / numericReadings.length,
+    latest: readings[0].value,
+  };
 };
 
 module.exports = mongoose.model("DailyChecklist", dailyChecklistSchema);

package/src/models/auditlog.js

@@ -1,83 +0,0 @@
-const mongoose = require('mongoose');
-
-const auditLogSchema = new mongoose.Schema({
-    action: {
-        type: String,
-        required: true,
-        trim: true
-    },
-    page: {
-        type: String,
-        required: true,
-        trim: true
-    },
-    userId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Company',
-        required: true
-    },
-    userInfo: {
-        type: mongoose.Schema.Types.Mixed,
-        required: true
-    },
-    projectId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Project',
-        required: true
-    },
-    projectInfo: {
-        type: mongoose.Schema.Types.Mixed,
-        required: true
-    },
-    computerName: {
-        type: String,
-        required: true,
-        trim: true
-    },
-    browser: {
-        type: String,
-        required: true,
-        trim: true
-    },
-    ipAddress: {
-        type: String,
-        required: true,
-        trim: true
-    },
-    time: {
-        type: String,
-        required: true,
-        trim: true
-    },
-    date: {
-        type: String,
-        required: true,
-        trim: true
-    },
-    createdOn: {
-        type: Date,
-        default: Date.now,
-        required: true
-    },
-    oldData: {
-        type: mongoose.Schema.Types.Mixed,
-        default: {}
-    },
-    newData: {
-        type: mongoose.Schema.Types.Mixed,
-        default: {}
-    },
-    deletedData: {
-        type: mongoose.Schema.Types.Mixed,
-        default: {}
-    }
-}, {
-    timestamps: true 
-});
-
-auditLogSchema.index({ userId: 1, projectId: 1, createdOn: -1 });
-auditLogSchema.index({ action: 1 });
-auditLogSchema.index({ page: 1 });
-const AuditLog = mongoose.model('AuditLog', auditLogSchema);
-
-module.exports = AuditLog;