tabletcommand-backend-models 7.4.111 → 7.4.112

package/src/models/department.ts

@@ -79,6 +79,7 @@ import {
   UnitStatusCodesConfigType,
   OneStepConfigurationType,
   DroneSenseConfigurationType,
+  DronesConfigurationType,
   USFTConfigurationType,
   VehicleStatusWebhookConfigType,
   VehicleStatusWebhookConnectionType,
@@ -547,6 +548,10 @@ export const DroneSenseConfigurationDefault = {
   apiKey: "",
 };
 
+export const DronesConfigurationDefault = {
+  enabled: false,
+};
+
 export const OrientationMarkerColorDefault: ColorSchemaType = {
   background: "#FC2125",
   text: "#FFFFFF",
@@ -1529,6 +1534,16 @@ export default async function DepartmentModule(mongoose: MongooseModule) {
     id: false,
   });
 
+  const DronesConfiguration = new Schema<DronesConfigurationType>({
+    enabled: {
+      type: Boolean,
+      default: false,
+    },
+  }, {
+    _id: false,
+    id: false,
+  });
+
   const FireMapperConfiguration = new Schema<FireMapperConfigurationType>({
     enabled: {
       type: Boolean,
@@ -2410,6 +2425,10 @@ export default async function DepartmentModule(mongoose: MongooseModule) {
       type: DroneSenseConfiguration,
       default: DroneSenseConfigurationDefault,
     },
+    drones: {
+      type: DronesConfiguration,
+      default: DronesConfigurationDefault,
+    },
     mark43: {
       type: Mark43Config,
       default: Mark43ConfigDefault

package/src/models/drone-connection.ts

@@ -0,0 +1,121 @@
+import { Model } from "mongoose";
+
+import { DroneProvider } from "../constants";
+import {
+  currentDate,
+  MongooseModule,
+} from "../helpers";
+import { EncryptedDataType } from "../types/common";
+import {
+  DroneConnectionOptionsType,
+  DroneConnectionType,
+} from "../types/drone-connection";
+
+export interface DroneConnection extends DroneConnectionType, Record<string, unknown> {
+}
+
+const EncryptedDataDefault: EncryptedDataType = {
+  iv: "",
+  encryptedData: "",
+};
+
+export function DroneConnectionSchema(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+
+  const EncryptedData = new Schema<EncryptedDataType>({
+    iv: {
+      type: String,
+      default: "",
+    },
+    encryptedData: {
+      type: String,
+      default: "",
+    },
+  }, {
+    _id: false,
+    id: false,
+  });
+
+  const DroneConnectionOptions = new Schema<DroneConnectionOptionsType>({
+    drones: {
+      type: String,
+      enum: ["all", "listed"],
+      default: "all",
+    },
+    serials: {
+      type: [String],
+      default: [],
+    },
+  }, {
+    _id: false,
+    id: false,
+  });
+
+  const modelSchema = new Schema<DroneConnectionType>({
+    departmentId: {
+      type: Schema.Types.ObjectId,
+      ref: "Department",
+      required: true,
+    },
+    provider: {
+      type: String,
+      enum: Object.values(DroneProvider),
+      required: true,
+    },
+    active: {
+      type: Boolean,
+      default: false,
+    },
+    label: {
+      type: String,
+      default: "",
+    },
+    authToken: {
+      type: EncryptedData,
+      default: EncryptedDataDefault,
+    },
+    authSecret: {
+      type: EncryptedData,
+      default: EncryptedDataDefault,
+    },
+    options: {
+      type: DroneConnectionOptions,
+      required: false,
+    },
+    modified: {
+      type: Date,
+      default: currentDate,
+    },
+  }, {
+    autoIndex: false,
+    timestamps: {
+      createdAt: false,
+      updatedAt: "modified",
+    },
+  });
+
+  modelSchema.index({
+    departmentId: 1,
+  }, {
+    name: "departmentId_1",
+  });
+
+  modelSchema.index({
+    departmentId: 1,
+    provider: 1,
+    label: 1,
+  }, {
+    name: "departmentId_1_provider_1_label_1_unique",
+    unique: true,
+  });
+
+  return modelSchema;
+}
+
+export default async function DroneConnectionModule(mongoose: MongooseModule) {
+  const modelSchema = DroneConnectionSchema(mongoose);
+  return mongoose.model<DroneConnection>("DroneConnection", modelSchema, "massive_drone_connection", { overwriteModels: true });
+}
+
+export interface DroneConnectionModel extends Model<DroneConnection> {
+}

package/src/models/user.ts

@@ -295,6 +295,10 @@ export function UserSchema(mongoose: MongooseModule) {
       type: String,
       default: "prohibited",
     },
+    visibleSources: {
+      type: [String],
+      default: [],
+    },
 
     canCreateShareIncidentCode: {
       type: Boolean,

package/src/test/department.ts

@@ -139,6 +139,12 @@ describe("Department", function () {
     assert.isFalse(sut.watchDuty.visible);
   });
 
+  it("defaults drones to disabled", async function () {
+    const item = new models.Department(testItem);
+    const sut = await item.save();
+    assert.isFalse(sut.drones.enabled);
+  });
+
   it("saves samsara.tagIds and defaults it to an empty array", async function () {
     const item = new models.Department({
       ...testItem,

package/src/test/drone-connection.ts

@@ -0,0 +1,164 @@
+import { assert } from "chai";
+import { Types } from "mongoose";
+import { describe, it, beforeEach, afterEach } from "node:test";
+import * as m from "../index";
+import * as config from "./config";
+
+describe("DroneConnection", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let departmentId: Types.ObjectId;
+
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+    departmentId = new mongoose.Types.ObjectId();
+    await models.DroneConnection.syncIndexes();
+  });
+  afterEach(async function() {
+    await models.DroneConnection.deleteMany({});
+    await mongoose.disconnect();
+  });
+
+  it("is saved and reads back every field", async function() {
+    const sut = await new models.DroneConnection({
+      departmentId,
+      provider: "skydio",
+      active: true,
+      label: "Skydio HQ",
+      authToken: { iv: "iv-token", encryptedData: "enc-token" },
+      authSecret: { iv: "iv-secret", encryptedData: "enc-secret" },
+      options: {
+        drones: "listed",
+        serials: ["SN-1", "SN-2"],
+      },
+    }).save();
+
+    assert.isNotNull(sut._id);
+    assert.equal(sut.departmentId.toString(), departmentId.toString());
+    assert.equal(sut.provider, "skydio");
+    assert.isTrue(sut.active);
+    assert.equal(sut.label, "Skydio HQ");
+    assert.equal(sut.authToken.iv, "iv-token");
+    assert.equal(sut.authToken.encryptedData, "enc-token");
+    assert.equal(sut.authSecret.iv, "iv-secret");
+    assert.equal(sut.authSecret.encryptedData, "enc-secret");
+    assert.equal(sut.options?.drones, "listed");
+    assert.deepEqual(sut.options?.serials, ["SN-1", "SN-2"]);
+    assert.instanceOf(sut.modified, Date);
+  });
+
+  it("leaves options undefined when none are given", async function() {
+    const sut = await new models.DroneConnection({
+      departmentId,
+      provider: "skydio",
+      label: "No options",
+      authToken: { iv: "iv", encryptedData: "t" },
+      authSecret: { iv: "iv", encryptedData: "s" },
+    }).save();
+
+    assert.isUndefined(sut.options);
+  });
+
+  it("rejects an unknown provider", async function() {
+    let thrownError: unknown = null;
+    try {
+      await new models.DroneConnection({
+        departmentId,
+        provider: "bogus",
+        label: "Bad provider",
+      }).save();
+    } catch (e) {
+      thrownError = e;
+    }
+
+    assert.isNotNull(thrownError, "expected an unknown provider to be rejected");
+    assert.include(String((thrownError as Error).message), "provider");
+  });
+
+  it("rejects an unknown options.drones value", async function() {
+    let thrownError: unknown = null;
+    try {
+      await new models.DroneConnection({
+        departmentId,
+        provider: "skydio",
+        label: "Bad options",
+        options: {
+          drones: "list",
+          serials: [],
+        },
+      }).save();
+    } catch (e) {
+      thrownError = e;
+    }
+
+    assert.isNotNull(thrownError, "expected an unknown options.drones value to be rejected");
+    assert.include(String((thrownError as Error).message), "options.drones");
+  });
+
+  it("stores no timestamp field outside the schema", async function() {
+    await new models.DroneConnection({
+      departmentId,
+      provider: "skydio",
+      label: "Raw read",
+    }).save();
+
+    const raw = await models.DroneConnection.collection.findOne({ departmentId });
+    assert.isNotNull(raw);
+    assert.notProperty(raw, "createdAt");
+    assert.notProperty(raw, "updatedAt");
+    assert.property(raw, "modified");
+  });
+
+  it("advances modified on findOneAndUpdate", async function() {
+    const staleDate = new Date("2020-01-02T03:04:05.000Z");
+    await new models.DroneConnection({
+      departmentId,
+      provider: "skydio",
+      label: "Stale",
+    }).save();
+    await models.DroneConnection.collection.updateOne({
+      departmentId,
+    }, {
+      $set: {
+        modified: staleDate,
+      },
+    });
+
+    const updated = await models.DroneConnection.findOneAndUpdate({
+      departmentId,
+    }, {
+      $set: {
+        active: true,
+      },
+    }, {
+      new: true,
+    });
+
+    assert.isNotNull(updated);
+    assert.isTrue(updated!.modified > staleDate, "expected modified to advance");
+  });
+
+  it("enforces a unique (departmentId, provider, label) index", async function() {
+    await new models.DroneConnection({
+      departmentId,
+      provider: "skydio",
+      label: "Skydio HQ",
+    }).save();
+
+    let thrownError: unknown = null;
+    try {
+      await new models.DroneConnection({
+        departmentId,
+        provider: "skydio",
+        label: "Skydio HQ",
+      }).save();
+    } catch (e) {
+      thrownError = e;
+    }
+
+    assert.isNotNull(thrownError, "expected a duplicate (departmentId, label) to be rejected");
+    assert.equal((thrownError as { code?: number }).code, 11000);
+    assert.include(String((thrownError as Error).message), "E11000");
+  });
+});

package/src/test/user.ts

@@ -51,4 +51,15 @@ describe("User", function () {
     assert.equal(item.restrictedCommentsEnabled, true);
     assert.isTrue(sut.canBlockIncidents);
   });
+
+  it("saves and retrieves visibleSources", async function () {
+    const item = new models.User({
+      ...testItem,
+      stealthStatus: m.UserStealthStatus.Hidden,
+      visibleSources: [m.LocationSource.VehicleModem, m.LocationSource.TCIOS],
+    });
+    const sut = await item.save();
+    assert.equal(sut.stealthStatus, "hidden");
+    assert.deepEqual(sut.visibleSources, [m.LocationSource.VehicleModem, m.LocationSource.TCIOS]);
+  });
 });

package/src/types/department.ts

@@ -359,6 +359,10 @@ export interface DroneSenseConfigurationType {
   apiKey: string,
 }
 
+export interface DronesConfigurationType {
+  enabled: boolean,
+}
+
 export interface FireMapperConfigurationType {
   enabled: boolean,
   auth: FireMapperAuthV2Type,
@@ -707,6 +711,7 @@ export interface DepartmentType {
   usft: USFTConfigurationType,
   onestep: OneStepConfigurationType, // cspell:disable-line
   dronesense: DroneSenseConfigurationType,
+  drones: DronesConfigurationType,
   selfAssignmentEnabled: boolean,
   shareAVL: AccountConfigurationShareAVL,
   shareIncident: AccountConfigurationShareIncident,

package/src/types/drone-connection.ts

@@ -0,0 +1,21 @@
+import { Types } from "mongoose";
+import { DroneProvider } from "../constants";
+import { EncryptedDataType } from "./common";
+
+export interface DroneConnectionOptionsType {
+  drones: "all" | "listed",
+  serials: string[],
+}
+
+export interface DroneConnectionType {
+  // The stable id the video gateway diffs on.
+  _id: Types.ObjectId,
+  departmentId: Types.ObjectId,
+  provider: DroneProvider,
+  active: boolean,
+  label: string,
+  authToken: EncryptedDataType,     // Skydio token id
+  authSecret: EncryptedDataType,    // Skydio token secret
+  options?: DroneConnectionOptionsType, // omitted means every drone on the account
+  modified: Date,
+}

package/src/types/user.ts

@@ -139,6 +139,7 @@ export interface UserType {
   shareWith3rdPartiesEnabled: boolean,
   socketIO: PubNubTokenSchemaType,
   stealthStatus: string, // UserStealthStatus
+  visibleSources: string[],
   superuser: boolean,
   superUserReadOnly: boolean
   syncLoggingExpireDate: Date,