tabletcommand-backend-models 5.39.6 → 7.0.0

package/src/models/cad-incident.ts

@@ -1,16 +1,12 @@
+import { Model } from "mongoose";
 import {
-  createModel,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseModule,
-  ReplaceModelReturnType,
 } from "../helpers";
 
-import { CADIncidentSchema } from "./schema/cad-incident";
+import { CADIncidentSchema, CADIncidentSchemaType } from "./schema/cad-incident";
 
-export async function CADIncidentModule(mongoose: MongooseModule) {
+export default async function CADIncidentModule(mongoose: MongooseModule) {
   const modelSchema = CADIncidentSchema(mongoose);
-  modelSchema.set("collection", "massive_incident_cad");
   modelSchema.set("strict", false); // Because we accept all kind of data in
 
   // Indexes
@@ -22,9 +18,8 @@ export async function CADIncidentModule(mongoose: MongooseModule) {
     unique: true,
   });
 
-  return createModel(mongoose, "CADIncident", modelSchema);
+  return mongoose.model<CADIncidentSchemaType>("CADIncident", modelSchema, "massive_incident_cad", { overwriteModels: true });
 }
 
-export interface CADIncident extends ItemTypeFromTypeSchemaFunction<typeof CADIncidentModule> { }
-export interface CADIncidentModel extends ModelTypeFromTypeSchemaFunction<CADIncident> { }
-export default CADIncidentModule as ReplaceModelReturnType<typeof CADIncidentModule, CADIncidentModel>;
+export interface CADIncident extends CADIncidentSchemaType { }
+export interface CADIncidentModel extends Model<CADIncidentSchemaType> { }

package/src/models/cad-simulation.ts

@@ -1,21 +1,87 @@
+import { Model, Types } from "mongoose";
 import {
-  createModel,
-  createSchema,
   currentDate,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseModule,
-  ReplaceModelReturnType,
 } from "../helpers";
 import * as uuid from "uuid";
 
-export async function CADSimulationModule(mongoose: MongooseModule) {
-  const {
-    Schema,
-    Types,
-  } = mongoose;
+interface SimPriorCommentType {
+  Comment?: string,
+  CommentSource?: string,
+  CommentDateTime?: string,
+}
+
+interface SimPriorIncidentType {
+  IncidentNumber: string,
+  IncidentDateTime: string,
+  Problem: string,
+  Address: string,
+  Suite: string,
+  Comment: SimPriorCommentType[]
+}
+interface SimRadioChannelType {
+  name: string,
+  channel: string,
+}
+interface SimCommentType {
+  comment: string,
+  source: string,
+}
+
+interface SimUnitType {
+  alarmLevelAtDispatch: string,
+  units: string[]
+}
+
+interface SequenceType {
+  _id: Types.ObjectId,
+  title: string,
+  alarm: string,
+  sequenceId: number,
+  unitsConfig: SimUnitType
+  comments: SimCommentType[]
+}
 
-  const SimPriorComment = createSchema(Schema, {
+export interface CADSimulation {
+  uuid: string,
+  departmentId: string,
+  modifiedDate: number,
+  modified: Date,
+  active: boolean,
+  friendlyId: string,
+  title: string,
+  notes: string,
+  simulation: boolean,
+  notify: boolean,
+  rts: boolean,
+  tags: string[],
+  incidentType: string,
+  streetName: string,
+  locationComment: string,
+  suite: string,
+  CrossStreet1: string,
+  city: string,
+  state: string,
+  lat: string,
+  lon: string,
+  firemap: string,
+  mapPages: string,
+  tacticalChannel: string,
+  commandChannel: string,
+  radioChannels: SimRadioChannelType[]
+  closeDelay: number,
+  priorIncidents: SimPriorIncidentType[]
+  randomPriorIncidents: boolean
+  randomStaffing: boolean,
+  sequences: SequenceType[]
+  sortId: number,
+  sendStatus: boolean,
+}
+
+export default async function CADSimulationModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+
+  const SimPriorComment = new Schema<SimPriorCommentType>({
     Comment: {
       type: String,
       default: "",
@@ -33,7 +99,7 @@ export async function CADSimulationModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const SimPriorIncident = createSchema(Schema, {
+  const SimPriorIncident = new Schema<SimPriorIncidentType>({
     IncidentNumber: {
       type: String,
       default: "",
@@ -63,7 +129,7 @@ export async function CADSimulationModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const SimRadioChannel = createSchema(Schema, {
+  const SimRadioChannel = new Schema<SimRadioChannelType>({
     name: {
       type: String,
       default: "",
@@ -77,7 +143,7 @@ export async function CADSimulationModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const SimComment = createSchema(Schema, {
+  const SimComment = new Schema<SimCommentType>({
     comment: {
       type: String,
       default: "",
@@ -91,7 +157,7 @@ export async function CADSimulationModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const SimUnit = createSchema(Schema, {
+  const SimUnit = new Schema<SimUnitType>({
     alarmLevelAtDispatch: {
       type: String,
       default: "",
@@ -105,9 +171,9 @@ export async function CADSimulationModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const Sequence = createSchema(Schema, {
-     _id: {
-      type: Types.ObjectId,
+  const Sequence = new Schema<SequenceType>({
+    _id: {
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     title: {
@@ -132,7 +198,7 @@ export async function CADSimulationModule(mongoose: MongooseModule) {
     }
   }, {});
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<CADSimulation>({
     // Internal
     uuid: {
       type: String,
@@ -155,7 +221,7 @@ export async function CADSimulationModule(mongoose: MongooseModule) {
       default: currentDate,
     },
     active: {
-      type: Boolean, 
+      type: Boolean,
       default: true
     },
     friendlyId: {
@@ -171,7 +237,7 @@ export async function CADSimulationModule(mongoose: MongooseModule) {
       default: "",
     },
     simulation: {
-      type: Boolean, 
+      type: Boolean,
       default: true,
     },
     notify: {
@@ -179,11 +245,11 @@ export async function CADSimulationModule(mongoose: MongooseModule) {
       default: false,
     },
     rts: {
-      type: Boolean, 
+      type: Boolean,
       default: false
     },
     tags: {
-      type: [String], 
+      type: [String],
       default: []
     },
     incidentType: {
@@ -251,11 +317,11 @@ export async function CADSimulationModule(mongoose: MongooseModule) {
       default: [],
     },
     randomPriorIncidents: {
-      type: Boolean, 
+      type: Boolean,
       default: false
     },
     randomStaffing: {
-      type: Boolean, 
+      type: Boolean,
       default: false
     },
     sequences: {
@@ -271,13 +337,10 @@ export async function CADSimulationModule(mongoose: MongooseModule) {
       default: false,
     },
   }, {
-    collection: "massive_cad_simulation",
   });
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "CADSimulation", modelSchema);
+  return mongoose.model<CADSimulation>("CADSimulation", modelSchema, "massive_cad_simulation", { overwriteModels: true });
 }
 
-export interface CADSimulation extends ItemTypeFromTypeSchemaFunction<typeof CADSimulationModule> { }
-export interface CADSimulationModel extends ModelTypeFromTypeSchemaFunction<CADSimulation> { }
-export default CADSimulationModule as ReplaceModelReturnType<typeof CADSimulationModule, CADSimulationModel>;
+export interface CADSimulationModel extends Model<CADSimulation> { }

package/src/models/cad-status-map.ts

@@ -1,17 +1,28 @@
+import { Model } from "mongoose";
 import {
-  createModel,
-  createSchema,
   currentDate,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseModule,
-  ReplaceModelReturnType,
 } from "../helpers";
 
-export async function CADStatusMapModule(mongoose: MongooseModule) {
+interface ToStatusIdType {
+  statusId: number,
+  userEnabled: boolean,
+  position: number,
+}
+
+export interface CADStatusMap {
+  departmentId: string,
+  modifiedDate: number,
+  modified: Date,
+  fromStatusId: number,
+  toStatusIds: ToStatusIdType[]
+  backupDate: Date,
+}
+
+export default async function CADStatusMapModule(mongoose: MongooseModule) {
   const Schema = mongoose.Schema;
 
-  const ToStatusIdSchema = createSchema(Schema, {
+  const ToStatusIdSchema = new Schema<ToStatusIdType>({
     statusId: {
       type: Number,
       default: 0,
@@ -31,7 +42,7 @@ export async function CADStatusMapModule(mongoose: MongooseModule) {
   });
 
   // Update static items (keep in sync with the lib/cad-status-map/updateDocument!)
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<CADStatusMap>({
     departmentId: {
       type: String,
       default: "",
@@ -61,13 +72,10 @@ export async function CADStatusMapModule(mongoose: MongooseModule) {
       type: Date,
     },
   }, {
-    collection: "massive_cad_status_map",
   });
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "CADStatusMap", modelSchema);
+  return mongoose.model<CADStatusMap>("CADStatusMap", modelSchema, "massive_cad_status_map", { overwriteModels: true });
 }
 
-export interface CADStatusMap extends ItemTypeFromTypeSchemaFunction<typeof CADStatusMapModule> { }
-export interface CADStatusMapModel extends ModelTypeFromTypeSchemaFunction<CADStatusMap> { }
-export default CADStatusMapModule as ReplaceModelReturnType<typeof CADStatusMapModule, CADStatusMapModel>;
+export interface CADStatusMapModel extends Model<CADStatusMap> { }

package/src/models/cad-status.ts

@@ -1,20 +1,54 @@
 import * as uuid from "uuid";
 import {
-  createModel,
-  createSchema,
   currentDate,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseModule,
-  ReplaceModelReturnType,
 } from "../helpers";
-import ColorModule from "./schema/color";
+import ColorModule, { ColorSchemaType } from "./schema/color";
+import { Model } from "mongoose";
 
-export async function CADStatusModule(mongoose: MongooseModule) {
+interface StatusOptionValueType {
+  name: string,
+  type: string,
+  visible: boolean,
+  value: string,
+  favorite: boolean,
+  position: number,
+  isDefault: boolean,
+  latitude: number,
+  longitude: number,
+  time: number,
+}
+
+interface StatusOptionType {
+  name: string,
+  position: number,
+  visible: boolean,
+  cadKey: string,
+  cadValues: StatusOptionValueType[]
+}
+export interface CADStatus {
+  uuid: string,
+  departmentId: string,
+  modifiedDate: number,
+  modified: Date,
+  statusId: number
+  code: string,
+  codeDisplay: string,
+  status: string,
+  name: string,
+  normalized: string,
+  selfAssignable: boolean,
+  roaming: boolean,
+  options: StatusOptionValueType,
+  color: ColorSchemaType,
+  backupDate: Date,
+}
+
+export default async function CADStatusModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
   const Color = ColorModule(mongoose);
 
-  const StatusOptionValue = createSchema(Schema, {
+  const StatusOptionValue = new Schema<StatusOptionValueType>({
     name: {
       type: String,
       default: "",
@@ -61,7 +95,7 @@ export async function CADStatusModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const StatusOption = createSchema(Schema, {
+  const StatusOption = new Schema<StatusOptionType>({
     name: {
       type: String,
       default: "",
@@ -87,7 +121,7 @@ export async function CADStatusModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<CADStatus>({
     uuid: {
       type: String,
       index: true,
@@ -158,13 +192,10 @@ export async function CADStatusModule(mongoose: MongooseModule) {
       type: Date,
     },
   }, {
-    collection: "massive_cad_status",
   });
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "CADStatus", modelSchema);
+  return mongoose.model<CADStatus>("CADStatus", modelSchema, "massive_cad_status", { overwriteModels: true });
 }
 
-export interface CADStatus extends ItemTypeFromTypeSchemaFunction<typeof CADStatusModule> { }
-export interface CADStatusModel extends ModelTypeFromTypeSchemaFunction<CADStatus> { }
-export default CADStatusModule as ReplaceModelReturnType<typeof CADStatusModule, CADStatusModel>;
+export interface CADStatusModel extends Model<CADStatus> { }

package/src/models/cad-vehicle-status-history.ts

@@ -1,20 +1,32 @@
+import { Model } from "mongoose";
 import {
-  createModel,
-  createSchema,
-  createSchemaDefinition,
   currentDate,
   MongooseModule,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
-import CADStatusOptionSelectedModule from "./schema/cad-status-option-selected";
+import CADStatusOptionSelectedModule, { CADStatusOptionSelectedSchemaType } from "./schema/cad-status-option-selected";
 
-export async function CADVehicleStatusHistoryModule(mongoose: MongooseModule) {
+export interface CADVehicleStatusHistory {
+  departmentId: string,
+  vehicleId: string,
+  radioName: string,
+  status: string,
+  statusCode: string,
+  requestedAt: number,
+  requested: Date,
+  requestDelay: number,
+  requestedBy: string,
+  incidentNumber: string,
+  options: CADStatusOptionSelectedSchemaType[]
+  e: string,
+  locationCurrent: string,
+  locationDestination: string,
+}
+
+export default async function CADVehicleStatusHistoryModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
   const CADStatusOptionSelected = CADStatusOptionSelectedModule(mongoose);
 
-  const modelSchemaConfig = createSchemaDefinition({
+  const modelSchema = new Schema<CADVehicleStatusHistory>({
     departmentId: {
       type: String,
       default: "",
@@ -76,16 +88,11 @@ export async function CADVehicleStatusHistoryModule(mongoose: MongooseModule) {
       type: String,
       default: "",
     },
-  });
-
-  const modelSchema = createSchema(Schema, modelSchemaConfig, {
-    collection: "massive_cad_vehicle_status_history",
+  }, {
   });
 
   modelSchema.set("autoIndex", false);
-  return createModel(mongoose, "CADVehicleStatusHistory", modelSchema);
+  return mongoose.model<CADVehicleStatusHistory>("CADVehicleStatusHistory", modelSchema, "massive_cad_vehicle_status_history", { overwriteModels: true });
 }
 
-export interface CADVehicleStatusHistory extends ItemTypeFromTypeSchemaFunction<typeof CADVehicleStatusHistoryModule> { }
-export interface CADVehicleStatusHistoryModel extends ModelTypeFromTypeSchemaFunction<CADVehicleStatusHistory> { }
-export default CADVehicleStatusHistoryModule as ReplaceModelReturnType<typeof CADVehicleStatusHistoryModule, CADVehicleStatusHistoryModel>;
+export interface CADVehicleStatusHistoryModel extends Model<CADVehicleStatusHistory> { }

package/src/models/cad-vehicle-status.ts

@@ -1,21 +1,45 @@
 import * as  uuid from "uuid";
 import {
-  createModel,
-  createSchema,
-  createSchemaDefinition,
   currentDate,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseModule,
-  ReplaceModelReturnType,
 } from "../helpers";
-import CADStatusOptionSelectedModule from "./schema/cad-status-option-selected";
+import CADStatusOptionSelectedModule, { CADStatusOptionSelectedSchemaType } from "./schema/cad-status-option-selected";
+import { Model } from "mongoose";
 
-export async function CADVehicleStatusModule(mongoose: MongooseModule) {
+interface DestinationType {
+  address: string,
+  name: string,
+}
+export interface CADVehicleStatus {
+  uuid: string,
+  departmentId: string,
+  vehicleId: string,
+  radioName: string,
+  requestTime: number,
+  responseTime: number,
+  changedAt: Date,
+  status: string,
+  statusCode: string,
+  modifiedDate: number,
+  modified: Date,
+  requestStatus: number,
+  owner: string,
+  ownerId: string,
+  incidentNumber: string,
+  options: CADStatusOptionSelectedSchemaType[]
+  capability: string,
+  locationCurrent: string,
+  locationDestination: string,
+  destination: DestinationType,
+  assignableByUser: boolean,
+  backupDate: Date,
+}
+
+export default async function CADVehicleStatusModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
   const CADStatusOptionSelected = CADStatusOptionSelectedModule(mongoose);
 
-  const Destination = createSchema(Schema, {
+  const Destination = new Schema<DestinationType>({
     // eg 1234 Main St
     address: {
       type: String,
@@ -31,7 +55,8 @@ export async function CADVehicleStatusModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchemaConfig = createSchemaDefinition({
+
+  const modelSchema = new Schema<CADVehicleStatus>({
     uuid: {
       type: String,
       index: true,
@@ -134,16 +159,11 @@ export async function CADVehicleStatusModule(mongoose: MongooseModule) {
     backupDate: {
       type: Date,
     },
-  });
-
-  const modelSchema = createSchema(Schema, modelSchemaConfig, {
-    collection: "massive_cad_vehicle_status",
+  }, {
   });
 
   modelSchema.set("autoIndex", false);
-  return createModel(mongoose, "CADVehicleStatus", modelSchema);
+  return mongoose.model<CADVehicleStatus>("CADVehicleStatus", modelSchema, "massive_cad_vehicle_status", { overwriteModels: true });
 }
 
-export interface CADVehicleStatus extends ItemTypeFromTypeSchemaFunction<typeof CADVehicleStatusModule> { }
-export interface CADVehicleStatusModel extends ModelTypeFromTypeSchemaFunction<CADVehicleStatus> { }
-export default CADVehicleStatusModule as ReplaceModelReturnType<typeof CADVehicleStatusModule, CADVehicleStatusModel>;
+export interface CADVehicleStatusModel extends Model<CADVehicleStatus> { }

package/src/models/cad-vehicle.ts

@@ -1,18 +1,32 @@
+import { Model } from "mongoose";
 import {
-  createModel,
-  createSchema,
   currentDate,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseModule,
-  ReplaceModelReturnType,
 } from "../helpers";
 import * as uuid from "uuid";
 
-export async function CADVehicleModule(mongoose: MongooseModule) {
+interface StationType {
+  code: string,
+  name: string,
+}
+export interface CADVehicle {
+  uuid: string,
+  departmentId: string,
+  modifiedDate: number,
+  modified: Date,
+  vehicleId: string
+  radioName: string,
+  station: StationType,
+  capability: string,
+  mapHidden: boolean
+  locationToCAD: boolean,
+  backupDate: Date,
+}
+
+export default async function CADVehicleModule(mongoose: MongooseModule) {
   const Schema = mongoose.Schema;
 
-  const Station = createSchema(Schema, {
+  const Station = new Schema<StationType>({
     code: {
       type: String,
       default: "",
@@ -26,7 +40,7 @@ export async function CADVehicleModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<CADVehicle>({
     // Internal
     uuid: {
       type: String,
@@ -84,13 +98,10 @@ export async function CADVehicleModule(mongoose: MongooseModule) {
       type: Date,
     },
   }, {
-    collection: "massive_cad_vehicle",
   });
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "CADVehicle", modelSchema);
+  return mongoose.model<CADVehicle>("CADVehicle", modelSchema, "massive_cad_vehicle", { overwriteModels: true });
 }
 
-export interface CADVehicle extends ItemTypeFromTypeSchemaFunction<typeof CADVehicleModule> { }
-export interface CADVehicleModel extends ModelTypeFromTypeSchemaFunction<CADVehicle> { }
-export default CADVehicleModule as ReplaceModelReturnType<typeof CADVehicleModule, CADVehicleModel>;
+export interface CADVehicleModel extends Model<CADVehicle> { }

package/src/models/chart-device-stats.ts

@@ -1,20 +1,32 @@
 import {
   MongooseModule,
   MongooseDocument,
-  createSchema,
-  createModel,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
+import { Model, Types } from "mongoose";
 
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
 const defaultDate = new Date("2023-04-19T00:00:00.000Z"); // Chart fallback date, after the feature was implemented
 
-export async function ChartDeviceStatsModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+interface ChartItemType {
+  email: string,
+  dateAt: Date,
+  os: string,
+  osSemVer: string,
+  app: string,
+  appSemVer: string,
+}
+export interface ChartDeviceStats {
+  _id: Types.ObjectId,
+  id?: string,
+  dateAt: Date,
+  departmentId: string,
+  items: ChartItemType[],
+}
+
+export default async function ChartDeviceStatsModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
 
-  const ChartItem = createSchema(Schema, {
+  const ChartItem = new Schema<ChartItemType>({
     // used to keep track of current user, 
     // email + os + app would be a good unique key
     email: {
@@ -52,9 +64,9 @@ export async function ChartDeviceStatsModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<ChartDeviceStats>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     dateAt: {
@@ -72,7 +84,6 @@ export async function ChartDeviceStatsModule(mongoose: MongooseModule) {
       default: [],
     },
   }, {
-    collection: "massive_chart_device_stat",
   });
   modelSchema.set("autoIndex", false);
 
@@ -81,16 +92,14 @@ export async function ChartDeviceStatsModule(mongoose: MongooseModule) {
     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, "ChartDeviceStat", modelSchema);
+  return mongoose.model<ChartDeviceStats>("ChartDeviceStat", modelSchema, "massive_chart_device_stat", { overwriteModels: true });
 }
 
-export interface ChartDeviceStats extends ItemTypeFromTypeSchemaFunction<typeof ChartDeviceStatsModule> { }
-export interface ChartDeviceStatsModel extends ModelTypeFromTypeSchemaFunction<ChartDeviceStats> { }
-export default ChartDeviceStatsModule as ReplaceModelReturnType<typeof ChartDeviceStatsModule, ChartDeviceStatsModel>;
+export interface ChartDeviceStatsModel extends Model<ChartDeviceStats> { }