tabletcommand-backend-models 7.4.106 → 7.4.107

package/src/models/tracker-responder.ts

@@ -0,0 +1,107 @@
+import * as uuid from "uuid";
+
+import {
+  MongooseModule,
+} from "../helpers";
+import { Model } from "mongoose";
+import { TrackerResponderType } from "../types/tracker-responder";
+
+export interface TrackerResponder extends TrackerResponderType, Record<string, unknown> { }
+
+export default async function TrackerResponderModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+
+  const modelSchema = new Schema<TrackerResponder>({
+    _id: {
+      type: Schema.Types.ObjectId,
+      auto: true,
+    },
+    departmentId: {
+      type: String,
+      required: true,
+    },
+    // Transponder MAC address, the vendor-side identity of the tracked seat
+    mac: {
+      type: String,
+      required: true,
+      uppercase: true,
+    },
+    // Stable identity carried by Location.transponderUUID
+    uuid: {
+      type: String,
+      required: true,
+      default: uuid.v4,
+    },
+    // Vendor personnelId verbatim (not a PersonnelKnown reference)
+    trackerPersonnelId: {
+      type: String,
+      default: "",
+    },
+    // Vendor-owned names, taken verbatim from the TXRX webhook body
+    personnelName: {
+      type: String,
+      default: "",
+    },
+    friendlyName: {
+      type: String,
+      default: "",
+    },
+    // User-owned display name, editable on our end (eventually via iOS);
+    // the webhook never touches this
+    displayName: {
+      type: String,
+      default: "",
+    },
+    seatPosition: {
+      type: String,
+      default: "",
+    },
+    // "" = unassigned, otherwise PersonnelKnown.uuid
+    personnelUUID: {
+      type: String,
+      default: "",
+    },
+    assignedBy: {
+      type: String,
+      default: "",
+    },
+    assignedAt: {
+      type: Date,
+      default: null,
+    },
+    active: {
+      type: Boolean,
+      default: true,
+    },
+    source: {
+      type: String,
+      default: "",
+    },
+  }, {
+    timestamps: {
+      updatedAt: "modified",
+    },
+    autoIndex: false,
+  });
+
+  modelSchema.index({
+    departmentId: 1,
+    mac: 1,
+  }, {
+    name: "departmentId_1_mac_1_unique",
+    unique: true,
+  });
+
+  // Lookup path for resolving Location.transponderUUID back to a responder
+  modelSchema.index({
+    departmentId: 1,
+    uuid: 1,
+  }, {
+    name: "departmentId_1_uuid_1_unique",
+    unique: true,
+  });
+
+  return mongoose.model<TrackerResponder>("TrackerResponder", modelSchema, "massive_tracker_responders", { overwriteModels: true });
+}
+
+export interface TrackerResponderModel extends Model<TrackerResponder> { }

package/src/test/location.ts

@@ -116,6 +116,28 @@ describe("Location", function() {
     assert.equal(sut.kindColor?.text, "#FFFFFF");
   });
 
+  it("defaults transponderUUID to empty and persists it", async function() {
+    const empty = await new models.Location({
+      departmentId: "d1",
+      userId: "u1",
+      username: "E3",
+      device_type: "ipad",
+    }).save();
+    assert.equal(empty.transponderUUID, "");
+
+    const tracked = await new models.Location({
+      departmentId: "d1",
+      userId: "TXRX-tr-uuid-1",
+      username: "Fire Hose 1",
+      device_type: "cad",
+      kindType: "person",
+      locationType: "person",
+      transponderUUID: "tr-uuid-1",
+    }).save();
+    assert.equal(tracked.transponderUUID, "tr-uuid-1");
+    assert.equal(tracked.personnelUUID, "");
+  });
+
   it("does not auto-stamp kindColorChangedAt", async function() {
     const item = new models.Location({
       departmentId: "d1",

package/src/test/tracker-responder.ts

@@ -0,0 +1,144 @@
+import { assert } from "chai";
+import { describe, it, beforeEach, afterEach } from "node:test";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("TrackerResponder", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    await mock.beforeEach();
+    await models.TrackerResponder.deleteMany({});
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved with defaults", async function() {
+    const item = new models.TrackerResponder({
+      departmentId: "d1",
+      mac: "aa:bb:cc:dd:ee:01",
+    });
+    const sut = await item.save();
+
+    assert.isNotNull(sut._id);
+    assert.equal(sut.departmentId, "d1");
+    assert.equal(sut.mac, "AA:BB:CC:DD:EE:01");
+    assert.isTrue(sut.uuid !== "");
+    assert.equal(sut.trackerPersonnelId, "");
+    assert.equal(sut.personnelName, "");
+    assert.equal(sut.friendlyName, "");
+    assert.equal(sut.displayName, "");
+    assert.equal(sut.seatPosition, "");
+    assert.equal(sut.personnelUUID, "");
+    assert.equal(sut.assignedBy, "");
+    assert.isNull(sut.assignedAt);
+    assert.isTrue(sut.active);
+    assert.equal(sut.source, "");
+    assert.instanceOf(sut.createdAt, Date);
+    assert.instanceOf(sut.modified, Date);
+  });
+
+  it("persists vendor and user-owned fields", async function() {
+    const item = new models.TrackerResponder({
+      departmentId: "d1",
+      mac: "AA:BB:CC:DD:EE:02",
+      trackerPersonnelId: "12345",
+      personnelName: "Fire Hose 1",
+      friendlyName: "FH-1",
+      displayName: "Engine 1 Nozzle",
+      seatPosition: "Fire Hose 1",
+      personnelUUID: "pk-uuid-1",
+      assignedBy: "user-1",
+      assignedAt: new Date("2026-07-23T00:00:00.000Z"),
+      source: "TXRX",
+    });
+    const sut = await item.save();
+
+    assert.equal(sut.trackerPersonnelId, "12345");
+    assert.equal(sut.personnelName, "Fire Hose 1");
+    assert.equal(sut.friendlyName, "FH-1");
+    assert.equal(sut.displayName, "Engine 1 Nozzle");
+    assert.equal(sut.seatPosition, "Fire Hose 1");
+    assert.equal(sut.personnelUUID, "pk-uuid-1");
+    assert.equal(sut.assignedBy, "user-1");
+    assert.equal(sut.assignedAt?.toISOString(), "2026-07-23T00:00:00.000Z");
+    assert.equal(sut.source, "TXRX");
+  });
+
+  it("enforces unique (departmentId, mac)", async function() {
+    await models.TrackerResponder.createIndexes();
+
+    await new models.TrackerResponder({
+      departmentId: "d1",
+      mac: "AA:BB:CC:DD:EE:03",
+    }).save();
+
+    // Same MAC in another department is allowed
+    const other = await new models.TrackerResponder({
+      departmentId: "d2",
+      mac: "AA:BB:CC:DD:EE:03",
+    }).save();
+    assert.isNotNull(other._id);
+
+    try {
+      await new models.TrackerResponder({
+        departmentId: "d1",
+        mac: "aa:bb:cc:dd:ee:03",
+      }).save();
+      assert.isFalse(true, "Expecting duplicate (departmentId, mac) to fail.");
+    } catch (error) {
+      assert.match((error as Error).message, /E11000/);
+    }
+  });
+
+  it("enforces unique (departmentId, uuid)", async function() {
+    await models.TrackerResponder.createIndexes();
+
+    const first = await new models.TrackerResponder({
+      departmentId: "d1",
+      mac: "AA:BB:CC:DD:EE:04",
+    }).save();
+
+    // Same uuid in another department is allowed
+    const other = await new models.TrackerResponder({
+      departmentId: "d2",
+      mac: "AA:BB:CC:DD:EE:04",
+      uuid: first.uuid,
+    }).save();
+    assert.isNotNull(other._id);
+
+    try {
+      await new models.TrackerResponder({
+        departmentId: "d1",
+        mac: "AA:BB:CC:DD:EE:05",
+        uuid: first.uuid,
+      }).save();
+      assert.isFalse(true, "Expecting duplicate (departmentId, uuid) to fail.");
+    } catch (error) {
+      assert.match((error as Error).message, /E11000/);
+    }
+  });
+
+  it("rejects an empty or null uuid", async function() {
+    for (const uuid of ["", null]) {
+      try {
+        await new models.TrackerResponder({
+          departmentId: "d1",
+          mac: "AA:BB:CC:DD:EE:06",
+          uuid,
+        }).save();
+        assert.isFalse(true, `Expecting uuid ${JSON.stringify(uuid)} to fail validation.`);
+      } catch (error) {
+        assert.match((error as Error).message, /uuid.*required/i);
+      }
+    }
+  });
+});

package/src/types/department.ts

@@ -205,6 +205,10 @@ export interface SomewearType {
   enabled: boolean
 }
 
+export interface PersonnelWebhookType {
+  enabled: boolean
+}
+
 export interface SkytracConfigType {
   enabled: boolean
   licenseKey: string,
@@ -672,6 +676,7 @@ export interface DepartmentType {
   orientationMarkerColor: ColorSchemaType,
   partialApiKey: string,
   personnelStaffingEnabled: boolean,
+  personnelWebhook: PersonnelWebhookType,
   pubNubV3: PubNubTokenSchemaType,
   remoteLoggingEnabled: boolean,
   reportNumberEnabled: boolean,

package/src/types/location.ts

@@ -40,6 +40,7 @@ export interface LocationType {
   username: string,
   uuid: string,
   personnelUUID: string,
+  transponderUUID: string,
   version: number,
   visibility: string[],
 }

package/src/types/tracker-responder.ts

@@ -0,0 +1,28 @@
+import { Types } from "mongoose";
+
+export interface TrackerResponderType {
+  _id: Types.ObjectId,
+  departmentId: string,
+  // Transponder MAC address, normalized uppercase. Unique per department.
+  mac: string,
+  // Stable identity carried by Location.transponderUUID.
+  uuid: string,
+  // Vendor personnelId verbatim (not a PersonnelKnown reference).
+  trackerPersonnelId: string,
+  // Vendor-owned names, taken verbatim from the TXRX webhook body.
+  personnelName: string,
+  friendlyName: string,
+  // User-owned display name, editable on our end (eventually via iOS);
+  // the webhook never touches this.
+  displayName: string,
+  seatPosition: string,
+  // "" = unassigned, otherwise PersonnelKnown.uuid.
+  personnelUUID: string,
+  assignedBy: string,
+  // null while unassigned
+  assignedAt: Date | null,
+  active: boolean,
+  source: string,
+  createdAt: Date,
+  modified: Date,
+}