@justair/justair-library 4.7.25 → 4.7.26

package/src/models/dataCompleteness.js

@@ -1,42 +1,42 @@
-import mongoose from "mongoose";
-
-const dataCompletenessSchema = mongoose.Schema(
-  {
-    monitorId: { type: mongoose.Types.ObjectId, ref: "Monitors" },
-    supplierId: { type: mongoose.Types.ObjectId, ref: "MonitorSuppliers" },
-    parameter: String,
-    count: Number,
-    threshold: Number,
-    completeness: Number, // percent 0–100
-    measurementsStartTime: Date,
-    measurementsEndTime: Date,
-    flags: Object
-  },
-  { timestamps: true }
-);
-const DataCompleteness = mongoose.model(
-  "DataCompleteness",
-  dataCompletenessSchema
-);
-
-
-dataCompletenessSchema.index({
-  monitorId: 1,
-  parameter: 1,
-  measurementsStartTime: 1
-});
-
-
-dataCompletenessSchema.index({
-  monitorId: 1,
-  measurementsStartTime: 1
-});
-
-
-dataCompletenessSchema.index({
-  monitorId: 1,
-  measurementsStartTime: 1,
-  flags: 1
-});
-
-export { dataCompletenessSchema, DataCompleteness };
+import mongoose from "mongoose";
+
+const dataCompletenessSchema = mongoose.Schema(
+  {
+    monitorId: { type: mongoose.Types.ObjectId, ref: "Monitors" },
+    supplierId: { type: mongoose.Types.ObjectId, ref: "MonitorSuppliers" },
+    parameter: String,
+    count: Number,
+    threshold: Number,
+    completeness: Number, // percent 0–100
+    measurementsStartTime: Date,
+    measurementsEndTime: Date,
+    flags: Object
+  },
+  { timestamps: true }
+);
+const DataCompleteness = mongoose.model(
+  "DataCompleteness",
+  dataCompletenessSchema
+);
+
+
+dataCompletenessSchema.index({
+  monitorId: 1,
+  parameter: 1,
+  measurementsStartTime: 1
+});
+
+
+dataCompletenessSchema.index({
+  monitorId: 1,
+  measurementsStartTime: 1
+});
+
+
+dataCompletenessSchema.index({
+  monitorId: 1,
+  measurementsStartTime: 1,
+  flags: 1
+});
+
+export { dataCompletenessSchema, DataCompleteness };

package/src/models/events.js

@@ -1,130 +1,130 @@
-import mongoose, {Types} from "mongoose";
-
-// Events Audit Schema
-const eventsAuditSchema = mongoose.Schema(
-  {
-    monitorId: { type: mongoose.Types.ObjectId, ref: "Monitors" },
-    parameter: {
-      type: String,
-      enum: ["AQI", "PID", "AQI-Daily"],
-    },
-    values: Object,
-    alertLevels: Object,
-    currentMonitorState: {
-      type: String,
-      enum: ["Collocation", "Deployed", "Maintenance", "Pending Deployment"],
-    },
-    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"],
-    },
-    pausedParameters: [String],
-    originalId: { type: mongoose.Types.ObjectId },
-  },
-  {
-    timestamps: true,
-  },
-);
-
-// Primary lookup pattern from monitors - for $lookup operations
-eventsSchema.index({ monitorId: 1, createdAt: -1 });
-// Date range filtering index
-eventsSchema.index({ monitorId: 1, updatedAt: -1 });
-
-// Keep individual indexes for other query patterns
-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,
-      originalId: doc._id, // store reference to original _id
-      _id: undefined, // let Mongo generate new _id
-      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,
-      originalId: docToDelete._id, // store reference to original _id
-      _id: undefined, // let Mongo generate new _id
-      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,
-      originalId: doc._id, // store reference to original _id
-      _id: undefined, // let Mongo generate new _id
-      deletedAt: null, // Not deleted
-    }));
-    await EventsAudit.insertMany(auditLogs);
-  }
-});
-
-const Events = mongoose.model("Events", eventsSchema);
-
-export { eventsSchema, Events, EventsAudit, eventsAuditSchema };
+import mongoose, {Types} from "mongoose";
+
+// Events Audit Schema
+const eventsAuditSchema = mongoose.Schema(
+  {
+    monitorId: { type: mongoose.Types.ObjectId, ref: "Monitors" },
+    parameter: {
+      type: String,
+      enum: ["AQI", "PID", "AQI-Daily"],
+    },
+    values: Object,
+    alertLevels: Object,
+    currentMonitorState: {
+      type: String,
+      enum: ["Collocation", "Deployed", "Maintenance", "Pending Deployment"],
+    },
+    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"],
+    },
+    pausedParameters: [String],
+    originalId: { type: mongoose.Types.ObjectId },
+  },
+  {
+    timestamps: true,
+  },
+);
+
+// Primary lookup pattern from monitors - for $lookup operations
+eventsSchema.index({ monitorId: 1, createdAt: -1 });
+// Date range filtering index
+eventsSchema.index({ monitorId: 1, updatedAt: -1 });
+
+// Keep individual indexes for other query patterns
+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,
+      originalId: doc._id, // store reference to original _id
+      _id: undefined, // let Mongo generate new _id
+      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,
+      originalId: docToDelete._id, // store reference to original _id
+      _id: undefined, // let Mongo generate new _id
+      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,
+      originalId: doc._id, // store reference to original _id
+      _id: undefined, // let Mongo generate new _id
+      deletedAt: null, // Not deleted
+    }));
+    await EventsAudit.insertMany(auditLogs);
+  }
+});
+
+const Events = mongoose.model("Events", eventsSchema);
+
+export { eventsSchema, Events, EventsAudit, eventsAuditSchema };

package/src/models/features.js

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

package/src/models/jobs.js

@@ -1,49 +1,49 @@
-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);
-
-// Requestor-based queries with category filtering
-jobsSchema.index({ requestorId: 1, category: 1 });
-// Exclude specific categories efficiently with timestamp ordering
-jobsSchema.index({ requestorId: 1, category: 1, createdAt: -1 });
-// Monitor-based job lookups (if monitorId field exists in resourceMetaData)
-// Note: This may need to be adjusted based on actual schema structure
-// jobsSchema.index({ "resourceMetaData.monitorId": 1, updatedAt: -1 });
-
-// Keep individual indexes for backward compatibility
-jobsSchema.index({ requestorId: 1 });
-jobsSchema.index({ createdAt: 1 });
-jobsSchema.index({ category: 1 });
-jobsSchema.index({ jobStatus: 1 });
-
-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);
+
+// Requestor-based queries with category filtering
+jobsSchema.index({ requestorId: 1, category: 1 });
+// Exclude specific categories efficiently with timestamp ordering
+jobsSchema.index({ requestorId: 1, category: 1, createdAt: -1 });
+// Monitor-based job lookups (if monitorId field exists in resourceMetaData)
+// Note: This may need to be adjusted based on actual schema structure
+// jobsSchema.index({ "resourceMetaData.monitorId": 1, updatedAt: -1 });
+
+// Keep individual indexes for backward compatibility
+jobsSchema.index({ requestorId: 1 });
+jobsSchema.index({ createdAt: 1 });
+jobsSchema.index({ category: 1 });
+jobsSchema.index({ jobStatus: 1 });
+
+export { jobsSchema, Jobs };

package/src/models/lightmonitors.js

@@ -1,30 +1,30 @@
-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,
-      accessTokenCapturedAt: { type: Date },
-      refreshTokenInfo: Object,
-      refreshTokenCapturedAt: { type: Date },
-      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,
+      accessTokenCapturedAt: { type: Date },
+      refreshTokenInfo: Object,
+      refreshTokenCapturedAt: { type: Date },
+      hueCode: { type: String, required: true },
+      hueCodeHistory: [Object],
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+lightMonitorSchema.index({ monitorId: 1 });
+
+const LightMonitors = mongoose.model("LightMonitor", lightMonitorSchema);
+
+export { lightMonitorSchema, LightMonitors };