tabletcommand-backend-models 5.39.6 → 7.0.0

package/src/models/device-mapping.ts

@@ -1,20 +1,36 @@
 import * as  uuid from "uuid";
 import {
-  createSchema,
-  createModel,
   currentDate,
   MongooseModule,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
+import { Model, Types } from "mongoose";
 
-export async function DeviceMappingModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface DeviceMapping {
+  _id: Types.ObjectId,
+  departmentId: string,
+  userId: string,
+  deviceType: string,
+  mapId: string,
+  deviceId: string,
+  location: {
+    longitude: number,
+    latitude: number,
+  },
+  modified_unix_date: number,
+  modified: Date,
+  active: boolean,
+  remoteAddress: string,
+  uuid: string,
+  note: string,
+  mapHidden: boolean,
+}
+
+export default async function DeviceMappingModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<DeviceMapping>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     departmentId: {
@@ -74,13 +90,10 @@ export async function DeviceMappingModule(mongoose: MongooseModule) {
       default: false,
     },
   }, {
-    collection: "massive_device_mapping",
   });
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "DeviceMapping", modelSchema);
+  return mongoose.model<DeviceMapping>("DeviceMapping", modelSchema, "massive_device_mapping", { overwriteModels: true });
 }
 
-export interface DeviceMapping extends ItemTypeFromTypeSchemaFunction<typeof DeviceMappingModule> { }
-export interface DeviceMappingModel extends ModelTypeFromTypeSchemaFunction<DeviceMapping> { }
-export default DeviceMappingModule as ReplaceModelReturnType<typeof DeviceMappingModule, DeviceMappingModel>;
+export interface DeviceMappingModel extends Model<DeviceMapping> { }

package/src/models/esri.ts

@@ -1,27 +1,43 @@
 // import * as uuid from "uuid";
+import { Model, Types } from "mongoose";
 import {
-  createModel,
-  createSchema,
-  DocumentTypeFromSchema,
-  FieldsOfDocument,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseModule,
-  ReplaceModelReturnType,
 } from "../helpers";
-import EsriAuthModule from "./schema/esri-auth";
-import EsriErrorModule from "./schema/esri-error";
-import EsriMapModule from "./schema/esri-map";
-import FireMapperAuthModule from "./schema/firemapper-auth";
+import EsriAuthModule, { EsriAuthSchemaType } from "./schema/esri-auth";
+import EsriErrorModule, { EsriErrorSchemaType } from "./schema/esri-error";
+import EsriMapModule, { EsriMapType } from "./schema/esri-map";
+import FireMapperAuthModule, { FireMapperAuthType } from "./schema/firemapper-auth";
+
+interface MapPropertiesType {
+  itemId: string,
+  download: boolean,
+}
+export interface Esri {
+  _id: Types.ObjectId,
+  id?: string,
+  runAt: Date,
+  departmentId: Types.ObjectId
+  auth: EsriAuthSchemaType,
+  authError: EsriErrorSchemaType,
+  fireMapperAuth: FireMapperAuthType,
+  arcGISGroupIds: string[],
+  arcGISAuth: EsriAuthSchemaType,
+  arcGISMigrated: boolean,
+  review: object,
+  reviewRunAt: Date,
+  maps: EsriMapType[],
+  mapsProperties: MapPropertiesType[],
+  mapLastUpdated: Date,
+}
 
 export function EsriSchema(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+  const { Schema } = mongoose;
   const EsriAuth = EsriAuthModule(mongoose);
   const EsriError = EsriErrorModule(mongoose);
   const EsriMap = EsriMapModule(mongoose);
   const FireMapperAuth = FireMapperAuthModule(mongoose);
 
-  const MapProperties = createSchema(Schema, {
+  const MapProperties = new Schema<MapPropertiesType>({
     // ArcGIS Item id
     itemId: {
       type: String,
@@ -36,9 +52,9 @@ export function EsriSchema(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<Esri>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
 
@@ -48,7 +64,7 @@ export function EsriSchema(mongoose: MongooseModule) {
       default: new Date("1970-01-01T00:00:00.000Z"),
     },
     departmentId: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       ref: "Department",
       required: true
     },
@@ -111,31 +127,25 @@ export function EsriSchema(mongoose: MongooseModule) {
       default: new Date("1970-01-01T00:00:00.000Z"),
     },
   }, {
-    collection: "massive_esri",
   });
   modelSchema.set("autoIndex", false);
 
+  // Deprecated. Check which apps rely on .id instead of using ._id.
+  modelSchema.virtual("id").get(function (this: Esri) {
+    return this._id.toHexString();
+  });
+
   modelSchema.set("toJSON", {
     virtuals: true,
     versionKey: false,
-    // Deprecated. Check which apps rely on .id instead of using ._id.
-    transform(doc: DocumentTypeFromSchema<typeof modelSchema>, ret: FieldsOfDocument<DocumentTypeFromSchema<typeof modelSchema>>) {
-      ret.id = ret._id;
-    },
   });
 
-  // Deprecated. Check which apps rely on .id instead of using ._id.
-  modelSchema.virtual("id").get(function(this: DocumentTypeFromSchema<typeof modelSchema>) {
-    return this._id.toHexString();
-  });
   return modelSchema;
 }
 
-export async function EsriModule(mongoose: MongooseModule) {
+export default async function EsriModule(mongoose: MongooseModule) {
   const modelSchema = EsriSchema(mongoose);
-  return createModel(mongoose, "Esri", modelSchema);
+  return mongoose.model<Esri>("Esri", modelSchema, "massive_esri", { overwriteModels: true });
 }
 
-export interface Esri extends ItemTypeFromTypeSchemaFunction<typeof EsriModule> { }
-export interface EsriModel extends ModelTypeFromTypeSchemaFunction<Esri> { }
-export default EsriModule as ReplaceModelReturnType<typeof EsriModule, EsriModel>;
+export interface EsriModel extends Model<Esri> { }

package/src/models/gst-mapping.ts

@@ -1,21 +1,36 @@
 import * as  uuid from "uuid";
 import {
-  createSchema,
-  createModel,
   currentDate,
   MongooseModule,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
   retrieveCurrentUnixTime,
 } from "../helpers";
+import { Model, Types } from "mongoose";
 
-export async function GSTMappingModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface GSTMapping {
+  _id: Types.ObjectId,
+  departmentId: string,
+  gstAgency: string,
+  deviceType: string,
+  unitId: string,
+  location: {
+    longitude: number,
+    latitude: number,
+  },
+  modified_unix_date: number,
+  modified: Date,
+  active: boolean,
+  mapHidden: boolean,
+  remoteAddress: string,
+  uuid: string,
+  note: string,
+}
+
+export default async function GSTMappingModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<GSTMapping>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     departmentId: {
@@ -36,10 +51,10 @@ export async function GSTMappingModule(mongoose: MongooseModule) {
     },
     location: {
       longitude: {
-          type: Number,
+        type: Number,
       },
       latitude: {
-          type: Number,
+        type: Number,
       },
     },
     modified_unix_date: {
@@ -71,13 +86,10 @@ export async function GSTMappingModule(mongoose: MongooseModule) {
       default: "",
     },
   }, {
-    collection: "massive_gst_mapping",
   });
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "GSTMapping", modelSchema);
+  return mongoose.model<GSTMapping>("GSTMapping", modelSchema, "massive_gst_mapping", { overwriteModels: true });
 }
 
-export interface GSTMapping extends ItemTypeFromTypeSchemaFunction<typeof GSTMappingModule> { }
-export interface GSTMappingModel extends ModelTypeFromTypeSchemaFunction<GSTMapping> { }
-export default GSTMappingModule as ReplaceModelReturnType<typeof GSTMappingModule, GSTMappingModel>;
+export interface GSTMappingModel extends Model<GSTMapping> { }

package/src/models/incident-event.ts

@@ -1,25 +1,43 @@
+import { Model, Types } from "mongoose";
 import {
-  createModel,
-  createSchema,
   currentDate,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseDocument,
   MongooseModule,
-  ReplaceModelReturnType,
   retrieveCurrentUnixTime,
 } from "../helpers";
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
 
-export async function IncidentEventModule(mongoose: MongooseModule) {
-  const modelSchema = IncidentEventSchema(mongoose);
-  return createModel(mongoose, "IncidentEvent", modelSchema);
+interface EventUserType {
+  username: string,
+  email: string,
+  radioName: string,
+  userId: string,
+}
+export interface IncidentEvent {
+  _id: Types.ObjectId,
+  id?: string,
+  departmentId: string,
+  IncidentNumber: string,
+  modified_unix_date: number,
+  modified: Date,
+  message: string,
+  location: {
+    longitude: number,
+    latitude: number,
+  },
+  type: string,
+  user: EventUserType,
+  serverTime: number,
+  userTime: number,
+  uuid: string,
+  ref_uuid: string,
+  opts: object,
+  archived: boolean,
 }
-
 export function IncidentEventSchema(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+  const { Schema } = mongoose;
 
-  const EventUser = createSchema(Schema, {
+  const EventUser = new Schema<EventUserType>({
     username: {
       type: String,
       default: "",
@@ -41,9 +59,9 @@ export function IncidentEventSchema(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<IncidentEvent>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     departmentId: {
@@ -118,14 +136,13 @@ export function IncidentEventSchema(mongoose: MongooseModule) {
       default: false,
     },
   }, {
-    collection: "massive_incident_event",
   });
   modelSchema.set("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();
   });
@@ -135,6 +152,9 @@ export function IncidentEventSchema(mongoose: MongooseModule) {
   return modelSchema;
 }
 
-export interface IncidentEvent extends ItemTypeFromTypeSchemaFunction<typeof IncidentEventModule> { }
-export interface IncidentEventModel extends ModelTypeFromTypeSchemaFunction<IncidentEvent> { }
-export default IncidentEventModule as ReplaceModelReturnType<typeof IncidentEventModule, IncidentEventModel>;
+export default async function IncidentEventModule(mongoose: MongooseModule) {
+  const modelSchema = IncidentEventSchema(mongoose);
+  return mongoose.model<IncidentEvent>("IncidentEvent", modelSchema, "massive_incident_event", { overwriteModels: true });
+}
+
+export interface IncidentEventModel extends Model<IncidentEvent> { }

package/src/models/incident-notified.ts

@@ -1,17 +1,34 @@
+import { Model, Types } from "mongoose";
 import {
-  createSchema,
-  createModel,
   currentDate,
   MongooseModule,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
 
-export async function IncidentNotifiedModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
-  
-  const SentItem = createSchema(Schema, {
+interface SentItemType {
+  name: string,
+  type: string,
+  date: Date,
+}
+
+interface UnitType {
+  UnitID: string,
+  UnitDispatchNumber: string,
+}
+export interface IncidentNotified {
+  _id: Types.ObjectId,
+  departmentId: string,
+  IncidentNumber: string,
+  incidentTypes: string[],
+  units: string[],
+  unitsByDispatch: UnitType[],
+  sent: SentItemType[],
+  updated: Date,
+}
+
+export default async function IncidentNotifiedModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+
+  const SentItem = new Schema<SentItemType>({
     name: {
       type: String,
       default: "",
@@ -29,7 +46,7 @@ export async function IncidentNotifiedModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const Unit = createSchema(Schema, {
+  const Unit = new Schema<UnitType>({
     UnitID: {
       type: String,
       default: "",
@@ -43,9 +60,9 @@ export async function IncidentNotifiedModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<IncidentNotified>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     departmentId: {
@@ -79,13 +96,10 @@ export async function IncidentNotifiedModule(mongoose: MongooseModule) {
       default: currentDate,
     },
   }, {
-    collection: "massive_incident_notified",
   });
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "IncidentNotified", modelSchema);
+  return mongoose.model<IncidentNotified>("IncidentNotified", modelSchema, "massive_incident_notified", { overwriteModels: true });
 }
 
-export interface IncidentNotified extends ItemTypeFromTypeSchemaFunction<typeof IncidentNotifiedModule> { }
-export interface IncidentNotifiedModel extends ModelTypeFromTypeSchemaFunction<IncidentNotified> { }
-export default IncidentNotifiedModule as ReplaceModelReturnType<typeof IncidentNotifiedModule, IncidentNotifiedModel>;
+export interface IncidentNotifiedModel extends Model<IncidentNotified> { }

package/src/models/incident-takeover.ts

@@ -1,19 +1,31 @@
 import * as uuid from "uuid";
 import {
-  createSchema,
-  createModel,
   MongooseModule,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
+import { Model, Types } from "mongoose";
 
-export async function IncidentTakeoverModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface IncidentTakeover {
+  _id: Types.ObjectId,
+  departmentId: string,
+  uuid: string,
+  incident_id: string,
+  incident_name: string,
+  incident_number: string,
+  old_owner: string,
+  new_owner: string,
+  owner: string,
+  status: string,
+  request_time: number,
+  last_response_time: number,
+  response_time: number,
+}
+
+export default async function IncidentTakeoverModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<IncidentTakeover>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     departmentId: {
@@ -72,13 +84,10 @@ export async function IncidentTakeoverModule(mongoose: MongooseModule) {
       default: 0,
     },
   }, {
-    collection: "massive_incident_takeover",
   });
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "IncidentTakeover", modelSchema);
+  return mongoose.model<IncidentTakeover>("IncidentTakeover", modelSchema, "massive_incident_takeover", { overwriteModels: true });
 }
 
-export interface IncidentTakeover extends ItemTypeFromTypeSchemaFunction<typeof IncidentTakeoverModule> { }
-export interface IncidentTakeoverModel extends ModelTypeFromTypeSchemaFunction<IncidentTakeover> { }
-export default IncidentTakeoverModule as ReplaceModelReturnType<typeof IncidentTakeoverModule, IncidentTakeoverModel>;
+export interface IncidentTakeoverModel extends Model<IncidentTakeover> { }

package/src/models/job-log.ts

@@ -1,21 +1,29 @@
+import { Model, Types } from "mongoose";
 import {
-  createModel,
-  createSchema,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseDocument,
   MongooseModule,
-  ReplaceModelReturnType,
   currentDate,
 } from "../helpers";
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
 
-export async function JobLogModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface JobLog {
+  _id: Types.ObjectId,
+  id?: string,
+  jobName: string,
+  host: string,
+  bidDate: Date,
+  startDate: Date,
+  completedDate: Date,
+  state: string
+  forceClosed: boolean,
+}
+
+export default async function JobLogModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<JobLog>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     jobName: {
@@ -44,23 +52,20 @@ export async function JobLogModule(mongoose: MongooseModule) {
       default: false,
     },
   }, {
-    collection: "massive_job_log",
   });
   modelSchema.set("toJSON", {
     virtuals: true,
     versionKey: false,
   });
 
-  modelSchema.virtual("id").get(function(this: MongooseDocument) {
+  modelSchema.virtual("id").get(function (this: MongooseDocument) {
     return this._id.toHexString();
   });
 
   modelSchema.plugin(mongooseLeanVirtuals);
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "JobLog", modelSchema);
+  return mongoose.model<JobLog>("JobLog", modelSchema, "massive_job_log", { overwriteModels: true });
 }
 
-export interface JobLog extends ItemTypeFromTypeSchemaFunction<typeof JobLogModule> { }
-export interface JobLogModel extends ModelTypeFromTypeSchemaFunction<JobLog> { }
-export default JobLogModule as ReplaceModelReturnType<typeof JobLogModule, JobLogModel>;
+export interface JobLogModel extends Model<JobLog> { }

package/src/models/location.ts

@@ -1,27 +1,57 @@
 import * as uuid from "uuid";
 import {
-  createModel,
-  createSchema,
   createSchemaDefinition,
   currentDate,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseDocument,
   MongooseModule,
-  ReplaceModelReturnType,
 } from "../helpers";
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
-import ColorModule from "./schema/color";
-import GeoJSONPointModule from "./schema/geojson-point";
+import ColorModule, { ColorSchemaType } from "./schema/color";
+import GeoJSONPointModule, { GeoJSONPointType } from "./schema/geojson-point";
+import { Model, Types } from "mongoose";
 
-export async function LocationModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface Location extends Record<string, unknown> {
+  _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,
+  altitude: number,
+  heading: number,
+  speed: number,
+  esriId: number,
+  locationGeoJSON: GeoJSONPointType,
+  opAreaCode: string
+  opAreaName: string,
+  agencyCode: string,
+  agencyName: string,
+  shared: boolean,
+  state: string,
+  sendToCAD: boolean,
+  color: ColorSchemaType,
+  colorChangedAt: Date,
+  source: string,
+  kindType: string,
+  typeDetails: object
+}
+
+export default async function LocationModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
   const Color = ColorModule(mongoose);
   const GeoJSONPoint = GeoJSONPointModule(mongoose);
 
   const modelSchemaDefinition = createSchemaDefinition({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     departmentId: {
@@ -175,8 +205,7 @@ export async function LocationModule(mongoose: MongooseModule) {
     },
   });
 
-  const modelSchema = createSchema(Schema, modelSchemaDefinition, {
-    collection: "massive_location",
+  const modelSchema = new Schema<Location>(modelSchemaDefinition, {
   });
 
   modelSchema.set("toJSON", {
@@ -184,11 +213,11 @@ export async function LocationModule(mongoose: MongooseModule) {
     versionKey: false,
   });
 
-  modelSchema.virtual("id").get(function(this: MongooseDocument) {
+  modelSchema.virtual("id").get(function (this: MongooseDocument) {
     return this._id.toHexString();
   });
 
-  modelSchema.virtual("location").get(function(this: { locationGeoJSON: { coordinates: number[] } } | null | undefined) {
+  modelSchema.virtual("location").get(function (this: { locationGeoJSON: { coordinates: number[] } } | null | undefined) {
     const location = {
       latitude: 0,
       longitude: 0
@@ -216,9 +245,7 @@ export async function LocationModule(mongoose: MongooseModule) {
 
   modelSchema.plugin(mongooseLeanVirtuals);
   modelSchema.set("autoIndex", false);
-  return createModel(mongoose, "Location", modelSchema);
+  return mongoose.model<Location>("Location", modelSchema, "massive_location", { overwriteModels: true });
 }
 
-export interface Location extends ItemTypeFromTypeSchemaFunction<typeof LocationModule> { }
-export interface LocationModel extends ModelTypeFromTypeSchemaFunction<Location> { }
-export default LocationModule as ReplaceModelReturnType<typeof LocationModule, LocationModel>;
+export interface LocationModel extends Model<Location> { }