tabletcommand-backend-models 5.39.7 → 7.0.1

package/src/models/template.ts

@@ -1,23 +1,19 @@
 import * as uuid from "uuid";
 
 import {
-  createModel,
-  createSchema,
   currentDate,
-  DocumentTypeFromSchema,
-  ItemTypeFromTypeSchemaFunction,
-  ModelFromSchema,
-  ModelTypeFromTypeSchemaFunction,
-  MongooseDocument,
   MongooseModule,
-  ReplaceModelReturnType,
   retrieveCurrentUnixTime
 } from "../helpers";
+import { Model } from "mongoose";
+import { ChecklistOptionType, GroupOptionType, TemplateType } from "../types/template";
+
+export interface Template extends TemplateType, Record<string, unknown> { }
 
 export function TemplateSchema(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+  const { Schema } = mongoose;
 
-  const ChecklistOption = createSchema(Schema, {
+  const ChecklistOption = new Schema<ChecklistOptionType>({
     name: {
       type: String,
       default: "",
@@ -35,7 +31,7 @@ export function TemplateSchema(mongoose: MongooseModule) {
     id: false,
   });
 
-  const GroupOption = createSchema(Schema, {
+  const GroupOption = new Schema<GroupOptionType>({
     name: {
       type: String,
       default: "",
@@ -53,9 +49,9 @@ export function TemplateSchema(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<TemplateType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     position: {
@@ -101,29 +97,28 @@ export function TemplateSchema(mongoose: MongooseModule) {
       default: []
     },
     agencyId: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       ref: "Agency",
       default: null,
     },
   }, {
-    collection: "massive_template",
   });
   modelSchema.set("autoIndex", false);
+  modelSchema.virtual("id").get(function(this: Template) {
+    return this._id.toHexString();
+  });
+
   modelSchema.set("toJSON", {
     virtuals: true,
     versionKey: false,
-    transform(doc: ModelFromSchema<typeof modelSchema>, ret: DocumentTypeFromSchema<typeof modelSchema>) {
+    transform(doc, ret) {
       strictSchema(doc.schema as typeof modelSchema, ret);
-      ret.id = ret._id;
     },
   });
 
-  modelSchema.virtual("id").get(function (this: MongooseDocument) {
-    return this._id.toHexString();
-  });
 
   function strictSchema(schema: typeof modelSchema, ret: Record<string, unknown>) {
-    Object.keys(ret).forEach(function (element) {
+    Object.keys(ret).forEach(function(element) {
       // Don't complain about the virtuals
       if (element === "id") {
         return;
@@ -139,11 +134,9 @@ export function TemplateSchema(mongoose: MongooseModule) {
   return modelSchema;
 }
 
-export async function TemplateModule(mongoose: MongooseModule) {
+export default async function TemplateModule(mongoose: MongooseModule) {
   const modelSchema = TemplateSchema(mongoose);
-  return createModel(mongoose, "Template", modelSchema);
+  return mongoose.model<Template>("Template", modelSchema, "massive_template", { overwriteModels: true });
 }
 
-export interface Template extends ItemTypeFromTypeSchemaFunction<typeof TemplateModule> { }
-export interface TemplateModel extends ModelTypeFromTypeSchemaFunction<Template> { }
-export default TemplateModule as ReplaceModelReturnType<typeof TemplateModule, TemplateModel>;
+export interface TemplateModel extends Model<Template> { }

package/src/models/user-device.ts

@@ -1,18 +1,17 @@
+import { Model } from "mongoose";
 import {
-  createSchema,
-  createModel,
   currentDate,
   MongooseModule,
   retrieveCurrentUnixTime,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
+import { UnitSettingType, IncidentSettingType, DeviceSchemaType, SoundSchemaItemType, SoundSchemaType, UserDeviceType } from "../types/user";
 
-export async function UserDeviceModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface UserDevice extends UserDeviceType { }
 
-  const UnitSetting = createSchema(Schema, {
+export default async function UserDeviceModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+
+  const UnitSetting = new Schema<UnitSettingType>({
     radioName: {
       type: String,
       default: "",
@@ -30,7 +29,7 @@ export async function UserDeviceModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const IncidentSetting = createSchema(Schema, {
+  const IncidentSetting = new Schema<IncidentSettingType>({
     incidentType: {
       type: String,
       default: "",
@@ -48,7 +47,7 @@ export async function UserDeviceModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const deviceSchema = createSchema(Schema, {
+  const deviceSchema = new Schema<DeviceSchemaType>({
     token: {
       type: String,
       default: "",
@@ -115,7 +114,7 @@ export async function UserDeviceModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const soundSchemaItem = createSchema(Schema, {
+  const soundSchemaItem = new Schema<SoundSchemaItemType>({
     sound: {
       type: String,
     },
@@ -131,7 +130,7 @@ export async function UserDeviceModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const soundSchema = createSchema(Schema, {
+  const soundSchema = new Schema<SoundSchemaType>({
     ios: {
       type: soundSchemaItem,
     },
@@ -143,9 +142,9 @@ export async function UserDeviceModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<UserDeviceType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     userId: {
@@ -196,13 +195,10 @@ export async function UserDeviceModule(mongoose: MongooseModule) {
       default: false,
     },
   }, {
-    collection: "massive_user_device",
   });
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "UserDevice", modelSchema);
+  return mongoose.model<UserDevice>("UserDevice", modelSchema, "massive_user_device", { overwriteModels: true });
 }
 
-export interface UserDevice extends ItemTypeFromTypeSchemaFunction<typeof UserDeviceModule> { }
-export interface UserDeviceModel extends ModelTypeFromTypeSchemaFunction<UserDevice> { }
-export default UserDeviceModule as ReplaceModelReturnType<typeof UserDeviceModule, UserDeviceModel>;
+export interface UserDeviceModel extends Model<UserDevice> { }

package/src/models/user-registration.ts

@@ -1,17 +1,16 @@
+import { Model } from "mongoose";
 import {
-  createModel,
-  createSchema,
   currentDate,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseModule,
-  ReplaceModelReturnType,
 } from "../helpers";
+import { UserRegistrationType } from "../types/user";
 
-export async function UserRegistrationModule(mongoose: MongooseModule) {
+export interface UserRegistration extends UserRegistrationType { }
+
+export default async function UserRegistrationModule(mongoose: MongooseModule) {
   const Schema = mongoose.Schema;
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<UserRegistrationType>({
     email: {
       type: String,
       default: "",
@@ -87,13 +86,10 @@ export async function UserRegistrationModule(mongoose: MongooseModule) {
       default: false,
     },
   }, {
-    collection: "massive_user_registration",
+    autoIndex: false
   });
-  modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "UserRegistration", modelSchema);
+  return mongoose.model<UserRegistration>("UserRegistration", modelSchema, "massive_user_registration", { overwriteModels: true });
 }
 
-export interface UserRegistration extends ItemTypeFromTypeSchemaFunction<typeof UserRegistrationModule> { }
-export interface UserRegistrationModel extends ModelTypeFromTypeSchemaFunction<UserRegistration> { }
-export default UserRegistrationModule as ReplaceModelReturnType<typeof UserRegistrationModule, UserRegistrationModel>;
+export interface UserRegistrationModel extends Model<UserRegistration> { }

package/src/models/user.ts

@@ -1,27 +1,24 @@
 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 { Model, Types } from "mongoose";
+import { UserType, VehicleSchemaType } from "../types/user";
+
+export interface User extends UserType, Record<string, unknown> { }
 
 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 +32,7 @@ export function UserSchema(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<UserType>({
     nick: {
       type: String,
       default: "",
@@ -68,7 +65,7 @@ export function UserSchema(mongoose: MongooseModule) {
       type: Date,
     },
     agencyId: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       ref: "Agency",
       default: null,
     },
@@ -267,30 +264,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,24 @@
+import { Model } from "mongoose";
 import {
-  createModel,
-  createSchema,
   currentDate,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseModule,
-  ReplaceModelReturnType,
 } from "../helpers";
 import ValidationErrorItemModule from "./schema/validation-error-item";
+import { ValidationReportType } from "../types/validation";
+
+export interface ValidationReport extends ValidationReportType { }
 
 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 +56,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,19 +1,19 @@
 
 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;
+describe("ArcGISGroup", function() {
+  // let models, 
+  //   mongoose: typeof import("mongoose"),
+  //   mock;
 
-  beforeEach(async function () {
+  beforeEach(async function() {
     const result = await connect(mongoURL);
     console.log(result);
     // models = result.models;
@@ -32,7 +32,7 @@ describe("ArcGISGroup", function () {
     // await mongoose.disconnect();
   });
 
-  it("is saved", async function () {
+  it("is saved", async function() {
     assert.isTrue(true);
   });
 });
@@ -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/src/tsconfig.json

@@ -11,6 +11,7 @@
     "noImplicitReturns": true,
     "noUncheckedIndexedAccess": true,
     "outDir": "../build",
+    "typeRoots": ["./types", "node_modules/@types"],
     "resolveJsonModule": true,
     "sourceMap": true,
     "strict": true,

package/src/types/action-log.ts

@@ -0,0 +1,17 @@
+import { Types } from "mongoose";
+
+export interface ActionLogType {
+  _id: Types.ObjectId,
+  departmentId: string,
+  email: string,
+  userId: string,
+  action: string,
+  object: object,
+  before: object,
+  after: object,
+  delta: object,
+  message: string,
+  createdAt: Date,
+  modified_unix_date: number,
+
+}

package/src/types/agency.ts

@@ -0,0 +1,104 @@
+import { Types } from "mongoose";
+
+export interface EncryptedDataType {
+  iv: string,
+  encryptedData: string,
+}
+
+export interface CronConfigSourceType extends Record<string, unknown> {
+  protocol: string,
+  username: string,
+  hostname: string,
+  filePath: string,
+}
+
+export interface CronConfigAuthType {
+  password: EncryptedDataType | null,
+  sshPrivateKey: EncryptedDataType | null,
+  sshPublicKey: EncryptedDataType | null,
+  useSSHKey: boolean,
+}
+
+export interface CronConfigCSVFieldMapType {
+  PersonnelID: string,
+  PersonnelName: string,
+  PersonnelRank: string,
+  PersonnelWorkCode: string,
+  PersonnelNote: string,
+  StartTime: string,
+  EndTime: string,
+  UnitName: string,
+  TimeFormat: string,
+}
+
+export interface ReconcileTimeOptionsType {
+  enabled: boolean,
+  startTime: string,
+  endTime: string,
+}
+
+export interface AgencyCronConfigType extends Record<string, unknown> {
+  enabled: boolean
+  source: CronConfigSourceType,
+  auth: CronConfigAuthType
+  processPath: string,
+  completedPath: string,
+  importType: string,
+  timezone: string,
+  customApiPath: string,
+  alterChunkSize: boolean,
+  reconcileEnabled: boolean,
+  reconcileTimeOptions: ReconcileTimeOptionsType,
+  hasLabelCustomization: boolean
+  assignmentOverride: boolean,
+  csvFieldMap: CronConfigCSVFieldMapType
+  useAlternateId: boolean
+  strictAgencyCodeMatch: boolean
+}
+
+export interface AgencyLicensing extends Record<string, unknown> {
+  tcPro: number,
+  tcManager: number,
+  tcStatus: number,
+  tcMobile: number,
+  tcWeb: number,
+  fireMapperPro: number,
+  locationToCAD: number,
+}
+
+export interface CrossStaffedUnitType {
+  radioName: string,
+  crossStaffedUnits: string[],
+  alwaysCrossStaff: boolean,
+}
+
+export interface AgencySAMLSchemaType extends Record<string, unknown> {
+  selector: string,
+  idp: string,
+  sp: string,
+  env: string,
+  name: string,
+  jumpPoint: string,
+}
+
+export interface AgencyType {
+  _id: Types.ObjectId,
+  code: string,
+  name: string,
+  domain: string
+  personnelApiKey: string,
+  agencyApiKey: string,
+  uuid: string,
+  modified_unix_date: number,
+  modified: Date,
+  active: boolean,
+  departmentId: Types.ObjectId,
+  administrators: Types.ObjectId[],
+  personnelIntegration: boolean,
+  personnelMonitorHours: number,
+  crossStaffing: CrossStaffedUnitType[],
+  licensing: AgencyLicensing,
+  cronConfig: AgencyCronConfigType,
+  saml: AgencySAMLSchemaType[],
+  activeUserCount: number,
+}

package/src/types/arcgis-group.ts

@@ -0,0 +1,49 @@
+export interface ArcGISGroupUserType {
+  username: string,
+  fullName: string,
+  memberType: string,
+  orgId: string,
+}
+
+export interface ArcGISUserInvitationType {
+  username: string,
+  atDate: Date,
+  invitedBy: string,
+}
+
+export interface ArcGISDepartmentUserType {
+  username: string,
+  // TC user account email
+  email: string,
+  // TC user id
+  userId: string,
+}
+
+export interface ArcGISDepartmentType {
+
+  department: string,
+  departmentId: string,
+  authUsername: string,
+  authError: string,
+  users: ArcGISDepartmentUserType[]
+
+}
+
+export interface ArcGISGroupType {
+  groupId: string,
+  title: string,
+  protected: boolean
+  owner: string,
+  access: string,
+  membershipAccess: string,
+  users: ArcGISGroupUserType[]
+  outsiders: ArcGISGroupUserType[]
+  removableUsers: ArcGISGroupUserType[]
+  externalOrgIds: string[]
+  invited: ArcGISUserInvitationType[]
+  linkedDepartments: ArcGISDepartmentType[]
+  modified: Date,
+  createdBy: string,
+  runAt: Date | string,
+
+}

package/src/types/assignment.ts

@@ -0,0 +1,20 @@
+import { Types } from "mongoose";
+
+export interface AssignmentType {
+  _id: Types.ObjectId,
+  id: string,
+  uuid: string,
+  active: boolean,
+  userId: string,
+  departmentId: string,
+  isMandatory: boolean,
+  modified: Date,
+  // Deprecated
+  modified_date: string,
+  // Deprecated
+  modified_unix_date: number,
+  position: number,
+  name: string,
+  description: string,
+  full_description: string,
+}

package/src/types/battalion.ts

@@ -0,0 +1,37 @@
+import { Types } from "mongoose";
+
+export interface BattalionUnitType extends Record<string, unknown> {
+  _id: Types.ObjectId,
+  id: string,
+  name: string,
+  friendly_id: string,
+  personnel: number,
+  position: number,
+  active: boolean,
+  isMandatory: boolean,
+  modified_date: string,
+  modified_unix_date: number,
+  modified: Date,
+  uuid: string,
+  api_battalion_id: string,
+  battalion_uuid: string,
+  battalion_name: string,
+  agencyId: Types.ObjectId
+}
+
+export interface BattalionType {
+  _id: Types.ObjectId,
+  id?: string,
+  name: string,
+  active: boolean,
+  modified_date: string,
+  modified_unix_date?: number,
+  modified: Date,
+  isMandatory: boolean
+  userId: string,
+  uuid: string,
+  departmentId: string,
+  agencyId: Types.ObjectId,
+  position: number,
+  units: BattalionUnitType[],
+}