tabletcommand-backend-models 7.3.29 → 7.3.30

package/src/models/incident-filter.ts

@@ -0,0 +1,122 @@
+import { Model } from "mongoose";
+import {
+  currentDate,
+  MongooseModule,
+} from "../helpers";
+
+import { IncidentFilterKind } from "../constants";
+import { GeoPolygon } from "../types/common";
+import { IncidentFilterOption, IncidentFilterType } from "../types/incident-filter";
+
+export interface IncidentFilter extends IncidentFilterType { }
+
+export default async function CADIncidentBlockModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+
+  const GeoPolygonSchema = new Schema<GeoPolygon>({
+    type: {
+      type: String,
+      enum: ["Polygon"],
+      required: true
+    },
+    coordinates: {
+      type: [[[Number]]], // Array of arrays of arrays of numbers number[][][]
+      required: true
+    },
+  }, {
+    _id: false,
+    id: false,
+  });
+
+  const IncidentFilterOptionSchema = new Schema<IncidentFilterOption>({
+    name: {
+      type: String,
+      default: "",
+    },
+    visible: {
+      type: Boolean,
+      default: true,
+    },
+    position: {
+      type: Number,
+      default: 1,
+    },
+    area: {
+      type: GeoPolygonSchema,
+      default: {
+        type: "Polygon",
+        coordinates: [],
+      }
+    },
+    value: {
+      type: String,
+      default: "",
+    },
+  }, {
+    _id: false,
+    id: false,
+  });
+
+  const modelSchema = new Schema<IncidentFilterType>({
+    _id: {
+      type: Schema.Types.ObjectId,
+      auto: true,
+    },
+    departmentId: {
+      type: String,
+      required: true,
+      index: true,
+    },
+
+    name: {
+      type: String,
+      default: "",
+      required: true,
+    },
+    position: {
+      type: Number,
+      default: 1,
+    },
+    kind: {
+      type: String,
+      enum: [
+        IncidentFilterKind.AgencyId,
+        IncidentFilterKind.AreaUnit,
+        IncidentFilterKind.City,
+        IncidentFilterKind.County,
+        IncidentFilterKind.ReportNumber,
+      ],
+    },
+    options: {
+      type: [IncidentFilterOptionSchema],
+      default: [],
+    },
+    createdAt: {
+      type: Date,
+      default: currentDate,
+    },
+    updatedAt: {
+      type: Date,
+      default: currentDate,
+    },
+  }, {
+    timestamps: true,
+    autoIndex: false,
+    toJSON: {
+      virtuals: true,
+      versionKey: false,
+    }
+  });
+
+  modelSchema.index({
+    departmentId: 1,
+    IncidentNumber: 1,
+  }, {
+    name: "departmentId_1_IncidentNumber_1_unique",
+    unique: true,
+  });
+
+  return mongoose.model<IncidentFilter>("IncidentFilter", modelSchema, "massive_incident_filter", { overwriteModels: true });
+}
+
+export interface IncidentFilterModel extends Model<IncidentFilter> { }

package/src/test/department.ts

@@ -98,17 +98,5 @@ describe("Department", function() {
     const callerResolver = sut.callerLocation.resolvers.find(() => true);
     assert.isObject(callerResolver);
     assert.equal(callerResolver?.type, m.AccountCallerType.Dummy);
-
-    const if1 = sut.incidentFilters.find(() => true);
-    assert.isObject(if1);
-    assert.equal(if1?.name, "Filter 1");
-    assert.equal(if1?.position, 12);
-    assert.equal(if1?.type, m.IncidentFilterType.AgencyId);
-    const if1o1 = if1?.options.find(() => true);
-    assert.equal(if1o1?.name, "Opt 1");
-    assert.equal(if1o1?.position, 10);
-    assert.equal(if1o1?.area?.type, "Polygon");
-    assert.equal(if1o1?.area?.coordinates.length, 1);
-    assert.equal(if1o1?.value, "P1");
   });
 });

package/src/test/incident-filter.ts

@@ -0,0 +1,41 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import { url } from "./config";
+import mockModule from "./mock";
+
+describe("IncidentFilter", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.IncidentFilter>;
+  beforeEach(async function() {
+    const c = await m.connect(url);
+    models = c.models;
+    mongoose = c.mongoose;
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.incidentFilterAgency;
+  });
+
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    assert.isObject(testItem);
+    const item = new models.IncidentFilter(testItem);
+    const sut = await item.save();
+
+    assert.equal(sut.name, testItem.name);
+    assert.equal(sut.position, testItem.position);
+    assert.equal(sut.kind, m.IncidentFilterKind.AgencyId);
+    assert.equal(sut.departmentId, testItem.departmentId);
+
+    const if1o1 = sut.options.find(() => true);
+    assert.equal(if1o1?.name, "Opt 1");
+    assert.equal(if1o1?.position, 10);
+    assert.equal(if1o1?.area?.type, "Polygon");
+    assert.equal(if1o1?.area?.coordinates.length, 1);
+    assert.equal(if1o1?.value, "P1");
+  });
+});

package/src/test/mock.ts

@@ -4,12 +4,13 @@ import * as uuid from "uuid";
 import { retrieveCurrentUnixTime } from "../helpers";
 import {
   AccountCallerType,
-  IncidentFilterType,
+  IncidentFilterKind,
   ShareIncidentRuleKind,
 } from "../constants";
 
 import { CADIncident } from "../models/cad-incident";
 import { Department } from "../models/department";
+import { IncidentFilter } from "models/incident-filter";
 import { ManagedIncident } from "../models/managed-incident";
 
 export default function mockModule(dependencies: { mongoose: Mongoose; }) {
@@ -689,25 +690,6 @@ export default function mockModule(dependencies: { mongoose: Mongoose; }) {
       new mongoose.Types.ObjectId(agency._id)
     ],
     signupKey: "A1B2",
-    incidentFilters: [
-      {
-        name: "Filter 1",
-        position: 12,
-        options: [
-          {
-            name: "Opt 1",
-            visible: false,
-            position: 10,
-            area: {
-              type: "Polygon",
-              coordinates: [[[0, 1], [1, 2], [2, 0]]],
-            },
-            value: "P1"
-          }
-        ],
-        type: IncidentFilterType.AgencyId,
-      }
-    ],
     incidentTypes: [{
       name: "Type",
       value: "type",
@@ -962,6 +944,25 @@ export default function mockModule(dependencies: { mongoose: Mongoose; }) {
     uuid: "ABCDEF"
   };
 
+  const incidentFilterAgency: Partial<IncidentFilter> = {
+    departmentId,
+    name: "Filter 1",
+    position: 12,
+    options: [
+      {
+        name: "Opt 1",
+        visible: false,
+        position: 10,
+        area: {
+          type: "Polygon",
+          coordinates: [[[0, 1], [1, 2], [2, 0]]],
+        },
+        value: "P1"
+      }
+    ],
+    kind: IncidentFilterKind.AgencyId,
+  };
+
   const incidentTakeover = {
     _id: new mongoose.Types.ObjectId(),
     incident_id: "i1234",
@@ -1456,6 +1457,7 @@ export default function mockModule(dependencies: { mongoose: Mongoose; }) {
     esri,
     gstMapping,
     incidentEvent,
+    incidentFilterAgency,
     incidentNotified,
     incidentTakeover,
     jobLog,

package/src/types/department.ts

@@ -5,10 +5,8 @@ import { PubNubTokenSchemaType } from "./pubnub-token";
 import {
   AccountCallerType,
   AccountIndustry,
-  IncidentFilterType,
 } from "../constants";
 import { ReportNumberSchemaType } from "./common-incident";
-import { GeoPolygon } from "./common";
 
 export interface WebhookProcessLocationConfigType {
   enabled: boolean,
@@ -424,21 +422,6 @@ export type AccountConfigurationCallerLocation = {
   resolvers: AccountConfigurationCallerLocationResolver[]
 };
 
-export type IncidentFilterOption = {
-  name: string,
-  visible: boolean,
-  position: number,
-  area: GeoPolygon,
-  value: string,
-};
-
-export type IncidentFilter = {
-  name: string,
-  position: number,
-  options: IncidentFilterOption[],
-  type: IncidentFilterType,
-};
-
 export interface DepartmentType {
   _id: Types.ObjectId,
   id?: string,
@@ -482,7 +465,6 @@ export interface DepartmentType {
   firstArrivingEnabled: boolean,
   forwarding: ForwardingConfigType,
   gst: GSTConfigType,
-  incidentFilters: IncidentFilter[],
   incidentReplay: IncidentReplayType,
   incidentTypes: IncidentTypeType[],
   incidentVehicleStatus: IncidentVehicleStatusConfigType,

package/src/types/incident-filter.ts

@@ -0,0 +1,25 @@
+import { Types } from "mongoose";
+import {
+  IncidentFilterKind,
+} from "../constants";
+import { GeoPolygon } from "./common";
+
+export type IncidentFilterOption = {
+  name: string,
+  visible: boolean,
+  position: number,
+  area: GeoPolygon,
+  value: string,
+};
+
+export interface IncidentFilterType {
+  _id: Types.ObjectId,
+  departmentId: string,
+  createdAt: Date,
+  updatedAt: Date,
+
+  name: string,
+  position: number,
+  kind: IncidentFilterKind,
+  options: IncidentFilterOption[],
+}