@justair/justair-library 4.7.25 → 4.7.26

package/src/models/monitors.js

@@ -1,400 +1,401 @@
-import mongoose from "mongoose";
-const parametersEnum = [
-  "NO2",
-  "SO2",
-  "PM2.5",
-  "PM10",
-  "Temperature",
-  "Humidity",
-  "OZONE",
-  "VOC",
-  "CO",
-  "NO",
-  "PM1",
-  "WS And Direction",
-  "DP",
-  "CH4",
-];
-
-const noteSchema = mongoose.Schema({
-  note: {
-    type: String,
-    required: true,
-  },
-  type: {
-    type: String,
-    required: true,
-  },
-  monitorState: {
-    type: String,
-    required: true,
-  },
-  adminId: {
-    type: mongoose.Types.ObjectId,
-    ref: "Admin",
-    required: true,
-  },
-  adminName: {
-    type: String,
-  },
-  date: {
-    type: Date,
-    default: Date.now,
-  },
-});
-
-const correctionSchema = mongoose.Schema(
-  {
-    equationType: {
-      type: String,
-      enum: ["linear", "custom"],
-      required: true,
-    },
-    equation: {
-      type: String,
-      required: function () {
-        return this.equationType === "custom";
-      },
-      validate: {
-        validator: function (value) {
-          if (!value) return true; // Allow empty for non-custom types
-          if (value.includes("\0")) return false;
-          try {
-            const encoder = new TextEncoder();
-            const decoder = new TextDecoder("utf-8", { fatal: true });
-            decoder.decode(encoder.encode(value));
-            return true;
-          } catch (e) {
-            return false;
-          }
-        },
-        message: "Equation contains invalid UTF-8 characters",
-      },
-    },
-    context: {
-      type: String,
-      enum: ["field", "colocation"],
-      required: false,
-    },
-    variables: {
-      required: function () {
-        return this.equationType === "linear";
-      },
-      type: Object,
-    },
-    dateCreated: {
-      type: Date,
-      default: Date.now,
-    },
-    applyCorrection: { type: Boolean, default: true },
-  },
-  { _id: false } // no separate _id for sub-docs
-);
-
-const correctionHistorySchema = mongoose.Schema(
-  {
-    pollutant: {
-      type: String,
-      required: true,
-      validate: {
-        validator: function (value) {
-          // Check for null bytes and validate UTF-8
-          if (value.includes("\0")) return false;
-          try {
-            const encoder = new TextEncoder();
-            const decoder = new TextDecoder("utf-8", { fatal: true });
-            decoder.decode(encoder.encode(value));
-            return true;
-          } catch (e) {
-            return false;
-          }
-        },
-        message: "Pollutant contains invalid UTF-8 characters",
-      },
-    },
-    oldValue: {
-      type: correctionSchema,
-      default: undefined,
-    },
-    newValue: {
-      type: correctionSchema,
-      default: undefined,
-    },
-    changedAt: {
-      type: Date,
-      default: Date.now,
-    },
-  },
-  { _id: false }
-);
-
-// Monitor Audit Schema
-const monitorAuditSchema = mongoose.Schema(
-  {
-    monitorId: { type: mongoose.Types.ObjectId, ref: "Monitors" },
-    orgId: { type: mongoose.Types.ObjectId, ref: "Organizations" },
-    timeUpdated: Date,
-    deletedAt: { type: Date, default: Date.now }, // Only populated on delete
-    monitorProperties: Object, // Stores properties of the monitor
-    monitorState: String, // Tracks the state of the monitor (e.g., "Deployed", "Maintenance")
-    monitorLocation: {
-      // Monitor GPS location (lat, lon)
-      type: { type: String, enum: ["Point"], required: true },
-      coordinates: { type: [Number], required: true },
-    },
-    parameterThresholds: Object,
-    corrections: {
-      type: Map,
-      of: correctionSchema,
-      default: {},
-    },
-    correctionHistory: {
-      type: [correctionHistorySchema],
-      default: [],
-    },
-  },
-  {
-    timestamps: true,
-  }
-);
-
-// Create the MonitorAudit model
-const MonitorAudit = mongoose.model("MonitorAudit", monitorAuditSchema);
-
-// Monitors Schema
-const monitorsSchema = mongoose.Schema(
-  {
-    monitorCode: String,
-    monitorSupplier: {
-      type: String,
-      enum: [
-        "clarity",
-        "aeroqual",
-        "purple air",
-        "reference monitor",
-        "earthview",
-        "sensit",
-        "blue sky",
-        "aq mesh",
-        "quant aq",
-        "airGradient",
-        "oizom",
-        "metOne",
-        "aqMesh",
-      ],
-    },
-    monitorType: String,
-    monitorIdFromSupplier: String,
-    measurementUpdate: Date,
-    monitorProperties: Object,
-    isPrivate: { type: Boolean, default: false, required: true },
-    monitorState: {
-      type: String,
-      enum: ["Collocation", "Deployed", "Maintenance", "Pending Deployment"],
-    },
-    monitorStateHistory: [Object],
-    monitorAlertStatus: {
-      type: String,
-      enum: [
-        "Good",
-        "Moderate",
-        "Unhealthy for SG",
-        "Unhealthy",
-        "Very Unhealthy",
-        "Hazardous",
-        "Bad",
-      ],
-      default: "Good",
-    },
-    sponsor: { type: mongoose.Types.ObjectId, ref: "Organizations" },
-    sponsorName: String,
-    monitorLatitude: Number,
-    monitorLongitude: Number,
-    gpsLocation: {
-      type: { type: String, enum: ["Point"], required: true },
-      coordinates: { type: [Number], required: true },
-    },
-    location: Object,
-    context: [String],
-    colocationDate: Date,
-    deploymentDate: Date,
-    subscriptionDate: Date,
-    parameters: [
-      {
-        type: String,
-        enum: parametersEnum,
-      },
-    ],
-    latestPM2_5: Number,
-    latestAQI_PM2_5: Number,
-    notes: [noteSchema],
-    calculatedAverages: [Object],
-    images: [String],
-    isActive: { type: Boolean, default: true },
-    parameterThresholds: Object,
-    completionPercentageThresholds: Object,
-    anomalyPercentageThresholds: Object,
-    // A Map, keyed by pollutant (e.g. "PM2_5"), storing Correction sub-docs
-    corrections: {
-      type: Map,
-      of: correctionSchema,
-      default: {},
-    },
-    correctionHistory: {
-      type: [correctionHistorySchema],
-      default: [],
-    },
-    applyCorrections: { type: Boolean, default: false },
-    pausedParameters: {
-      type: [{ parameter: String, timestamp: Date, isPaused: Boolean }],
-      default: [],
-    },
-  },
-  {
-    timestamps: true,
-  }
-);
-
-// Geographic queries - already exists
-monitorsSchema.index({ gpsLocation: "2dsphere" });
-
-// Sponsor-based queries
-monitorsSchema.index({ sponsor: 1, isPrivate: 1, isActive: 1 });
-
-// Location-based filtering
-monitorsSchema.index({ "location.city": 1, "location.state": 1 });
-monitorsSchema.index({ "location.neighborhood": 1 });
-monitorsSchema.index({ "location.county": 1 });
-
-// Query parameter filtering
-monitorsSchema.index({ monitorSupplier: 1, monitorState: 1 });
-monitorsSchema.index({ context: 1 });
-monitorsSchema.index({ parameters: 1 });
-
-// Monitor lookups by supplier
-monitorsSchema.index({ sponsor: 1, monitorSupplier: 1 });
-
-// Keep existing single-field indexes for backward compatibility
-monitorsSchema.index({ monitorSupplier: 1 });
-monitorsSchema.index({ monitorIdFromSupplier: 1 });
-monitorsSchema.index({ monitorState: 1 });
-
-//network metrics for anomalies
-monitorsSchema.index({ sponsor: 1, isActive: 1, monitorSupplier: 1 })
-
-// Pre-hook to log single document deletions
-monitorsSchema.pre("findOneAndDelete", async function () {
-  const docToDelete = await this.model.findOne(this.getFilter()).lean();
-  if (docToDelete) {
-    console.log("Logging findOneAndDelete to monitor audit", docToDelete);
-    const auditLog = new MonitorAudit({
-      monitorId: docToDelete._id,
-      orgId: docToDelete.sponsor,
-      timeUpdated: docToDelete.updatedAt,
-      monitorProperties: docToDelete.monitorProperties,
-      monitorState: docToDelete.monitorState,
-      monitorLocation: {
-        type: "Point",
-        coordinates: [
-          docToDelete.monitorLongitude,
-          docToDelete.monitorLatitude,
-        ],
-      },
-      parameterThresholds: docToDelete.parameterThresholds,
-      corrections: docToDelete.corrections,
-      correctionHistory: docToDelete.correctionHistory,
-      applyCorrections: docToDelete.applyCorrections,
-      deletedAt: new Date(),
-    });
-    await auditLog.save();
-  }
-});
-
-// Pre-hook to log multiple document deletions
-monitorsSchema.pre("deleteMany", async function () {
-  console.log("deleteMany pre-hook triggered for monitors");
-  const docsToDelete = await this.model.find(this.getFilter()).lean();
-
-  if (docsToDelete.length) {
-    console.log(`Logging ${docsToDelete.length} monitor documents to audit`);
-    const auditLogs = docsToDelete.map((doc) => ({
-      monitorId: doc._id,
-      orgId: doc.sponsor,
-      timeUpdated: doc.updatedAt,
-      monitorProperties: doc.monitorProperties,
-      monitorState: doc.monitorState,
-      monitorLocation: {
-        type: "Point",
-        coordinates: [doc.monitorLongitude, doc.monitorLatitude],
-      },
-      parameterThresholds: doc.parameterThresholds,
-      corrections: doc.corrections,
-      correctionHistory: doc.correctionHistory,
-      applyCorrections: doc.applyCorrections,
-      deletedAt: new Date(),
-    }));
-
-    await MonitorAudit.insertMany(auditLogs);
-  }
-});
-
-// Pre-hook to log a single document deletion (for deleteOne)
-monitorsSchema.pre("deleteOne", async function () {
-  console.log("deleteOne pre-hook triggered for monitors");
-  const docToDelete = await this.model.findOne(this.getFilter()).lean();
-
-  if (docToDelete) {
-    console.log("Logging deleteOne to monitor audit", docToDelete);
-    const auditLog = new MonitorAudit({
-      monitorId: docToDelete._id,
-      orgId: docToDelete.sponsor,
-      timeUpdated: docToDelete.updatedAt,
-      monitorProperties: docToDelete.monitorProperties,
-      monitorState: docToDelete.monitorState,
-      monitorLocation: {
-        type: "Point",
-        coordinates: [
-          docToDelete.monitorLongitude,
-          docToDelete.monitorLatitude,
-        ],
-      },
-      parameterThresholds: docToDelete.parameterThresholds,
-      corrections: docToDelete.corrections,
-      correctionHistory: docToDelete.correctionHistory,
-      applyCorrections: docToDelete.applyCorrections,
-      deletedAt: new Date(),
-    });
-    await auditLog.save();
-  }
-});
-
-// Pre-hook to log multiple document updates
-monitorsSchema.pre("updateMany", async function () {
-  const docsToUpdate = await this.model.find(this.getFilter()).lean();
-  if (docsToUpdate.length) {
-    console.log(`Logging ${docsToUpdate.length} monitor documents to audit`);
-    const auditLogs = docsToUpdate.map((doc) => ({
-      monitorId: doc._id,
-      orgId: doc.sponsor,
-      timeUpdated: doc.updatedAt,
-      monitorProperties: doc.monitorProperties,
-      monitorState: doc.monitorState,
-      monitorLocation: {
-        type: "Point",
-        coordinates: [doc.monitorLongitude, doc.monitorLatitude],
-      },
-      parameterThresholds: doc.parameterThresholds,
-      corrections: doc.corrections,
-      correctionHistory: doc.correctionHistory,
-      applyCorrections: doc.applyCorrections,
-      deletedAt: null, // Not a deletion, so this field is null
-    }));
-
-    await MonitorAudit.insertMany(auditLogs);
-  }
-});
-
-// Create the Monitors model
-const Monitors = mongoose.model("Monitors", monitorsSchema);
-
-export { monitorsSchema, Monitors, monitorAuditSchema, MonitorAudit };
+import mongoose from "mongoose";
+const parametersEnum = [
+  "NO2",
+  "SO2",
+  "PM2.5",
+  "PM10",
+  "Temperature",
+  "Humidity",
+  "OZONE",
+  "VOC",
+  "CO",
+  "NO",
+  "PM1",
+  "WS And Direction",
+  "DP",
+  "CO2",
+  "CH4",
+];
+
+const noteSchema = mongoose.Schema({
+  note: {
+    type: String,
+    required: true,
+  },
+  type: {
+    type: String,
+    required: true,
+  },
+  monitorState: {
+    type: String,
+    required: true,
+  },
+  adminId: {
+    type: mongoose.Types.ObjectId,
+    ref: "Admin",
+    required: true,
+  },
+  adminName: {
+    type: String,
+  },
+  date: {
+    type: Date,
+    default: Date.now,
+  },
+});
+
+const correctionSchema = mongoose.Schema(
+  {
+    equationType: {
+      type: String,
+      enum: ["linear", "custom"],
+      required: true,
+    },
+    equation: {
+      type: String,
+      required: function () {
+        return this.equationType === "custom";
+      },
+      validate: {
+        validator: function (value) {
+          if (!value) return true; // Allow empty for non-custom types
+          if (value.includes("\0")) return false;
+          try {
+            const encoder = new TextEncoder();
+            const decoder = new TextDecoder("utf-8", { fatal: true });
+            decoder.decode(encoder.encode(value));
+            return true;
+          } catch (e) {
+            return false;
+          }
+        },
+        message: "Equation contains invalid UTF-8 characters",
+      },
+    },
+    context: {
+      type: String,
+      enum: ["field", "colocation"],
+      required: false,
+    },
+    variables: {
+      required: function () {
+        return this.equationType === "linear";
+      },
+      type: Object,
+    },
+    dateCreated: {
+      type: Date,
+      default: Date.now,
+    },
+    applyCorrection: { type: Boolean, default: true },
+  },
+  { _id: false } // no separate _id for sub-docs
+);
+
+const correctionHistorySchema = mongoose.Schema(
+  {
+    pollutant: {
+      type: String,
+      required: true,
+      validate: {
+        validator: function (value) {
+          // Check for null bytes and validate UTF-8
+          if (value.includes("\0")) return false;
+          try {
+            const encoder = new TextEncoder();
+            const decoder = new TextDecoder("utf-8", { fatal: true });
+            decoder.decode(encoder.encode(value));
+            return true;
+          } catch (e) {
+            return false;
+          }
+        },
+        message: "Pollutant contains invalid UTF-8 characters",
+      },
+    },
+    oldValue: {
+      type: correctionSchema,
+      default: undefined,
+    },
+    newValue: {
+      type: correctionSchema,
+      default: undefined,
+    },
+    changedAt: {
+      type: Date,
+      default: Date.now,
+    },
+  },
+  { _id: false }
+);
+
+// Monitor Audit Schema
+const monitorAuditSchema = mongoose.Schema(
+  {
+    monitorId: { type: mongoose.Types.ObjectId, ref: "Monitors" },
+    orgId: { type: mongoose.Types.ObjectId, ref: "Organizations" },
+    timeUpdated: Date,
+    deletedAt: { type: Date, default: Date.now }, // Only populated on delete
+    monitorProperties: Object, // Stores properties of the monitor
+    monitorState: String, // Tracks the state of the monitor (e.g., "Deployed", "Maintenance")
+    monitorLocation: {
+      // Monitor GPS location (lat, lon)
+      type: { type: String, enum: ["Point"], required: true },
+      coordinates: { type: [Number], required: true },
+    },
+    parameterThresholds: Object,
+    corrections: {
+      type: Map,
+      of: correctionSchema,
+      default: {},
+    },
+    correctionHistory: {
+      type: [correctionHistorySchema],
+      default: [],
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+// Create the MonitorAudit model
+const MonitorAudit = mongoose.model("MonitorAudit", monitorAuditSchema);
+
+// Monitors Schema
+const monitorsSchema = mongoose.Schema(
+  {
+    monitorCode: String,
+    monitorSupplier: {
+      type: String,
+      enum: [
+        "clarity",
+        "aeroqual",
+        "purple air",
+        "reference monitor",
+        "earthview",
+        "sensit",
+        "blue sky",
+        "aq mesh",
+        "quant aq",
+        "airGradient",
+        "oizom",
+        "metOne",
+        "aqMesh",
+      ],
+    },
+    monitorType: String,
+    monitorIdFromSupplier: String,
+    measurementUpdate: Date,
+    monitorProperties: Object,
+    isPrivate: { type: Boolean, default: false, required: true },
+    monitorState: {
+      type: String,
+      enum: ["Collocation", "Deployed", "Maintenance", "Pending Deployment"],
+    },
+    monitorStateHistory: [Object],
+    monitorAlertStatus: {
+      type: String,
+      enum: [
+        "Good",
+        "Moderate",
+        "Unhealthy for SG",
+        "Unhealthy",
+        "Very Unhealthy",
+        "Hazardous",
+        "Bad",
+      ],
+      default: "Good",
+    },
+    sponsor: { type: mongoose.Types.ObjectId, ref: "Organizations" },
+    sponsorName: String,
+    monitorLatitude: Number,
+    monitorLongitude: Number,
+    gpsLocation: {
+      type: { type: String, enum: ["Point"], required: true },
+      coordinates: { type: [Number], required: true },
+    },
+    location: Object,
+    context: [String],
+    colocationDate: Date,
+    deploymentDate: Date,
+    subscriptionDate: Date,
+    parameters: [
+      {
+        type: String,
+        enum: parametersEnum,
+      },
+    ],
+    latestPM2_5: Number,
+    latestAQI_PM2_5: Number,
+    notes: [noteSchema],
+    calculatedAverages: [Object],
+    images: [String],
+    isActive: { type: Boolean, default: true },
+    parameterThresholds: Object,
+    completionPercentageThresholds: Object,
+    anomalyPercentageThresholds: Object,
+    // A Map, keyed by pollutant (e.g. "PM2_5"), storing Correction sub-docs
+    corrections: {
+      type: Map,
+      of: correctionSchema,
+      default: {},
+    },
+    correctionHistory: {
+      type: [correctionHistorySchema],
+      default: [],
+    },
+    applyCorrections: { type: Boolean, default: false },
+    pausedParameters: {
+      type: [{ parameter: String, timestamp: Date, isPaused: Boolean }],
+      default: [],
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+// Geographic queries - already exists
+monitorsSchema.index({ gpsLocation: "2dsphere" });
+
+// Sponsor-based queries
+monitorsSchema.index({ sponsor: 1, isPrivate: 1, isActive: 1 });
+
+// Location-based filtering
+monitorsSchema.index({ "location.city": 1, "location.state": 1 });
+monitorsSchema.index({ "location.neighborhood": 1 });
+monitorsSchema.index({ "location.county": 1 });
+
+// Query parameter filtering
+monitorsSchema.index({ monitorSupplier: 1, monitorState: 1 });
+monitorsSchema.index({ context: 1 });
+monitorsSchema.index({ parameters: 1 });
+
+// Monitor lookups by supplier
+monitorsSchema.index({ sponsor: 1, monitorSupplier: 1 });
+
+// Keep existing single-field indexes for backward compatibility
+monitorsSchema.index({ monitorSupplier: 1 });
+monitorsSchema.index({ monitorIdFromSupplier: 1 });
+monitorsSchema.index({ monitorState: 1 });
+
+//network metrics for anomalies
+monitorsSchema.index({ sponsor: 1, isActive: 1, monitorSupplier: 1 })
+
+// Pre-hook to log single document deletions
+monitorsSchema.pre("findOneAndDelete", async function () {
+  const docToDelete = await this.model.findOne(this.getFilter()).lean();
+  if (docToDelete) {
+    console.log("Logging findOneAndDelete to monitor audit", docToDelete);
+    const auditLog = new MonitorAudit({
+      monitorId: docToDelete._id,
+      orgId: docToDelete.sponsor,
+      timeUpdated: docToDelete.updatedAt,
+      monitorProperties: docToDelete.monitorProperties,
+      monitorState: docToDelete.monitorState,
+      monitorLocation: {
+        type: "Point",
+        coordinates: [
+          docToDelete.monitorLongitude,
+          docToDelete.monitorLatitude,
+        ],
+      },
+      parameterThresholds: docToDelete.parameterThresholds,
+      corrections: docToDelete.corrections,
+      correctionHistory: docToDelete.correctionHistory,
+      applyCorrections: docToDelete.applyCorrections,
+      deletedAt: new Date(),
+    });
+    await auditLog.save();
+  }
+});
+
+// Pre-hook to log multiple document deletions
+monitorsSchema.pre("deleteMany", async function () {
+  console.log("deleteMany pre-hook triggered for monitors");
+  const docsToDelete = await this.model.find(this.getFilter()).lean();
+
+  if (docsToDelete.length) {
+    console.log(`Logging ${docsToDelete.length} monitor documents to audit`);
+    const auditLogs = docsToDelete.map((doc) => ({
+      monitorId: doc._id,
+      orgId: doc.sponsor,
+      timeUpdated: doc.updatedAt,
+      monitorProperties: doc.monitorProperties,
+      monitorState: doc.monitorState,
+      monitorLocation: {
+        type: "Point",
+        coordinates: [doc.monitorLongitude, doc.monitorLatitude],
+      },
+      parameterThresholds: doc.parameterThresholds,
+      corrections: doc.corrections,
+      correctionHistory: doc.correctionHistory,
+      applyCorrections: doc.applyCorrections,
+      deletedAt: new Date(),
+    }));
+
+    await MonitorAudit.insertMany(auditLogs);
+  }
+});
+
+// Pre-hook to log a single document deletion (for deleteOne)
+monitorsSchema.pre("deleteOne", async function () {
+  console.log("deleteOne pre-hook triggered for monitors");
+  const docToDelete = await this.model.findOne(this.getFilter()).lean();
+
+  if (docToDelete) {
+    console.log("Logging deleteOne to monitor audit", docToDelete);
+    const auditLog = new MonitorAudit({
+      monitorId: docToDelete._id,
+      orgId: docToDelete.sponsor,
+      timeUpdated: docToDelete.updatedAt,
+      monitorProperties: docToDelete.monitorProperties,
+      monitorState: docToDelete.monitorState,
+      monitorLocation: {
+        type: "Point",
+        coordinates: [
+          docToDelete.monitorLongitude,
+          docToDelete.monitorLatitude,
+        ],
+      },
+      parameterThresholds: docToDelete.parameterThresholds,
+      corrections: docToDelete.corrections,
+      correctionHistory: docToDelete.correctionHistory,
+      applyCorrections: docToDelete.applyCorrections,
+      deletedAt: new Date(),
+    });
+    await auditLog.save();
+  }
+});
+
+// Pre-hook to log multiple document updates
+monitorsSchema.pre("updateMany", async function () {
+  const docsToUpdate = await this.model.find(this.getFilter()).lean();
+  if (docsToUpdate.length) {
+    console.log(`Logging ${docsToUpdate.length} monitor documents to audit`);
+    const auditLogs = docsToUpdate.map((doc) => ({
+      monitorId: doc._id,
+      orgId: doc.sponsor,
+      timeUpdated: doc.updatedAt,
+      monitorProperties: doc.monitorProperties,
+      monitorState: doc.monitorState,
+      monitorLocation: {
+        type: "Point",
+        coordinates: [doc.monitorLongitude, doc.monitorLatitude],
+      },
+      parameterThresholds: doc.parameterThresholds,
+      corrections: doc.corrections,
+      correctionHistory: doc.correctionHistory,
+      applyCorrections: doc.applyCorrections,
+      deletedAt: null, // Not a deletion, so this field is null
+    }));
+
+    await MonitorAudit.insertMany(auditLogs);
+  }
+});
+
+// Create the Monitors model
+const Monitors = mongoose.model("Monitors", monitorsSchema);
+
+export { monitorsSchema, Monitors, monitorAuditSchema, MonitorAudit };