@justair/justair-library 4.8.11 → 4.8.13

package/src/models/alerts.js

@@ -1,219 +1,219 @@
-import mongoose, { Schema } from "mongoose";
-
-const recipientSchema = new Schema(
-  {
-    adminId: {
-      type: mongoose.Types.ObjectId,
-      ref: "Admin",
-    },
-    typeOfCommunication: String,
-    dateCommunicated: {
-      type: Date,
-      defult: Date.now,
-    },
-  },
-  { _id: false }
-);
-
-const alertsSchema = mongoose.Schema(
-  {
-    type: {
-      type: String,
-      enum: ["Data Review"],
-    },
-    alertConfigurationId: mongoose.Types.ObjectId,
-    flagType: String,
-    orgId: { type: mongoose.Types.ObjectId, ref: "Organizations" },
-    monitorId: { type: mongoose.Types.ObjectId, ref: "Monitors" },
-    status: {
-      type: String,
-      enum: ["Active", "Ack", "Mute"],
-    },
-    activeUntil: { type: Date },
-    actionBy: { type: mongoose.Types.ObjectId, ref: "Admin" },
-    actionDate: { type: Date, default: Date.now },
-    recipients: [recipientSchema],
-    metaData: Object,
-    flaggedDataCompleteness: [Object],
-    flaggedMeasurementIds: [
-        {
-            type: mongoose.Types.ObjectId,
-            ref: "Measurements",
-        },
-    ],
-    flaggedMeasurements: [Object]
-  },
-  {
-    timestamps: true,
-  }
-);
-
-// Organization-based queries with timestamp ordering
-alertsSchema.index({ orgId: 1, updatedAt: -1 });
-// Monitor-based queries for lookups with timestamp ordering
-alertsSchema.index({ monitorId: 1, updatedAt: -1 });
-// Status-based filtering with organization and timestamp
-alertsSchema.index({ orgId: 1, status: 1, updatedAt: -1 });
-// Alert configuration matching - already optimal
-alertsSchema.index({ alertConfigurationId: 1 });
-
-alertsSchema.index({ type: 1 });
-
-const alertsAuditSchema = mongoose.Schema(
-  {
-    timeUpdated: Date,
-    deletedAt: { type: Date, default: Date.now },
-    type: {
-      type: String,
-      enum: ["Data Review"],
-    },
-    alertConfigurationId: mongoose.Types.ObjectId,
-    orgId: { type: mongoose.Types.ObjectId, ref: "Organizations" },
-    monitorId: { type: mongoose.Types.ObjectId, ref: "Monitors" },
-    status: {
-      type: String,
-      enum: ["Active", "Ack", "Mute"],
-    },
-    activeUntil: {type: Date},
-    actionBy: { type: mongoose.Types.ObjectId, ref: "Admin" },
-    actionDate: { type: Date, default: Date.now },
-    recipients: [recipientSchema],
-    metaData: Object,
-    flaggedMeasurementIds: [
-      {
-        type: mongoose.Types.ObjectId,
-        ref: "Measurements",
-      },
-    ],
-  },
-  {
-    timestamps: true,
-  }
-);
-
-const AlertsAudit = mongoose.model("AlertsAudit", alertsAuditSchema);
-
-// Fix the typo in the hook name - 'sindOneAndDelete' to 'findOneAndDelete'
-alertsSchema.pre("findOneAndDelete", async function () {
-  const docToDelete = await this.model.findOne(this.getFilter());
-  if (docToDelete) {
-    console.log("Logging findOneAndDelete to audit", docToDelete);
-    const auditLog = new AlertsAudit({
-      timeUpdated: docToDelete.updatedAt,
-      type: docToDelete.type,
-      orgId: docToDelete.orgId,
-      alertConfigurationId: docToDelete.alertConfigurationId,
-      monitorId: docToDelete.monitorId,
-      status: docToDelete.status,
-      activeUntil: docToDelete.activeUntil,
-      actionBy: docToDelete.actionBy,
-      actionDate: docToDelete.actionDate,
-      recipients: docToDelete.recipients,
-      flaggedMeasurementIds: docToDelete.flaggedMeasurementIds,
-      deletedAt: new Date(),
-    });
-    await auditLog.save();
-  }
-});
-
-// Pre-hook to log multiple alert deletions
-alertsSchema.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) => ({
-      timeUpdated: doc.updatedAt,
-      type: doc.type,
-      alertConfigurationId: doc.alertConfigurationId,
-      orgId: doc.orgId,
-      monitorId: doc.monitorId,
-      status: doc.status,
-      activeUntil: doc.activeUntil,
-      actionBy: doc.actionBy,
-      actionDate: doc.actionDate,
-      recipients: doc.recipients,
-      flaggedMeasurementIds: doc.flaggedMeasurementIds,
-      deletedAt: new Date(),
-    }));
-
-    await AlertsAudit.insertMany(auditLogs);
-  }
-});
-
-// Pre-hook to log a single alert deletion (for deleteOne)
-alertsSchema.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 AlertsAudit({
-      timeUpdated: docToDelete.updatedAt,
-      type: docToDelete.type,
-      alertConfigurationId: docToDelete.alertConfigurationId,
-      orgId: docToDelete.orgId,
-      monitorId: docToDelete.monitorId,
-      status: docToDelete.status,
-      activeUntil: docToDelete.activeUntil,
-      actionBy: docToDelete.actionBy,
-      actionDate: docToDelete.actionDate,
-      recipients: docToDelete.recipients,
-      flaggedMeasurementIds: docToDelete.flaggedMeasurementIds,
-      deletedAt: new Date(),
-    });
-    await auditLog.save();
-  }
-});
-
-// Pre-hook to log single alert updates
-alertsSchema.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 AlertsAudit({
-      timeUpdated: docToUpdate.updatedAt,
-      type: docToUpdate.type,
-      alertConfigurationId: docToUpdate.alertConfigurationId,
-      orgId: docToUpdate.orgId,
-      monitorId: docToUpdate.monitorId,
-      status: docToUpdate.status,
-      activeUntil: docToUpdate.activeUntil,
-      actionBy: docToUpdate.actionBy,
-      actionDate: docToUpdate.actionDate,
-      recipients: docToUpdate.recipients,
-      flaggedMeasurementIds: docToUpdate.flaggedMeasurementIds,
-      deletedAt: null, // No deletion happening
-    });
-    await auditLog.save();
-  }
-});
-
-// Pre-hook to log multiple alert updates
-alertsSchema.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) => ({
-      timeUpdated: doc.updatedAt,
-      type: doc.type,
-      alertConfigurationId: doc.alertConfigurationId,
-      orgId: doc.orgId,
-      monitorId: doc.monitorId,
-      status: doc.status,
-      activeUntil: doc.activeUntil,
-      actionBy: doc.actionBy,
-      actionDate: doc.actionDate,
-      recipients: doc.recipients,
-      flaggedMeasurementIds: doc.flaggedMeasurementIds,
-      deletedAt: null, // No deletion happening
-    }));
-
-    await AlertsAudit.insertMany(auditLogs);
-  }
-});
-
-const Alerts = mongoose.model("Alerts", alertsSchema);
-
-export { alertsSchema, Alerts, AlertsAudit, alertsAuditSchema };
+import mongoose, { Schema } from "mongoose";
+
+const recipientSchema = new Schema(
+  {
+    adminId: {
+      type: mongoose.Types.ObjectId,
+      ref: "Admin",
+    },
+    typeOfCommunication: String,
+    dateCommunicated: {
+      type: Date,
+      defult: Date.now,
+    },
+  },
+  { _id: false }
+);
+
+const alertsSchema = mongoose.Schema(
+  {
+    type: {
+      type: String,
+      enum: ["Data Review"],
+    },
+    alertConfigurationId: mongoose.Types.ObjectId,
+    flagType: String,
+    orgId: { type: mongoose.Types.ObjectId, ref: "Organizations" },
+    monitorId: { type: mongoose.Types.ObjectId, ref: "Monitors" },
+    status: {
+      type: String,
+      enum: ["Active", "Ack", "Mute"],
+    },
+    activeUntil: { type: Date },
+    actionBy: { type: mongoose.Types.ObjectId, ref: "Admin" },
+    actionDate: { type: Date, default: Date.now },
+    recipients: [recipientSchema],
+    metaData: Object,
+    flaggedDataCompleteness: [Object],
+    flaggedMeasurementIds: [
+        {
+            type: mongoose.Types.ObjectId,
+            ref: "Measurements",
+        },
+    ],
+    flaggedMeasurements: [Object]
+  },
+  {
+    timestamps: true,
+  }
+);
+
+// Organization-based queries with timestamp ordering
+alertsSchema.index({ orgId: 1, updatedAt: -1 });
+// Monitor-based queries for lookups with timestamp ordering
+alertsSchema.index({ monitorId: 1, updatedAt: -1 });
+// Status-based filtering with organization and timestamp
+alertsSchema.index({ orgId: 1, status: 1, updatedAt: -1 });
+// Alert configuration matching - already optimal
+alertsSchema.index({ alertConfigurationId: 1 });
+
+alertsSchema.index({ type: 1 });
+
+const alertsAuditSchema = mongoose.Schema(
+  {
+    timeUpdated: Date,
+    deletedAt: { type: Date, default: Date.now },
+    type: {
+      type: String,
+      enum: ["Data Review"],
+    },
+    alertConfigurationId: mongoose.Types.ObjectId,
+    orgId: { type: mongoose.Types.ObjectId, ref: "Organizations" },
+    monitorId: { type: mongoose.Types.ObjectId, ref: "Monitors" },
+    status: {
+      type: String,
+      enum: ["Active", "Ack", "Mute"],
+    },
+    activeUntil: {type: Date},
+    actionBy: { type: mongoose.Types.ObjectId, ref: "Admin" },
+    actionDate: { type: Date, default: Date.now },
+    recipients: [recipientSchema],
+    metaData: Object,
+    flaggedMeasurementIds: [
+      {
+        type: mongoose.Types.ObjectId,
+        ref: "Measurements",
+      },
+    ],
+  },
+  {
+    timestamps: true,
+  }
+);
+
+const AlertsAudit = mongoose.model("AlertsAudit", alertsAuditSchema);
+
+// Fix the typo in the hook name - 'sindOneAndDelete' to 'findOneAndDelete'
+alertsSchema.pre("findOneAndDelete", async function () {
+  const docToDelete = await this.model.findOne(this.getFilter());
+  if (docToDelete) {
+    console.log("Logging findOneAndDelete to audit", docToDelete);
+    const auditLog = new AlertsAudit({
+      timeUpdated: docToDelete.updatedAt,
+      type: docToDelete.type,
+      orgId: docToDelete.orgId,
+      alertConfigurationId: docToDelete.alertConfigurationId,
+      monitorId: docToDelete.monitorId,
+      status: docToDelete.status,
+      activeUntil: docToDelete.activeUntil,
+      actionBy: docToDelete.actionBy,
+      actionDate: docToDelete.actionDate,
+      recipients: docToDelete.recipients,
+      flaggedMeasurementIds: docToDelete.flaggedMeasurementIds,
+      deletedAt: new Date(),
+    });
+    await auditLog.save();
+  }
+});
+
+// Pre-hook to log multiple alert deletions
+alertsSchema.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) => ({
+      timeUpdated: doc.updatedAt,
+      type: doc.type,
+      alertConfigurationId: doc.alertConfigurationId,
+      orgId: doc.orgId,
+      monitorId: doc.monitorId,
+      status: doc.status,
+      activeUntil: doc.activeUntil,
+      actionBy: doc.actionBy,
+      actionDate: doc.actionDate,
+      recipients: doc.recipients,
+      flaggedMeasurementIds: doc.flaggedMeasurementIds,
+      deletedAt: new Date(),
+    }));
+
+    await AlertsAudit.insertMany(auditLogs);
+  }
+});
+
+// Pre-hook to log a single alert deletion (for deleteOne)
+alertsSchema.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 AlertsAudit({
+      timeUpdated: docToDelete.updatedAt,
+      type: docToDelete.type,
+      alertConfigurationId: docToDelete.alertConfigurationId,
+      orgId: docToDelete.orgId,
+      monitorId: docToDelete.monitorId,
+      status: docToDelete.status,
+      activeUntil: docToDelete.activeUntil,
+      actionBy: docToDelete.actionBy,
+      actionDate: docToDelete.actionDate,
+      recipients: docToDelete.recipients,
+      flaggedMeasurementIds: docToDelete.flaggedMeasurementIds,
+      deletedAt: new Date(),
+    });
+    await auditLog.save();
+  }
+});
+
+// Pre-hook to log single alert updates
+alertsSchema.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 AlertsAudit({
+      timeUpdated: docToUpdate.updatedAt,
+      type: docToUpdate.type,
+      alertConfigurationId: docToUpdate.alertConfigurationId,
+      orgId: docToUpdate.orgId,
+      monitorId: docToUpdate.monitorId,
+      status: docToUpdate.status,
+      activeUntil: docToUpdate.activeUntil,
+      actionBy: docToUpdate.actionBy,
+      actionDate: docToUpdate.actionDate,
+      recipients: docToUpdate.recipients,
+      flaggedMeasurementIds: docToUpdate.flaggedMeasurementIds,
+      deletedAt: null, // No deletion happening
+    });
+    await auditLog.save();
+  }
+});
+
+// Pre-hook to log multiple alert updates
+alertsSchema.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) => ({
+      timeUpdated: doc.updatedAt,
+      type: doc.type,
+      alertConfigurationId: doc.alertConfigurationId,
+      orgId: doc.orgId,
+      monitorId: doc.monitorId,
+      status: doc.status,
+      activeUntil: doc.activeUntil,
+      actionBy: doc.actionBy,
+      actionDate: doc.actionDate,
+      recipients: doc.recipients,
+      flaggedMeasurementIds: doc.flaggedMeasurementIds,
+      deletedAt: null, // No deletion happening
+    }));
+
+    await AlertsAudit.insertMany(auditLogs);
+  }
+});
+
+const Alerts = mongoose.model("Alerts", alertsSchema);
+
+export { alertsSchema, Alerts, AlertsAudit, alertsAuditSchema };

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};