tabletcommand-backend-models 7.4.113 → 7.4.115

package/src/models/department.ts

@@ -80,6 +80,8 @@ import {
   OneStepConfigurationType,
   DroneSenseConfigurationType,
   DronesConfigurationType,
+  DronesVideoType,
+  DronesVideoUrlsType,
   USFTConfigurationType,
   VehicleStatusWebhookConfigType,
   VehicleStatusWebhookConnectionType,
@@ -548,8 +550,14 @@ export const DroneSenseConfigurationDefault = {
   apiKey: "",
 };
 
+export const DronesVideoDefault: DronesVideoType = {
+  sources: [],
+  urls: { web: "" },
+};
+
 export const DronesConfigurationDefault = {
   enabled: false,
+  video: DronesVideoDefault,
 };
 
 export const OrientationMarkerColorDefault: ColorSchemaType = {
@@ -1534,11 +1542,39 @@ export default async function DepartmentModule(mongoose: MongooseModule) {
     id: false,
   });
 
+  const DronesVideoUrls = new Schema<DronesVideoUrlsType>({
+    web: {
+      type: String,
+      default: "",
+    },
+  }, {
+    _id: false,
+    id: false,
+  });
+
+  const DronesVideo = new Schema<DronesVideoType>({
+    sources: {
+      type: [String],
+      default: [],
+    },
+    urls: {
+      type: DronesVideoUrls,
+      default: () => ({ web: "" }),
+    },
+  }, {
+    _id: false,
+    id: false,
+  });
+
   const DronesConfiguration = new Schema<DronesConfigurationType>({
     enabled: {
       type: Boolean,
       default: false,
     },
+    video: {
+      type: DronesVideo,
+      default: () => ({ sources: [], urls: { web: "" } }),
+    },
   }, {
     _id: false,
     id: false,
@@ -2393,6 +2429,10 @@ export default async function DepartmentModule(mongoose: MongooseModule) {
         type: Number,
         default: 45000,
       },
+      accountName: {
+        type: String,
+        default: "",
+      },
     },
 
     watchDuty: {

package/src/models/zonehaven-account.ts

@@ -0,0 +1,78 @@
+import {
+  MongooseModule,
+} from "../helpers";
+import { Model } from "mongoose";
+import { ZonehavenAccountType } from "../types/zonehaven-account";
+import { EncryptedDataType } from "../types/common";
+
+export interface ZonehavenAccount extends ZonehavenAccountType { }
+
+export default async function ZonehavenAccountModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+
+  const EncryptedData = new Schema<EncryptedDataType>({
+    iv: {
+      type: String,
+      default: "",
+    },
+    encryptedData: {
+      type: String,
+      default: "",
+    },
+  }, {
+    _id: false,
+    id: false,
+  });
+
+  const modelSchema = new Schema<ZonehavenAccountType>({
+    _id: {
+      type: Schema.Types.ObjectId,
+      auto: true,
+    },
+    name: {
+      type: String,
+      required: true,
+      immutable: true,
+    },
+    url: {
+      type: String,
+      default: "",
+    },
+    username: {
+      type: String,
+      default: "",
+    },
+    password: {
+      type: EncryptedData,
+      default: null,
+    },
+    token: {
+      type: String,
+      default: null,
+    },
+    expireAt: {
+      type: Date,
+    },
+    referer: {
+      type: String,
+      default: null,
+    },
+  }, {
+    autoIndex: false,
+    timestamps: true,
+    toJSON: {
+      versionKey: false,
+    }
+  });
+
+  modelSchema.index({
+    name: 1,
+  }, {
+    name: "name_1_unique",
+    unique: true,
+  });
+
+  return mongoose.model<ZonehavenAccount>("ZonehavenAccount", modelSchema, "massive_zonehaven_account", { overwriteModels: true });
+}
+
+export interface ZonehavenAccountModel extends Model<ZonehavenAccount> { }

package/src/test/0index.ts

@@ -79,5 +79,6 @@ describe(" Models", function() {
     assert.isFunction(models.UserRegistration, "Missing UserRegistration");
     assert.isFunction(models.ValidationReport, "Missing ValidationReport");
     assert.isFunction(models.WatchDutyEvent, "Missing WatchDutyEvent");
+    assert.isFunction(models.ZonehavenAccount, "Missing ZonehavenAccount");
   });
 });

package/src/test/department.ts

@@ -145,6 +145,41 @@ describe("Department", function () {
     assert.isFalse(sut.drones.enabled);
   });
 
+  it("defaults drones.video to no sources and an empty web url", async function () {
+    const item = new models.Department(testItem);
+    const sut = await item.save();
+    assert.deepEqual(sut.drones.video.sources, []);
+    assert.equal(sut.drones.video.urls.web, "");
+  });
+
+  it("saves drones.video sources and urls, with no subdocument _id", async function () {
+    const item = new models.Department({
+      ...testItem,
+      drones: {
+        enabled: true,
+        video: {
+          sources: ["Skydio"],
+          urls: { web: "https://video.example.com/player/{uuid}?token={token}" },
+        },
+      },
+    });
+    const sut = await item.save();
+    assert.deepEqual(sut.drones.video.sources, ["Skydio"]);
+    assert.equal(sut.drones.video.urls.web, "https://video.example.com/player/{uuid}?token={token}");
+    assert.isUndefined((sut.drones.video as unknown as { _id?: unknown })._id);
+    assert.isUndefined((sut.drones.video.urls as unknown as { _id?: unknown })._id);
+  });
+
+  it("loads drones.video with defaults for a document saved without drones", async function () {
+    const legacyItem = { ...testItem };
+    delete legacyItem.drones;
+    const item = new models.Department(legacyItem);
+    const sut = await item.save();
+    const loaded = await models.Department.findOne({ _id: sut._id });
+    assert.deepEqual(loaded?.drones.video.sources, []);
+    assert.equal(loaded?.drones.video.urls.web, "");
+  });
+
   it("saves samsara.tagIds and defaults it to an empty array", async function () {
     const item = new models.Department({
       ...testItem,

package/src/test/mock.ts

@@ -18,6 +18,7 @@ import { IncidentNotified } from "../models/incident-notified";
 import { Location } from "../models/location";
 import { ManagedIncident } from "../models/managed-incident";
 import { SAML } from "../models/saml";
+import { ZonehavenAccountType } from "../types/zonehaven-account";
 
 export default function mockModule(dependencies: { mongoose: Mongoose; }) {
   function shouldRun() {
@@ -1031,6 +1032,22 @@ export default function mockModule(dependencies: { mongoose: Mongoose; }) {
     watchDutyModifiedAt: new Date("2025-08-02T11:00:00.000Z"),
   };
 
+  const zonehavenAccount: ZonehavenAccountType = {
+    _id: new mongoose.Types.ObjectId(),
+    name: "default",
+    url: "https://agservergenasys.zonehaven.com/arcgis/rest/services/tc_data/FeatureServer/0",
+    username: "zonehaven-user",
+    password: {
+      iv: "18f17",
+      encryptedData: "dee54",
+    },
+    token: "test-zonehaven-token",
+    expireAt: new Date("2025-12-12T01:02:03.000Z"),
+    referer: "tabletcommand.com",
+    createdAt: new Date("2025-11-10T20:01:01.111+0000"),
+    updatedAt: new Date("2025-11-20T20:02:02.222+0000"),
+  };
+
   const dataSharingAgreement = {
     departmentId: "5195426cc4e016a988000965",
     departmentName: "Test Department",
@@ -1739,5 +1756,6 @@ export default function mockModule(dependencies: { mongoose: Mongoose; }) {
     userRegistration,
     validationReport,
     watchDutyEvent,
+    zonehavenAccount,
   };
 }

package/src/test/zonehaven-account.ts

@@ -0,0 +1,70 @@
+import { assert } from "chai";
+import { describe, it, beforeEach, afterEach } from "node:test";
+import { isDate } from "lodash";
+
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("ZonehavenAccount", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.ZonehavenAccount>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.zonehavenAccount;
+    await mock.beforeEach();
+  });
+
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    assert.isObject(testItem);
+    const item = new models.ZonehavenAccount(testItem);
+    const sut = await item.save();
+    assert.isNotNull(sut._id);
+    assert.isNotNull(sut.id);
+    assert.equal(sut._id.toString(), testItem._id?.toString());
+
+    assert.equal(sut.name, "default");
+    assert.equal(sut.url, testItem.url);
+    assert.equal(sut.username, testItem.username);
+
+    assert.isObject(sut.password);
+    assert.equal(sut.password?.iv, testItem.password?.iv);
+    assert.equal(sut.password?.encryptedData, testItem.password?.encryptedData);
+
+    assert.equal(sut.token, testItem.token);
+    assert.isTrue(isDate(sut.expireAt));
+    assert.equal(sut.expireAt?.toISOString(), testItem.expireAt?.toISOString());
+    assert.equal(sut.referer, testItem.referer);
+  });
+
+  it("enforces a unique name", async function() {
+    const item = new models.ZonehavenAccount(testItem);
+    await item.save();
+
+    const duplicate = new models.ZonehavenAccount({ ...testItem, _id: new mongoose.Types.ObjectId() });
+    try {
+      await duplicate.save();
+      assert.fail("Should have thrown duplicate key error");
+    } catch (error) {
+      assert.include(String((error as Error).message), "duplicate key");
+    }
+  });
+
+  it("does not allow changing name after creation", async function() {
+    const item = new models.ZonehavenAccount(testItem);
+    const sut = await item.save();
+
+    sut.name = "demo";
+    const saved = await sut.save();
+    assert.equal(saved.name, "default");
+  });
+});

package/src/types/department.ts

@@ -359,8 +359,18 @@ export interface DroneSenseConfigurationType {
   apiKey: string,
 }
 
+export interface DronesVideoUrlsType {
+  web: string,
+}
+
+export interface DronesVideoType {
+  sources: string[],
+  urls: DronesVideoUrlsType,
+}
+
 export interface DronesConfigurationType {
   enabled: boolean,
+  video: DronesVideoType,
 }
 
 export interface FireMapperConfigurationType {
@@ -567,6 +577,8 @@ export type AccountConfigurationZonehaven = {
   visible: boolean,
   layerUrl: string,
   fadeZoomLevel: number,
+  // References ZonehavenAccount.name - empty string means unassigned/legacy fallback.
+  accountName: string,
 };
 
 export type AccountConfigurationWatchDuty = {

package/src/types/zonehaven-account.ts

@@ -0,0 +1,15 @@
+import { Types } from "mongoose";
+import { EncryptedDataType } from "./common";
+
+export interface ZonehavenAccountType {
+  _id: Types.ObjectId,
+  name: string, // "default", "demo" - unique, immutable once set
+  url: string,
+  username: string,
+  password: EncryptedDataType | null,
+  token: string | null,
+  expireAt: Date | null,
+  referer: string | null,
+  createdAt: Date,
+  updatedAt: Date,
+}