tabletcommand-backend-models 7.0.0 → 7.0.2

package/src/models/battalion.ts

@@ -7,42 +7,10 @@ import {
   retrieveCurrentUnixTime
 } from "../helpers";
 
-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
-}
+import { Model } from "mongoose";
+import { BattalionType, BattalionUnitType } from "../types/battalion";
 
-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[],
-}
+export interface Battalion extends BattalionType, Record<string, unknown> { }
 
 export function BattalionSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
@@ -107,7 +75,7 @@ export function BattalionSchema(mongoose: MongooseModule) {
     },
   }, {});
 
-  BattalionUnit.virtual("id").get(function (this: MongooseDocument) {
+  BattalionUnit.virtual("id").get(function(this: MongooseDocument) {
     // tslint:disable-next-line: no-unsafe-any
     return this._id.toString();
   });
@@ -120,7 +88,7 @@ export function BattalionSchema(mongoose: MongooseModule) {
   });
 
 
-  const modelSchema = new Schema<Battalion>({
+  const modelSchema = new Schema<BattalionType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,
@@ -178,7 +146,7 @@ export function BattalionSchema(mongoose: MongooseModule) {
     autoIndex: false,
   });
   modelSchema.set("autoIndex", 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();
   });
@@ -192,7 +160,7 @@ export function BattalionSchema(mongoose: MongooseModule) {
 
 
   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;

package/src/models/beacon-log.ts

@@ -3,21 +3,15 @@ import {
   currentDate,
   retrieveCurrentUnixTime,
 } from "../helpers";
-import { Types, Model } from "mongoose";
+import { Model } from "mongoose";
+import { BeaconLogType } from "../types/beacon-log";
 
-export interface BeaconLog {
-  _id: Types.ObjectId,
-  departmentId: string,
-  userId: string,
-  object: object,
-  createdAt: Date,
-  modified_unix_date: number,
-}
+export interface BeaconLog extends BeaconLogType { }
 
 export default async function BeaconLogModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const modelSchema = new Schema<BeaconLog>({
+  const modelSchema = new Schema<BeaconLogType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,

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

@@ -5,19 +5,11 @@ import {
 
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
 
-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[]
-}
+import { ReportNumberSchema } from "./schema/shared-incident";
+import { Model } from "mongoose";
+import { CADIncidentBlockType } from "../types/cad";
+
+export interface CADIncidentBlock extends CADIncidentBlockType { }
 
 export default async function CADIncidentBlockModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
@@ -26,7 +18,7 @@ export default async function CADIncidentBlockModule(mongoose: MongooseModule) {
   // Simplified schema.
   // Payload should confirm to cad-incident (more or less)
 
-  const modelSchema = new Schema<CADIncidentBlock>({
+  const modelSchema = new Schema<CADIncidentBlockType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,
@@ -70,7 +62,7 @@ export default 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();
   });

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

@@ -6,17 +6,10 @@ import {
 
 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,
-}
+import { Model } from "mongoose";
+import { CADIncidentStreamType } from "../types/cad";
+
+export interface CADIncidentStream extends CADIncidentStreamType { }
 
 export default async function CADIncidentStreamModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
@@ -24,7 +17,7 @@ export default async function CADIncidentStreamModule(mongoose: MongooseModule)
   // Simplified schema.
   // Payload should confirm to cad-incident (more or less)
 
-  const modelSchema = new Schema<CADIncidentStream>({
+  const modelSchema = new Schema<CADIncidentStreamType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,
@@ -64,7 +57,7 @@ export default async function CADIncidentStreamModule(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();
   });

package/src/models/cad-incident.ts

@@ -3,7 +3,10 @@ import {
   MongooseModule,
 } from "../helpers";
 
-import { CADIncidentSchema, CADIncidentSchemaType } from "./schema/cad-incident";
+import { CADIncidentSchema } from "./schema/cad-incident";
+import { CADIncidentSchemaType } from "../types/cad-incident";
+
+export interface CADIncident extends CADIncidentSchemaType, Record<string, unknown> { }
 
 export default async function CADIncidentModule(mongoose: MongooseModule) {
   const modelSchema = CADIncidentSchema(mongoose);
@@ -18,8 +21,8 @@ export default async function CADIncidentModule(mongoose: MongooseModule) {
     unique: true,
   });
 
-  return mongoose.model<CADIncidentSchemaType>("CADIncident", modelSchema, "massive_incident_cad", { overwriteModels: true });
+  return mongoose.model<CADIncident>("CADIncident", modelSchema, "massive_incident_cad", { overwriteModels: true });
 }
 
-export interface CADIncident extends CADIncidentSchemaType { }
-export interface CADIncidentModel extends Model<CADIncidentSchemaType> { }
+
+export interface CADIncidentModel extends Model<CADIncident> { }

package/src/models/cad-simulation.ts

@@ -1,82 +1,12 @@
-import { Model, Types } from "mongoose";
+import { Model } from "mongoose";
 import {
   currentDate,
   MongooseModule,
 } from "../helpers";
 import * as uuid from "uuid";
+import { SimPriorCommentType, SimPriorIncidentType, SimRadioChannelType, SimCommentType, SimUnitType, SequenceType, CADSimulationType } from "../types/cad";
 
-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[]
-}
-
-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 interface CADSimulation extends CADSimulationType { }
 
 export default async function CADSimulationModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
@@ -198,7 +128,7 @@ export default async function CADSimulationModule(mongoose: MongooseModule) {
     }
   }, {});
 
-  const modelSchema = new Schema<CADSimulation>({
+  const modelSchema = new Schema<CADSimulationType>({
     // Internal
     uuid: {
       type: String,

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

@@ -3,21 +3,9 @@ import {
   currentDate,
   MongooseModule,
 } from "../helpers";
+import { CADStatusMapType, ToStatusIdType } from "../types/cad";
 
-interface ToStatusIdType {
-  statusId: number,
-  userEnabled: boolean,
-  position: number,
-}
-
-export interface CADStatusMap {
-  departmentId: string,
-  modifiedDate: number,
-  modified: Date,
-  fromStatusId: number,
-  toStatusIds: ToStatusIdType[]
-  backupDate: Date,
-}
+export interface CADStatusMap extends CADStatusMapType { }
 
 export default async function CADStatusMapModule(mongoose: MongooseModule) {
   const Schema = mongoose.Schema;

package/src/models/cad-status.ts

@@ -3,46 +3,11 @@ import {
   currentDate,
   MongooseModule,
 } from "../helpers";
-import ColorModule, { ColorSchemaType } from "./schema/color";
+import ColorModule from "./schema/color";
 import { Model } from "mongoose";
+import { StatusOptionValueType, StatusOptionType, CADStatusType } from "../types/cad";
 
-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 interface CADStatus extends CADStatusType { }
 
 export default async function CADStatusModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;

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

@@ -3,30 +3,16 @@ import {
   currentDate,
   MongooseModule,
 } from "../helpers";
-import CADStatusOptionSelectedModule, { CADStatusOptionSelectedSchemaType } from "./schema/cad-status-option-selected";
+import CADStatusOptionSelectedModule from "./schema/cad-status-option-selected";
+import { CADVehicleStatusHistoryType } from "../types/cad";
 
-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 interface CADVehicleStatusHistory extends CADVehicleStatusHistoryType { }
 
 export default async function CADVehicleStatusHistoryModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
   const CADStatusOptionSelected = CADStatusOptionSelectedModule(mongoose);
 
-  const modelSchema = new Schema<CADVehicleStatusHistory>({
+  const modelSchema = new Schema<CADVehicleStatusHistoryType>({
     departmentId: {
       type: String,
       default: "",

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

@@ -3,37 +3,16 @@ import {
   currentDate,
   MongooseModule,
 } from "../helpers";
-import CADStatusOptionSelectedModule, { CADStatusOptionSelectedSchemaType } from "./schema/cad-status-option-selected";
+import CADStatusOptionSelectedModule from "./schema/cad-status-option-selected";
 import { Model } from "mongoose";
+import { CADVehicleStatusType } from "../types/cad";
+
+export interface CADVehicleStatus extends CADVehicleStatusType { }
 
 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;
@@ -56,7 +35,7 @@ export default async function CADVehicleStatusModule(mongoose: MongooseModule) {
   });
 
 
-  const modelSchema = new Schema<CADVehicleStatus>({
+  const modelSchema = new Schema<CADVehicleStatusType>({
     uuid: {
       type: String,
       index: true,

package/src/models/cad-vehicle.ts

@@ -4,24 +4,9 @@ import {
   MongooseModule,
 } from "../helpers";
 import * as uuid from "uuid";
+import { CADVehicleType, StationType } from "../types/cad";
 
-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 interface CADVehicle extends CADVehicleType { }
 
 export default async function CADVehicleModule(mongoose: MongooseModule) {
   const Schema = mongoose.Schema;
@@ -40,7 +25,7 @@ export default async function CADVehicleModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = new Schema<CADVehicle>({
+  const modelSchema = new Schema<CADVehicleType>({
     // Internal
     uuid: {
       type: String,

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

@@ -2,26 +2,13 @@ import {
   MongooseModule,
   MongooseDocument,
 } from "../helpers";
-import { Model, Types } from "mongoose";
+import { Model } from "mongoose";
 
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
+import { ChartDeviceStatsType, ChartItemType } from "../types/chart";
 const defaultDate = new Date("2023-04-19T00:00:00.000Z"); // Chart fallback date, after the feature was implemented
 
-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 interface ChartDeviceStats extends ChartDeviceStatsType { }
 
 export default async function ChartDeviceStatsModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
@@ -64,7 +51,7 @@ export default async function ChartDeviceStatsModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = new Schema<ChartDeviceStats>({
+  const modelSchema = new Schema<ChartDeviceStatsType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,
@@ -92,7 +79,7 @@ export default 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();
   });

package/src/models/chart-incident.ts

@@ -1,24 +1,14 @@
-import { Model, Types } from "mongoose";
+import { Model } from "mongoose";
 import {
   MongooseModule,
   MongooseDocument,
 } from "../helpers";
 
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
+import { ChartIncidentType, ChartItemType } from "../types/chart";
 const defaultDate = new Date("2013-01-01T00:26:40.000Z"); // Chart fallback date, before sync
 
-interface ChartItemType {
-  item: string,
-  dateAt: Date,
-}
-export interface ChartIncident {
-  _id: Types.ObjectId,
-  id?: string,
-  dateAt: Date,
-  departmentId: string,
-  count: number,
-  items: ChartItemType[]
-}
+export interface ChartIncident extends ChartIncidentType { }
 
 export default async function ChartIncidentModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
@@ -37,7 +27,7 @@ export default async function ChartIncidentModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = new Schema<ChartIncident>({
+  const modelSchema = new Schema<ChartIncidentType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,
@@ -69,7 +59,7 @@ export default async function ChartIncidentModule(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();
   });

package/src/models/chart-managed-incident.ts

@@ -1,25 +1,15 @@
-import { Model, Types } from "mongoose";
+import { Model } from "mongoose";
 import {
   MongooseModule,
   MongooseDocument,
 } from "../helpers";
 
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
+import { ChartItemType, ChartManagedIncidentType } from "../types/chart";
+
+export interface ChartManagedIncident extends ChartManagedIncidentType { }
 
 const defaultDate = new Date("2013-01-01T00:26:40.000Z"); // Chart fallback date, before sync
-interface ChartItemType {
-  item: string,
-  dateAt: Date,
-}
-export interface ChartManagedIncident {
-  _id: Types.ObjectId,
-  id?: string,
-  dateAt: Date,
-  departmentId: string,
-  userId: string,
-  count: number,
-  items: ChartItemType[]
-}
 
 export default async function ChartManagedIncidentModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
@@ -38,7 +28,7 @@ export default async function ChartManagedIncidentModule(mongoose: MongooseModul
     id: false,
   });
 
-  const modelSchema = new Schema<ChartManagedIncident>({
+  const modelSchema = new Schema<ChartManagedIncidentType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,
@@ -75,7 +65,7 @@ export default async function ChartManagedIncidentModule(mongoose: MongooseModul
     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();
   });

package/src/models/chart-user.ts

@@ -1,25 +1,19 @@
-import { Model, Types } from "mongoose";
+import { Model } from "mongoose";
 import {
   MongooseModule,
   MongooseDocument,
 } from "../helpers";
 
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
+import { ChartUserType } from "../types/chart";
 const defaultDate = new Date("2013-01-01T00:26:40.000Z"); // Chart fallback date, before sync
 
-export interface ChartUser {
-  _id: Types.ObjectId,
-  id?: string,
-  dateAt: Date,
-  departmentId: string,
-  count: number,
-  items: string[],
-}
+export interface ChartUser extends ChartUserType { }
 
 export default async function ChartUserModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const modelSchema = new Schema<ChartUser>({
+  const modelSchema = new Schema<ChartUserType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,
@@ -51,7 +45,7 @@ export default async function ChartUserModule(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();
   });