@justair/justair-library 4.8.18 → 4.8.20

package/package.json

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

package/src/models/monitors.js

@@ -248,6 +248,8 @@ const monitorsSchema = mongoose.Schema(
       default: [],
     },
     applyCorrections: { type: Boolean, default: false },
+    // Optional readKey for private API access (e.g. PurpleAir)
+    readKey: { type: String, required: false },
     pausedParameters: {
       type: [{ parameter: String, timestamp: Date, isPaused: Boolean }],
       default: [],

package/src/models/organizations.js

@@ -61,6 +61,32 @@ const featureSchema = new Schema({
   },
 });
 
+const computeResetTime = (rateLimitType, baseTime = new Date()) => {
+  const resetTime = new Date(baseTime);
+
+  switch (rateLimitType) {
+    case "second":
+      resetTime.setSeconds(resetTime.getSeconds() + 1);
+      break;
+    case "hourly":
+      resetTime.setHours(resetTime.getHours() + 1);
+      break;
+    case "daily":
+      resetTime.setDate(resetTime.getDate() + 1);
+      break;
+    case "weekly":
+      resetTime.setDate(resetTime.getDate() + 7);
+      break;
+    case "monthly":
+      resetTime.setMonth(resetTime.getMonth() + 1);
+      break;
+    default:
+      break;
+  }
+
+  return resetTime;
+};
+
 const organizationsSchema = mongoose.Schema(
   {
     name: String,
@@ -85,6 +111,54 @@ const organizationsSchema = mongoose.Schema(
   }
 );
 
+organizationsSchema.methods.setRateLimitProperties = function () {
+  if (!Array.isArray(this.orgAPIKey)) {
+    return;
+  }
+
+  const now = new Date();
+
+  this.orgAPIKey = this.orgAPIKey.map((apiKeyEntry) => {
+    if (!apiKeyEntry || !Array.isArray(apiKeyEntry.rateLimits)) {
+      return apiKeyEntry;
+    }
+
+    const updatedRateLimits = apiKeyEntry.rateLimits.map((rateLimit) => {
+      if (!rateLimit) {
+        return rateLimit;
+      }
+
+      const updatedRateLimit = { ...rateLimit };
+
+      if (updatedRateLimit.apiCount == null) {
+        updatedRateLimit.apiCount = 0;
+      }
+
+      if (!updatedRateLimit.resetTime) {
+        updatedRateLimit.resetTime = computeResetTime(
+          updatedRateLimit.type,
+          now
+        );
+      }
+
+      return updatedRateLimit;
+    });
+
+    return {
+      ...apiKeyEntry,
+      rateLimits: updatedRateLimits,
+    };
+  });
+};
+
+organizationsSchema.pre("save", function (next) {
+  if (this.isModified("orgAPIKey")) {
+    this.setRateLimitProperties();
+  }
+
+  next();
+});
+
 // Name-based sorting index
 organizationsSchema.index({ name: 1 });
 // Connected monitors array queries

package/src/models/sampleSites.js

@@ -0,0 +1,198 @@
+import mongoose from "mongoose";
+const sampleParametersEnum = [
+  "C6H6", // Benzene
+  "PB", // Lead
+  "AS", // Arsenic
+  "CD", // Cadmium
+  "CR", // Chromium
+  "NI", // Nickel
+  "BA", // Barium
+  "FE", // Iron
+  "CU", // Copper
+  "ZN", // Zinc
+];
+
+const noteSchema = mongoose.Schema({
+  note: {
+    type: String,
+    required: true,
+  },
+  type: {
+    type: String,
+    required: true,
+  },
+  adminId: {
+    type: mongoose.Types.ObjectId,
+    ref: "Admin",
+    required: true,
+  },
+  adminName: {
+    type: String,
+  },
+  date: {
+    type: Date,
+    default: Date.now,
+  },
+});
+
+// Sample Site Audit Schema
+const sampleSiteAuditSchema = mongoose.Schema(
+  {
+    monitorId: { type: mongoose.Types.ObjectId, ref: "SampleSites" },
+    orgId: { type: mongoose.Types.ObjectId, ref: "Organizations" },
+    timeUpdated: Date,
+    deletedAt: { type: Date, default: Date.now }, // Only populated on delete
+    monitorLocation: {
+      // Monitor GPS location (lat, lon)
+      type: { type: String, enum: ["Point"], required: true },
+      coordinates: { type: [Number], required: true },
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+// Create the SampleSiteAudit model
+const SampleSiteAudit = mongoose.model("SampleSiteAudit", sampleSiteAuditSchema);
+
+// Sample Sites Schema
+const sampleSitesSchema = mongoose.Schema(
+  {
+    monitorCode: String,
+    // Managed By and Sponsored By fields
+    managedBy: String,
+    sponsoredBy: String,
+    measurementUpdate: Date,
+    isPrivate: { type: Boolean, default: false, required: true },
+    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],
+    parameters: [
+      {
+        type: String,
+        enum: sampleParametersEnum,
+      },
+    ],
+    notes: [noteSchema],
+    image: String,
+  },
+  {
+    timestamps: true,
+  }
+);
+
+// Geographic queries - already exists
+sampleSitesSchema.index({ gpsLocation: "2dsphere" });
+
+// Sponsor-based queries
+sampleSitesSchema.index({ sponsor: 1, isActive: 1 });
+
+// Location-based filtering
+sampleSitesSchema.index({ "location.city": 1, "location.state": 1 });
+sampleSitesSchema.index({ "location.neighborhood": 1 });
+sampleSitesSchema.index({ "location.county": 1 });
+
+// Query parameter filtering
+sampleSitesSchema.index({ context: 1 });
+sampleSitesSchema.index({ parameters: 1 });
+
+// Pre-hook to log single document deletions
+sampleSitesSchema.pre("findOneAndDelete", async function () {
+  const docToDelete = await this.model.findOne(this.getFilter()).lean();
+  if (docToDelete) {
+    console.log("Logging findOneAndDelete to sample site audit", docToDelete);
+    const auditLog = new SampleSiteAudit({
+      monitorId: docToDelete._id,
+      orgId: docToDelete.sponsor,
+      timeUpdated: docToDelete.updatedAt,
+      monitorLocation: {
+        type: "Point",
+        coordinates: [
+          docToDelete.monitorLongitude,
+          docToDelete.monitorLatitude,
+        ],
+      },
+      deletedAt: new Date(),
+    });
+    await auditLog.save();
+  }
+});
+
+// Pre-hook to log multiple document deletions
+sampleSitesSchema.pre("deleteMany", async function () {
+  console.log("deleteMany pre-hook triggered for sample sites");
+  const docsToDelete = await this.model.find(this.getFilter()).lean();
+
+  if (docsToDelete.length) {
+    console.log(`Logging ${docsToDelete.length} sample site documents to audit`);
+    const auditLogs = docsToDelete.map((doc) => ({
+      monitorId: doc._id,
+      orgId: doc.sponsor,
+      timeUpdated: doc.updatedAt,
+      monitorLocation: {
+        type: "Point",
+        coordinates: [doc.monitorLongitude, doc.monitorLatitude],
+      },
+      deletedAt: new Date(),
+    }));
+
+    await SampleSiteAudit.insertMany(auditLogs);
+  }
+});
+
+// Pre-hook to log a single document deletion (for deleteOne)
+sampleSitesSchema.pre("deleteOne", async function () {
+  console.log("deleteOne pre-hook triggered for sample sites");
+  const docToDelete = await this.model.findOne(this.getFilter()).lean();
+
+  if (docToDelete) {
+    console.log("Logging deleteOne to sample site audit", docToDelete);
+    const auditLog = new SampleSiteAudit({
+      monitorId: docToDelete._id,
+      orgId: docToDelete.sponsor,
+      timeUpdated: docToDelete.updatedAt,
+      monitorLocation: {
+        type: "Point",
+        coordinates: [
+          docToDelete.monitorLongitude,
+          docToDelete.monitorLatitude,
+        ],
+      },
+      deletedAt: new Date(),
+    });
+    await auditLog.save();
+  }
+});
+
+// Pre-hook to log multiple document updates
+sampleSitesSchema.pre("updateMany", async function () {
+  const docsToUpdate = await this.model.find(this.getFilter()).lean();
+  if (docsToUpdate.length) {
+    console.log(`Logging ${docsToUpdate.length} sample site documents to audit`);
+    const auditLogs = docsToUpdate.map((doc) => ({
+      monitorId: doc._id,
+      orgId: doc.sponsor,
+      timeUpdated: doc.updatedAt,
+      monitorLocation: {
+        type: "Point",
+        coordinates: [doc.monitorLongitude, doc.monitorLatitude],
+      },
+      deletedAt: null, // Not a deletion, so this field is null
+    }));
+
+    await SampleSiteAudit.insertMany(auditLogs);
+  }
+});
+
+// Create the SampleSites model
+const SampleSites = mongoose.model("SampleSites", sampleSitesSchema);
+
+export { sampleSitesSchema, SampleSites, sampleSiteAuditSchema, SampleSiteAudit, sampleParametersEnum };