tabletcommand-backend-models 7.0.13 → 7.0.15

package/src/test/incident-notified.ts

@@ -0,0 +1,41 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("IncidentNotified", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.IncidentNotified>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.incidentNotified;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.IncidentNotified(testItem);
+    const sut = await item.save();
+
+    assert.isNotNull(testItem._id);
+    assert.equal(testItem.departmentId, sut.departmentId);
+    assert.equal(testItem.IncidentNumber, sut.IncidentNumber);
+    assert.deepEqual(testItem.incidentTypes, sut.incidentTypes);
+    assert.deepEqual(testItem.units, sut.units);
+    if (testItem.unitsByDispatch?.length) {
+      assert.equal(testItem.unitsByDispatch[0]?.UnitID, sut.unitsByDispatch[0]?.UnitID);
+      assert.equal(testItem.unitsByDispatch[0]?.UnitDispatchNumber, sut.unitsByDispatch[0]?.UnitDispatchNumber);
+    } else {
+      assert.equal(testItem?.unitsByDispatch?.length, 1);
+    }
+    assert.equal(testItem.updated?.toISOString(), sut.updated.toISOString());
+  });
+});

package/src/test/incident-takeover.ts

@@ -0,0 +1,39 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("IncidentTakeover", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.IncidentTakeover>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.incidentTakeover;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.IncidentTakeover(testItem);
+    const sut = await item.save();
+
+    assert.isNotNull(testItem._id);
+    assert.equal(testItem.departmentId, sut.departmentId);
+    assert.equal(testItem.incident_id, sut.incident_id);
+    assert.equal(testItem.incident_name, sut.incident_name);
+    assert.equal(testItem.incident_number, sut.incident_number);
+    assert.equal(testItem.old_owner, sut.old_owner);
+    assert.equal(testItem.new_owner, sut.new_owner);
+    assert.equal(testItem.status, sut.status);
+    assert.equal(testItem.request_time, sut.request_time);
+    assert.isTrue(sut.uuid !== "");
+  });
+});

package/src/test/job-log.ts

@@ -0,0 +1,37 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("JobLog", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.JobLog>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.jobLog;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.JobLog(testItem);
+    const sut = await item.save();
+
+    assert.isNotNull(testItem._id);
+    assert.equal(testItem.host, sut.host);
+    assert.equal(testItem.jobName, sut.jobName);
+    assert.equal(testItem.state, sut.state);
+    assert.equal(testItem.bidDate, sut.bidDate);
+    assert.equal(testItem.startDate, sut.startDate);
+    assert.equal(testItem.completedDate, sut.completedDate);
+    assert.equal(testItem.forceClosed, sut.forceClosed);
+  });
+});

package/src/test/location.ts

@@ -0,0 +1,93 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+import { decodeLocationVisibility } from "../models/location";
+import { LocationVisibility } from "../constants";
+
+describe("Location", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.Location>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.location;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.Location(testItem);
+    const sut = await item.save();
+    assert.isNotNull(testItem._id);
+    assert.equal(testItem.departmentId, sut.departmentId);
+    assert.equal(testItem.userId, sut.userId);
+    assert.equal(testItem.uuid, sut.uuid);
+    assert.equal(testItem.username, sut.username);
+    assert.equal(testItem.device_type, sut.device_type);
+    assert.equal(testItem.session, sut.session);
+    assert.equal(testItem.active, sut.active);
+    assert.equal(testItem.heading, sut.heading);
+    assert.equal(testItem.locationGeoJSON?.coordinates[0], sut.location?.longitude);
+    assert.equal(testItem.locationGeoJSON?.coordinates[1], sut.location?.latitude);
+    assert.equal(testItem.locationGeoJSON?.type, "Point");
+    assert.equal(testItem.locationGeoJSON?.coordinates[0], sut.locationGeoJSON.coordinates[0]);
+    assert.equal(testItem.locationGeoJSON?.coordinates[1], sut.locationGeoJSON.coordinates[1]);
+    assert.equal(testItem.opAreaCode, sut.opAreaCode);
+    assert.equal(testItem.opAreaName, sut.opAreaName);
+    assert.equal(testItem.shared, sut.shared);
+    assert.equal(testItem.state, sut.state);
+    assert.equal(testItem.sendToCAD, sut.sendToCAD);
+    assert.equal(testItem.color?.text, sut.color.text);
+    assert.equal(testItem.color?.background, sut.color.background);
+    assert.isTrue(sut.uuid !== "");
+
+    const { longitude, latitude } = sut.location ?? { latitude: 0, longitude: 0 };
+    const maxDistance = 10000;
+    const geoQuery = {
+      locationGeoJSON: {
+        $nearSphere: {
+          $geometry: {
+            type: "Point",
+            coordinates: [longitude, latitude],
+          },
+          $maxDistance: maxDistance
+        }
+      }
+    };
+
+    try {
+      await models.Location.findOne(geoQuery);
+      assert.isFalse(true, "Expecting above to fail.");
+    } catch (error) {
+      assert.isNotNull(error, "Expecting above to fail");
+    }
+
+    await models.Location.createIndexes();
+
+    const found = await models.Location.findOne(geoQuery);
+    assert.isObject(found);
+
+    await models.Location.collection.dropIndexes();
+  });
+
+  it("decodes .visibility", async function() {
+    const item = new models.Location(testItem);
+    const sut = await item.save();
+
+    const sutVis = decodeLocationVisibility(sut.visibility);
+
+    assert.equal(sutVis.length, 4);
+    assert.notEqual(sutVis.indexOf(LocationVisibility.Hidden), -1);
+    assert.notEqual(sutVis.indexOf(LocationVisibility.Visible), -1);
+    assert.notEqual(sutVis.indexOf(LocationVisibility.CAD), -1);
+    assert.notEqual(sutVis.indexOf(LocationVisibility.Shared), -1);
+  });
+});

package/src/test/mail-log.ts

@@ -0,0 +1,51 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("MailLog", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.MailLog>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.mailLog;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.MailLog(testItem);
+    const sut = await item.save();
+
+    assert.isNotNull(testItem._id);
+    assert.equal(testItem.mailId, sut.mailId);
+    assert.equal(testItem.event, sut.event);
+    assert.equal(testItem.timestamp, sut.timestamp);
+    assert.equal(testItem.recipient, sut.recipient);
+    assert.equal(testItem.recipientDomain, sut.recipientDomain);
+    if (testItem.tags?.length) {
+      assert.equal(testItem.tags[0], sut.tags[0]);
+    } else {
+      assert.equal(testItem.tags?.length, 1);
+    }
+    assert.equal(testItem.deliveryStatus, sut.deliveryStatus);
+    assert.equal(testItem.message, sut.message);
+    assert.equal(testItem.deliveryStatus, sut.deliveryStatus);
+    assert.equal(testItem.flags, sut.flags);
+    assert.equal(testItem.envelope, sut.envelope);
+    assert.equal(testItem.logLevel, sut.logLevel);
+    assert.equal(testItem.reason, sut.reason);
+    assert.equal(testItem.severity, sut.severity);
+    const expectedDate = new Date().valueOf() / 1000.0;
+    const timeDelta = expectedDate - sut.modified_unix_date;
+    assert.isTrue(timeDelta < 1);
+  });
+});

package/src/test/managed-incident.ts

@@ -0,0 +1,116 @@
+import { assert } from "chai";
+import "mocha";
+import * as _ from "lodash";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("ManagedIncident", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.ManagedIncident>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.managedIncident;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.ManagedIncident(testItem);
+    const sut = await item.save();
+
+
+    assert.isNotNull(testItem._id);
+    assert.equal(sut.departmentId, testItem.departmentId);
+    assert.equal(sut.CallerNumber, testItem.CallerNumber);
+    assert.equal(sut.CommandChannel, testItem.CommandChannel);
+    assert.equal(sut.TacticalAltChannel, testItem.TacticalAltChannel);
+    assert.equal(sut.TacticalChannel, testItem.TacticalChannel);
+    assert.equal(sut.active, testItem.active);
+    assert.equal(sut.address, testItem.address);
+    assert.equal(sut.api_incident_number, testItem.api_incident_number);
+    assert.equal(sut.channel, testItem.channel);
+    assert.equal(sut.channel_owner, testItem.channel_owner);
+    assert.equal(sut.end_time, testItem.end_time);
+    assert.equal(sut.end_unix_time, testItem.end_unix_time);
+    assert.equal(sut.is_closed, testItem.is_closed);
+    assert.equal(sut.location, testItem.location);
+    assert.equal(sut.managed, testItem.managed);
+    assert.equal(sut.modified_date, testItem.modified_date);
+    assert.equal(sut.modified_unix_date, testItem.modified_unix_date);
+    assert.equal(sut.name, testItem.name);
+    assert.equal(sut.preference_location, testItem.preference_location);
+    assert.equal(sut.slave_map_changed, testItem.slave_map_changed);
+    assert.equal(sut.source, testItem.source);
+    assert.equal(sut.start_time, testItem.start_time);
+    assert.equal(sut.start_unix_time, testItem.start_unix_time);
+    assert.equal(sut.userId, testItem.userId);
+    assert.equal(sut.uuid, testItem.uuid);
+
+    assert.isTrue(sut.active);
+    assert.isTrue(sut.is_closed);
+
+    const unit = _.first(sut.units.filter((x) => x.UnitID === "M12"));
+    assert.equal(unit?.Personnel.length, 2);
+    const p1 = _.first(unit?.Personnel.filter((x) => x.PersonnelID === "X14"));
+    assert.equal(p1?.PersonnelName, "Mary Smith");
+    assert.equal(p1?.PersonnelNote, "X");
+    assert.equal(p1?.PersonnelRank, "Captain");
+    assert.equal(p1?.PersonnelWorkCode, "TRD");
+
+    // Share incident properties
+    assert.isArray(sut.ReportNumber);
+    assert.equal(sut.ReportNumber.length, 2);
+    const rna = _.first(sut.ReportNumber.filter((x) => x.name === "A"));
+    assert.isObject(rna);
+    assert.equal(rna?.number, "07-0351");
+    const rnb = _.first(sut.ReportNumber.filter((x) => x.name === "B"));
+    assert.isObject(rnb);
+    assert.equal(rnb?.number, "UM-02210");
+
+    assert.isArray(sut.radioChannels);
+    assert.equal(sut.radioChannels.length, 2);
+    const rca = _.first(sut.radioChannels.filter((x) => x.name === "CMD"));
+    assert.isObject(rca);
+    assert.equal(rca?.channel, "LOCAL Tone: 3");
+    assert.equal(rca?.url, "http://example.com/stream1");
+    const rcb = _.first(sut.radioChannels.filter((x) => x.name === "TAC"));
+    assert.isObject(rcb);
+    assert.equal(rcb?.channel, "CDF TAC 10");
+    assert.equal(rcb?.url, "http://example.com/stream2");
+
+    assert.isObject(sut.record);
+    assert.equal(sut.record.name, "John");
+    assert.equal(sut.record.value, "Smith");
+
+    assert.isObject(sut.sharedSource);
+    assert.equal(sut.sharedSource.isExternal, true);
+    assert.equal(sut.sharedSource.name, "Demo RTS Fire Department");
+    assert.isArray(sut.sharedSource.reasons);
+    assert.equal(sut.sharedSource.reasons.length, 1);
+    const ssr1 = _.first(sut.sharedSource.reasons);
+    assert.isObject(ssr1);
+    assert.equal(ssr1?.name, "Unit B10 assigned");
+    assert.equal(ssr1?.date.toISOString(), "2024-05-03T00:00:00.000Z");
+
+    assert.isArray(sut.sharedTo);
+    assert.equal(sut.sharedTo.length, 1);
+    const st1 = _.first(sut.sharedTo);
+    assert.equal(st1?.active, true);
+    assert.equal(st1?.departmentId, "5195426cc4e016a988000965");
+    assert.equal(st1?.expireAt.toISOString(), "2024-08-01T10:20:30.400Z");
+    assert.equal(st1?.name, "Test Fire Department");
+    assert.equal(st1?.startAt.toISOString(), "2024-05-01T01:02:03.040Z");
+    assert.equal(st1?.reasons.length, 1);
+    const str1 = _.first(st1?.reasons);
+    assert.equal(str1?.name, "Unit M10 assigned");
+    assert.equal(str1?.date.toISOString(), "2024-05-03T01:01:01.010Z");
+  });
+});

package/src/test/mark43-incident-retry.ts

@@ -0,0 +1,34 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("Mark43IncidentRetry", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.Mark43IncidentRetry>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.mark43IncidentRetry;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.Mark43IncidentRetry(testItem);
+    const sut = await item.save();
+
+    assert.isNotNull(sut._id);
+    assert.equal(testItem.departmentId, sut.departmentId);
+    assert.equal(testItem.active, sut.active);
+    assert.equal(testItem.mark43IncidentId, sut.mark43IncidentId);
+    assert.equal(JSON.stringify(testItem.retryPayload), JSON.stringify(sut.retryPayload));
+  });
+});

package/src/test/message.ts

@@ -0,0 +1,39 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("Message", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.Message>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.message;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.Message(testItem);
+    const sut = await item.save();
+
+    assert.isNotNull(testItem._id);
+    assert.equal(testItem.departmentId, sut.departmentId);
+    assert.equal(testItem.title, sut.title);
+    assert.equal(testItem.uuid, sut.uuid);
+    assert.equal(testItem.requestId, sut.requestId);
+    assert.equal(testItem.body, sut.body);
+    assert.equal(testItem.actionTitle, sut.actionTitle);
+    assert.equal(testItem.url, sut.url);
+    assert.equal(testItem.priority, sut.priority);
+    assert.equal(JSON.stringify(testItem.type), JSON.stringify(sut.type));
+  });
+});