tabletcommand-backend-models 5.39.6 → 7.0.0

package/src/models/agency.ts

@@ -1,23 +1,57 @@
 import * as uuid from "uuid";
 import {
-  createModel,
-  createSchema,
   currentDate,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseModule,
-  ReplaceModelReturnType,
   retrieveCurrentUnixTime,
 } from "../helpers";
-import AgencyCronConfigModule from "./schema/agency-cron-config";
-import AgencySAMLModule from "./schema/agency-saml";
+import AgencyCronConfigModule, { AgencyCronConfigType } from "./schema/agency-cron-config";
+import AgencySAMLModule, { AgencySAMLSchemaType } from "./schema/agency-saml";
+import { Model, Types } from "mongoose";
+
+interface AgencyLicensing extends Record<string, unknown> {
+  tcPro: number,
+  tcManager: number,
+  tcStatus: number,
+  tcMobile: number,
+  tcWeb: number,
+  fireMapperPro: number,
+  locationToCAD: number,
+}
+
+interface CrossStaffedUnitType {
+  radioName: string,
+  crossStaffedUnits: string[],
+  alwaysCrossStaff: boolean,
+}
+
+export interface Agency extends Record<string, unknown> {
+  _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,
+}
 
 export function AgencySchema(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+  const { Schema } = mongoose;
   const AgencyCronConfig = AgencyCronConfigModule(mongoose);
   const AgencySAML = AgencySAMLModule(mongoose);
 
-  const CrossStaffedUnit = createSchema(Schema, {
+  const CrossStaffedUnit = new Schema<CrossStaffedUnitType>({
     radioName: {
       type: String,
       default: "",
@@ -45,9 +79,9 @@ export function AgencySchema(mongoose: MongooseModule) {
     locationToCAD: 0
   };
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<Agency>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     code: {
@@ -89,12 +123,12 @@ export function AgencySchema(mongoose: MongooseModule) {
       default: false,
     },
     departmentId: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       ref: "Department",
       required: true
     },
     administrators: {
-      type: [Types.ObjectId],
+      type: [Schema.Types.ObjectId],
       ref: "User",
       default: []
     },
@@ -128,18 +162,14 @@ export function AgencySchema(mongoose: MongooseModule) {
       default: 0,
     },
   }, {
-    collection: "massive_agency",
+    autoIndex: false,
   });
-  modelSchema.set("autoIndex", false);
-
   return modelSchema;
 }
 
-export async function AgencyModule(mongoose: MongooseModule) {
+export default async function AgencyModule(mongoose: MongooseModule) {
   const modelSchema = AgencySchema(mongoose);
-  return createModel(mongoose, "Agency", modelSchema);
+  return mongoose.model<Agency>("Agency", modelSchema, "massive_agency", { overwriteModels: true });
 }
 
-export interface Agency extends ItemTypeFromTypeSchemaFunction<typeof AgencyModule> { }
-export interface AgencyModel extends ModelTypeFromTypeSchemaFunction<Agency> { }
-export default AgencyModule as ReplaceModelReturnType<typeof AgencyModule, AgencyModel>;
+export interface AgencyModel extends Model<Agency> { }

package/src/models/arcgis-group.ts

@@ -1,18 +1,63 @@
 // import * as uuid from "uuid";
+import { Model } from "mongoose";
 import {
-  createModel,
-  createSchema,
   currentDate,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseModule,
-  ReplaceModelReturnType,
 } from "../helpers";
+interface ArcGISGroupUserType {
+  username: string,
+  fullName: string,
+  memberType: string,
+  orgId: string,
+}
+
+interface ArcGISUserInvitationType {
+  username: string,
+  atDate: Date,
+  invitedBy: string,
+}
+
+interface ArcGISDepartmentUserType {
+  username: string,
+  // TC user account email
+  email: string,
+  // TC user id
+  userId: string,
+}
+
+interface ArcGISDepartmentType {
+
+  department: string,
+  departmentId: string,
+  authUsername: string,
+  authError: string,
+  users: ArcGISDepartmentUserType[]
 
-export async function ArcGISGroupModule(mongoose: MongooseModule) {
+}
+
+export interface ArcGISGroup {
+  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,
+
+}
+
+export default async function ArcGISGroupModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const ArcGISGroupUser = createSchema(Schema, {
+  const ArcGISGroupUser = new Schema<ArcGISGroupUserType>({
     username: {
       type: String,
       default: "",
@@ -34,7 +79,7 @@ export async function ArcGISGroupModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const ArcGISUserInvitation = createSchema(Schema, {
+  const ArcGISUserInvitation = new Schema<ArcGISUserInvitationType>({
     username: {
       type: String,
       default: "",
@@ -52,7 +97,7 @@ export async function ArcGISGroupModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const ArcGISDepartmentUser = createSchema(Schema, {
+  const ArcGISDepartmentUser = new Schema<ArcGISDepartmentUserType>({
     // ArcGIS username
     username: {
       type: String,
@@ -73,7 +118,7 @@ export async function ArcGISGroupModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const ArcGISDepartment = createSchema(Schema, {
+  const ArcGISDepartment = new Schema<ArcGISDepartmentType>({
     department: {
       type: String,
       default: "",
@@ -99,7 +144,7 @@ export async function ArcGISGroupModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<ArcGISGroup>({
     // Unique, to be able to use replaceInto
     groupId: {
       type: String,
@@ -166,17 +211,14 @@ export async function ArcGISGroupModule(mongoose: MongooseModule) {
     // if date is in the past, we should refresh this
     // at run success, update this date to a date in the future
     runAt: {
-      type: Date,
+      type: Date || String,
       default: "",
     },
   }, {
-    collection: "massive_arcgis_group",
+    autoIndex: false,
   });
-  modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "ArcGISGroup", modelSchema);
+  return mongoose.model<ArcGISGroup>("ArcGISGroup", modelSchema, "massive_arcgis_group", { overwriteModels: true });
 }
 
-export interface ArcGISGroup extends ItemTypeFromTypeSchemaFunction<typeof ArcGISGroupModule> { }
-export interface ArcGISGroupModel extends ModelTypeFromTypeSchemaFunction<ArcGISGroup> { }
-export default ArcGISGroupModule as ReplaceModelReturnType<typeof ArcGISGroupModule, ArcGISGroupModel>;
+export interface ArcGISGroupModel extends Model<ArcGISGroup> { }

package/src/models/assignment.ts

@@ -1,24 +1,37 @@
 import * as uuid from "uuid";
 
 import {
-  createModel,
-  createSchema,
   currentDate,
-  DocumentTypeFromSchema,
-  ItemTypeFromTypeSchemaFunction,
-  ModelFromSchema,
-  ModelTypeFromTypeSchemaFunction,
   MongooseModule,
-  ReplaceModelReturnType,
   retrieveCurrentUnixTime,
 } from "../helpers";
+import { Model, Types } from "mongoose";
 
-export async function AssignmentModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface Assignment extends Record<string, unknown> {
+  _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,
+}
+
+export default async function AssignmentModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<Assignment>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     uuid: {
@@ -52,7 +65,6 @@ export async function AssignmentModule(mongoose: MongooseModule) {
       type: Number,
       default: retrieveCurrentUnixTime,
     },
-
     //
     position: {
       type: Number,
@@ -71,20 +83,18 @@ export async function AssignmentModule(mongoose: MongooseModule) {
       default: "",
     },
   }, {
-    collection: "massive_assignment",
+    autoIndex: false,
   });
   modelSchema.set("autoIndex", false);
+  modelSchema.virtual("id").get(function (this: Assignment) {
+    return this._id.toString();
+  });
   modelSchema.set("toJSON", {
     virtuals: true,
     versionKey: false,
-    transform(doc: ModelFromSchema<typeof modelSchema>, ret: DocumentTypeFromSchema<typeof modelSchema>) {
-      ret.id = ret._id.toString();
-    },
   });
 
-  return createModel(mongoose, "Assignment", modelSchema);
+  return mongoose.model<Assignment>("Assignment", modelSchema, "massive_assignment", { overwriteModels: true });
 }
 
-export interface Assignment extends ItemTypeFromTypeSchemaFunction<typeof AssignmentModule> { }
-export interface AssignmentModel extends ModelTypeFromTypeSchemaFunction<Assignment> { }
-export default AssignmentModule as ReplaceModelReturnType<typeof AssignmentModule, AssignmentModel>;
+export interface AssignmentModel extends Model<Assignment> { }

package/src/models/battalion.ts

@@ -3,32 +3,52 @@ import * as uuid from "uuid";
 import {
   MongooseModule,
   MongooseDocument,
-  createSchema,
   currentDate,
-  DocumentTypeFromSchema,
-  ModelFromSchema,
-  createModel,
-  FieldsOfDocument,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
   retrieveCurrentUnixTime
 } from "../helpers";
 
-export function BattalionSchema(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
-  const toJSONOpts = {
-    virtuals: true,
-    versionKey: false,
-    transform(doc: DocumentTypeFromSchema<typeof modelSchema>, ret: FieldsOfDocument<DocumentTypeFromSchema<typeof modelSchema>>) {
-      strictSchema(doc.schema, ret);
-      ret.id = ret._id;
-    },
-  };
+import { Model, Types } from "mongoose";
+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 Battalion extends Record<string, unknown> {
+  _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[],
+}
 
-  const BattalionUnit = createSchema(Schema, {
+export function BattalionSchema(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+  const BattalionUnit = new Schema<BattalionUnitType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     name: {
@@ -81,17 +101,28 @@ export function BattalionSchema(mongoose: MongooseModule) {
       type: String,
     },
     agencyId: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       ref: "Agency",
       default: null,
     },
   }, {});
 
-  BattalionUnit.set("toJSON", toJSONOpts);
+  BattalionUnit.virtual("id").get(function (this: MongooseDocument) {
+    // tslint:disable-next-line: no-unsafe-any
+    return this._id.toString();
+  });
+  BattalionUnit.set("toJSON", {
+    virtuals: true,
+    versionKey: false,
+    transform(doc, ret) {
+      strictSchema(doc.schema as typeof modelSchema, ret);
+    },
+  });
 
-  const modelSchema = createSchema(Schema, {
+
+  const modelSchema = new Schema<Battalion>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     name: {
@@ -131,7 +162,7 @@ export function BattalionSchema(mongoose: MongooseModule) {
       index: true,
     },
     agencyId: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       ref: "Agency",
       default: null,
     },
@@ -144,22 +175,21 @@ export function BattalionSchema(mongoose: MongooseModule) {
       default: []
     },
   }, {
-    collection: "massive_battalion",
+    autoIndex: false,
   });
   modelSchema.set("autoIndex", false);
+  modelSchema.virtual("id").get(function (this: MongooseDocument) {
+    // tslint:disable-next-line: no-unsafe-any
+    return this._id.toString();
+  });
   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) {
-    // tslint:disable-next-line: no-unsafe-any
-    return this._id.toString();
-  });
 
   function strictSchema(schema: typeof modelSchema, ret: Record<string, unknown>) {
     Object.keys(ret).forEach(function (element) {
@@ -178,11 +208,9 @@ export function BattalionSchema(mongoose: MongooseModule) {
   return modelSchema;
 }
 
-export async function BattalionModule(mongoose: MongooseModule) {
+export default async function BattalionModule(mongoose: MongooseModule) {
   const modelSchema = BattalionSchema(mongoose);
-  return createModel(mongoose, "Battalion", modelSchema);
+  return mongoose.model<Battalion>("Battalion", modelSchema, "massive_battalion", { overwriteModels: true });
 }
 
-export interface Battalion extends ItemTypeFromTypeSchemaFunction<typeof BattalionModule> { }
-export interface BattalionModel extends ModelTypeFromTypeSchemaFunction<Battalion> { }
-export default BattalionModule as ReplaceModelReturnType<typeof BattalionModule, BattalionModel>;
+export interface BattalionModel extends Model<Battalion> { }

package/src/models/beacon-log.ts

@@ -1,20 +1,25 @@
 import {
   MongooseModule,
-  createSchema,
-  createModel,
   currentDate,
   retrieveCurrentUnixTime,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
+import { Types, Model } from "mongoose";
 
-export async function BeaconLogModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface BeaconLog {
+  _id: Types.ObjectId,
+  departmentId: string,
+  userId: string,
+  object: object,
+  createdAt: Date,
+  modified_unix_date: number,
+}
+
+export default async function BeaconLogModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<BeaconLog>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     departmentId: {
@@ -38,13 +43,10 @@ export async function BeaconLogModule(mongoose: MongooseModule) {
       default: retrieveCurrentUnixTime,
     },
   }, {
-    collection: "massive_beacon_log",
+    autoIndex: false,
   });
-  modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "BeaconLog", modelSchema);
+  return mongoose.model<BeaconLog>("BeaconLog", modelSchema, "massive_beacon_log", { overwriteModels: true });
 }
 
-export interface BeaconLog extends ItemTypeFromTypeSchemaFunction<typeof BeaconLogModule> { }
-export interface BeaconLogModel extends ModelTypeFromTypeSchemaFunction<BeaconLog> { }
-export default BeaconLogModule as ReplaceModelReturnType<typeof BeaconLogModule, BeaconLogModel>;
+export interface BeaconLogModel extends Model<BeaconLog> { }

package/src/models/cad-incident-block.ts

@@ -1,27 +1,34 @@
 import {
   MongooseModule,
   MongooseDocument,
-  createSchema,
-  createModel,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
 
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
 
-import { ReportNumberSchema } from "./schema/shared-incident";
+import { ReportNumberSchema, ReportNumberSchemaType } from "./schema/shared-incident";
+import { Model, Types } from "mongoose";
+export interface CADIncidentBlock {
+  _id: Types.ObjectId,
+  id?: string,
+  departmentId: string,
+  source: string,
+  IncidentNumber: string,
+  AgencyIncidentCallTypeDescription: string,
+  EntryDateTime: string,
+  ClosedDateTime: string,
+  ReportNumber: ReportNumberSchemaType[]
+}
 
-export async function CADIncidentBlockModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export default async function CADIncidentBlockModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
   const ReportNumber = ReportNumberSchema(mongoose);
 
   // Simplified schema.
   // Payload should confirm to cad-incident (more or less)
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<CADIncidentBlock>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     departmentId: {
@@ -55,7 +62,6 @@ export async function CADIncidentBlockModule(mongoose: MongooseModule) {
       default: [],
     }
   }, {
-    collection: "massive_cad_incident_block",
     timestamps: true,
     autoIndex: false,
     toJSON: {
@@ -64,16 +70,14 @@ export async function CADIncidentBlockModule(mongoose: MongooseModule) {
     }
   });
 
-  modelSchema.virtual("id").get(function(this: MongooseDocument) {
+  modelSchema.virtual("id").get(function (this: MongooseDocument) {
     // tslint:disable-next-line: no-unsafe-any
     return this._id.toString();
   });
 
   modelSchema.plugin(mongooseLeanVirtuals);
 
-  return createModel(mongoose, "CADIncidentBlock", modelSchema);
+  return mongoose.model<CADIncidentBlock>("CADIncidentBlock", modelSchema, "massive_cad_incident_block", { overwriteModels: true });
 }
 
-export interface CADIncidentBlock extends ItemTypeFromTypeSchemaFunction<typeof CADIncidentBlockModule> { }
-export interface CADIncidentBlockModel extends ModelTypeFromTypeSchemaFunction<CADIncidentBlock> { }
-export default CADIncidentBlockModule as ReplaceModelReturnType<typeof CADIncidentBlockModule, CADIncidentBlockModel>;
+export interface CADIncidentBlockModel extends Model<CADIncidentBlock> { }

package/src/models/cad-incident-stream.ts

@@ -1,26 +1,32 @@
 import {
   MongooseModule,
   MongooseDocument,
-  createSchema,
-  createModel,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
   currentDate,
 } from "../helpers";
 
 import * as uuid from "uuid";
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
+import { Types, Model } from "mongoose";
+export interface CADIncidentStream {
+  _id: Types.ObjectId,
+  id?: string,
+  uuid: string,
+  tag: string,
+  departmentId: string,
+  incidentNumber: string,
+  createdAt: Date,
+  payload: object,
+}
 
-export async function CADIncidentStreamModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export default async function CADIncidentStreamModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
 
   // Simplified schema.
   // Payload should confirm to cad-incident (more or less)
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<CADIncidentStream>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     uuid: {
@@ -52,23 +58,20 @@ export async function CADIncidentStreamModule(mongoose: MongooseModule) {
     },
   }, {
     autoIndex: false,
-    collection: "massive_cad_incident_stream",
     toJSON: {
       virtuals: true,
       versionKey: false,
     }
   });
 
-  modelSchema.virtual("id").get(function(this: MongooseDocument) {
+  modelSchema.virtual("id").get(function (this: MongooseDocument) {
     // tslint:disable-next-line: no-unsafe-any
     return this._id.toString();
   });
 
   modelSchema.plugin(mongooseLeanVirtuals);
 
-  return createModel(mongoose, "CADIncidentStream", modelSchema);
+  return mongoose.model<CADIncidentStream>("CADIncidentStream", modelSchema, "massive_cad_incident_stream", { overwriteModels: true });
 }
 
-export interface CADIncidentStream extends ItemTypeFromTypeSchemaFunction<typeof CADIncidentStreamModule> { }
-export interface CADIncidentStreamModel extends ModelTypeFromTypeSchemaFunction<CADIncidentStream> { }
-export default CADIncidentStreamModule as ReplaceModelReturnType<typeof CADIncidentStreamModule, CADIncidentStreamModel>;
+export interface CADIncidentStreamModel extends Model<CADIncidentStream> { }