tabletcommand-backend-models 7.4.61 → 7.4.63

package/src/models/checklist-item.ts

@@ -59,7 +59,15 @@ export function ChecklistItemSchema(mongoose: MongooseModule) {
     description: {
       type: String,
       default: ""
-    }
+    },
+    neris_benchmark: {
+      type: String,
+      default: "",
+    },
+    send_to_cad: {
+      type: Boolean,
+      default: false,
+    },
   }, {
     autoIndex: false,
   });

package/src/models/department.ts

@@ -15,6 +15,7 @@ import {
 import ColorModule from "./schema/color";
 import { ReportNumberSchema } from "./schema/common-incident";
 import { GeoPolygonSchema } from "./schema/geojson";
+import { FireMapperAuthV2Schema } from "./schema/firemapper-auth";
 import PubNubTokenSchema from "./schema/pubnub-token";
 import { WebhookSchema } from "./schema/webhook";
 import { WSFeedSchema } from "./schema/ws-feed";
@@ -143,7 +144,7 @@ export const IntterraFieldsDefault = [
 
 // If any of the following fields are updated/added/deleted,
 // make sure to update the database records, before/after release (script/query)
-export const FireMapperConfigurationDefault = {
+export const FireMapperConfigurationDefault: FireMapperConfigurationType = {
   enabled: false,
   layerRefreshInterval: 15,
   proLicenseCount: 0,
@@ -175,6 +176,12 @@ export const FireMapperConfigurationDefault = {
     },
   ],
   staticLayer: [],
+  auth: {
+    username: "",
+    apiKeyManagement: undefined,
+    apiKeyReadOnly: undefined,
+    licenseCode: undefined
+  }
 };
 
 export const LicensingDefault = {
@@ -544,6 +551,7 @@ export default async function DepartmentModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
   const Color = ColorModule(mongoose);
+  const FireMapperAuth = FireMapperAuthV2Schema(mongoose);
   const GeoPolygon = GeoPolygonSchema(mongoose);
   const PubNubToken = PubNubTokenSchema(mongoose);
   const ReportNumber = ReportNumberSchema(mongoose);
@@ -1412,6 +1420,12 @@ export default async function DepartmentModule(mongoose: MongooseModule) {
       type: [FireMapperOutline],
       default: [],
     },
+
+    // Auth
+    auth: {
+      type: FireMapperAuth,
+      default: {},
+    },
   }, {
     _id: false,
     id: false,

package/src/models/esri.ts

@@ -6,7 +6,9 @@ import {
 import EsriAuthModule from "./schema/esri-auth";
 import EsriErrorModule from "./schema/esri-error";
 import EsriMapModule from "./schema/esri-map";
-import FireMapperAuthModule from "./schema/firemapper-auth";
+import {
+  FireMapperAuthSchema,
+} from "./schema/firemapper-auth";
 import { EsriType, MapPropertiesType } from "../types/esri";
 
 export interface Esri extends EsriType { }
@@ -16,7 +18,7 @@ export function EsriSchema(mongoose: MongooseModule) {
   const EsriAuth = EsriAuthModule(mongoose);
   const EsriError = EsriErrorModule(mongoose);
   const EsriMap = EsriMapModule(mongoose);
-  const FireMapperAuth = FireMapperAuthModule(mongoose);
+  const FireMapperAuth = FireMapperAuthSchema(mongoose);
 
   const MapProperties = new Schema<MapPropertiesType>({
     // ArcGIS Item id

package/src/models/managed-incident.ts

@@ -342,6 +342,18 @@ export default async function ManagedIncidentModule(mongoose: MongooseModule) {
     id: {
       type: String,
     },
+    neris_benchmark: {
+      type: String,
+      default: "",
+    },
+    send_to_cad: {
+      type: Boolean,
+      default: false,
+    },
+    checked_at: {
+      type: String,
+      default: "",
+    },
   }, {
     _id: false,
     id: false,

package/src/models/schema/firemapper-auth.ts

@@ -2,12 +2,15 @@ import {
   MongooseModule,
 } from "../../helpers";
 import { EncryptedDataType } from "../../types/common";
-import { FireMapperAuthType } from "../../types/firemapper-auth";
+import {
+  FireMapperAuthType,
+  FireMapperAuthV2Type,
+} from "../../types/firemapper-auth";
 
-export default function FireMapperAuthSchema(mongoose: MongooseModule) {
+export function FireMapperAuthSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const FireMapperEncrypted = new Schema<EncryptedDataType>({
+  const EncryptedData = new Schema<EncryptedDataType>({
     iv: {
       type: String,
       default: "",
@@ -27,11 +30,53 @@ export default function FireMapperAuthSchema(mongoose: MongooseModule) {
       default: "",
     },
     encrypted: {
-      type: FireMapperEncrypted,
+      type: EncryptedData,
       default: null,
     },
     encryptedAccessCode: {
-      type: FireMapperEncrypted,
+      type: EncryptedData,
+      default: null,
+    },
+  }, {
+    _id: false,
+    id: false,
+  });
+
+  return FireMapperAuth;
+}
+
+export function FireMapperAuthV2Schema(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+
+  const EncryptedData = new Schema<EncryptedDataType>({
+    iv: {
+      type: String,
+      default: "",
+    },
+    encryptedData: {
+      type: String,
+      default: "",
+    },
+  }, {
+    _id: false,
+    id: false,
+  });
+
+  const FireMapperAuth = new Schema<FireMapperAuthV2Type>({
+    username: {
+      type: String,
+      default: "",
+    },
+    apiKeyReadOnly: {
+      type: EncryptedData,
+      default: null,
+    },
+    apiKeyManagement: {
+      type: EncryptedData,
+      default: null,
+    },
+    licenseCode: {
+      type: EncryptedData,
       default: null,
     },
   }, {

package/src/models/user.ts

@@ -120,6 +120,11 @@ export function UserSchema(mongoose: MongooseModule) {
       default: false,
     },
 
+    canBlockIncidents: {
+      type: Boolean,
+      default: false,
+    },
+
     beaconEnabled: {
       type: Boolean,
       default: false,

package/src/test/checklist-item.ts

@@ -36,6 +36,8 @@ describe("ChecklistItem", function() {
     assert.equal(testItem.api_checklist_id, sut.api_checklist_id);
     assert.equal(testItem.checklist_uuid, sut.checklist_uuid);
     assert.equal(testItem.description, sut.description);
+    assert.equal(sut.neris_benchmark, "");
+    assert.equal(sut.send_to_cad, false);
     const expectedDate = new Date().valueOf() / 1000.0;
     const timeDelta = expectedDate - sut.modified_unix_date;
     assert.isTrue(timeDelta < 1);

package/src/test/department.ts

@@ -39,56 +39,22 @@ describe("Department", function() {
     await models.Department.findOne({ _id: testItem._id }).lean();
     assert.isNotNull(sut._id);
     assert.isNotNull(sut.id);
-    assert.equal(sut.department, testItem.department);
     assert.equal(sut.addressDetails.city, testItem.addressDetails?.city);
     assert.isTrue(sut.active);
-    assert.equal(sut.apikey, testItem.apikey);
-    assert.equal(sut.partialApiKey, testItem.partialApiKey);
-    assert.isTrue(sut.personnelStaffingEnabled);
-    assert.isTrue(sut.rtsEnabled);
-    assert.equal(sut.rtsChannelPrefix, testItem.rtsChannelPrefix);
-    assert.equal(sut.pubNubV3.token, testItem.pubNubV3?.token);
-    assert.equal(sut.pubNubV3.expireAt.toISOString(), testItem.pubNubV3?.expireAt.toISOString());
-    assert.equal(sut.pubNubV3.runAt.toISOString(), testItem.pubNubV3?.runAt.toISOString());
-    assert.equal(sut.pubNubV3.env, testItem.pubNubV3?.env);
-    assert.equal(sut.signupKey, testItem.signupKey);
-    assert.equal(sut.incidentTypes.length, 1);
+    assert.equal(sut.accountType, testItem.accountType);
     assert.equal(sut.agencyIds.length, 1);
     if (testItem.agencyIds?.length) {
       assert.equal(sut.agencyIds[0], testItem.agencyIds[0]);
     } else {
       assert.equal(testItem.agencyIds?.length, 1);
     }
-    assert.equal(sut.safetyPriorityKeywords.length, 3);
-    if (testItem.incidentTypes?.length) {
-      assert.equal(sut.incidentTypes[0]?.name, testItem.incidentTypes[0]?.name);
-    } else {
-      assert.equal(testItem.incidentTypes?.length, 1);
-    }
-    assert.isFalse(sut.shareLocationPhones);
-    assert.isTrue(sut.shareLocationTablets);
+    assert.equal(sut.apikey, testItem.apikey);
     assert.isFalse(sut.cadOneWayVehiclesEnabled);
     assert.isFalse(sut.cadGetLocationEnabled);
-    assert.isTrue(sut.mowsEnabled);
-    assert.isTrue(sut.shareAVL.enabled);
-    assert.equal(sut.shareAVL.opAreaCode, testItem.shareAVL?.opAreaCode);
-    assert.equal(sut.shareAVL.opAreaName, testItem.shareAVL?.opAreaName);
-    assert.equal(sut.accountType, testItem.accountType);
-    assert.equal(sut.timeZone, testItem.timeZone);
-    assert.equal(sut.firstArrivingEnabled, testItem.firstArrivingEnabled);
-    assert.equal(sut.simpleSense.token, testItem.simpleSense?.token);
-    assert.equal(sut.firstArriving.token, testItem.firstArriving?.token);
-    assert.equal(sut.simpleSenseEnabled, testItem.simpleSenseEnabled);
-    assert.equal(sut.webDisclaimer.message, testItem.webDisclaimer?.message);
-    assert.equal(sut.webDisclaimer.enabled, testItem.webDisclaimer?.enabled);
-    assert.equal(JSON.stringify(sut.licensing), JSON.stringify(testItem.licensing));
-    assert.equal(sut.externalNotificationsEnabled, testItem.externalNotificationsEnabled);
-    assert.equal(sut.notificationEmails.length, testItem.notificationEmails?.length);
-    assert.equal(sut.restrictedComments.callTypesAllowed.length, testItem.restrictedComments?.callTypesAllowed.length);
-    assert.equal(sut.restrictedComments.statusesAllowed.length, testItem.restrictedComments?.statusesAllowed.length);
-    assert.equal(sut.restrictedComments.restrictedFields.length, testItem.restrictedComments?.restrictedFields.length);
-    assert.equal(sut.restrictedComments.restrictedMessage, testItem.restrictedComments?.restrictedMessage);
-    assert.equal(sut.restrictedComments.enabled, testItem.restrictedComments?.enabled);
+    assert.equal(sut.callerLocation.enabled, testItem.callerLocation?.enabled);
+    const callerResolver = sut.callerLocation.resolvers.find(() => true);
+    assert.isObject(callerResolver);
+    assert.equal(callerResolver?.type, m.AccountCallerType.Dummy);
     if (testItem.customButtons?.length) {
       assert.equal(sut.customButtons[0]?.name, testItem.customButtons[0]?.name);
       assert.equal(sut.customButtons[0]?.url, testItem.customButtons[0]?.url);
@@ -100,15 +66,72 @@ describe("Department", function() {
     } else {
       assert.equal(testItem.customButtons?.length, 1);
     }
-    assert.equal(sut.reportNumberEnabled, testItem.reportNumberEnabled);
-    assert.equal(JSON.stringify(sut.samsara), JSON.stringify(testItem.samsara));
-    assert.equal(sut.reportOdometer, "status");
+    assert.equal(sut.department, testItem.department);
+    assert.equal(sut.externalNotificationsEnabled, testItem.externalNotificationsEnabled);
+    assert.isTrue(sut.fireMapper.enabled);
+    assert.equal(sut.fireMapper?.auth?.username, testItem.fireMapper?.auth?.username);
+    assert.equal(sut.fireMapper?.auth?.apiKeyManagement?.encryptedData, testItem.fireMapper?.auth?.apiKeyManagement?.encryptedData);
+    assert.equal(sut.fireMapper?.auth?.apiKeyManagement?.iv, testItem.fireMapper?.auth?.apiKeyManagement?.iv);
+    assert.equal(sut.fireMapper?.auth?.apiKeyReadOnly?.encryptedData, testItem.fireMapper?.auth?.apiKeyReadOnly?.encryptedData);
+    assert.equal(sut.fireMapper?.auth?.apiKeyReadOnly?.iv, testItem.fireMapper?.auth?.apiKeyReadOnly?.iv);
+    assert.equal(sut.fireMapper?.auth?.licenseCode?.encryptedData, testItem.fireMapper?.auth?.licenseCode?.encryptedData);
+    assert.equal(sut.fireMapper?.auth?.licenseCode?.iv, testItem.fireMapper?.auth?.licenseCode?.iv);
+    assert.equal(sut.fireMapper.layerRefreshInterval, testItem.fireMapper?.layerRefreshInterval);
+    assert.equal(sut.fireMapper?.layer?.length, 1);
+    const fmLayer = sut.fireMapper?.layer?.find(() => true);
+    assert.isObject(fmLayer);
+    assert.equal(fmLayer?.name, "abc");
+    assert.equal(fmLayer?.pathname, "/a/b/c");
+    assert.equal(sut.fireMapper.proLicenseCount, testItem.fireMapper?.proLicenseCount);
+    assert.equal(sut.fireMapper?.staticLayer?.length, 1);
+    const stLayer = sut.fireMapper?.staticLayer?.find(() => true);
+    assert.isObject(stLayer);
+    assert.equal(stLayer?.uuid, "u1");
+    const stLayer1 = stLayer?.layer?.find(() => true);
+    assert.isObject(stLayer1);
+    assert.equal(stLayer1?.name, "sa");
+    assert.equal(stLayer1?.pathname, "s/a/b");
+    assert.equal(sut.firstArrivingEnabled, testItem.firstArrivingEnabled);
+    assert.equal(sut.firstArriving.token, testItem.firstArriving?.token);
+    assert.equal(sut.incidentTypes.length, 1);
+    if (testItem.incidentTypes?.length) {
+      assert.equal(sut.incidentTypes[0]?.name, testItem.incidentTypes[0]?.name);
+    } else {
+      assert.equal(testItem.incidentTypes?.length, 1);
+    }
+    assert.equal(JSON.stringify(sut.licensing), JSON.stringify(testItem.licensing));
+    assert.equal(sut.notificationEmails.length, testItem.notificationEmails?.length);
+    assert.isTrue(sut.mowsEnabled);
     assert.equal(sut.orientationMarkerColor.text, testItem.orientationMarkerColor?.text);
     assert.equal(sut.orientationMarkerColor.background, testItem.orientationMarkerColor?.background);
-    assert.equal(sut.callerLocation.enabled, testItem.callerLocation?.enabled);
-    const callerResolver = sut.callerLocation.resolvers.find(() => true);
-    assert.isObject(callerResolver);
-    assert.equal(callerResolver?.type, m.AccountCallerType.Dummy);
+    assert.equal(sut.partialApiKey, testItem.partialApiKey);
+    assert.isTrue(sut.personnelStaffingEnabled);
+    assert.equal(sut.pubNubV3.token, testItem.pubNubV3?.token);
+    assert.equal(sut.pubNubV3.expireAt.toISOString(), testItem.pubNubV3?.expireAt.toISOString());
+    assert.equal(sut.pubNubV3.runAt.toISOString(), testItem.pubNubV3?.runAt.toISOString());
+    assert.equal(sut.pubNubV3.env, testItem.pubNubV3?.env);
+    assert.equal(sut.restrictedComments.callTypesAllowed.length, testItem.restrictedComments?.callTypesAllowed.length);
+    assert.equal(sut.restrictedComments.statusesAllowed.length, testItem.restrictedComments?.statusesAllowed.length);
+    assert.equal(sut.restrictedComments.restrictedFields.length, testItem.restrictedComments?.restrictedFields.length);
+    assert.equal(sut.restrictedComments.restrictedMessage, testItem.restrictedComments?.restrictedMessage);
+    assert.equal(sut.restrictedComments.enabled, testItem.restrictedComments?.enabled);
+    assert.equal(sut.reportOdometer, "status");
+    assert.equal(sut.reportNumberEnabled, testItem.reportNumberEnabled);
+    assert.isTrue(sut.rtsEnabled);
+    assert.equal(sut.rtsChannelPrefix, testItem.rtsChannelPrefix);
+    assert.equal(sut.safetyPriorityKeywords.length, 3);
+    assert.equal(JSON.stringify(sut.samsara), JSON.stringify(testItem.samsara));
+    assert.equal(sut.signupKey, testItem.signupKey);
+    assert.isFalse(sut.shareLocationPhones);
+    assert.isTrue(sut.shareLocationTablets);
+    assert.isTrue(sut.shareAVL.enabled);
+    assert.equal(sut.shareAVL.opAreaCode, testItem.shareAVL?.opAreaCode);
+    assert.equal(sut.shareAVL.opAreaName, testItem.shareAVL?.opAreaName);
+    assert.equal(sut.simpleSense.token, testItem.simpleSense?.token);
+    assert.equal(sut.simpleSenseEnabled, testItem.simpleSenseEnabled);
+    assert.equal(sut.timeZone, testItem.timeZone);
+    assert.equal(sut.webDisclaimer.message, testItem.webDisclaimer?.message);
+    assert.equal(sut.webDisclaimer.enabled, testItem.webDisclaimer?.enabled);
   });
 
   it("saves SOAP forwarding connection properties", async function() {
@@ -141,10 +164,12 @@ describe("Department", function() {
       }
     };
 
-    const testItemWithForwarding = testItem as m.Department;
-    testItemWithForwarding.forwarding = {
-      enabled: true,
-      connections: [soapConnection]
+    const testItemWithForwarding: Partial<m.Department> = {
+      ...testItem,
+      forwarding: {
+        enabled: true,
+        connections: [soapConnection]
+      }
     };
 
     const item = new models.Department(testItemWithForwarding);
@@ -162,7 +187,7 @@ describe("Department", function() {
     assert.equal(connection.customHeaders.get("SOAPAction"), "SubmitIncident");
   });
 
-  it("saves rules v2", async function() {
+  it("saves shareIncident.rulesV2", async function() {
     const item = new models.Department(testItem);
     const sut = await item.save();
     assert.deepEqual(sut.shareIncident.rulesV2, []);

package/src/test/mock.ts

@@ -325,6 +325,8 @@ export default function mockModule(dependencies: { mongoose: Mongoose; }) {
     description: "Testing Description",
     modified_date: "",
     modified_unix_date: retrieveCurrentUnixTime(),
+    neris_benchmark: "",
+    send_to_cad: false,
   };
 
   const checklist = {
@@ -700,7 +702,8 @@ export default function mockModule(dependencies: { mongoose: Mongoose; }) {
 
   const department: Partial<Department> = {
     _id: new mongoose.Types.ObjectId(),
-    department: "Test Department",
+    accountType: "production",
+    active: true,
     addressDetails: {
       city: "San Francisco",
       address: "",
@@ -708,50 +711,86 @@ export default function mockModule(dependencies: { mongoose: Mongoose; }) {
       zipCode: "",
       country: "",
     },
-    active: true,
-    apikey: "abcd",
-    partialApiKey: "ab",
-    personnelStaffingEnabled: true,
-    rtsEnabled: true,
-    rtsChannelPrefix: "CH_TEST",
-    pubNubV3: {
-      token: "CH_AUTH_TOKEN",
-      expireAt: new Date("2021-09-10T23:25:02.196Z"),
-      runAt: new Date("2021-09-10T08:25:02.196Z"),
-      env: "qa",
-    },
     agencyIds: [
       new mongoose.Types.ObjectId(agency._id)
     ],
-    signupKey: "A1B2",
-    incidentTypes: [{
-      name: "Type",
-      value: "type",
-      allowPartialMatch: true,
-      callTypeDescription: [],
-      callType: [],
-    }],
-    shareLocationPhones: false,
-    shareLocationTablets: true,
+    apikey: "abcd",
     cadOneWayVehiclesEnabled: false,
-    mowsEnabled: true,
-    shareAVL: {
+    callerLocation: {
       enabled: true,
-      opAreaCode: "DAL",
-      opAreaName: "Delta Operations",
-      fadeZoomLevel: 1,
+      resolvers: [
+        {
+          type: AccountCallerType.Dummy,
+          opts: {},
+        }
+      ]
+    },
+    customButtons: [
+      {
+        name: "Button Custom",
+        url: "",
+        order: 1,
+        allowExternal: false,
+        defaultExternal: false,
+        allowFloating: false,
+        color: {
+          background: "#512e5f",
+          text: "#F8F9F9"
+        }
+      }
+    ],
+    department: "Test Department",
+    externalNotificationsEnabled: true,
+    fireMapper: {
+      enabled: true,
+      auth: {
+        username: "fm-user",
+        apiKeyManagement: {
+          iv: "iv-mgm",
+          encryptedData: "encrypted-nt",
+        },
+        apiKeyReadOnly: {
+          iv: "iv-read-only",
+          encryptedData: "encrypted-read-only",
+        },
+        licenseCode: {
+          iv: "iv-license",
+          encryptedData: "encrypted-license",
+        },
+      },
+      host: "",
+      layer: [
+        {
+          pathname: "/a/b/c",
+          name: "abc",
+        },
+      ],
+      layerRefreshInterval: 10,
+      proLicenseCount: 20,
+      staticLayer: [
+        {
+          uuid: "u1",
+          layer: [
+            {
+              name: "sa",
+              pathname: "s/a/b",
+            }
+          ]
+        }
+      ],
     },
-    accountType: "production",
-    timeZone: "America/Los_Angeles",
     firstArrivingEnabled: true,
     firstArriving: {
       token: "123",
       apiUrl: "",
     },
-    simpleSenseEnabled: true,
-    simpleSense: {
-      token: "123"
-    },
+    incidentTypes: [{
+      name: "Type",
+      value: "type",
+      allowPartialMatch: true,
+      callTypeDescription: [],
+      callType: [],
+    }],
     licensing: {
       tcPro2Way: 0,
       tcPro1Way: 0,
@@ -761,16 +800,21 @@ export default function mockModule(dependencies: { mongoose: Mongoose; }) {
       sendToCAD: 0,
       tcStreams: 0,
     },
-    webDisclaimer: {
-      message: "test",
-      enabled: true
-    },
+    mowsEnabled: true,
     notificationEmails: ["test@test.com"],
-    externalNotificationsEnabled: true,
     orientationMarkerColor: {
       text: "a",
       background: "b",
     },
+    partialApiKey: "ab",
+    personnelStaffingEnabled: true,
+    pubNubV3: {
+      token: "CH_AUTH_TOKEN",
+      expireAt: new Date("2021-09-10T23:25:02.196Z"),
+      runAt: new Date("2021-09-10T08:25:02.196Z"),
+      env: "qa",
+    },
+    reportNumberEnabled: true,
     restrictedComments: {
       enabled: false,
       callTypesAllowed: [],
@@ -778,35 +822,31 @@ export default function mockModule(dependencies: { mongoose: Mongoose; }) {
       restrictedFields: [],
       restrictedMessage: "Restricted Message"
     },
-    customButtons: [
-      {
-        name: "Button Custom",
-        url: "",
-        order: 1,
-        allowExternal: false,
-        defaultExternal: false,
-        allowFloating: false,
-        color: {
-          background: "#512e5f",
-          text: "#F8F9F9"
-        }
-      }
-    ],
-    reportNumberEnabled: true,
+    rtsEnabled: true,
+    rtsChannelPrefix: "CH_TEST",
     samsara: {
       enabled: false,
       token: "",
     },
-    reportOdometer: "status",
-    callerLocation: {
+    shareAVL: {
       enabled: true,
-      resolvers: [
-        {
-          type: AccountCallerType.Dummy,
-          opts: {},
-        }
-      ]
-    }
+      opAreaCode: "DAL",
+      opAreaName: "Delta Operations",
+      fadeZoomLevel: 1,
+    },
+    shareLocationPhones: false,
+    shareLocationTablets: true,
+    signupKey: "A1B2",
+    simpleSenseEnabled: true,
+    simpleSense: {
+      token: "123"
+    },
+    reportOdometer: "status",
+    timeZone: "America/Los_Angeles",
+    webDisclaimer: {
+      message: "test",
+      enabled: true
+    },
   };
 
   const esriMap = {
@@ -1335,7 +1375,8 @@ export default function mockModule(dependencies: { mongoose: Mongoose; }) {
       defaultCenter: [1, 1],
       defaultMap: "Default"
     },
-    restrictedCommentsEnabled: true
+    restrictedCommentsEnabled: true,
+    canBlockIncidents: true
   };
 
   const userRegistration = {

package/src/test/user.ts

@@ -47,5 +47,6 @@ describe("User", function() {
     assert.equal(item.webMapSettings.defaultCenter[1], 1);
     assert.equal(item.webMapSettings.defaultMap, "Default");
     assert.equal(item.restrictedCommentsEnabled, true);
+    assert.isTrue(sut.canBlockIncidents);
   });
 });

package/src/types/checklist.ts

@@ -32,4 +32,6 @@ export interface ChecklistItemType {
   active: boolean,
   name: string,
   description: string,
+  neris_benchmark: string,
+  send_to_cad: boolean,
 }

package/src/types/department.ts

@@ -1,6 +1,6 @@
 import { Types } from "mongoose";
 import { ColorSchemaType } from "./color";
-import { FireMapperAuthType } from "./firemapper-auth";
+import { FireMapperAuthV2Type } from "./firemapper-auth";
 import { PubNubTokenSchemaType } from "./pubnub-token";
 import {
   AccountCallerType,
@@ -310,12 +310,12 @@ export interface USFTConfigurationType {
 
 export interface FireMapperConfigurationType {
   enabled: boolean,
-  layerRefreshInterval: number,
-  proLicenseCount: number,
+  auth: FireMapperAuthV2Type,
   host: string,
   layer: FireMapperLayerType[],
+  layerRefreshInterval: number,
+  proLicenseCount: number,
   staticLayer: FireMapperOutlineType[],
-  auth: FireMapperAuthType,
 }
 
 export interface LicensingType {

package/src/types/firemapper-auth.ts

@@ -5,3 +5,13 @@ export interface FireMapperAuthType {
   encrypted: EncryptedDataType,
   encryptedAccessCode: EncryptedDataType,
 }
+
+export interface FireMapperAuthV2Type {
+  username: string,
+  // used by backend to create FM incidents
+  apiKeyManagement: EncryptedDataType | undefined,
+  // used by the iOS maps, and backend to check if map is active
+  apiKeyReadOnly: EncryptedDataType | undefined,
+  // used by the iOS link to
+  licenseCode: EncryptedDataType | undefined,
+}

package/src/types/managed-incident.ts

@@ -93,6 +93,9 @@ export interface IncidentChecklistItemType {
   checklist_uuid: string,
   description: string,
   id: string,
+  neris_benchmark: string,
+  send_to_cad: boolean,
+  checked_at: string,
 }
 
 export interface IncidentChecklistType {

package/src/types/user.ts

@@ -100,6 +100,7 @@ export interface UserType {
   beacons: string[],
   cadSimulatorAccess: boolean,
   canAddRemoveVehicle: boolean,
+  canBlockIncidents: boolean,
   canCreateShareIncidentCode: boolean,
   departmentId: string,
   email: string,