tabletcommand-backend-models 7.4.61 → 7.4.62

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/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

@@ -700,7 +700,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 +709,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 +798,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 +820,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 = {

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,
+}