tabletcommand-backend-models 7.4.33 → 7.4.35

package/src/models/department.ts

@@ -24,6 +24,7 @@ import {
   AccountConfigurationCallerLocation,
   AccountConfigurationCallerLocationResolver,
   ADSBConfigType,
+  AudioStreamAuthType,
   AudioStreamGroupType,
   AudioStreamType,
   CADGetLocationSettingsType,
@@ -811,6 +812,25 @@ export default async function DepartmentModule(mongoose: MongooseModule) {
       type: String,
       default: "",
     },
+    // Extended properties for SOAP and other protocols
+    timeout: {
+      type: Number,
+      default: undefined,
+    },
+    namespace: {
+      type: String,
+      default: "",
+    },
+    soapVersion: {
+      type: String,
+      enum: ["1.1", "1.2"],
+      default: undefined,
+    },
+    customHeaders: {
+      type: Map,
+      of: String,
+      default: {},
+    },
   }, {
     _id: false,
     id: false,
@@ -1168,6 +1188,25 @@ export default async function DepartmentModule(mongoose: MongooseModule) {
     id: false,
   });
 
+  const AudioStreamAuth = new Schema<AudioStreamAuthType>({
+    authId: {
+      type: Schema.Types.ObjectId,
+      ref: "AudioStreamAuthentication",
+      required: true,
+    },
+    app: {
+      type: String,
+      required: true,
+    },
+    streamKey: {
+      type: String,
+      required: true,
+    },
+  }, {
+    _id: false,
+    id: false,
+  });
+
   const AudioStream = new Schema<AudioStreamType>({
     // eg. Central Dispatch Talk Group or also Available on 89.5 MHz
     description: {
@@ -1186,7 +1225,11 @@ export default async function DepartmentModule(mongoose: MongooseModule) {
     order: {
       type: Number,
       default: 0,
-    }
+    },
+    authentication: {
+      type: AudioStreamAuth,
+      default: undefined,
+    },
   }, {
     _id: false,
     id: false,

package/src/test/audio-stream-authentication.ts

@@ -0,0 +1,81 @@
+import { assert } from "chai";
+import "mocha";
+
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("AudioStreamAuthentication", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.AudioStreamAuthentication>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.audioStreamAuthentication;
+    await mock.cleanup();
+  });
+
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    assert.isObject(testItem);
+    const item = new models.AudioStreamAuthentication(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, "test-stream");
+    assert.equal(sut.rotateInterval, 3600);
+
+    assert.isObject(sut.secret);
+    assert.equal(sut.secret?.iv, testItem.secret?.iv);
+    assert.equal(sut.secret?.encryptedData, testItem.secret?.encryptedData);
+  });
+
+  it("enforces unique name constraint", async function() {
+    const item1 = new models.AudioStreamAuthentication(testItem);
+    await item1.save();
+
+    const item2 = new models.AudioStreamAuthentication({
+      name: "test-stream",
+      secret: {
+        iv: "different-iv",
+        encryptedData: "different-data"
+      },
+      rotateInterval: 7200,
+    });
+
+    try {
+      await item2.save();
+      assert.fail("Should have thrown duplicate key error");
+    } catch (error) {
+      assert.include(String((error as Error).message), "duplicate key");
+    }
+  });
+
+  it("allows different names", async function() {
+    const item1 = new models.AudioStreamAuthentication(testItem);
+    await item1.save();
+
+    const item2 = new models.AudioStreamAuthentication({
+      name: "different-stream",
+      secret: {
+        iv: "different-iv",
+        encryptedData: "different-data"
+      },
+      rotateInterval: 7200,
+    });
+
+    const sut = await item2.save();
+    assert.isNotNull(sut._id);
+    assert.equal(sut.name, "different-stream");
+    assert.equal(sut.rotateInterval, 7200);
+  });
+});

package/src/test/audio-stream.ts

@@ -0,0 +1,230 @@
+import { assert } from "chai";
+import "mocha";
+
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("AudioStream", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let authRecord: m.AudioStreamAuthentication;
+
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+    const mock = mockModule({
+      mongoose
+    });
+    await mock.cleanup();
+
+    // Create an AudioStreamAuthentication record to reference
+    const authItem = new models.AudioStreamAuthentication({
+      name: "test-auth-record",
+      secret: {
+        iv: "test-iv",
+        encryptedData: "test-encrypted-data"
+      },
+      rotateInterval: 3600,
+    });
+    authRecord = await authItem.save();
+  });
+
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("saves Department with AudioStream authentication", async function() {
+    const department = new models.Department({
+      department: "Test Fire Department",
+      apikey: "test-api-key-123",
+      audioConfiguration: [
+        {
+          group: "Fire Dispatch",
+          order: 1,
+          streams: [
+            {
+              description: "Main Dispatch Channel",
+              channel: "CH1",
+              url: "https://example.com/stream1",
+              order: 1,
+              authentication: {
+                authId: authRecord._id,
+                app: "test-app",
+                streamKey: "stream-key-123",
+              }
+            }
+          ]
+        }
+      ]
+    });
+
+    const saved = await department.save();
+
+    assert.isNotNull(saved._id);
+    assert.isArray(saved.audioConfiguration);
+    assert.equal(saved.audioConfiguration.length, 1);
+
+    const group = saved.audioConfiguration[0];
+    if (!group) {
+      assert.fail("Group should be defined");
+      return;
+    }
+    assert.equal(group.group, "Fire Dispatch");
+    assert.equal(group.order, 1);
+    assert.equal(group.streams.length, 1);
+
+    const stream = group.streams[0];
+    if (!stream) {
+      assert.fail("Stream should be defined");
+      return;
+    }
+    assert.equal(stream.description, "Main Dispatch Channel");
+    assert.equal(stream.channel, "CH1");
+    assert.equal(stream.url, "https://example.com/stream1");
+    assert.equal(stream.order, 1);
+
+    // Verify authentication
+    assert.isObject(stream.authentication);
+    if (!stream.authentication) {
+      assert.fail("Authentication should be defined");
+      return;
+    }
+    assert.equal(stream.authentication.authId.toString(), authRecord._id.toString());
+    assert.equal(stream.authentication.app, "test-app");
+    assert.equal(stream.authentication.streamKey, "stream-key-123");
+  });
+
+  it("saves Department with AudioStream without authentication", async function() {
+    const department = new models.Department({
+      department: "Test Fire Department 2",
+      apikey: "test-api-key-456",
+      audioConfiguration: [
+        {
+          group: "Police Dispatch",
+          order: 1,
+          streams: [
+            {
+              description: "Public Channel",
+              channel: "CH2",
+              url: "https://example.com/stream2",
+              order: 1,
+            }
+          ]
+        }
+      ]
+    });
+
+    const saved = await department.save();
+
+    assert.isNotNull(saved._id);
+    assert.isArray(saved.audioConfiguration);
+    assert.equal(saved.audioConfiguration.length, 1);
+
+    const group = saved.audioConfiguration[0];
+    if (!group) {
+      assert.fail("Group should be defined");
+      return;
+    }
+    const stream = group.streams[0];
+    if (!stream) {
+      assert.fail("Stream should be defined");
+      return;
+    }
+    assert.equal(stream.description, "Public Channel");
+    assert.isUndefined(stream.authentication);
+  });
+
+  it("saves Department with mixed AudioStreams (with and without auth)", async function() {
+    const department = new models.Department({
+      department: "Test Mixed Department",
+      apikey: "test-api-key-789",
+      audioConfiguration: [
+        {
+          group: "Dispatch Channels",
+          order: 1,
+          streams: [
+            {
+              description: "Secure Channel",
+              channel: "CH1",
+              url: "https://example.com/secure",
+              order: 1,
+              authentication: {
+                authId: authRecord._id,
+                app: "secure-app",
+                streamKey: "secure-key-456",
+              }
+            },
+            {
+              description: "Public Channel",
+              channel: "CH2",
+              url: "https://example.com/public",
+              order: 2,
+            }
+          ]
+        }
+      ]
+    });
+
+    const saved = await department.save();
+
+    const group = saved.audioConfiguration[0];
+    if (!group) {
+      assert.fail("Group should be defined");
+      return;
+    }
+    assert.equal(group.streams.length, 2);
+
+    const secureStream = group.streams[0];
+    if (!secureStream) {
+      assert.fail("Secure stream should be defined");
+      return;
+    }
+    assert.isObject(secureStream.authentication);
+    if (!secureStream.authentication) {
+      assert.fail("Authentication should be defined");
+      return;
+    }
+    assert.equal(secureStream.authentication.app, "secure-app");
+
+    const publicStream = group.streams[1];
+    if (!publicStream) {
+      assert.fail("Public stream should be defined");
+      return;
+    }
+    assert.isUndefined(publicStream.authentication);
+  });
+
+  it("validates required authentication fields when present", async function() {
+    const department = new models.Department({
+      department: "Test Invalid Department",
+      apikey: "test-api-key-invalid",
+      audioConfiguration: [
+        {
+          group: "Test Group",
+          order: 1,
+          streams: [
+            {
+              description: "Invalid Stream",
+              channel: "CH1",
+              url: "https://example.com/invalid",
+              order: 1,
+              authentication: {
+                authId: authRecord._id,
+                app: "test-app",
+                // Missing streamKey - should fail validation
+              } as unknown as { authId: m.AudioStreamAuthentication["_id"]; app: string; streamKey: string; }
+            }
+          ]
+        }
+      ]
+    });
+
+    try {
+      await department.save();
+      assert.fail("Should have thrown validation error");
+    } catch (error) {
+      assert.include(String((error as Error).message), "streamKey");
+    }
+  });
+});

package/src/test/department.ts

@@ -15,6 +15,7 @@ describe("Department", function() {
       mongoose
     });
     testItem = mock.department;
+    await mock.cleanup();
   });
 
   afterEach(async function() {
@@ -99,4 +100,55 @@ describe("Department", function() {
     assert.isObject(callerResolver);
     assert.equal(callerResolver?.type, m.AccountCallerType.Dummy);
   });
+
+  it("saves SOAP forwarding connection properties", async function() {
+    // **Feature: eso-soap-incident-forwarding, Property 6: Configuration Validation**
+    // **Validates: Requirements 3.2, 6.5**
+    const soapConnection: m.ForwardingConnectionType = {
+      active: true,
+      connectionType: "eso",
+      fields: [{
+        key: "IncidentNumber",
+        value: "incidentNumber",
+        required: true,
+        enabled: true,
+        transformationRequired: false,
+      }],
+      callTypes: ["FIRE"],
+      forwardAll: false,
+      apiUrl: "https://eso.example.com/soap",
+      authType: "basic",
+      authUser: "user",
+      authKey: "pass",
+      authKeySecret: "",
+      label: "ESO Service",
+      description: "ESO SOAP service",
+      timeout: 30000,
+      namespace: "http://eso.namespace",
+      soapVersion: "1.2" as const,
+      customHeaders: {
+        SOAPAction: "SubmitIncident"
+      }
+    };
+
+    const testItemWithForwarding = testItem as m.Department;
+    testItemWithForwarding.forwarding = {
+      enabled: true,
+      connections: [soapConnection]
+    };
+
+    const item = new models.Department(testItemWithForwarding);
+    const sut = await item.save();
+
+    // Validate SOAP-specific properties are saved correctly
+    const connection = sut.forwarding.connections[0];
+    assert.isNotNull(connection);
+    assert.isDefined(connection);
+    assert.equal(connection.connectionType, "eso");
+    assert.equal(connection.timeout, 30000);
+    assert.equal(connection.namespace, "http://eso.namespace");
+    assert.equal(connection.soapVersion, "1.2");
+    assert.instanceOf(connection.customHeaders, Map);
+    assert.equal(connection.customHeaders.get("SOAPAction"), "SubmitIncident");
+  });
 });

package/src/test/mock.ts

@@ -939,6 +939,16 @@ export default function mockModule(dependencies: { mongoose: Mongoose; }) {
     },
   };
 
+  const audioStreamAuthentication = {
+    _id: new mongoose.Types.ObjectId(),
+    name: "test-stream",
+    secret: {
+      iv: "a1b2c3d4e5f6",
+      encryptedData: "encrypted-secret-data-here"
+    },
+    rotateInterval: 3600,
+  };
+
   const gstMapping = {
     _id: new mongoose.Types.ObjectId(),
     departmentId: "d123",
@@ -1475,6 +1485,7 @@ export default function mockModule(dependencies: { mongoose: Mongoose; }) {
     agency,
     arcGISGroup,
     assignment,
+    audioStreamAuthentication,
     battalion,
     cadIncident,
     cadIncidentBlock,

package/src/types/audio-stream-authentication.ts

@@ -0,0 +1,9 @@
+import { Types } from "mongoose";
+import { EncryptedDataType } from "./common";
+
+export interface AudioStreamAuthenticationType {
+  _id: Types.ObjectId,
+  secret: EncryptedDataType,
+  rotateInterval: number,
+  name: string,
+}

package/src/types/department.ts

@@ -243,11 +243,18 @@ export interface WebDisclaimerType {
   enabled: boolean,
 }
 
+export interface AudioStreamAuthType {
+  authId: Types.ObjectId,
+  app: string,
+  streamKey: string,
+}
+
 export interface AudioStreamType {
   description: string,
   channel: string,
   url: string,
   order: number,
+  authentication?: AudioStreamAuthType,
 }
 
 export interface AudioStreamGroupType {
@@ -371,6 +378,11 @@ export interface ForwardingConnectionType {
   authKeySecret: string,
   label: string,
   description: string,
+  // Extended properties for SOAP and other protocols
+  timeout?: number,
+  namespace?: string,
+  soapVersion?: "1.1" | "1.2",
+  customHeaders?: Record<string, string>,
 }
 
 export interface VehicleStatusWebhookConnectionType {