tabletcommand-backend-models 5.39.6 → 7.0.0

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

@@ -1,52 +1,205 @@
 import {
-  createSchema,
   currentDate,
-  DocumentTypeFromSchema,
-  FieldsOfDocument,
-  ModelFromSchema,
-  MongooseDocument,
   MongooseModule,
 } from "../../helpers";
 
 import * as uuid from "uuid";
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
-import { IncidentEventSchema } from "../incident-event";
+import { IncidentEventSchema, IncidentEvent } from "../incident-event";
 import {
   CADPersonSchema,
+  CADPersonSchemaType,
   RadioChannelSchema,
+  RadioChannelSchemaType,
   RecordSchema,
+  RecordSchemaType,
   ReportNumberSchema,
+  ReportNumberSchemaType,
   SharedSourceSchema,
+  SharedSourceSchemaType,
   SharedToSchema,
+  SharedToSchemaType,
 } from "./shared-incident";
+import { Types } from "mongoose";
 
-export function CADIncidentSchema(mongoose: MongooseModule) {
-  const toJSONOpts = {
-    versionKey: false,
-    transform(doc: DocumentTypeFromSchema<typeof modelSchema>, ret: FieldsOfDocument<DocumentTypeFromSchema<typeof modelSchema>>) {
-      strictSchema(doc.schema, ret);
-    },
-  };
+interface CADCommentOptsTypes {
+  type: string,
+  item: string,
+}
+
+interface CADCommentType extends Record<string, unknown> {
+  Comment: string,
+  CommentSource: string,
+  CommentDateTime: string,
+  CommentConfidential: boolean,
+  CommentOpts: CADCommentOptsTypes
+}
+
+interface CADUnitType extends Record<string, unknown> {
+  UnitID: string,
+  UnitDispatchNumber: string,
+  AlarmAtDispatch: string,
+  TimeDispatched: string,
+  TimeEnroute: string,
+  TimeArrived: string,
+  TimeStaged: string,
+  TimeCleared: string,
+  TimeAtHospital: string,
+  TimePatient: string,
+  TimeTransport: string,
+  TimeTransporting: string,
+  PersonnelCount: number,
+  Personnel: CADPersonSchemaType[],
+  uuid: string,
+}
 
-  const { Schema, Types } = mongoose;
+interface APNNotificationTypeType {
+  name: string,
+  value: string,
+}
+
+interface CADPriorIncidentType {
+  Address: string,
+  Comment: CADCommentType[],
+  IncidentDateTime: string,
+  IncidentNumber: string,
+  Jurisdiction: string,
+  Problem: string,
+  Suite: string,
+}
+export interface CADIncidentSchemaType extends Record<string, unknown> {
+  _id: Types.ObjectId,
+  id?: string,
+  uuid: string,
+  departmentId: string,
+  AgencyID: string,
+  IncidentNumber: string,
+  TransactionID: string,
+  AgencyIncidentCallTypeDescription: string,
+  AgencyIncidentCallType: string,
+  AgencyIncidentCallSubTypeDescription: string,
+  AgencyIncidentCallSubType: string,
+  AgencyIncidentPriorityDescription: string,
+  PulsePointIncidentCallType: string,
+  PulsePointDeterminantCode: string,
+  AlarmLevel: string,
+  CommandName: string,
+  FireMap: string,
+  TBMap: string,
+  MapPages: string,
+  TacticalChannel: string,
+  TacticalAltChannel: string,
+  CommandChannel: string,
+  EntryDateTime: string,
+  ClosedDateTime: string,
+  CallReceivedDateTime: string,
+  DispatchDateTime: string,
+  IncidentLastUpdate: string,
+  EnrouteDateTime: string,
+  OnSceneDateTime: string,
+  modified_date: string,
+  modified_unix_date: number
+  modified: Date,
+  start_unix_date: number,
+  closed_unix_date: number,
+  queued_at: number,
+  scheduled_at: number,
+  ignored: boolean,
+  expiration_date: Date,
+  StreetName: string,
+  StreetSuffix: string,
+  Predirectional: string,
+  Postdirectional: string,
+  CityOrLocality: string,
+  StateOrProvince: string,
+  StateOfProvince: string,
+  CommonPlaceName: string,
+  CrossStreet1: string,
+  CrossStreet2: string,
+  StreetNumber: string,
+  Building: string,
+  Floor: string,
+  Suite: string,
+  City: string,
+  County: string,
+  PostalCode: string,
+  CrossStreetName: string,
+  LocationComment: string,
+  full_address: string,
+  address: string,
+  cross_streets: string,
+  PriorIncidentChanged: boolean,
+  PriorIncident: CADPriorIncidentType[],
+  CallerNumber: string,
+  ReportNumber: ReportNumberSchemaType[]
+  radioChannels: RadioChannelSchemaType[],
+  Latitude: number,
+  Longitude: number,
+  Comment: CADCommentType[]
+  units: CADUnitType[]
+  events: IncidentEvent[],
+  preference_location: string,
+  simulation: boolean,
+  simulationId: string,
+  simulationSequences: number[],
+  notify: boolean,
+  rts: boolean,
+  notificationType: APNNotificationTypeType[],
+  sharedTo: SharedToSchemaType[],
+  sharedSource: SharedSourceSchemaType,
+  record: RecordSchemaType,
+}
+
+export function CADIncidentSchema(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
   const IncidentEvent = IncidentEventSchema(mongoose);
 
   // Share incident properties - copy to managed incidents
   const CADPerson = CADPersonSchema(mongoose);
-  CADPerson.set("toJSON", toJSONOpts);
+  CADPerson.set("toJSON", {
+    versionKey: false,
+    transform(doc, ret) {
+      strictSchema(doc.schema as typeof modelSchema, ret);
+    }
+  });
   const RadioChannel = RadioChannelSchema(mongoose);
-  RadioChannel.set("toJSON", toJSONOpts);
+  RadioChannel.set("toJSON", {
+    versionKey: false,
+    transform(doc, ret) {
+      strictSchema(doc.schema as typeof modelSchema, ret);
+    }
+  });
   const RecordValue = RecordSchema(mongoose);
-  RecordValue.set("toJSON", toJSONOpts);
+  RecordValue.set("toJSON", {
+    versionKey: false,
+    transform(doc, ret) {
+      strictSchema(doc.schema as typeof modelSchema, ret);
+    }
+  });
   const ReportNumber = ReportNumberSchema(mongoose);
-  ReportNumber.set("toJSON", toJSONOpts);
+  ReportNumber.set("toJSON", {
+    versionKey: false,
+    transform(doc, ret) {
+      strictSchema(doc.schema as typeof modelSchema, ret);
+    }
+  });
   const SharedSource = SharedSourceSchema(mongoose);
-  SharedSource.set("toJSON", toJSONOpts);
+  SharedSource.set("toJSON", {
+    versionKey: false,
+    transform(doc, ret) {
+      strictSchema(doc.schema as typeof modelSchema, ret);
+    }
+  });
   const SharedTo = SharedToSchema(mongoose);
-  SharedTo.set("toJSON", toJSONOpts);
+  SharedTo.set("toJSON", {
+    versionKey: false,
+    transform(doc, ret) {
+      strictSchema(doc.schema as typeof modelSchema, ret);
+    }
+  });
 
   // Currently, supporting type: "ack", item: "knife"
-  const CADCommentOpts = createSchema(Schema, {
+  const CADCommentOpts = new Schema<CADCommentOptsTypes>({
     type: {
       type: String,
     },
@@ -57,9 +210,11 @@ export function CADIncidentSchema(mongoose: MongooseModule) {
     _id: false,
     id: false,
   });
-  CADCommentOpts.set("toJSON", toJSONOpts);
+  CADCommentOpts.set("toJSON", {
 
-  const CADComment = createSchema(Schema, {
+  });
+
+  const CADComment = new Schema<CADCommentType>({
     Comment: {
       type: String,
     },
@@ -80,9 +235,14 @@ export function CADIncidentSchema(mongoose: MongooseModule) {
     _id: false,
     id: false,
   });
-  CADComment.set("toJSON", toJSONOpts);
+  CADComment.set("toJSON", {
+    versionKey: false,
+    transform(doc, ret) {
+      strictSchema(doc.schema as typeof modelSchema, ret);
+    }
+  });
 
-  const CADUnit = createSchema(Schema, {
+  const CADUnit = new Schema<CADUnitType>({
     UnitID: {
       type: String,
       required: true,
@@ -137,9 +297,14 @@ export function CADIncidentSchema(mongoose: MongooseModule) {
     _id: false,
     id: false,
   });
-  CADUnit.set("toJSON", toJSONOpts);
+  CADUnit.set("toJSON", {
+    versionKey: false,
+    transform(doc, ret) {
+      strictSchema(doc.schema as typeof modelSchema, ret);
+    }
+  });
 
-  const APNNotificationType = createSchema(Schema, {
+  const APNNotificationType = new Schema<APNNotificationTypeType>({
     name: {
       type: String,
     },
@@ -150,9 +315,14 @@ export function CADIncidentSchema(mongoose: MongooseModule) {
     _id: false,
     id: false,
   });
-  APNNotificationType.set("toJSON", toJSONOpts);
+  APNNotificationType.set("toJSON", {
+    versionKey: false,
+    transform(doc, ret) {
+      strictSchema(doc.schema as typeof modelSchema, ret);
+    }
+  });
 
-  const CADPriorIncident = createSchema(Schema, {
+  const CADPriorIncident = new Schema<CADPriorIncidentType>({
     Address: {
       type: String,
     },
@@ -178,12 +348,17 @@ export function CADIncidentSchema(mongoose: MongooseModule) {
     _id: false,
     id: false,
   });
-  CADPriorIncident.set("toJSON", toJSONOpts);
+  CADPriorIncident.set("toJSON", {
+    versionKey: false,
+    transform(doc, ret) {
+      strictSchema(doc.schema as typeof modelSchema, ret);
+    }
+  });
 
   // Main schema
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<CADIncidentSchemaType>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     uuid: {
@@ -481,29 +656,26 @@ export function CADIncidentSchema(mongoose: MongooseModule) {
     // collection: "massive_incident_cad",
     // strict: false, // Because we accept all kind of data in
   });
+  modelSchema.virtual("id").get(function (this: CADIncidentSchemaType) {
+    return this._id.toString();
+  });
 
   modelSchema.set("toJSON", {
     virtuals: true,
     versionKey: false,
-    transform(doc: ModelFromSchema<typeof modelSchema>, ret: DocumentTypeFromSchema<typeof modelSchema>) {
+    transform(doc, ret: Record<string, unknown>) {
       // Remove fields that should not be here
       delete (ret as unknown as { apikey: unknown }).apikey;
 
       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();
-  });
 
   const ignoreFields: ReadonlyArray<string> = ["station", "callerNumber"];
 
   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/schema/cad-status-option-selected.ts

@@ -1,12 +1,18 @@
 import {
   MongooseModule,
-  createSchema,
 } from "../../helpers";
 
+export interface CADStatusOptionSelectedSchemaType {
+  name: string,
+  type: string,
+  value: string,
+  key: string,
+}
+
 export default function CADStatusOptionSelectedSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const Item = createSchema(Schema, {
+  const Item = new Schema<CADStatusOptionSelectedSchemaType>({
     name: {
       type: String,
       default: "",

package/src/models/schema/color.ts

@@ -1,12 +1,16 @@
 import {
   MongooseModule,
-  createSchema,
 } from "../../helpers";
 
+export interface ColorSchemaType extends Record<string, unknown> {
+  background: string,
+  text: string,
+}
+
 export default function ColorSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const Color = createSchema(Schema, {
+  const Color = new Schema<ColorSchemaType>({
     background: {
       type: String,
       default: "#851414", // Red-like

package/src/models/schema/esri-auth.ts

@@ -1,12 +1,21 @@
 import {
-  createSchema,
   MongooseModule,
 } from "../../helpers";
 
+interface EsriAuthPasswordType {
+  iv: string,
+  encryptedData: string,
+}
+
+export interface EsriAuthSchemaType {
+  username: string,
+  encrypted: EsriAuthPasswordType
+}
+
 export default function EsriAuthSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const EsriAuthPassword = createSchema(Schema, {
+  const EsriAuthPassword = new Schema<EsriAuthPasswordType>({
     iv: {
       type: String,
       default: "",
@@ -20,7 +29,7 @@ export default function EsriAuthSchema(mongoose: MongooseModule) {
     id: false,
   });
 
-  const EsriAuth = createSchema(Schema, {
+  const EsriAuth = new Schema<EsriAuthSchemaType>({
     username: {
       type: String,
       default: "",

package/src/models/schema/esri-error.ts

@@ -1,12 +1,18 @@
 import {
-  createSchema,
   MongooseModule,
 } from "../../helpers";
 
+export interface EsriErrorSchemaType {
+  code: number,
+  error: string,
+  error_description: string,
+  message: string,
+}
+
 export default function EsriErrorSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const EsriError = createSchema(Schema, {
+  const EsriError = new Schema<EsriErrorSchemaType>({
     code: {
       type: Number,
       default: 1,

package/src/models/schema/esri-map.ts

@@ -1,12 +1,50 @@
 import {
-  createSchema,
   MongooseModule,
 } from "../../helpers";
 
+interface MapLayerType {
+  layerId: string,
+  itemId: string,
+  title: string,
+  layerType: string,
+  url: string,
+  visibility: boolean,
+  opacity: number,
+  access: string,
+  owner: string,
+}
+
+interface BaseMapType {
+  baseMapLayers: MapLayerType[],
+  title: string,
+}
+
+interface SimpleMapSchemaType {
+  itemId: string,
+  title: string,
+  url: string,
+  access: string,
+  owner: string,
+  type: string,
+  modified: number,
+  modifiedAt: Date,
+}
+
+interface OfflineMapType extends SimpleMapSchemaType { status: string }
+
+export interface EsriMapType extends SimpleMapSchemaType {
+  mapLayers: MapLayerType[]
+  baseMap: BaseMapType
+  offline: OfflineMapType[]
+  tags: string[],
+  development: boolean,
+  size: number,
+}
+
 export default function EsriMapSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const MapLayer = createSchema(Schema, {
+  const MapLayer = new Schema<MapLayerType>({
     layerId: {
       type: String,
       default: "",
@@ -48,7 +86,7 @@ export default function EsriMapSchema(mongoose: MongooseModule) {
     id: false,
   });
 
-  const BaseMap = createSchema(Schema, {
+  const BaseMap = new Schema<BaseMapType>({
     baseMapLayers: {
       type: [MapLayer],
       default: [],
@@ -97,7 +135,7 @@ export default function EsriMapSchema(mongoose: MongooseModule) {
     },
   };
 
-  const OfflineMap = createSchema(Schema, {
+  const OfflineMap = new Schema<OfflineMapType>({
     ...SimpleMapSchema,
     status: {
       type: String,
@@ -108,7 +146,7 @@ export default function EsriMapSchema(mongoose: MongooseModule) {
     id: false,
   });
 
-  const Map = createSchema(Schema, {
+  const Map = new Schema<EsriMapType>({
     ...SimpleMapSchema,
     mapLayers: {
       type: [MapLayer],

package/src/models/schema/firemapper-auth.ts

@@ -1,12 +1,22 @@
 import {
-  createSchema,
   MongooseModule,
 } from "../../helpers";
 
+interface FireMapperEncryptedType {
+  iv: string,
+  encryptedData: string,
+}
+
+export interface FireMapperAuthType {
+  username: string,
+  encrypted: FireMapperEncryptedType
+  encryptedAccessCode: FireMapperEncryptedType
+}
+
 export default function FireMapperAuthSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const FireMapperEncrypted = createSchema(Schema, {
+  const FireMapperEncrypted = new Schema<FireMapperEncryptedType>({
     iv: {
       type: String,
       default: "",
@@ -20,7 +30,7 @@ export default function FireMapperAuthSchema(mongoose: MongooseModule) {
     id: false,
   });
 
-  const FireMapperAuth = createSchema(Schema, {
+  const FireMapperAuth = new Schema<FireMapperAuthType>({
     username: {
       type: String,
       default: "",

package/src/models/schema/geojson-point.ts

@@ -1,12 +1,16 @@
 import {
-  createSchema,
   MongooseModule,
 } from "../../helpers";
 
+export interface GeoJSONPointType {
+  type: string
+  coordinates: number[]
+}
+
 export default function GeoJSONPointSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const GeoJSONPoint = createSchema(Schema, {
+  const GeoJSONPoint = new Schema<GeoJSONPointType>({
     type: {
       type: String,
       required: true,

package/src/models/schema/oauth.ts

@@ -1,12 +1,17 @@
 import {
   MongooseModule,
-  createSchema,
 } from "../../helpers";
 
+export interface OAuthSchemaType {
+  accessToken: string,
+  refreshToken: string,
+  expireAt: Date,
+}
+
 export default function OAuthSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const Item = createSchema(Schema, {
+  const Item = new Schema<OAuthSchemaType>({
     accessToken: {
       type: String,
       default: "",
@@ -22,7 +27,7 @@ export default function OAuthSchema(mongoose: MongooseModule) {
   }, {
     _id: false,
     id: false,
-  });  
+  });
 
   return Item;
 }

package/src/models/schema/pubnub-token.ts

@@ -1,13 +1,18 @@
 import {
   MongooseModule,
-  createSchema,
   currentDate,
 } from "../../helpers";
 
+export interface PubNubTokenSchemaType {
+  token: string,
+  expireAt: Date,
+  runAt: Date | string,
+}
+
 export default function PubNubTokenSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const Item = createSchema(Schema, {
+  const Item = new Schema<PubNubTokenSchemaType>({
     token: {
       type: String,
       default: "",
@@ -17,13 +22,13 @@ export default function PubNubTokenSchema(mongoose: MongooseModule) {
       default: currentDate,
     },
     runAt: {
-      type: Date,
+      type: Date || String,
       default: "",
     },
   }, {
     _id: false,
     id: false,
-  });  
+  });
 
   return Item;
 }