payservedb 6.6.0 → 6.6.1

package/package.json

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

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);