tabletcommand-backend-models 7.4.91 → 7.4.93

package/src/test/esri.ts

@@ -1,5 +1,6 @@
 import { assert } from "chai";
 import { describe, it, beforeEach, afterEach } from "node:test";
+import { rejects as assertRejects } from "node:assert/strict";
 import * as m from "../index";
 import * as config from "./config";
 import mockModule from "./mock";
@@ -59,4 +60,49 @@ describe("Esri", function() {
     const props = mapPropsFound[0];
     assert.equal(props?.download, true);
   });
+
+  it("enforces unique arcGISAuth.username constraint", async function() {
+    await new models.Esri({
+      departmentId: new mongoose.Types.ObjectId(),
+      arcGISAuth: { username: "tc_dup_user" },
+    }).save();
+
+    // A second department claiming the same non-empty username must be rejected.
+    // assertRejects fails if the save does NOT reject, so there is no false-positive.
+    await assertRejects(
+      new models.Esri({
+        departmentId: new mongoose.Types.ObjectId(),
+        arcGISAuth: { username: "tc_dup_user" },
+      }).save(),
+      /duplicate key/
+    );
+  });
+
+  it("normalizes an empty arcGISAuth.username to null", async function() {
+    // EsriAuth.username defaults to "" (schema shared with auth); an arcGISAuth
+    // present without a real username collapses to null so it is never indexed.
+    const saved = await new models.Esri({
+      departmentId: new mongoose.Types.ObjectId(),
+      arcGISAuth: { username: "" },
+    }).save();
+    assert.isNull(saved.arcGISAuth);
+  });
+
+  it("allows multiple missing/empty arcGISAuth.username and distinct values", async function() {
+    // missing arcGISAuth entirely (defaults to null) — not indexed
+    await new models.Esri({ departmentId: new mongoose.Types.ObjectId() }).save();
+    await new models.Esri({ departmentId: new mongoose.Types.ObjectId() }).save();
+    // empty-string username — normalized to null by the pre-save hook, so not indexed.
+    // Both must coexist: without normalization the second would collide on "" under $exists.
+    const empty1 = await new models.Esri({ departmentId: new mongoose.Types.ObjectId(), arcGISAuth: { username: "" } }).save();
+    const empty2 = await new models.Esri({ departmentId: new mongoose.Types.ObjectId(), arcGISAuth: { username: "" } }).save();
+    assert.isNull(empty1.arcGISAuth);
+    assert.isNull(empty2.arcGISAuth);
+    // distinct non-empty usernames — allowed
+    await new models.Esri({ departmentId: new mongoose.Types.ObjectId(), arcGISAuth: { username: "tc_user_a" } }).save();
+    await new models.Esri({ departmentId: new mongoose.Types.ObjectId(), arcGISAuth: { username: "tc_user_b" } }).save();
+
+    const count = await models.Esri.countDocuments({});
+    assert.equal(count, 6);
+  });
 });

package/src/test/kindtype-catalog.ts

@@ -0,0 +1,60 @@
+import { assert } from "chai";
+import { describe, it, beforeEach, afterEach } from "node:test";
+import * as m from "../index";
+import * as config from "./config";
+
+describe("KindTypeCatalog", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models; mongoose = c.mongoose;
+    await models.KindTypeCatalog.syncIndexes();
+  });
+  afterEach(async function() {
+    await models.KindTypeCatalog.deleteMany({});
+    await mongoose.disconnect();
+  });
+
+  it("is saved with a colorization", async function() {
+    const sut = await new models.KindTypeCatalog({
+      kind: "engine",
+      type: "1",
+      locationType: "vehicle",
+      colorization: { background: "#0000FF", text: "#FFFFFF" },
+    }).save();
+    assert.equal(sut.kind, "engine");
+    assert.equal(sut.type, "1");
+    assert.equal(sut.locationType, "vehicle");
+    assert.equal(sut.colorization?.background, "#0000FF");
+    assert.isTrue(sut.active);
+  });
+
+  it("enforces a unique (kind, type) index", async function() {
+    await new models.KindTypeCatalog({ kind: "engine", type: "1", locationType: "vehicle" }).save();
+    let err: unknown = null;
+    try {
+      await new models.KindTypeCatalog({ kind: "engine", type: "1", locationType: "vehicle" }).save();
+    } catch (e) {
+      err = e;
+    }
+    assert.isNotNull(err, "expected duplicate (kind,type) to be rejected");
+    assert.include(String((err as Error).message), "duplicate key");
+  });
+
+  it("allows the same kind with a different type", async function() {
+    await new models.KindTypeCatalog({ kind: "engine", type: "1", locationType: "vehicle" }).save();
+    const sut = await new models.KindTypeCatalog({ kind: "engine", type: "2", locationType: "vehicle" }).save();
+    assert.equal(sut.type, "2");
+  });
+
+  it("requires a non-empty kind", async function() {
+    let err: unknown = null;
+    try {
+      await new models.KindTypeCatalog({ type: "1", locationType: "vehicle" }).save();
+    } catch (e) {
+      err = e;
+    }
+    assert.isNotNull(err, "expected a missing kind to be rejected");
+    assert.include(String((err as Error).message), "kind");
+  });
+});

package/src/test/location.ts

@@ -96,4 +96,35 @@ describe("Location", function() {
     assert.notEqual(sutVis.indexOf(LocationVisibility.CAD), -1);
     assert.notEqual(sutVis.indexOf(LocationVisibility.Shared), -1);
   });
+
+  it("persists kind, type, locationType and kindColor", async function() {
+    const item = new models.Location({
+      departmentId: "d1",
+      userId: "u1",
+      username: "E1",
+      device_type: "ipad",
+      kind: "engine",
+      type: "1",
+      locationType: "vehicle",
+      kindColor: { background: "#0000FF", text: "#FFFFFF" },
+    });
+    const sut = await item.save();
+    assert.equal(sut.kind, "engine");
+    assert.equal(sut.type, "1");
+    assert.equal(sut.locationType, "vehicle");
+    assert.equal(sut.kindColor?.background, "#0000FF");
+    assert.equal(sut.kindColor?.text, "#FFFFFF");
+  });
+
+  it("does not auto-stamp kindColorChangedAt", async function() {
+    const item = new models.Location({
+      departmentId: "d1",
+      userId: "u1",
+      username: "E2",
+      device_type: "ipad",
+      kindColor: { background: "#0000FF", text: "#FFFFFF" },
+    });
+    const sut = await item.save();
+    assert.isUndefined(sut.kindColorChangedAt);
+  });
 });

package/src/test/mock.ts

@@ -280,6 +280,9 @@ export default function mockModule(dependencies: { mongoose: Mongoose; }) {
     agencyId: new mongoose.Types.ObjectId(),
     name: "BattalionUnit Test",
     kindType: "vehicle",
+    locationType: "vehicle",
+    kind: "engine",
+    type: "1",
     friendly_id: "B1",
     local_id: 321,
     personnel: 4,

package/src/types/battalion.ts

@@ -18,6 +18,9 @@ export interface BattalionUnitType extends Record<string, unknown> {
   battalion_name: string,
   agencyId: Types.ObjectId
   kindType: string,
+  kind?: string,
+  type?: string,
+  locationType?: string,
 }
 
 export interface BattalionType {

package/src/types/kindtype-catalog.ts

@@ -0,0 +1,15 @@
+import { Types } from "mongoose";
+import { ColorSchemaType } from "./color";
+
+export interface KindTypeCatalogType extends Record<string, unknown> {
+  _id: Types.ObjectId,
+  id?: string,
+  uuid: string,
+  kind: string,
+  type: string,
+  locationType: string,
+  colorization?: ColorSchemaType,
+  active: boolean,
+  modifiedDate: number,
+  modified: Date,
+}

package/src/types/location.ts

@@ -17,6 +17,11 @@ export interface LocationType {
   esriId: number,
   heading: number,
   kindType: string,
+  kind?: string,
+  type?: string,
+  locationType?: string,
+  kindColor?: ColorSchemaType,
+  kindColorChangedAt?: Date,
   location?: { latitude: number, longitude: number, }; // provided by virtual.location
   locationGeoJSON: GeoPoint,
   modified: Date,