@justair/justair-library 3.3.2 → 3.3.3

package/src/models/announcements.js

@@ -1,31 +1,31 @@
-import mongoose from "mongoose";
-
-const locationSchema = mongoose.Schema(
-  {
-    city: { type: String, default: null },
-    county: { type: String, default: null },
-    state: { type: String, required: [true, "state is required"] },
-  },
-  {
-    timestamps: false,
-    _id: false,
-  }
-);
-
-const announcementSchema = mongoose.Schema(
-  {
-    category: { type: String, required: [true, "category is required"]},
-    message: { type: String, required: [true, "message is required"] },
-    link: String,
-    location: { type: locationSchema, required: [true, "location is required"] },
-    isActive: { type: Boolean, default: false },
-  },
-  {
-    timestamps: true,
-  }
-);
-
-const Announcements = mongoose.model("Announcements", announcementSchema);
-
-export { announcementSchema, Announcements };
-
+import mongoose from "mongoose";
+
+const locationSchema = mongoose.Schema(
+  {
+    city: { type: String, default: null },
+    county: { type: String, default: null },
+    state: { type: String, required: [true, "state is required"] },
+  },
+  {
+    timestamps: false,
+    _id: false,
+  }
+);
+
+const announcementSchema = mongoose.Schema(
+  {
+    category: { type: String, required: [true, "category is required"]},
+    message: { type: String, required: [true, "message is required"] },
+    link: String,
+    location: { type: locationSchema, required: [true, "location is required"] },
+    isActive: { type: Boolean, default: false },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+const Announcements = mongoose.model("Announcements", announcementSchema);
+
+export { announcementSchema, Announcements };
+

package/src/models/apiKey.js

@@ -1,23 +1,23 @@
-import mongoose from "mongoose";
-const apiKeySchema = mongoose.Schema(
-  {
-    adminId: { type: mongoose.Schema.Types.ObjectId, ref: "Admin" },
-    clientKey: { type: String, unique: true },
-    permissions: {
-      type: Object,
-      of: [{ type: mongoose.Schema.Types.ObjectId }],
-      default: new Map(),
-    },
-    accessToken: String,
-    refreshToken: String,
-    lastUsedAt: Date,
-    isActive: Boolean,
-  },
-  {
-    timestamps: true,
-  }
-);
-
-const ApiKey = mongoose.model("ApiKey", apiKeySchema);
-
+import mongoose from "mongoose";
+const apiKeySchema = mongoose.Schema(
+  {
+    adminId: { type: mongoose.Schema.Types.ObjectId, ref: "Admin" },
+    clientKey: { type: String, unique: true },
+    permissions: {
+      type: Object,
+      of: [{ type: mongoose.Schema.Types.ObjectId }],
+      default: new Map(),
+    },
+    accessToken: String,
+    refreshToken: String,
+    lastUsedAt: Date,
+    isActive: Boolean,
+  },
+  {
+    timestamps: true,
+  }
+);
+
+const ApiKey = mongoose.model("ApiKey", apiKeySchema);
+
 export { apiKeySchema, ApiKey };

package/src/models/configurations.js

@@ -1,17 +1,17 @@
-import mongoose from 'mongoose';
-
-const configurationsSchema = mongoose.Schema({
-    type: { type: String, enum: ['flag'] },
-    name: String,
-    properties: Object,
-    isActive: { type: Boolean, default: false },
-    firstRun: {type: Boolean, default: false}
-}, {
-    timestamps: true
-});
-
-configurationsSchema.index({name: 1});
-
-const Configurations = mongoose.model('Configurations', configurationsSchema);
-
-export {configurationsSchema, Configurations};
+import mongoose from 'mongoose';
+
+const configurationsSchema = mongoose.Schema({
+    type: { type: String, enum: ['flag'] },
+    name: String,
+    properties: Object,
+    isActive: { type: Boolean, default: false },
+    firstRun: {type: Boolean, default: false}
+}, {
+    timestamps: true
+});
+
+configurationsSchema.index({name: 1});
+
+const Configurations = mongoose.model('Configurations', configurationsSchema);
+
+export {configurationsSchema, Configurations};

package/src/models/contexts.js

@@ -1,14 +1,14 @@
-import mongoose from "mongoose";
-
-const contextsSchema = mongoose.Schema(
-    {
-        name: String
-    },
-    {
-        timestamps: true
-    }
-);
-
-const Contexts = mongoose.model("Contexts", contextsSchema);
-
+import mongoose from "mongoose";
+
+const contextsSchema = mongoose.Schema(
+    {
+        name: String
+    },
+    {
+        timestamps: true
+    }
+);
+
+const Contexts = mongoose.model("Contexts", contextsSchema);
+
 export {contextsSchema, Contexts};

package/src/models/events.js

@@ -1,30 +1,124 @@
-import mongoose from "mongoose";
-//TODO: Capture historical data, every hour record AQI values for monitors
-const eventsSchema = 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: {},
-    }
-  },
-  {
-    timestamps: true,
-  }
-);
-
-eventsSchema.index({ monitorId: 1 });
-eventsSchema.index({ parameter: 1 });
-
-const Events = mongoose.model("Events", eventsSchema);
-export { eventsSchema, Events };
+import mongoose from "mongoose";
+
+// 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" },
+    parameter: {
+      type: String,
+      enum: ["AQI", "PID"],
+    },
+    values: Object,
+    alertLevels: Object,
+    currentMonitorState: {
+      type: String,
+      enum: ["Collocation", "Deployed", "Maintenance", "Pending Deployment"],
+    },
+    pollutantsFlags: {
+      type: Object,
+      default: {},
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+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, EventsAudit, eventsAuditSchema };

package/src/models/jobs.js

@@ -1,34 +1,34 @@
-import mongoose from "mongoose";
-
-const jobsSchema = mongoose.Schema(
-  {
-    requestorId: { type: mongoose.Types.ObjectId, ref: "Admin" },
-    requestorEmail: String,
-    category: {
-      type: String,
-      enum: [
-        "Truck Detection",
-        "Backfill Monitor Data",
-        "AQI Network Summary",
-        "Multi Monitor Data Pull",
-        "Multi Monitor Average AQI Data Pull",
-      ],
-    },
-    resourceURL: String,
-    publicResourceURL: String,
-    resourceMetaData: Object,
-    resultData: { type: mongoose.Schema.Types.Mixed, default: {} },
-    jobStatus: {
-      type: String,
-      enum: ["New", "In-Progress", "Complete", "Cancelled", "Failed"],
-    },
-    jobStatusHistory: [Object],
-    sharedWith: [{ type: mongoose.Types.ObjectId, ref: "Admin" }],
-  },
-  {
-    timestamps: true,
-  }
-);
-
-const Jobs = mongoose.model("Jobs", jobsSchema);
-export { jobsSchema, Jobs };
+import mongoose from "mongoose";
+
+const jobsSchema = mongoose.Schema(
+  {
+    requestorId: { type: mongoose.Types.ObjectId, ref: "Admin" },
+    requestorEmail: String,
+    category: {
+      type: String,
+      enum: [
+        "Truck Detection",
+        "Backfill Monitor Data",
+        "AQI Network Summary",
+        "Multi Monitor Data Pull",
+        "Multi Monitor Average AQI Data Pull",
+      ],
+    },
+    resourceURL: String,
+    publicResourceURL: String,
+    resourceMetaData: Object,
+    resultData: { type: mongoose.Schema.Types.Mixed, default: {} },
+    jobStatus: {
+      type: String,
+      enum: ["New", "In-Progress", "Complete", "Cancelled", "Failed"],
+    },
+    jobStatusHistory: [Object],
+    sharedWith: [{ type: mongoose.Types.ObjectId, ref: "Admin" }],
+  },
+  {
+    timestamps: true,
+  }
+);
+
+const Jobs = mongoose.model("Jobs", jobsSchema);
+export { jobsSchema, Jobs };

package/src/models/lightmonitors.js

@@ -1,28 +1,28 @@
-import mongoose from "mongoose";
-
-const lightMonitorSchema = mongoose.Schema(
-  {
-    monitorId: { type: mongoose.Types.ObjectId, ref: "Monitors" },
-    currentColor: { type: String, default: "16000" },
-    isActive: { type: Boolean, default: false },
-    configuration: {
-      hueUsername: { type: String },
-      clientId: { type: String, required: true },
-      clientSecret: { type: String, required: true },
-      lightId: { type: String, required: true },
-      accessTokenInfo: Object,
-      refreshTokenInfo: Object,
-      hueCode: { type: String, required: true },
-      hueCodeHistory: [Object],
-    },
-  },
-  {
-    timestamps: true,
-  }
-);
-
-lightMonitorSchema.index({ monitorId: 1 });
-
-const LightMonitors = mongoose.model("LightMonitor", lightMonitorSchema);
-
-export { lightMonitorSchema, LightMonitors };
+import mongoose from "mongoose";
+
+const lightMonitorSchema = mongoose.Schema(
+  {
+    monitorId: { type: mongoose.Types.ObjectId, ref: "Monitors" },
+    currentColor: { type: String, default: "16000" },
+    isActive: { type: Boolean, default: false },
+    configuration: {
+      hueUsername: { type: String },
+      clientId: { type: String, required: true },
+      clientSecret: { type: String, required: true },
+      lightId: { type: String, required: true },
+      accessTokenInfo: Object,
+      refreshTokenInfo: Object,
+      hueCode: { type: String, required: true },
+      hueCodeHistory: [Object],
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+lightMonitorSchema.index({ monitorId: 1 });
+
+const LightMonitors = mongoose.model("LightMonitor", lightMonitorSchema);
+
+export { lightMonitorSchema, LightMonitors };

package/src/models/measurements.js

@@ -1,95 +1,130 @@
-import mongoose from "mongoose";
-
-// Audit Schema
-const auditSchema = mongoose.Schema(
-  {
-    monitorId: { type: mongoose.Types.ObjectId, ref: "Monitors" },
-    orgId: { type: mongoose.Types.ObjectId, ref: "Organizations" },
-    timeUpdated: Date,
-    deletedAt: { type: Date, default: Date.now },
-    measurements: Object,
-    monitorState: String,
-  },
-  {
-    timestamps: true,
-  }
-);
-
-const Audit = mongoose.model("Audit", auditSchema);
-
-// Measurements Schema
-const measurementsSchema = mongoose.Schema(
-  {
-    monitorId: { type: mongoose.Types.ObjectId, ref: "Monitors" },
-    orgId: { type: mongoose.Types.ObjectId, ref: "Organizations" },
-    timeUpdated: Date,
-    measurements: Object,
-    monitorState: String,
-  },
-  {
-    timestamps: true,
-  }
-);
-
-measurementsSchema.index({ monitorId: 1 });
-measurementsSchema.index({ timeUpdated: 1 });
-
-// Pre-hook to log single document deletions
-measurementsSchema.pre("findOneAndDelete", async function () {
-  const docToDelete = await this.model.findOne(this.getFilter());
-  if (docToDelete) {
-    console.log("Logging findOneAndDelete to audit", docToDelete);
-    const auditLog = new Audit({
-      monitorId: docToDelete.monitorId,
-      orgId: docToDelete.orgId,
-      timeUpdated: docToDelete.timeUpdated,
-      measurements: docToDelete.measurements,
-      monitorState: docToDelete.monitorState,
-      deletedAt: new Date(),
-    });
-    await auditLog.save();
-  }
-});
-
-// Pre-hook to log multiple document deletions
-measurementsSchema.pre("deleteMany", async function () {
-  console.log("deleteMany pre-hook triggered");
-  const docsToDelete = await this.model.find(this.getFilter()).lean();
-
-  if (docsToDelete.length) {
-    console.log(`Logging ${docsToDelete.length} documents to audit`);
-    const auditLogs = docsToDelete.map((doc) => ({
-      monitorId: doc.monitorId,
-      orgId: doc.orgId,
-      timeUpdated: doc.timeUpdated,
-      measurements: doc.measurements,
-      monitorState: doc.monitorState,
-      deletedAt: new Date(),
-    }));
-
-    await Audit.insertMany(auditLogs);
-  }
-});
-
-// Pre-hook to log a single document deletion (for deleteOne)
-measurementsSchema.pre("deleteOne", async function () {
-  console.log("deleteOne pre-hook triggered");
-  const docToDelete = await this.model.findOne(this.getFilter()).lean();
-
-  if (docToDelete) {
-    console.log("Logging deleteOne to audit", docToDelete);
-    const auditLog = new Audit({
-      monitorId: docToDelete.monitorId,
-      orgId: docToDelete.orgId,
-      timeUpdated: docToDelete.timeUpdated,
-      measurements: docToDelete.measurements,
-      monitorState: docToDelete.monitorState,
-      deletedAt: new Date(),
-    });
-    await auditLog.save();
-  }
-});
-
-const Measurements = mongoose.model("Measurements", measurementsSchema);
-
-export { measurementsSchema, Measurements, Audit, auditSchema };
+import mongoose from "mongoose";
+
+// Audit Schema
+const auditSchema = mongoose.Schema(
+  {
+    monitorId: { type: mongoose.Types.ObjectId, ref: "Monitors" },
+    orgId: { type: mongoose.Types.ObjectId, ref: "Organizations" },
+    timeUpdated: Date,
+    deletedAt: { type: Date, default: Date.now },
+    measurements: Object,
+    monitorState: String,
+  },
+  {
+    timestamps: true,
+  }
+);
+
+const Audit = mongoose.model("Audit", auditSchema);
+
+// Measurements Schema
+const measurementsSchema = mongoose.Schema(
+  {
+    monitorId: { type: mongoose.Types.ObjectId, ref: "Monitors" },
+    orgId: { type: mongoose.Types.ObjectId, ref: "Organizations" },
+    timeUpdated: Date,
+    measurements: Object,
+    monitorState: String,
+  },
+  {
+    timestamps: true,
+  }
+);
+
+measurementsSchema.index({ monitorId: 1 });
+measurementsSchema.index({ timeUpdated: 1 });
+
+// Pre-hook to log single document deletions
+measurementsSchema.pre("findOneAndDelete", async function () {
+  const docToDelete = await this.model.findOne(this.getFilter());
+  if (docToDelete) {
+    console.log("Logging findOneAndDelete to audit", docToDelete);
+    const auditLog = new Audit({
+      monitorId: docToDelete.monitorId,
+      orgId: docToDelete.orgId,
+      timeUpdated: docToDelete.timeUpdated,
+      measurements: docToDelete.measurements,
+      monitorState: docToDelete.monitorState,
+      deletedAt: new Date(),
+    });
+    await auditLog.save();
+  }
+});
+
+// Pre-hook to log multiple document deletions
+measurementsSchema.pre("deleteMany", async function () {
+  console.log("deleteMany pre-hook triggered");
+  const docsToDelete = await this.model.find(this.getFilter()).lean();
+
+  if (docsToDelete.length) {
+    console.log(`Logging ${docsToDelete.length} documents to audit`);
+    const auditLogs = docsToDelete.map((doc) => ({
+      monitorId: doc.monitorId,
+      orgId: doc.orgId,
+      timeUpdated: doc.timeUpdated,
+      measurements: doc.measurements,
+      monitorState: doc.monitorState,
+      deletedAt: new Date(),
+    }));
+
+    await Audit.insertMany(auditLogs);
+  }
+});
+
+// Pre-hook to log a single document deletion (for deleteOne)
+measurementsSchema.pre("deleteOne", async function () {
+  console.log("deleteOne pre-hook triggered");
+  const docToDelete = await this.model.findOne(this.getFilter()).lean();
+
+  if (docToDelete) {
+    console.log("Logging deleteOne to audit", docToDelete);
+    const auditLog = new Audit({
+      monitorId: docToDelete.monitorId,
+      orgId: docToDelete.orgId,
+      timeUpdated: docToDelete.timeUpdated,
+      measurements: docToDelete.measurements,
+      monitorState: docToDelete.monitorState,
+      deletedAt: new Date(),
+    });
+    await auditLog.save();
+  }
+});
+
+// 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 };