tabletcommand-backend-models 7.0.13 → 7.0.15

package/src/test/monitor.ts

@@ -0,0 +1,35 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("Monitor", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.Monitor>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.monitor;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.Monitor(testItem);
+    const sut = await item.save();
+    assert.isNotNull(sut._id);
+
+    assert.equal(testItem.departmentId, sut.departmentId);
+    assert.equal(testItem.agencyId, sut.agencyId);
+    assert.equal(testItem.notificationType, sut.notificationType);
+    assert.equal(testItem.status, sut.status);
+    assert.equal(testItem.sentUnixDate, sut.sentUnixDate);
+  });
+});

package/src/test/personnel-import.ts

@@ -0,0 +1,55 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("PersonnelImport", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.PersonnelImport>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.personnelImport;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+
+  it("is saved", async function() {
+    const item = new models.PersonnelImport(testItem);
+    const sut = await item.save();
+    assert.equal(testItem._id, sut._id);
+    assert.equal(testItem.PersonnelID, sut.PersonnelID);
+    assert.equal(testItem.PersonnelName, sut.PersonnelName);
+    assert.equal(testItem.PersonnelRank, sut.PersonnelRank);
+    assert.equal(testItem.PersonnelWorkCode, sut.PersonnelWorkCode);
+    assert.equal(testItem.PersonnelNote, sut.PersonnelNote);
+    assert.equal(testItem.departmentId, sut.departmentId);
+    if (testItem.radioNames?.length) {
+      assert.equal(testItem.radioNames[0], sut.radioNames[0]);
+      assert.equal(testItem.radioNames[1], sut.radioNames[1]);
+    } else {
+      assert.equal(testItem.radioNames?.length, 1);
+    }
+    assert.equal(sut.radioNames.length, 2);
+    assert.equal(testItem.shiftStartTime, sut.shiftStartTime);
+    assert.equal(testItem.shiftEndTime, sut.shiftEndTime);
+    assert.equal(testItem.modified_unix_date, sut.modified_unix_date);
+    assert.equal(testItem.active, sut.active);
+    assert.equal(testItem.agencyName, sut.agencyName);
+    assert.equal(testItem.agencyCode, sut.agencyCode);
+    assert.equal(testItem.agencyId, sut.agencyId);
+    assert.equal(testItem.importNotes, sut.importNotes);
+    assert.equal(testItem.modified?.toISOString(), sut.modified.toISOString());
+    assert.equal(testItem.shiftStart?.toISOString(), sut.shiftStart.toISOString());
+    assert.equal(testItem.shiftEnd?.toISOString(), sut.shiftEnd.toISOString());
+  });
+});
+

package/src/test/rate-limit.ts

@@ -0,0 +1,33 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("RateLimit", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.RateLimit>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.rateLimit;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.RateLimit(testItem);
+    const sut = await item.save();
+
+    assert.isNotNull(testItem._id);
+    assert.equal(sut.username, testItem.username);
+    assert.equal(sut.modified_unix_date, testItem.modified_unix_date);
+    assert.equal(sut.count, testItem.count);
+  });
+});

package/src/test/release-note.ts

@@ -0,0 +1,36 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("ReleaseNote", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.ReleaseNote>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.releaseNote;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+
+  it("is saved", async function() {
+    const item = new models.ReleaseNote(testItem);
+    const sut = await item.save();
+
+    assert.isNotNull(testItem._id);
+    assert.equal(testItem.title, sut.title);
+    assert.equal(testItem.notes, sut.notes);
+    assert.equal(testItem.version, sut.version);
+    assert.equal(testItem.releaseDate, sut.releaseDate);
+    assert.equal(testItem.status, sut.status);
+  });
+});

package/src/test/session.ts

@@ -0,0 +1,43 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("Session", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.Session>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.session;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.Session(testItem);
+    const sut = await item.save();
+
+    assert.isNotNull(testItem._id);
+    assert.equal(sut.user, testItem.user);
+    assert.equal(sut.email, testItem.email);
+    assert.equal(sut.nick, testItem.nick);
+    assert.isFalse(sut.active);
+    assert.equal(sut.deviceId, testItem.deviceId);
+    assert.equal(sut.remoteAddress, testItem.remoteAddress);
+    assert.equal(sut.userAgent, testItem.userAgent);
+    assert.equal(sut.source, testItem.source);
+    assert.equal(sut.token, testItem.token);
+    assert.equal(sut.ended, testItem.ended);
+    assert.equal(sut.departmentId, testItem.departmentId);
+    assert.equal(sut.when, testItem.when);
+    assert.equal(sut.id, sut._id);
+  });
+});

package/src/test/template.ts

@@ -0,0 +1,44 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("Template", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.Template>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.template;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.Template(testItem);
+    const sut = await item.save();
+
+    assert.isNotNull(item._id);
+    assert.equal(item._id, sut.id);
+    assert.equal(sut.id, sut._id);
+    assert.equal(testItem.position, sut.position);
+    assert.equal(testItem.active, sut.active);
+    assert.equal(testItem.name, sut.name);
+    assert.equal(testItem.userId, sut.userId);
+    assert.equal(testItem.departmentId, sut.departmentId);
+    assert.equal(testItem.isMandatory, sut.isMandatory);
+    assert.isArray(testItem.group);
+    assert.isArray(testItem.checklist);
+    assert.equal(testItem.agencyId, sut.agencyId);
+    const expectedDate = new Date().valueOf() / 1000.0;
+    const timeDelta = expectedDate - sut.modified_unix_date;
+    assert.isTrue(timeDelta < 1);
+  });
+});

package/src/test/user-device.ts

@@ -0,0 +1,66 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("UserDevice", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.UserDevice>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.userDevice;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.UserDevice(testItem);
+    const sut = await item.save();
+
+    assert.isNotNull(testItem._id);
+    assert.equal(sut.id, sut._id);
+    assert.equal(testItem.userId, sut.userId);
+    assert.equal(testItem.departmentId, sut.departmentId);
+    assert.equal(sut.devices.length, 1);
+    if (testItem.devices?.length) {
+      assert.equal(testItem.devices[0]?.token, sut.devices[0]?.token);
+      assert.equal(testItem.devices[0]?.env, sut.devices[0]?.env);
+      assert.equal(testItem.devices[0]?.ua, sut.devices[0]?.ua);
+      assert.equal(testItem.devices[0]?.time, sut.devices[0]?.time);
+      assert.equal(testItem.devices[0]?.drift, sut.devices[0]?.drift);
+      assert.equal(testItem.devices[0]?.bundleIdentifier, sut.devices[0]?.bundleIdentifier);
+      assert.equal(testItem.devices[0]?.silentEnabled, sut.devices[0]?.silentEnabled);
+      assert.equal(testItem.devices[0]?.criticalAlertsEnabled, sut.devices[0]?.criticalAlertsEnabled);
+      assert.equal(testItem.devices[0]?.session, sut.devices[0]?.session);
+      assert.equal(testItem.devices[0]?.active, sut.devices[0]?.active);
+      assert.equal(testItem.devices[0]?.offDuty, sut.devices[0]?.offDuty);
+    } else {
+      assert.equal(testItem.devices?.length, 1);
+    }
+    assert.equal(testItem.notificationCount, sut.notificationCount);
+    if (testItem.notificationIncidentSettings?.length) {
+      assert.equal(JSON.stringify(testItem.notificationIncidentSettings[0]), JSON.stringify(sut.notificationIncidentSettings[0]));
+    } else {
+      assert.equal(testItem.notificationIncidentSettings?.length, 1);
+    }
+    if (testItem.notificationUnitSettings?.length) {
+      assert.equal(JSON.stringify(testItem.notificationUnitSettings[0]), JSON.stringify(sut.notificationUnitSettings[0]));
+    } else {
+      assert.equal(testItem.notificationUnitSettings?.length, 1);
+    }
+    assert.equal(testItem.offDuty, true);
+    assert.equal(testItem.criticalAlertsVolume, "MED");
+    assert.isObject(sut.notificationSounds);
+    assert.deepEqual(sut.notificationSounds, item.notificationSounds);
+    assert.isObject(sut.notificationSounds.ios);
+    assert.isObject(sut.notificationSounds.android);
+  });
+});

package/src/test/user-registration.ts

@@ -0,0 +1,45 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("UserRegistration", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.UserRegistration>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.userRegistration;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.UserRegistration(testItem);
+    const sut = await item.save();
+
+    assert.isNotNull(sut._id);
+    assert.equal(sut.id, sut._id);
+    assert.equal(testItem.email, sut.email);
+    assert.equal(testItem.name, sut.name);
+    assert.equal(testItem.firstName, sut.firstName);
+    assert.equal(testItem.lastName, sut.lastName);
+    assert.equal(testItem.department, sut.department);
+    assert.equal(testItem.title, sut.title);
+    assert.equal(testItem.modifiedDate, sut.modifiedDate);
+    assert.equal(testItem.stage, sut.stage);
+    assert.equal(testItem.presentedAt, sut.presentedAt);
+    assert.equal(testItem.managedIncidentsCount, sut.managedIncidentsCount);
+    assert.equal(testItem.checklistsCount, sut.checklistsCount);
+    assert.equal(testItem.firstIncidentUnixTime, sut.firstIncidentUnixTime);
+    assert.equal(testItem.lastIncidentLocation, sut.lastIncidentLocation);
+    assert.equal(testItem.lastIncidentUnixTime, sut.lastIncidentUnixTime);
+  });
+});

package/src/test/user.ts

@@ -0,0 +1,51 @@
+import { assert } from "chai";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("User", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.User>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.user;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.User(testItem);
+    const sut = await item.save();
+    assert.isNotNull(sut.uuid);
+    assert.isNotNull(testItem._id);
+    assert.equal(sut.nick, testItem.nick);
+    assert.equal(sut.email, testItem.email);
+    assert.equal(sut.mapId, testItem.mapId);
+    assert.equal(sut.departmentId, testItem.departmentId);
+    assert.isFalse(sut.active);
+    assert.isFalse(sut.admin);
+    assert.isFalse(sut.superuser);
+    assert.isTrue(sut.isPro);
+    assert.isTrue(sut.mobileAccess);
+    assert.isFalse(sut.webAccess);
+    assert.isFalse(sut.shareLocationPhone);
+    assert.isTrue(sut.shareLocationTablet);
+    assert.equal(item.uuid, sut.uuid);
+    assert.equal(item.agencyId, sut.agencyId);
+    assert.equal(item.offDutyEnabled, sut.offDutyEnabled);
+    assert.equal(item.managedAgencies[0], sut.managedAgencies[0]);
+    assert.isTrue(sut.offlineMapsEnabled);
+    assert.equal(item.webMapSettings.defaultZoomLevel, 10);
+    assert.equal(item.webMapSettings.defaultCenter[0], 1);
+    assert.equal(item.webMapSettings.defaultCenter[1], 1);
+    assert.equal(item.webMapSettings.defaultMap, "Default");
+    assert.equal(item.restrictedCommentsEnabled, true);
+  });
+});

package/src/test/validation-report.ts

@@ -0,0 +1,33 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("ValidationReport", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.ValidationReport>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.validationReport;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.ValidationReport(testItem);
+    const sut = await item.save();
+
+    assert.isNotNull(item._id);
+    assert.equal(testItem.departmentId?.toString(), sut.departmentId.toString());
+    assert.equal(testItem.modified?.toString(), sut.modified.toString());
+    assert.deepEqual(testItem.location, []);
+  });
+});

package/src/tsconfig.json

@@ -1,5 +1,6 @@
 {
   "compilerOptions": {
+    "baseUrl": "./",
     "declaration": true,
     "declarationDir": "../definitions",
     "declarationMap": true,
@@ -10,12 +11,14 @@
     "noImplicitAny": true,
     "noImplicitReturns": true,
     "noUncheckedIndexedAccess": true,
+    "noUnusedLocals": true,
     "outDir": "../build",
-    "typeRoots": ["./types", "node_modules/@types"],
     "resolveJsonModule": true,
     "sourceMap": true,
     "strict": true,
     "target": "es2017",
-    // "noUnusedLocals": true,
-  }
+    "types": ["node", "mocha"]
+  },
+  "include": ["**/*.ts", "mongoose-lean-virtuals.d.ts"],
+  "exclude": ["node_modules"],
 }

package/src/types/cad.ts

@@ -67,7 +67,7 @@ export interface CADVehicleStatusHistoryType {
   locationDestination: string,
 }
 
-export interface StatusOptionValueType {
+export interface StatusOptionValueType extends Record<string, unknown> {
   name: string,
   type: string,
   visible: boolean,
@@ -100,7 +100,7 @@ export interface CADStatusType {
   normalized: string,
   selfAssignable: boolean,
   roaming: boolean,
-  options: StatusOptionValueType,
+  options: StatusOptionType[],
   color: ColorSchemaType,
   backupDate: Date,
 }

package/src/types/department.ts

@@ -385,4 +385,5 @@ export interface DepartmentType {
   somewear: SomewearType,
   cadBidirectionalException: boolean,
   forwarding: ForwardingConfigType,
+  reportOdometer: string,
 }

package/src/types/location.ts

@@ -5,37 +5,35 @@ import { ColorSchemaType } from "./color";
 export interface LocationType {
   _id: Types.ObjectId,
   id?: string,
-  departmentId: string,
-  userId: string,
-  uuid: string,
-  username: string,
-  device_type: string,
   active: boolean,
-  deleteAfterDate: Date,
-  modified: Date,
-  movedAt: Date,
-  propsChangedAt: Date,
-  version: number,
-  session: string,
+  agencyCode: string,
+  agencyName: string,
   altitude: number,
-  heading: number,
-  speed: number,
+  color: ColorSchemaType,
+  colorChangedAt: Date,
+  deleteAfterDate: Date,
+  departmentId: string,
+  device_type: string,
   esriId: number,
+  heading: number,
+  kindType: string,
+  location?: { latitude: number, longitude: number, }; // provided by virtual.location
   locationGeoJSON: GeoJSONPointType,
+  modified: Date,
+  movedAt: Date,
   opAreaCode: string
   opAreaName: string,
-  agencyCode: string,
-  agencyName: string,
-  shared: boolean,
-  state: string,
+  propsChangedAt: Date,
   sendToCAD: boolean,
-  color: ColorSchemaType,
-  colorChangedAt: Date,
+  session: string,
+  shared: boolean,
   source: string,
-  kindType: string,
+  speed: number,
+  state: string,
   typeDetails: object
-  location?: {
-    latitude: number,
-    longitude: number,
-  };
+  userId: string,
+  username: string,
+  uuid: string,
+  version: number,
+  visibility: string[],
 }

package/tslint.json

@@ -1,28 +0,0 @@
-{
-    "defaultSeverity": "error",
-    "extends": [
-        "tslint:recommended"
-    ],
-    "linterOptions": {
-        "exclude": ["package.json"]
-    },
-    "jsRules": {},
-    "rules": {
-        "quotemark": [true, "double"],
-        "no-var-requires": true,
-        "ordered-imports": false,
-        "object-literal-sort-keys":false,
-        "only-arrow-functions": false,
-        "no-namespace":false,
-        "interface-name":false,
-        "no-shadowed-variable":false,
-        "no-console":false,
-        "no-any": true,
-        "no-unsafe-any":true,
-        "max-line-length":false,
-        "radix":false,
-        "no-floating-promises": true,
-        "no-trailing-whitespace": true
-    },
-    "rulesDirectory": []
-}