tabletcommand-backend-models 5.37.4 → 5.37.6

package/src/models/schema/cad-incident.ts

@@ -11,13 +11,16 @@ import {
 import * as uuid from "uuid";
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
 import { IncidentEventSchema } from "../incident-event";
-import ReportNumberModule from "./report-number";
+import {
+  CADPersonSchema,
+  RadioChannelSchema,
+  RecordSchema,
+  ReportNumberSchema,
+  SharedSourceSchema,
+  SharedToSchema,
+} from "./shared-incident";
 
 export function CADIncidentSchema(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
-  const IncidentEvent = IncidentEventSchema(mongoose);
-  const ReportNumber = ReportNumberModule(mongoose);
-
   const toJSONOpts = {
     versionKey: false,
     transform(doc: DocumentTypeFromSchema<typeof modelSchema>, ret: FieldsOfDocument<DocumentTypeFromSchema<typeof modelSchema>>) {
@@ -25,6 +28,23 @@ export function CADIncidentSchema(mongoose: MongooseModule) {
     },
   };
 
+  const { Schema, Types } = mongoose;
+  const IncidentEvent = IncidentEventSchema(mongoose);
+
+  // Share incident properties - copy to managed incidents
+  const CADPerson = CADPersonSchema(mongoose);
+  CADPerson.set("toJSON", toJSONOpts);
+  const RadioChannel = RadioChannelSchema(mongoose);
+  RadioChannel.set("toJSON", toJSONOpts);
+  const RecordValue = RecordSchema(mongoose);
+  RecordValue.set("toJSON", toJSONOpts);
+  const ReportNumber = ReportNumberSchema(mongoose);
+  ReportNumber.set("toJSON", toJSONOpts);
+  const SharedSource = SharedSourceSchema(mongoose);
+  SharedSource.set("toJSON", toJSONOpts);
+  const SharedTo = SharedToSchema(mongoose);
+  SharedTo.set("toJSON", toJSONOpts);
+
   // Currently, supporting type: "ack", item: "knife"
   const CADCommentOpts = createSchema(Schema, {
     type: {
@@ -62,28 +82,6 @@ export function CADIncidentSchema(mongoose: MongooseModule) {
   });
   CADComment.set("toJSON", toJSONOpts);
 
-  const CADPerson = createSchema(Schema, {
-    PersonnelID: {
-      type: String,
-    },
-    PersonnelName: {
-      type: String,
-    },
-    PersonnelRank: {
-      type: String,
-    },
-    PersonnelWorkCode: {
-      type: String,
-    },
-    PersonnelNote: {
-      type: String,
-    },
-  }, {
-    _id: false,
-    id: false,
-  });
-  CADPerson.set("toJSON", toJSONOpts);
-
   const CADUnit = createSchema(Schema, {
     UnitID: {
       type: String,
@@ -182,116 +180,6 @@ export function CADIncidentSchema(mongoose: MongooseModule) {
   });
   CADPriorIncident.set("toJSON", toJSONOpts);
 
-  const RadioChannel = createSchema(Schema, {
-    name: {
-      type: String,
-      default: "",
-    },
-    channel: {
-      type: String,
-      default: "",
-    },
-    url: {
-      type: String,
-      default: "",
-    },
-  }, {
-    _id: false,
-    id: false,
-  });
-  RadioChannel.set("toJSON", toJSONOpts);
-
-  const RecordValue = createSchema(Schema, {
-    name: {
-      type: String,
-      default: "",
-    },
-    value: {
-      type: String,
-      default: "",
-    },
-  }, {
-    _id: false,
-    id: false,
-  });
-  RecordValue.set("toJSON", toJSONOpts);
-
-  const ShareReason = createSchema(Schema, {
-    name: {
-      type: String,
-      default: "",
-    },
-    date: {
-      type: Date,
-      default: currentDate,
-    },
-  }, {
-    _id: false,
-    id: false,
-  });
-  ShareReason.set("toJSON", toJSONOpts);
-
-  const SharedTo = createSchema(Schema, {
-    departmentId: {
-      type: String,
-      default: "",
-    },
-    // Department Name
-    name: {
-      type: String,
-      default: "",
-    },
-    startAt: {
-      type: Date,
-      default: currentDate,
-    },
-    expireAt: {
-      type: Date,
-      default: currentDate,
-    },
-    active: {
-      type: Boolean,
-      default: true, // overwritten later, when expireAt is older than now
-    },
-    reasons: {
-      type: [ShareReason],
-      default: [],
-    }
-  }, {
-    _id: false,
-    id: false,
-  });
-  SharedTo.set("toJSON", toJSONOpts);
-
-  const SharedSource = createSchema(Schema, {
-    // Department Name (always matches record .departmentId)
-    name: {
-      type: String,
-      default: "",
-    },
-    // Output overwritten by backend when record is included in another department's list
-    isExternal: {
-      type: Boolean,
-      default: false,
-    },
-
-    // Output will be overwritten by backend
-    startAt: {
-      type: Date,
-    },
-    expireAt: {
-      type: Date,
-    },
-    reasons: {
-      type: [ShareReason],
-      default: [],
-    }
-  }, {
-    _id: false,
-    id: false,
-  });
-  SharedSource.set("toJSON", toJSONOpts);
-
   // Main schema
   const modelSchema = createSchema(Schema, {
     _id: {

package/src/models/schema/shared-incident.ts

@@ -0,0 +1,217 @@
+import {
+  MongooseModule,
+  createSchema,
+  currentDate,
+} from "../../helpers";
+
+// Properties shared between CAD and Managed Incident
+// They are copied on iOS
+
+export function CADPersonSchema(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+
+  const Person = createSchema(Schema, {
+    PersonnelID: {
+      type: String,
+    },
+    PersonnelName: {
+      type: String,
+    },
+    PersonnelRank: {
+      type: String,
+      default: ""
+    },
+    PersonnelWorkCode: {
+      type: String,
+      default: ""
+    },
+    PersonnelNote: {
+      type: String,
+      default: ""
+    },
+  }, {
+    _id: false,
+    id: false,
+  });
+
+  return Person;
+}
+
+export function RadioChannelSchema(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+
+  const RadioChannel = createSchema(Schema, {
+    name: {
+      type: String,
+      default: "",
+    },
+    channel: {
+      type: String,
+      default: "",
+    },
+    url: {
+      type: String,
+      default: "",
+    },
+    channelDescription: {
+      type: String,
+      default: "",
+    },
+  }, {
+    _id: false,
+    id: false,
+    toJSON: {
+      versionKey: false,
+    }
+  });
+
+  return RadioChannel;
+}
+
+export function RecordSchema(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+
+  const Record = createSchema(Schema, {
+    name: {
+      type: String,
+      default: ""
+    },
+    value: {
+      type: String,
+      default: "",
+    },
+  }, {
+    _id: false,
+    id: false,
+    toJSON: {
+      versionKey: false,
+    }
+  });
+
+  return Record;
+}
+
+export function ReportNumberSchema(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+
+  const ReportNumber = createSchema(Schema, {
+    name: {
+      type: String,
+      default: "",
+    },
+    number: {
+      type: String,
+      default: "",
+    },
+  }, {
+    _id: false,
+    id: false,
+    toJSON: {
+      versionKey: false,
+    }
+  });
+
+  return ReportNumber;
+}
+
+export function ShareReasonSchema(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+
+  const ShareReason = createSchema(Schema, {
+    name: {
+      type: String,
+      default: "",
+    },
+    date: {
+      type: Date,
+      default: currentDate,
+    },
+  }, {
+    _id: false,
+    id: false,
+    toJSON: {
+      versionKey: false,
+    },
+  });
+
+  return ShareReason;
+}
+
+export function SharedToSchema(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+  const ShareReason = ShareReasonSchema(mongoose);
+
+  const SharedTo = createSchema(Schema, {
+    departmentId: {
+      type: String,
+      default: "",
+    },
+    // Department Name
+    name: {
+      type: String,
+      default: "",
+    },
+    startAt: {
+      type: Date,
+      default: currentDate,
+    },
+    expireAt: {
+      type: Date,
+      default: currentDate,
+    },
+    active: {
+      type: Boolean,
+      default: true, // overwritten later, when expireAt is older than now
+    },
+    reasons: {
+      type: [ShareReason],
+      default: [],
+    }
+  }, {
+    _id: false,
+    id: false,
+    toJSON: {
+      versionKey: false,
+    }
+  });
+
+  return SharedTo;
+}
+
+export function SharedSourceSchema(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+  const ShareReason = ShareReasonSchema(mongoose);
+
+  const SharedSource = createSchema(Schema, {
+    // Department Name (always matches record .departmentId)
+    name: {
+      type: String,
+      default: "",
+    },
+    // Output overwritten by backend when record is included in another department's list
+    isExternal: {
+      type: Boolean,
+      default: false,
+    },
+
+    // Output will be overwritten by backend
+    startAt: {
+      type: Date,
+    },
+    expireAt: {
+      type: Date,
+    },
+    reasons: {
+      type: [ShareReason],
+      default: [],
+    }
+  }, {
+    _id: false,
+    id: false,
+    toJSON: {
+      versionKey: false,
+    }
+  });
+
+  return SharedSource;
+}

package/test/cad-incident-block.js

@@ -0,0 +1,44 @@
+"use strict";
+
+const _ = require("lodash");
+const assert = require("chai").assert;
+
+const m = require("..");
+const config = require("./config");
+
+describe("CADIncidentBlock", function() {
+  let models, mongoose;
+  let testItem;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = require("./mock")({
+      mongoose
+    });
+    testItem = mock.cadIncidentBlock;
+    await mock.beforeEach();
+  });
+  afterEach(function() {
+    mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.CADIncidentBlock(testItem);
+    const sut = await item.save();
+
+    assert.isNotNull(testItem._id);
+    assert.equal(sut.EntryDateTime, testItem.EntryDateTime);
+    assert.equal(sut.ClosedDateTime, testItem.ClosedDateTime);
+    assert.equal(sut.source, testItem.source);
+    assert.equal(sut.IncidentNumber, testItem.IncidentNumber);
+    assert.equal(sut.departmentId, testItem.departmentId);
+    assert.equal(sut.AgencyIncidentCallTypeDescription, testItem.AgencyIncidentCallTypeDescription);
+    assert.equal(sut.createdAt.toISOString(), new Date(testItem.createdAt).toISOString());
+    assert.equal(sut.ReportNumber.length, 1);
+    const rn = _.first(sut.ReportNumber);
+    assert.equal(rn.name, "Incident");
+    assert.equal(rn.number, "CA68");
+  });
+});

package/test/cad-incident.js

@@ -1,5 +1,6 @@
 "use strict";
 
+const _ = require("lodash");
 const assert = require("chai").assert;
 
 const m = require("..");
@@ -81,11 +82,67 @@ describe("CADIncident", function() {
     assert.equal(sut.units[0].UnitDispatchNumber, testItem.units[0].UnitDispatchNumber);
     assert.equal(sut.units[0].UnitID, testItem.units[0].UnitID);
     assert.equal(sut.units[0].TimeDispatched, testItem.units[0].TimeDispatched);
+    
+    const unit = _.first(sut.units.filter((x) => x.UnitID === "MA31"));
+    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");
 
     assert.equal(sut.Comment.length, 1);
     assert.equal(sut.Comment[0].Comment, testItem.Comment[0].Comment);
     assert.equal(sut.Comment[0].CommentSource, testItem.Comment[0].CommentSource);
     assert.equal(sut.Comment[0].CommentDateTime, testItem.Comment[0].CommentDateTime);
+
+    // 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");
   });
 
   it("no virtuals id if _id not present", async function() {

package/test/managed-incident.js

@@ -1,5 +1,6 @@
 "use strict";
 
+const _ = require("lodash");
 const assert = require("chai").assert;
 
 const m = require("..");
@@ -57,6 +58,62 @@ describe("ManagedIncident", function() {
       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");
+
       return done();
     });
   });