@justair/justair-library 4.7.12 → 4.7.13

package/src/models/organizations.js

@@ -1,97 +1,97 @@
-import mongoose, { Schema } from "mongoose";
-
-const alertSchema = new Schema({
-  type: {
-    type: String,
-    enum: ["Data Review"],
-  },
-  flagType: String,
-  metadata: Object,
-  frequency: Object,
-  communicationType: [String],
-  recipients: [
-    {
-      type: mongoose.Types.ObjectId,
-      ref: "Admin",
-    },
-  ],
-  isActive: {
-    type: Boolean,
-    default: true,
-  },
-});
-
-const correctionSchema = new Schema(
-  {
-    correctionName: String,
-    equationType: {
-      type: String,
-      required: true,
-    },
-    equation: {
-      type: String,
-      required: function () {
-        return this.equationType === 'custom';
-      },
-    },
-    context: {
-      type: String,
-      enum: ["field", "colocation"],
-      required: false,
-    },
-    variables: {
-      required: function () {
-        return this.equationType === 'linear';
-      },
-      type: Object,
-    },
-    dateCreated: {
-      type: Date,
-      default: Date.now,
-    },
-  },
-  { _id: false }
-);
-
-const featureSchema = new Schema({
-  featureName: String,
-  dateAdded: {
-    type: Date,
-    default: Date.now,
-  },
-});
-
-const organizationsSchema = mongoose.Schema(
-  {
-    name: String,
-    website: String,
-    location: Object,
-    authorized: { type: Boolean, default: false },
-    orgAPIKey: [Object],
-    orgCode: String,
-    orgDescription: String,
-    orgLogo: String,
-    customAlertLevels: [Object],
-    connectedMonitors: [{ type: mongoose.Types.ObjectId, ref: "Monitors" }],
-    communityMessages: [Object],
-    weeklyReportData: [Object],
-    isActive: { type: Boolean, default: true },
-    correctionRules: [correctionSchema],
-    alertConfigurations: [alertSchema],
-    features: [featureSchema],
-  },
-  {
-    timestamps: true,
-  }
-);
-
-// Name-based sorting index
-organizationsSchema.index({ name: 1 });
-// Connected monitors array queries
-organizationsSchema.index({ connectedMonitors: 1 });
-// Alert configuration queries
-organizationsSchema.index({ _id: 1, "alertConfigurations.isActive": 1 });
-
-const Organizations = mongoose.model("Organizations", organizationsSchema);
-
-export { organizationsSchema, Organizations };
+import mongoose, { Schema } from "mongoose";
+
+const alertSchema = new Schema({
+  type: {
+    type: String,
+    enum: ["Data Review"],
+  },
+  flagType: String,
+  metadata: Object,
+  frequency: Object,
+  communicationType: [String],
+  recipients: [
+    {
+      type: mongoose.Types.ObjectId,
+      ref: "Admin",
+    },
+  ],
+  isActive: {
+    type: Boolean,
+    default: true,
+  },
+});
+
+const correctionSchema = new Schema(
+  {
+    correctionName: String,
+    equationType: {
+      type: String,
+      required: true,
+    },
+    equation: {
+      type: String,
+      required: function () {
+        return this.equationType === 'custom';
+      },
+    },
+    context: {
+      type: String,
+      enum: ["field", "colocation"],
+      required: false,
+    },
+    variables: {
+      required: function () {
+        return this.equationType === 'linear';
+      },
+      type: Object,
+    },
+    dateCreated: {
+      type: Date,
+      default: Date.now,
+    },
+  },
+  { _id: false }
+);
+
+const featureSchema = new Schema({
+  featureName: String,
+  dateAdded: {
+    type: Date,
+    default: Date.now,
+  },
+});
+
+const organizationsSchema = mongoose.Schema(
+  {
+    name: String,
+    website: String,
+    location: Object,
+    authorized: { type: Boolean, default: false },
+    orgAPIKey: [Object],
+    orgCode: String,
+    orgDescription: String,
+    orgLogo: String,
+    customAlertLevels: [Object],
+    connectedMonitors: [{ type: mongoose.Types.ObjectId, ref: "Monitors" }],
+    communityMessages: [Object],
+    weeklyReportData: [Object],
+    isActive: { type: Boolean, default: true },
+    correctionRules: [correctionSchema],
+    alertConfigurations: [alertSchema],
+    features: [featureSchema],
+  },
+  {
+    timestamps: true,
+  }
+);
+
+// Name-based sorting index
+organizationsSchema.index({ name: 1 });
+// Connected monitors array queries
+organizationsSchema.index({ connectedMonitors: 1 });
+// Alert configuration queries
+organizationsSchema.index({ _id: 1, "alertConfigurations.isActive": 1 });
+
+const Organizations = mongoose.model("Organizations", organizationsSchema);
+
+export { organizationsSchema, Organizations };

package/src/models/parameters.js

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

package/src/models/referenceMonitorInfo.js

@@ -1,19 +1,19 @@
-import mongoose from 'mongoose';
-
-const referenceMonitorInfoSchema = mongoose.Schema({
-    bboxStartLat: String,
-    bboxStartLong: String,
-    bboxEndLat: String,
-    bboxEndLong: String,
-    parameters: String,
-    sponsor: { type: mongoose.Types.ObjectId, ref: 'Organizations' },
-    location: Object,
-    isActive: { type: Boolean, default: true },
-    context: [String]
-}, {
-    timestamps: true
-});
-
-const ReferenceMonitorInfo = mongoose.model('ReferenceMonitorInfo', referenceMonitorInfoSchema);
-
+import mongoose from 'mongoose';
+
+const referenceMonitorInfoSchema = mongoose.Schema({
+    bboxStartLat: String,
+    bboxStartLong: String,
+    bboxEndLat: String,
+    bboxEndLong: String,
+    parameters: String,
+    sponsor: { type: mongoose.Types.ObjectId, ref: 'Organizations' },
+    location: Object,
+    isActive: { type: Boolean, default: true },
+    context: [String]
+}, {
+    timestamps: true
+});
+
+const ReferenceMonitorInfo = mongoose.model('ReferenceMonitorInfo', referenceMonitorInfoSchema);
+
 export {referenceMonitorInfoSchema, ReferenceMonitorInfo};

package/src/models/tests/admin.test.js

@@ -1,42 +1,42 @@
-import mongoose from 'mongoose';
-import { MongoMemoryServer } from 'mongodb-memory-server';
-import Admin from '../admins.js'; // Assuming this file is in the same directory
-
-let mongoServer;
-
-// Before running the tests, start the mock MongoDB server
-beforeAll(async () => {
-  mongoServer = await MongoMemoryServer.create();
-  const mongoUri = mongoServer.getUri();
-  mongoose.connect(mongoUri, { useNewUrlParser: true, useUnifiedTopology: true });
-});
-
-// After running the tests, stop the mock MongoDB server and close the Mongoose connection
-afterAll(async () => {
-  await mongoose.disconnect();
-  await mongoServer.stop();
-});
-
-// Clear the database and reset the state before each test
-beforeEach(async () => {
-  await mongoose.connection.dropDatabase();
-});
-
-// Sample test case
-test('Create admin and fetch it from the database', async () => {
-  const adminData = {
-    name: 'John Doe',
-    phone: '1234567890',
-    email: 'john@example.com',
-    password: 'password123',
-    orgId: mongoose.Types.ObjectId(), // Generate a new ObjectId for orgId
-  };
-
-  // Create a new admin document
-  const createdAdmin = await Admin.create(adminData);
-
-  // Fetch the admin from the database
-  const fetchedAdmin = await Admin.findById(createdAdmin._id);
-
-  expect(fetchedAdmin).toMatchObject(adminData);
-});
+import mongoose from 'mongoose';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import Admin from '../admins.js'; // Assuming this file is in the same directory
+
+let mongoServer;
+
+// Before running the tests, start the mock MongoDB server
+beforeAll(async () => {
+  mongoServer = await MongoMemoryServer.create();
+  const mongoUri = mongoServer.getUri();
+  mongoose.connect(mongoUri, { useNewUrlParser: true, useUnifiedTopology: true });
+});
+
+// After running the tests, stop the mock MongoDB server and close the Mongoose connection
+afterAll(async () => {
+  await mongoose.disconnect();
+  await mongoServer.stop();
+});
+
+// Clear the database and reset the state before each test
+beforeEach(async () => {
+  await mongoose.connection.dropDatabase();
+});
+
+// Sample test case
+test('Create admin and fetch it from the database', async () => {
+  const adminData = {
+    name: 'John Doe',
+    phone: '1234567890',
+    email: 'john@example.com',
+    password: 'password123',
+    orgId: mongoose.Types.ObjectId(), // Generate a new ObjectId for orgId
+  };
+
+  // Create a new admin document
+  const createdAdmin = await Admin.create(adminData);
+
+  // Fetch the admin from the database
+  const fetchedAdmin = await Admin.findById(createdAdmin._id);
+
+  expect(fetchedAdmin).toMatchObject(adminData);
+});

package/src/models/tests/configurations.test.js

@@ -1,44 +1,44 @@
-import mongoose from 'mongoose';
-import { MongoMemoryServer } from 'mongodb-memory-server';
-import Configurations from '../configurations.js'; // Assuming this file is in the same directory
-
-let mongoServer;
-
-// Before running the tests, start the mock MongoDB server
-beforeAll(async () => {
-    mongoServer = await MongoMemoryServer.create();
-    const mongoUri = mongoServer.getUri();
-    mongoose.connect(mongoUri, { useNewUrlParser: true, useUnifiedTopology: true });
-});
-
-// After running the tests, stop the mock MongoDB server and close the Mongoose connection
-afterAll(async () => {
-  await mongoose.disconnect();
-  await mongoServer.stop();
-});
-
-// Clear the database and reset the state before each test
-beforeEach(async () => {
-  await mongoose.connection.dropDatabase();
-});
-
-// Sample test case
-test('Create configuration and fetch it from the database', async () => {
-  const configurationData = {
-    type: 'flag',
-    name: 'FeatureA',
-    properties: {
-      enabled: true,
-      percentage: 50,
-    },
-    isActive: true,
-  };
-
-  // Create a new configuration document
-  const createdConfiguration = await Configurations.create(configurationData);
-
-  // Fetch the configuration from the database
-  const fetchedConfiguration = await Configurations.findById(createdConfiguration._id);
-
-  expect(fetchedConfiguration).toMatchObject(configurationData);
-});
+import mongoose from 'mongoose';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import Configurations from '../configurations.js'; // Assuming this file is in the same directory
+
+let mongoServer;
+
+// Before running the tests, start the mock MongoDB server
+beforeAll(async () => {
+    mongoServer = await MongoMemoryServer.create();
+    const mongoUri = mongoServer.getUri();
+    mongoose.connect(mongoUri, { useNewUrlParser: true, useUnifiedTopology: true });
+});
+
+// After running the tests, stop the mock MongoDB server and close the Mongoose connection
+afterAll(async () => {
+  await mongoose.disconnect();
+  await mongoServer.stop();
+});
+
+// Clear the database and reset the state before each test
+beforeEach(async () => {
+  await mongoose.connection.dropDatabase();
+});
+
+// Sample test case
+test('Create configuration and fetch it from the database', async () => {
+  const configurationData = {
+    type: 'flag',
+    name: 'FeatureA',
+    properties: {
+      enabled: true,
+      percentage: 50,
+    },
+    isActive: true,
+  };
+
+  // Create a new configuration document
+  const createdConfiguration = await Configurations.create(configurationData);
+
+  // Fetch the configuration from the database
+  const fetchedConfiguration = await Configurations.findById(createdConfiguration._id);
+
+  expect(fetchedConfiguration).toMatchObject(configurationData);
+});

package/src/models/tests/measurements.test.js

@@ -1,46 +1,46 @@
-import mongoose from 'mongoose';
-import { MongoMemoryServer } from 'mongodb-memory-server';
-import Measurements from '../measurements.js'; // Assuming this file is in the same directory
-
-let mongoServer;
-
-// Before running the tests, start the mock MongoDB server
-beforeAll(async () => {
-    mongoServer = await MongoMemoryServer.create();
-    const mongoUri = mongoServer.getUri();
-    mongoose.connect(mongoUri, { useNewUrlParser: true, useUnifiedTopology: true });
-});
-
-// After running the tests, stop the mock MongoDB server and close the Mongoose connection
-afterAll(async () => {
-  await mongoose.disconnect();
-  await mongoServer.stop();
-});
-
-// Clear the database and reset the state before each test
-beforeEach(async () => {
-  await mongoose.connection.dropDatabase();
-});
-
-// Sample test case
-test('Create measurement and fetch it from the database', async () => {
-  const measurementData = {
-    monitorId: mongoose.Types.ObjectId(), // Generate a new ObjectId for monitorId
-    orgId: mongoose.Types.ObjectId(), // Generate a new ObjectId for orgId
-    timeUpdated: new Date(),
-    measurements: {
-      temperature: 25,
-      humidity: 60,
-    },
-    alert: 'Good',
-    alertMessage: 'High temperature detected',
-  };
-
-  // Create a new measurement document
-  const createdMeasurement = await Measurements.create(measurementData);
-
-  // Fetch the measurement from the database
-  const fetchedMeasurement = await Measurements.findById(createdMeasurement._id);
-
-  expect(fetchedMeasurement).toMatchObject(measurementData);
-});
+import mongoose from 'mongoose';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import Measurements from '../measurements.js'; // Assuming this file is in the same directory
+
+let mongoServer;
+
+// Before running the tests, start the mock MongoDB server
+beforeAll(async () => {
+    mongoServer = await MongoMemoryServer.create();
+    const mongoUri = mongoServer.getUri();
+    mongoose.connect(mongoUri, { useNewUrlParser: true, useUnifiedTopology: true });
+});
+
+// After running the tests, stop the mock MongoDB server and close the Mongoose connection
+afterAll(async () => {
+  await mongoose.disconnect();
+  await mongoServer.stop();
+});
+
+// Clear the database and reset the state before each test
+beforeEach(async () => {
+  await mongoose.connection.dropDatabase();
+});
+
+// Sample test case
+test('Create measurement and fetch it from the database', async () => {
+  const measurementData = {
+    monitorId: mongoose.Types.ObjectId(), // Generate a new ObjectId for monitorId
+    orgId: mongoose.Types.ObjectId(), // Generate a new ObjectId for orgId
+    timeUpdated: new Date(),
+    measurements: {
+      temperature: 25,
+      humidity: 60,
+    },
+    alert: 'Good',
+    alertMessage: 'High temperature detected',
+  };
+
+  // Create a new measurement document
+  const createdMeasurement = await Measurements.create(measurementData);
+
+  // Fetch the measurement from the database
+  const fetchedMeasurement = await Measurements.findById(createdMeasurement._id);
+
+  expect(fetchedMeasurement).toMatchObject(measurementData);
+});

package/src/models/tests/monitorRequests.test.js

@@ -1,46 +1,46 @@
-import mongoose from 'mongoose';
-import { MongoMemoryServer } from 'mongodb-memory-server';
-import MonitorRequests from '../monitorRequests.js'; // Assuming this file is in the same directory
-
-let mongoServer;
-
-// Before running the tests, start the mock MongoDB server
-beforeAll(async () => {
-    mongoServer = await MongoMemoryServer.create();
-    const mongoUri = mongoServer.getUri();
-    mongoose.connect(mongoUri, { useNewUrlParser: true, useUnifiedTopology: true });
-});
-
-// After running the tests, stop the mock MongoDB server and close the Mongoose connection
-afterAll(async () => {
-  await mongoose.disconnect();
-  await mongoServer.stop();
-});
-
-// Clear the database and reset the state before each test
-beforeEach(async () => {
-  await mongoose.connection.dropDatabase();
-});
-
-// Sample test case
-test('Create monitor request and fetch it from the database', async () => {
-  const monitorRequestData = {
-    monitorOwnerOrg: mongoose.Types.ObjectId(), // Generate a new ObjectId for monitorOwnerOrg
-    monitorOwnerOrgName: 'Organization A',
-    monitorSharerOrg: mongoose.Types.ObjectId(), // Generate a new ObjectId for monitorSharerOrg
-    monitorSharerOrgName: 'Organization B',
-    monitorList: [
-      mongoose.Types.ObjectId(), // Generate a new ObjectId for each monitor in the list
-      mongoose.Types.ObjectId(),
-    ],
-    status: 'Requested',
-  };
-
-  // Create a new monitor request document
-  const createdMonitorRequest = await MonitorRequests.create(monitorRequestData);
-
-  // Fetch the monitor request from the database
-  const fetchedMonitorRequest = await MonitorRequests.findById(createdMonitorRequest._id);
-
-  expect(fetchedMonitorRequest).toMatchObject(monitorRequestData);
-});
+import mongoose from 'mongoose';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import MonitorRequests from '../monitorRequests.js'; // Assuming this file is in the same directory
+
+let mongoServer;
+
+// Before running the tests, start the mock MongoDB server
+beforeAll(async () => {
+    mongoServer = await MongoMemoryServer.create();
+    const mongoUri = mongoServer.getUri();
+    mongoose.connect(mongoUri, { useNewUrlParser: true, useUnifiedTopology: true });
+});
+
+// After running the tests, stop the mock MongoDB server and close the Mongoose connection
+afterAll(async () => {
+  await mongoose.disconnect();
+  await mongoServer.stop();
+});
+
+// Clear the database and reset the state before each test
+beforeEach(async () => {
+  await mongoose.connection.dropDatabase();
+});
+
+// Sample test case
+test('Create monitor request and fetch it from the database', async () => {
+  const monitorRequestData = {
+    monitorOwnerOrg: mongoose.Types.ObjectId(), // Generate a new ObjectId for monitorOwnerOrg
+    monitorOwnerOrgName: 'Organization A',
+    monitorSharerOrg: mongoose.Types.ObjectId(), // Generate a new ObjectId for monitorSharerOrg
+    monitorSharerOrgName: 'Organization B',
+    monitorList: [
+      mongoose.Types.ObjectId(), // Generate a new ObjectId for each monitor in the list
+      mongoose.Types.ObjectId(),
+    ],
+    status: 'Requested',
+  };
+
+  // Create a new monitor request document
+  const createdMonitorRequest = await MonitorRequests.create(monitorRequestData);
+
+  // Fetch the monitor request from the database
+  const fetchedMonitorRequest = await MonitorRequests.findById(createdMonitorRequest._id);
+
+  expect(fetchedMonitorRequest).toMatchObject(monitorRequestData);
+});