@justair/justair-library 3.3.2 → 3.3.4-alpha

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@justair/justair-library",
-  "version": "3.3.2",
+  "version": "3.3.4-alpha",
   "description": "JustAir Internal Library",
   "main": "src/index.js", 
   "type": "module",

package/src/index.js

@@ -27,7 +27,12 @@ import {
 import { contextsSchema, Contexts } from "./models/contexts.js";
 import { parametersSchema, Parameters } from "./models/parameters.js";
 import { usersSchema, Users } from "./models/users.js";
-import { eventsSchema, Events } from "./models/events.js";
+import {
+  eventsSchema,
+  Events,
+  eventsAuditSchema,
+  EventsAudit,
+} from "./models/events.js";
 import {
   qaNotificationsSchema,
   QANotifications,
@@ -83,4 +88,6 @@ export {
   usageMetricsSchema,
   Audit,
   auditSchema,
+  EventsAudit,
+  eventsAuditSchema,
 };

package/src/models/events.js

@@ -1,5 +1,33 @@
 import mongoose from "mongoose";
-//TODO: Capture historical data, every hour record AQI values for monitors
+
+// Events Audit Schema
+const eventsAuditSchema = mongoose.Schema(
+  {
+    monitorId: { type: mongoose.Types.ObjectId, ref: "Monitors" },
+    parameter: {
+      type: String,
+      enum: ["AQI", "PID"],
+    },
+    values: Object,
+    alertLevels: Object,
+    currentMonitorState: {
+      type: String,
+      enum: ["Collocation", "Deployed", "Maintenance", "Pending Deployment"],
+    },
+    pollutantsFlags: {
+      type: Object,
+      default: {},
+    },
+    deletedAt: { type: Date, default: null },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+const EventsAudit = mongoose.model("EventsAudit", eventsAuditSchema);
+
+// Events Schema
 const eventsSchema = mongoose.Schema(
   {
     monitorId: { type: mongoose.Types.ObjectId, ref: "Monitors" },
@@ -16,7 +44,7 @@ const eventsSchema = mongoose.Schema(
     pollutantsFlags: {
       type: Object,
       default: {},
-    }
+    },
   },
   {
     timestamps: true,
@@ -26,5 +54,71 @@ const eventsSchema = mongoose.Schema(
 eventsSchema.index({ monitorId: 1 });
 eventsSchema.index({ parameter: 1 });
 
+// Pre-hook to log single document deletions
+eventsSchema.pre("findOneAndDelete", async function () {
+  const docToDelete = await this.model.findOne(this.getFilter());
+  if (docToDelete) {
+    console.log("Logging findOneAndDelete to events audit", docToDelete);
+    const auditLog = new EventsAudit({
+      ...docToDelete.toObject(),
+      deletedAt: new Date(),
+    });
+    await auditLog.save();
+  }
+});
+
+// Pre-hook to log multiple document deletions
+eventsSchema.pre("deleteMany", async function () {
+  const docsToDelete = await this.model.find(this.getFilter()).lean();
+  if (docsToDelete.length) {
+    console.log(`Logging ${docsToDelete.length} documents to events audit`);
+    const auditLogs = docsToDelete.map((doc) => ({
+      ...doc,
+      deletedAt: new Date(),
+    }));
+    await EventsAudit.insertMany(auditLogs);
+  }
+});
+
+// Pre-hook to log a single document deletion (for deleteOne)
+eventsSchema.pre("deleteOne", async function () {
+  const docToDelete = await this.model.findOne(this.getFilter()).lean();
+  if (docToDelete) {
+    console.log("Logging deleteOne to events audit", docToDelete);
+    const auditLog = new EventsAudit({
+      ...docToDelete,
+      deletedAt: new Date(),
+    });
+    await auditLog.save();
+  }
+});
+
+// Pre-hook to log single document updates
+eventsSchema.pre("findOneAndUpdate", async function () {
+  const docToUpdate = await this.model.findOne(this.getFilter()).lean();
+  if (docToUpdate) {
+    console.log("Logging findOneAndUpdate to events audit", docToUpdate);
+    const auditLog = new EventsAudit({
+      ...docToUpdate,
+      deletedAt: null, // Not deleted
+    });
+    await auditLog.save();
+  }
+});
+
+// Pre-hook to log multiple document updates
+eventsSchema.pre("updateMany", async function () {
+  const docsToUpdate = await this.model.find(this.getFilter()).lean();
+  if (docsToUpdate.length) {
+    console.log(`Logging ${docsToUpdate.length} documents to events audit`);
+    const auditLogs = docsToUpdate.map((doc) => ({
+      ...doc,
+      deletedAt: null, // Not deleted
+    }));
+    await EventsAudit.insertMany(auditLogs);
+  }
+});
+
 const Events = mongoose.model("Events", eventsSchema);
-export { eventsSchema, Events };
+
+export { eventsSchema, Events, EventsAudit, eventsAuditSchema };

package/src/models/measurements.js

@@ -90,6 +90,41 @@ measurementsSchema.pre("deleteOne", async function () {
   }
 });
 
+// Pre-hook to log single document updates
+measurementsSchema.pre("findOneAndUpdate", async function () {
+  const docToUpdate = await this.model.findOne(this.getFilter()).lean();
+  if (docToUpdate) {
+    console.log("Logging findOneAndUpdate to audit", docToUpdate);
+    const auditLog = new Audit({
+      monitorId: docToUpdate.monitorId,
+      orgId: docToUpdate.orgId,
+      timeUpdated: docToUpdate.timeUpdated,
+      measurements: docToUpdate.measurements,
+      monitorState: docToUpdate.monitorState,
+      deletedAt: null, // No deletion happening, so set it to null or undefined
+    });
+    await auditLog.save();
+  }
+});
+
+// Pre-hook to log multiple document updates
+measurementsSchema.pre("updateMany", async function () {
+  const docsToUpdate = await this.model.find(this.getFilter()).lean();
+  if (docsToUpdate.length) {
+    console.log(`Logging ${docsToUpdate.length} documents to audit`);
+    const auditLogs = docsToUpdate.map((doc) => ({
+      monitorId: doc.monitorId,
+      orgId: doc.orgId,
+      timeUpdated: doc.timeUpdated,
+      measurements: doc.measurements,
+      monitorState: doc.monitorState,
+      deletedAt: null, // No deletion happening
+    }));
+
+    await Audit.insertMany(auditLogs);
+  }
+});
+
 const Measurements = mongoose.model("Measurements", measurementsSchema);
 
 export { measurementsSchema, Measurements, Audit, auditSchema };

package/src/models/monitorType.js

@@ -0,0 +1,40 @@
+import mongoose from "mongoose";
+
+const parametersEnum = [
+  "NO2",
+  "SO2",
+  "PM2.5",
+  "PM10",
+  "Temperature",
+  "Humidity",
+  "OZONE",
+  "VOC",
+  "CO",
+  "NO",
+  "PM1",
+  "WS And Direction",
+];
+
+const monitorTypeSchema = mongoose.Schema(
+  {
+    model: {
+      type: String,
+      required: true,
+    },
+
+    supplier: {
+      type: mongoose.Types.ObjectId,
+      required: true,
+      ref: "MonitorSuppliers",
+    },
+
+    parameters: {
+      type: String,
+      enum: parametersEnum,
+      required: true,
+    },
+  },
+  { timestamps: true }
+);
+
+const monitorType = mongoose.model("MonitorType", monitorTypeSchema);

package/src/models/monitors.js

@@ -1,5 +1,47 @@
-import mongoose from "mongoose";
+import mongoose from "mongoose";import { emitWarning } from "process";
+const parametersEnum = [
+  "NO2",
+  "SO2",
+  "PM2.5",
+  "PM10",
+  "Temperature",
+  "Humidity",
+  "OZONE",
+  "VOC",
+  "CO",
+  "NO",
+  "PM1",
+  "WS And Direction",
+];
 
+const parameterThresholdsSchema = mongoose.Schema({
+  parameter: {
+    type: Map,
+    of: new mongoose.Schema({
+      invalid: {
+        upper: Number,
+        lower: Number,
+      },
+
+      warning: {
+        upper: Number,
+        lower: Number,
+      },
+    }),
+  },
+});
+
+/*Ensure the parameter value is one of our valid parameters */
+parameterThresholdsSchema.path('parameter').validate(function(value) {
+  for (let key of value.keys()) {
+    if (!parametersEnum.includes(key)) {
+      return false;
+    }
+  }
+  return true;
+}, 'Invalid parameter key');
+
+// Monitors Schema
 const monitorsSchema = mongoose.Schema(
   {
     monitorCode: String,
@@ -57,20 +99,7 @@ const monitorsSchema = mongoose.Schema(
     parameters: [
       {
         type: String,
-        enum: [
-          "NO2",
-          "SO2",
-          "PM2.5",
-          "PM10",
-          "Temperature",
-          "Humidity",
-          "OZONE",
-          "VOC",
-          "CO",
-          "NO",
-          "PM1",
-          "WS And Direction",
-        ],
+        enum: parametersEnum,
       },
     ],
     latestPM2_5: Number,
@@ -79,6 +108,7 @@ const monitorsSchema = mongoose.Schema(
     calculatedAverages: [Object],
     images: [String],
     isActive: { type: Boolean, default: true },
+    parameterThresholds: { type: Map, of: parameterThresholdsSchema },
   },
   {
     timestamps: true,