tabletcommand-backend-models 5.39.6 → 7.0.0

package/src/models/user.ts

@@ -1,27 +1,83 @@
 import * as uuid from "uuid";
 import {
-  createSchema,
-  createModel,
-  DocumentTypeFromSchema,
-  FieldsOfDocument,
   MongooseModule,
   MongooseDocument,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
   currentDate,
 } from "../helpers";
-import EsriAuthSchema from "./schema/esri-auth";
-import EsriErrorSchema from "./schema/esri-error";
-import PubNubTokenSchema from "./schema/pubnub-token";
+import EsriAuthSchema, { EsriAuthSchemaType } from "./schema/esri-auth";
+import EsriErrorSchema, { EsriErrorSchemaType } from "./schema/esri-error";
+import PubNubTokenSchema, { PubNubTokenSchemaType } from "./schema/pubnub-token";
+import { Model, Types } from "mongoose";
+
+interface VehicleSchemaType {
+  radioName: string,
+  vehicleId: string,
+}
+
+export interface User extends Record<string, unknown> {
+  _id: Types.ObjectId,
+  id?: string, // Coming from virtuals
+  nick: string,
+  email: string,
+  name: string,
+  uuid: string,
+  departmentId: string,
+  modified_date: Date,
+  when: Date,
+  agencyId: Types.ObjectId,
+  managedAgencies: Types.ObjectId[],
+  active: boolean,
+  admin: boolean,
+  superuser: boolean,
+  isPro: boolean,
+  isIncidentManager: boolean,
+  mobileAccess: boolean,
+  webAccess: boolean,
+  cadSimulatorAccess: boolean,
+  canAddRemoveVehicle: boolean,
+  beaconEnabled: boolean,
+  userContributionEnabled: boolean,
+  syncLoggingExpireDate: Date,
+  beacons: string[],
+  salt: string,
+  pass: string,
+  auth: string[],
+  mapHidden: boolean,
+  mapId: string,
+  vehicle: VehicleSchemaType,
+  sessionCountiPhone: number,
+  sessionCountiPad: number,
+  rtsAuthKey: string,
+  pubNubV2: PubNubTokenSchemaType
+  pubNubV3: PubNubTokenSchemaType
+  socketIO: PubNubTokenSchemaType,
+  token: string,
+  tokenExpireAt: Date,
+  shareLocationPhone: boolean,
+  shareLocationTablet: boolean,
+  offlineMapsEnabled: boolean,
+  fireMapperProEnabled: boolean,
+  arcGISAuth: EsriAuthSchemaType,
+  arcGISAuthError: EsriErrorSchemaType,
+  offDutyEnabled: boolean,
+  webMapSettings: {
+    defaultZoomLevel: number,
+    defaultCenter: number[],
+    defaultMap: string,
+  },
+  locationToCAD: boolean,
+  logOffEnabled: boolean,
+  restrictedCommentsEnabled: boolean,
+  superUserReadOnly: boolean
+}
 
 export function UserSchema(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+  const { Schema } = mongoose;
   const EsriAuth = EsriAuthSchema(mongoose);
   const EsriError = EsriErrorSchema(mongoose);
   const PubNubToken = PubNubTokenSchema(mongoose);
 
-  const VehicleSchema = createSchema(Schema, {
+  const VehicleSchema = new Schema<VehicleSchemaType>({
     radioName: {
       type: String,
       default: "",
@@ -35,7 +91,7 @@ export function UserSchema(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<User>({
     nick: {
       type: String,
       default: "",
@@ -68,7 +124,7 @@ export function UserSchema(mongoose: MongooseModule) {
       type: Date,
     },
     agencyId: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       ref: "Agency",
       default: null,
     },
@@ -267,30 +323,26 @@ export function UserSchema(mongoose: MongooseModule) {
       default: false,
     }
   }, {
-    collection: "sys_user",
+    autoIndex: false,
+  });
+
+  // NO _id on User schema?
+  modelSchema.virtual("id").get(function (this: MongooseDocument) {
+    return this._id.toHexString();
   });
-  modelSchema.set("autoIndex", false);
 
   modelSchema.set("toJSON", {
     virtuals: true,
     versionKey: false,
-    transform(doc: DocumentTypeFromSchema<typeof modelSchema>, ret: FieldsOfDocument<DocumentTypeFromSchema<typeof modelSchema>>) {
-      ret.id = ret._id;
-    },
   });
 
-  modelSchema.virtual("id").get(function(this: MongooseDocument) {
-    return this._id.toHexString();
-  });
 
   return modelSchema;
 }
 
-export async function UserModule(mongoose: MongooseModule) {
+export default async function UserModule(mongoose: MongooseModule) {
   const modelSchema = UserSchema(mongoose);
-  return createModel(mongoose, "User", modelSchema);
+  return mongoose.model<User>("User", modelSchema, "sys_user", { overwriteModels: true });
 }
 
-export interface User extends ItemTypeFromTypeSchemaFunction<typeof UserModule> { }
-export interface UserModel extends ModelTypeFromTypeSchemaFunction<User> { }
-export default UserModule as ReplaceModelReturnType<typeof UserModule, UserModel>;
+export interface UserModel extends Model<User> { }

package/src/models/validation-report.ts

@@ -1,25 +1,34 @@
+import { Model, Types } from "mongoose";
 import {
-  createModel,
-  createSchema,
   currentDate,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseModule,
-  ReplaceModelReturnType,
 } from "../helpers";
-import ValidationErrorItemModule from "./schema/validation-error-item";
+import ValidationErrorItemModule, { ValidationErrorItemSchemaType } from "./schema/validation-error-item";
+
+export interface ValidationReport {
+  _id: Types.ObjectId,
+  departmentId: Types.ObjectId,
+  location: ValidationErrorItemSchemaType[],
+  statusMap: ValidationErrorItemSchemaType[],
+  status: ValidationErrorItemSchemaType[],
+  vehicleStatus: ValidationErrorItemSchemaType[],
+  vehicle: ValidationErrorItemSchemaType[],
+  incident: ValidationErrorItemSchemaType[],
+  personnel: ValidationErrorItemSchemaType[],
+  modified: Date,
+}
 
 export function ValidationReportSchema(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+  const { Schema } = mongoose;
   const ValidationErrorItem = ValidationErrorItemModule(mongoose);
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<ValidationReport>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     departmentId: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       ref: "Department",
       required: true,
       unique: true,
@@ -57,18 +66,15 @@ export function ValidationReportSchema(mongoose: MongooseModule) {
       default: currentDate,
     },
   }, {
-    collection: "massive_validation_report",
   });
   modelSchema.set("autoIndex", false);
 
   return modelSchema;
 }
 
-export async function ValidationReportModule(mongoose: MongooseModule) {
+export default async function ValidationReportModule(mongoose: MongooseModule) {
   const modelSchema = ValidationReportSchema(mongoose);
-  return createModel(mongoose, "ValidationReport", modelSchema);
+  return mongoose.model<ValidationReport>("ValidationReport", modelSchema, "massive_validation_report", { overwriteModels: true });
 }
 
-export interface ValidationReport extends ItemTypeFromTypeSchemaFunction<typeof ValidationReportModule> { }
-export interface ValidationReportModel extends ModelTypeFromTypeSchemaFunction<ValidationReport> { }
-export default ValidationReportModule as ReplaceModelReturnType<typeof ValidationReportModule, ValidationReportModel>;
+export interface ValidationReportModel extends Model<ValidationReport> { }

package/src/test/arcgis-group.ts

@@ -1,17 +1,17 @@
 
 import { assert } from "chai";
 import "mocha";
-import * as _ from "lodash";
+// import * as _ from "lodash";
 
 import { url as mongoURL } from "./config";
 
 import { connect } from "..";
-import MockModule from "./mock";
+// import MockModule from "./mock";
 
 describe("ArcGISGroup", function () {
-  let models, 
-    mongoose: typeof import("mongoose"), 
-    mock;
+  // let models, 
+  //   mongoose: typeof import("mongoose"),
+  //   mock;
 
   beforeEach(async function () {
     const result = await connect(mongoURL);
@@ -56,8 +56,8 @@ describe("ArcGISGroup", function() {
     await mock.cleanup();
   });
 
-  afterEach(function() {
-    mongoose.disconnect();
+  afterEach(async function() {
+    await mongoose.disconnect();
   });
 
   it("is saved", async function() {

package/src/test/mock.ts

@@ -1,13 +1,15 @@
 
 // import * as uuid from "uuid";
-import { Types } from "mongoose";
+// import { Types } from "mongoose";
 
 import { checkIfTestDatabase } from "./config";
 checkIfTestDatabase();
 
-export default function MockModule(dependecies: {
-  models: unknown,
-}) {
+export default function MockModule(
+  // dependecies: {
+  //   models: unknown,
+  // }
+) {
 
   async function cleanup() {
     return "";

package/test/0index.js

@@ -2,21 +2,22 @@
 
 const assert = require("chai").assert;
 
+const mongoose = require("mongoose");
 const m = require("../");
 const config = require("./config");
 
-describe(" Models", function() {
-  let models, mongoose;
-  beforeEach(async function() {
+after(async function () {
+  await mongoose.disconnect();
+})
+
+describe("Models", function () {
+  let models;
+  before(async function () {
     const c = await m.connect(config.url);
     models = c.models;
-    mongoose = c.mongoose;
-  });
-  afterEach(function() {
-    mongoose.disconnect();
   });
 
-  it("are wired", function() {
+  it("are wired", function () {
     // These should match index.js
     assert.isFunction(models.ActionLog, "Missing ActionLog");
     assert.isFunction(models.Agency, "Missing Agency");

package/test/action-log.js

@@ -2,44 +2,34 @@
 
 const assert = require("chai").assert;
 
-const m = require("..");
-const config = require("./config");
 
-describe("ActionLog", function() {
-  let models, mongoose;
-  let testItem;
-  beforeEach(async function() {
-    const c = await m.connect(config.url);
-    models = c.models;
-    mongoose = c.mongoose;
+const mongoose = require('mongoose');
 
+describe("ActionLog", function () {
+  let models = mongoose.models;
+  let testItem;
+  before(async function () {
     const mock = require("./mock")({
       mongoose
     });
     testItem = mock.actionLog;
   });
-  afterEach(function() {
-    mongoose.disconnect();
-  });
-
-  it("is saved", function(done) {
-    var item = new models.ActionLog(testItem);
-    item.save(function(err, sut) {
-      assert.isNull(err, "Should not err");
 
+  it("is saved", async function () {
+    const item = new models.ActionLog(testItem);
+    await item.save().then((ress) => {
       assert.isNotNull(testItem._id);
-      assert.equal(testItem.departmentId, sut.departmentId);
-      assert.equal(testItem.action, sut.action);
-      assert.equal(testItem.email, sut.email);
-      assert.equal(testItem.userId, sut.userId);
-      assert.equal(testItem.object, sut.object);
-      assert.equal(testItem.before, sut.before);
-      assert.equal(testItem.after, sut.after);
-      assert.equal(testItem.delta, sut.delta);
+      assert.equal(testItem.departmentId, ress.departmentId);
+      assert.equal(testItem.action, ress.action);
+      assert.equal(testItem.email, ress.email);
+      assert.equal(testItem.userId, ress.userId);
+      assert.equal(testItem.object, ress.object);
+      assert.equal(testItem.before, ress.before);
+      assert.equal(testItem.after, ress.after);
+      assert.equal(testItem.delta, ress.delta);
       const expectedDate = new Date().valueOf() / 1000.0;
-      const timeDelta = expectedDate - sut.modified_unix_date;
+      const timeDelta = expectedDate - ress.modified_unix_date;
       assert.isTrue(timeDelta < 1);
-      return done();
-    });
+    }).catch((err) => { assert.isNull(err, "Should not err"); });
   });
 });

package/test/agency.js

@@ -1,45 +1,33 @@
 "use strict";
 
 const assert = require("chai").assert;
+const mongoose = require('mongoose');
 
-const m = require("..");
-const config = require("./config");
-
-describe("Agency", function() {
-  let models, mongoose;
+describe("Agency", function () {
+  let models = mongoose.models;;
   let testItem;
-  beforeEach(async function() {
-    const c = await m.connect(config.url);
-    models = c.models;
-    mongoose = c.mongoose;
-
+  beforeEach(async function () {
     const mock = require("./mock")({
       mongoose
     });
     testItem = mock.agency;
   });
-  afterEach(function() {
-    mongoose.disconnect();
-  });
-
-  it("is saved", function(done) {
-    var item = new models.Agency(testItem);
-    item.save(function(err, sut) {
-      assert.isNull(err, "Should not err");
 
+  it("is saved", async function () {
+    const item = new models.Agency(testItem);
+    item.save().then((ress) => {
       assert.isNotNull(testItem._id);
-      assert.equal(testItem.departmentId, sut.departmentId);
-      assert.equal(testItem.active, sut.active);
-      assert.equal(testItem.code, sut.code);
-      assert.equal(testItem.name, sut.name);
+      assert.equal(testItem.departmentId, ress.departmentId);
+      assert.equal(testItem.active, ress.active);
+      assert.equal(testItem.code, ress.code);
+      assert.equal(testItem.name, ress.name);
       assert.equal(testItem.administrators.length, 1);
-      assert.equal(testItem.personnelIntegration, sut.personnelIntegration);
-      assert.equal(testItem.personnelMonitorHours, sut.personnelMonitorHours);
+      assert.equal(testItem.personnelIntegration, ress.personnelIntegration);
+      assert.equal(testItem.personnelMonitorHours, ress.personnelMonitorHours);
       assert.equal(testItem.crossStaffing.length, 1);
       const expectedDate = new Date().valueOf() / 1000.0;
-      const timeDelta = expectedDate - sut.modified_unix_date;
+      const timeDelta = expectedDate - ress.modified_unix_date;
       assert.isTrue(timeDelta < 1);
-      return done();
-    });
+    }).catch((err) => { assert.isNull(err, "Should not err"); });
   });
 });

package/test/arcgis-group.js

@@ -3,16 +3,12 @@
 const assert = require("chai").assert;
 const _ = require("lodash");
 
-const m = require("..");
-const config = require("./config");
+const mongoose = require('mongoose');
 
-describe("ArcGISGroup", function() {
-  let models, mongoose, mock;
-
-  beforeEach(async function() {
-    const c = await m.connect(config.url);
-    models = c.models;
-    mongoose = c.mongoose;
+describe("ArcGISGroup", function () {
+  const models = mongoose.models;
+  let mock;
+  beforeEach(async function () {
     mock = require("./mock")({
       models,
       mongoose,
@@ -20,11 +16,7 @@ describe("ArcGISGroup", function() {
     await mock.cleanup();
   });
 
-  afterEach(function() {
-    mongoose.disconnect();
-  });
-
-  it("is saved", async function() {
+  it("is saved", async function () {
     const testItem = mock.arcGISGroup;
     assert.isObject(testItem);
     const item = new models.ArcGISGroup(testItem);

package/test/assignment.js

@@ -2,41 +2,33 @@
 
 const assert = require("chai").assert;
 
-const m = require("..");
-const config = require("./config");
+const mongoose = require('mongoose');
 
-describe("Assignment", function() {
-  let models, mongoose;
+describe("Assignment", function () {
+  let models = mongoose.models;
   let testItem;
-  beforeEach(async function() {
-    const c = await m.connect(config.url);
-    models = c.models;
-    mongoose = c.mongoose;
-
+  beforeEach(async function () {
     const mock = require("./mock")({
       mongoose
     });
     testItem = mock.assignment;
   });
-  afterEach(function() {
-    mongoose.disconnect();
-  });
 
-  it("is saved", async function() {
+  it("is saved", async function () {
     const item = new models.Assignment(testItem);
-    const sut = await item.save();
+    const ress = await item.save();
 
     assert.isNotNull(testItem._id);
-    assert.equal(sut._id.toString(), sut.id.toString());
+    assert.equal(ress._id.toString(), ress.id.toString());
 
-    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.equal(testItem.position, ress.position);
+    assert.equal(testItem.active, ress.active);
+    assert.equal(testItem.name, ress.name);
+    assert.equal(testItem.userId, ress.userId);
+    assert.equal(testItem.departmentId, ress.departmentId);
+    assert.equal(testItem.isMandatory, ress.isMandatory);
     const expectedDate = new Date().valueOf() / 1000.0;
-    const timeDelta = expectedDate - sut.modified_unix_date;
+    const timeDelta = expectedDate - ress.modified_unix_date;
     assert.isTrue(timeDelta < 1);
   });
 });

package/test/battalion.js

@@ -2,45 +2,35 @@
 
 const assert = require("chai").assert;
 
-const m = require("..");
-const config = require("./config");
+const mongoose = require('mongoose');
 
 describe("Battalion", function() {
-  let models, mongoose;
+  let models = mongoose.models;
   let testItem;
   beforeEach(async function() {
-    const c = await m.connect(config.url);
-    models = c.models;
-    mongoose = c.mongoose;
-
     const mock = require("./mock")({
       mongoose
     });
     testItem = mock.battalion;
   });
-  afterEach(function() {
-    mongoose.disconnect();
-  });
 
-  it("is saved", function(done) {
+  it("is saved", function() {
     var item = new models.Battalion(testItem);
-    item.save(function(err, sut) {
-      assert.isNull(err, "Should not err");
+    item.save().then((ress) => {
 
       assert.isNotNull(testItem._id);
-      assert.equal(testItem.departmentId, sut.departmentId);
-      assert.equal(testItem.active, sut.active);
-      assert.equal(testItem.isMandatory, sut.isMandatory);
-      assert.equal(testItem.name, sut.name);
-      assert.equal(testItem.userId, sut.userId);
-      assert.equal(testItem.position, sut.position);
-      assert.equal(testItem.agencyId, sut.agencyId);
-      assert.equal(testItem.local_id, sut.local_id);
+      assert.equal(testItem.departmentId, ress.departmentId);
+      assert.equal(testItem.active, ress.active);
+      assert.equal(testItem.isMandatory, ress.isMandatory);
+      assert.equal(testItem.name, ress.name);
+      assert.equal(testItem.userId, ress.userId);
+      assert.equal(testItem.position, ress.position);
+      assert.equal(testItem.agencyId, ress.agencyId);
+      assert.equal(testItem.local_id, ress.local_id);
       assert.equal(testItem.units.length, 1);
       const expectedDate = new Date().valueOf() / 1000.0;
-      const timeDelta = expectedDate - sut.modified_unix_date;
+      const timeDelta = expectedDate - ress.modified_unix_date;
       assert.isTrue(timeDelta < 1);
-      return done();
-    });
+    }).catch((err) => { assert.isNull(err, "Should not err"); });
   });
 });

package/test/cad-incident-block.js

@@ -3,16 +3,12 @@
 const _ = require("lodash");
 const assert = require("chai").assert;
 
-const m = require("..");
-const config = require("./config");
+const mongoose = require('mongoose');
 
 describe("CADIncidentBlock", function() {
-  let models, mongoose;
+  let models = mongoose.models;
   let testItem;
   beforeEach(async function() {
-    const c = await m.connect(config.url);
-    models = c.models;
-    mongoose = c.mongoose;
 
     const mock = require("./mock")({
       mongoose
@@ -20,24 +16,22 @@ describe("CADIncidentBlock", function() {
     testItem = mock.cadIncidentBlock;
     await mock.beforeEach();
   });
-  afterEach(function() {
-    mongoose.disconnect();
-  });
+
 
   it("is saved", async function() {
     const item = new models.CADIncidentBlock(testItem);
-    const sut = await item.save();
+    const ress = await item.save();
 
     assert.isNotNull(testItem._id);
-    assert.equal(sut.EntryDateTime, testItem.EntryDateTime);
-    assert.equal(sut.ClosedDateTime, testItem.ClosedDateTime);
-    assert.equal(sut.source, testItem.source);
-    assert.equal(sut.IncidentNumber, testItem.IncidentNumber);
-    assert.equal(sut.departmentId, testItem.departmentId);
-    assert.equal(sut.AgencyIncidentCallTypeDescription, testItem.AgencyIncidentCallTypeDescription);
-    assert.equal(sut.createdAt.toISOString(), new Date(testItem.createdAt).toISOString());
-    assert.equal(sut.ReportNumber.length, 1);
-    const rn = _.first(sut.ReportNumber);
+    assert.equal(ress.EntryDateTime, testItem.EntryDateTime);
+    assert.equal(ress.ClosedDateTime, testItem.ClosedDateTime);
+    assert.equal(ress.source, testItem.source);
+    assert.equal(ress.IncidentNumber, testItem.IncidentNumber);
+    assert.equal(ress.departmentId, testItem.departmentId);
+    assert.equal(ress.AgencyIncidentCallTypeDescription, testItem.AgencyIncidentCallTypeDescription);
+    assert.equal(ress.createdAt.toISOString(), new Date(testItem.createdAt).toISOString());
+    assert.equal(ress.ReportNumber.length, 1);
+    const rn = _.first(ress.ReportNumber);
     assert.equal(rn.name, "Incident");
     assert.equal(rn.number, "CA68");
   });