tabletcommand-backend-models 7.0.0 → 7.0.2

package/src/models/personnel-known.ts

@@ -4,28 +4,10 @@ import {
   MongooseModule,
   currentDate,
 } from "../helpers";
-import { Model, Types } from "mongoose";
+import { Model } from "mongoose";
+import { PersonnelKnownType, RadioType } from "../types/personnel";
 
-interface RadioType {
-  radioName: string,
-  active: boolean,
-}
-
-export interface PersonnelKnown extends Record<string, unknown> {
-  _id: Types.ObjectId,
-  PersonnelID: string,
-  PersonnelName: string,
-  PersonnelRank: string,
-  PersonnelWorkCode: string,
-  modified: Date,
-  departmentId: string,
-  uuid: string,
-  radios: RadioType[],
-  active: boolean,
-  jurisdiction: string,
-  agencyId: Types.ObjectId,
-  source: string,
-}
+export interface PersonnelKnown extends PersonnelKnownType, Record<string, unknown> { }
 
 export function PersonnelKnownSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
@@ -43,7 +25,7 @@ export function PersonnelKnownSchema(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = new Schema<PersonnelKnown>({
+  const modelSchema = new Schema<PersonnelKnownType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,

package/src/models/personnel-roster.ts

@@ -1,29 +1,16 @@
-import { Model, Types } from "mongoose";
+import { Model } from "mongoose";
 import {
   MongooseModule,
   currentDate,
 } from "../helpers";
+import { PersonnelRosterType } from "../types/personnel";
 
-export interface PersonnelRoster {
-  _id: Types.ObjectId,
-  PersonnelID: string,
-  PersonnelName: string,
-  PersonnelRank: string,
-  PersonnelWorkCode: string,
-  PersonnelUUID: string,
-  departmentId: string,
-  modified: Date,
-  action: string,
-  radioName: string,
-  shiftStart: Date,
-  shiftEnd: Date,
-  active: boolean,
-}
+export interface PersonnelRoster extends PersonnelRosterType { }
 
 export function PersonnelRosterSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const modelSchema = new Schema<PersonnelRoster>({
+  const modelSchema = new Schema<PersonnelRosterType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,

package/src/models/rate-limit.ts

@@ -1,22 +1,16 @@
-import { Model, Types } from "mongoose";
+import { Model } from "mongoose";
 import {
   currentDate,
   MongooseModule,
 } from "../helpers";
+import { RateLimitType } from "../types/rate-limit";
 
-export interface RateLimit {
-  _id: Types.ObjectId,
-  username: string,
-  modified_unix_date: number,
-  modified: Date,
-  count: number,
-  remoteAddress: string,
-}
+export interface RateLimit extends RateLimitType { }
 
 export default async function RateLimitModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const modelSchema = new Schema<RateLimit>({
+  const modelSchema = new Schema<RateLimitType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,

package/src/models/release-note.ts

@@ -1,23 +1,16 @@
-import { Model, Types } from "mongoose";
+import { Model } from "mongoose";
 import {
   MongooseModule,
   currentDate,
 } from "../helpers";
+import { ReleaseNoteType } from "../types/release-note";
 
-export interface ReleaseNote extends Record<string, unknown> {
-  _id: Types.ObjectId
-  title: string
-  notes: string
-  version: string
-  releaseDate: Date
-  status: string
-  modified: Date
-}
+export interface ReleaseNote extends ReleaseNoteType, Record<string, unknown> { }
 
 export default async function ReleaseNoteModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const modelSchema = new Schema<ReleaseNote>({
+  const modelSchema = new Schema<ReleaseNoteType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,

package/src/models/remote-log-stream.ts

@@ -3,86 +3,18 @@ import {
   MongooseModule,
   currentDate,
 } from "../helpers";
-import { Model, Types } from "mongoose";
+import { Model } from "mongoose";
+import RemoteFileSchema from "./schema/remote-file";
+import { RemoteLogStreamType } from "../types/remote-log";
 
-interface FileSchemaType {
-  originalName: string
-  encoding: string
-  mimeType: string
-  fieldname: string
-  localPath: string
-  remotePath: string
-  hostname: string
-  size: number
-  received: Date
-}
-
-export interface RemoteLogStream extends Record<string, unknown> {
-  _id: Types.ObjectId
-  departmentId: string
-  userId: string
-  isCADRequest: boolean
-  session: string
-  requestId: string
-  requested: Date
-  active: boolean
-  uuid: string
-  createdAt: Date
-  updatedAt: Date
-  status: string
-  message: string
-  manifest: string[]
-  userAgent: string
-  appVersion: string
-  file: FileSchemaType
-}
+export interface RemoteLogStream extends RemoteLogStreamType, Record<string, unknown> { }
 
 export default async function RemoteLogStreamModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const FileSchema = new Schema<FileSchemaType>({
-    originalName: {
-      type: String,
-      default: "", // e.g database.sqlite
-    },
-    encoding: {
-      type: String,
-      default: "", // e.g utf8
-    },
-    mimeType: {
-      type: String,
-      default: "", // e.g application/text
-    },
-    fieldname: {
-      type: String,
-      default: "", // e.g "database" or "logs"
-    },
-    localPath: {
-      type: String,
-      default: "", // e.g /tmp/some/path
-    },
-    remotePath: {
-      type: String,
-      default: "", // e.g https://google.com?
-    },
-    hostname: {
-      type: String,
-      default: "", // e.g ip-10-6-56-205.ca-central-1.compute.internal
-    },
-    size: {
-      type: Number,
-      default: 0,
-    },
-    received: {
-      type: Date,
-      default: currentDate,
-    },
-  }, {
-    _id: false,
-    id: false,
-  });
+  const RemoteFile = RemoteFileSchema(mongoose);
 
-  const modelSchema = new Schema<RemoteLogStream>({
+  const modelSchema = new Schema<RemoteLogStreamType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,
@@ -153,7 +85,16 @@ export default async function RemoteLogStreamModule(mongoose: MongooseModule) {
       default: "",
     },
     file: {
-      type: FileSchema,
+      type: RemoteFile,
+    },
+    // Google Drive
+    remoteFolderPath: {
+      type: String,
+      default: "", // e.g https://drive.google.com/drive/folders/1efgEFG
+    },
+    remoteFolderId: {
+      type: String,
+      default: "", // e.g 1efgEFG
     },
   }, {
     autoIndex: false,

package/src/models/remote-log.ts

@@ -3,88 +3,18 @@ import {
   MongooseModule,
   currentDate,
 } from "../helpers";
-import { Model, Types } from "mongoose";
+import { Model } from "mongoose";
+import RemoteFileSchema from "./schema/remote-file";
+import { RemoteLogType } from "../types/remote-log";
 
-interface FileSchemaType {
-  originalName: string,
-  encoding: string,
-  mimeType: string,
-  localPath: string,
-  remotePath: string,
-  size: number,
-  received: Date,
-  fieldname: string,
-  hostname: string,
-}
-
-export interface RemoteLog {
-  _id: Types.ObjectId,
-  departmentId: string,
-  userId: string,
-  session: string,
-  active: boolean,
-  uuid: string,
-  requestId: string,
-  received: Date,
-  hostname: string,
-  status: string,
-  lastStatusChange: Date,
-  isCADRequest: boolean,
-  createdAt: Date,
-  updatedAt: Date
-  message: string,
-  manifest: string[],
-  userAgent: string,
-  appVersion: string,
-  files: FileSchemaType[],
-}
+export interface RemoteLog extends RemoteLogType { }
 
 export default async function RemoteLogModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const FileSchema = new Schema<FileSchemaType>({
-    originalName: {
-      type: String,
-      default: "", // e.g database.sqlite
-    },
-    encoding: {
-      type: String,
-      default: "", // e.g utf8
-    },
-    mimeType: {
-      type: String,
-      default: "", // e.g application/text
-    },
-    fieldname: {
-      type: String,
-      default: "", // e.g "database" or "logs"
-    },
-    localPath: {
-      type: String,
-      default: "", // e.g /tmp/some/path
-    },
-    remotePath: {
-      type: String,
-      default: "", // e.g https://google.com?
-    },
-    hostname: {
-      type: String,
-      default: "", // e.g ip-10-6-56-205.ca-central-1.compute.internal
-    },
-    size: {
-      type: Number,
-      default: 0,
-    },
-    received: {
-      type: Date,
-      default: currentDate,
-    },
-  }, {
-    _id: false,
-    id: false,
-  });
+  const RemoteFile = RemoteFileSchema(mongoose);
 
-  const modelSchema = new Schema<RemoteLog>({
+  const modelSchema = new Schema<RemoteLogType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,
@@ -152,9 +82,18 @@ export default async function RemoteLogModule(mongoose: MongooseModule) {
       default: "",
     },
     files: {
-      type: [FileSchema],
+      type: [RemoteFile],
       default: [],
     },
+    // Google Drive
+    remoteFolderPath: {
+      type: String,
+      default: "", // e.g https://drive.google.com/drive/folders/1efgEFG
+    },
+    remoteFolderId: {
+      type: String,
+      default: "", // e.g 1efgEFG
+    },
   }, {
     autoIndex: false,
     timestamps: true,

package/src/models/schema/agency-cron-config.ts

@@ -1,62 +1,7 @@
 import {
   MongooseModule,
 } from "../../helpers";
-
-interface EncryptedDataType {
-  iv: string,
-  encryptedData: string,
-}
-
-export interface CronConfigSourceType extends Record<string, unknown> {
-  protocol: string,
-  username: string,
-  hostname: string,
-  filePath: string,
-}
-
-interface CronConfigAuthType {
-  password: EncryptedDataType | null,
-  sshPrivateKey: EncryptedDataType | null,
-  sshPublicKey: EncryptedDataType | null,
-  useSSHKey: boolean,
-}
-
-interface CronConfigCSVFieldMapType {
-  PersonnelID: string,
-  PersonnelName: string,
-  PersonnelRank: string,
-  PersonnelWorkCode: string,
-  PersonnelNote: string,
-  StartTime: string,
-  EndTime: string,
-  UnitName: string,
-  TimeFormat: string,
-}
-
-interface ReconcileTimeOptionsType {
-  enabled: boolean,
-  startTime: string,
-  endTime: string,
-}
-
-export interface AgencyCronConfigType extends Record<string, unknown> {
-  enabled: boolean
-  source: CronConfigSourceType,
-  auth: CronConfigAuthType
-  processPath: string,
-  completedPath: string,
-  importType: string,
-  timezone: string,
-  customApiPath: string,
-  alterChunkSize: boolean,
-  reconcileEnabled: boolean,
-  reconcileTimeOptions: ReconcileTimeOptionsType,
-  hasLabelCustomization: boolean
-  assignmentOverride: boolean,
-  csvFieldMap: CronConfigCSVFieldMapType
-  useAlternateId: boolean
-  strictAgencyCodeMatch: boolean
-}
+import { EncryptedDataType, CronConfigSourceType, CronConfigAuthType, CronConfigCSVFieldMapType, ReconcileTimeOptionsType, AgencyCronConfigType } from "../../types/agency";
 
 export default function AgencyCronSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;

package/src/models/schema/agency-saml.ts

@@ -1,15 +1,7 @@
 import {
   MongooseModule,
 } from "../../helpers";
-
-export interface AgencySAMLSchemaType extends Record<string, unknown> {
-  selector: string,
-  idp: string,
-  sp: string,
-  env: string,
-  name: string,
-  jumpPoint: string,
-}
+import { AgencySAMLSchemaType } from "../../types/agency";
 
 export default function AgencySAMLSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;

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

@@ -5,150 +5,16 @@ import {
 
 import * as uuid from "uuid";
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
-import { IncidentEventSchema, IncidentEvent } from "../incident-event";
+import { IncidentEventSchema } from "../incident-event";
 import {
   CADPersonSchema,
-  CADPersonSchemaType,
   RadioChannelSchema,
-  RadioChannelSchemaType,
   RecordSchema,
-  RecordSchemaType,
   ReportNumberSchema,
-  ReportNumberSchemaType,
   SharedSourceSchema,
-  SharedSourceSchemaType,
   SharedToSchema,
-  SharedToSchemaType,
 } from "./shared-incident";
-import { Types } from "mongoose";
-
-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,
-}
-
-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,
-}
+import { CADCommentOptsTypes, CADCommentType, CADUnitType, APNNotificationTypeType, CADPriorIncidentType, CADIncidentSchemaType } from "../../types/cad-incident";
 
 export function CADIncidentSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
@@ -656,7 +522,7 @@ 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) {
+  modelSchema.virtual("id").get(function(this: CADIncidentSchemaType) {
     return this._id.toString();
   });
 
@@ -675,7 +541,7 @@ export function CADIncidentSchema(mongoose: MongooseModule) {
   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,13 +1,7 @@
 import {
   MongooseModule,
 } from "../../helpers";
-
-export interface CADStatusOptionSelectedSchemaType {
-  name: string,
-  type: string,
-  value: string,
-  key: string,
-}
+import { CADStatusOptionSelectedSchemaType } from "../../types/cad";
 
 export default function CADStatusOptionSelectedSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;

package/src/models/schema/color.ts

@@ -1,11 +1,7 @@
 import {
   MongooseModule,
 } from "../../helpers";
-
-export interface ColorSchemaType extends Record<string, unknown> {
-  background: string,
-  text: string,
-}
+import { ColorSchemaType } from "../../types/color";
 
 export default function ColorSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;

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

@@ -1,16 +1,7 @@
 import {
   MongooseModule,
 } from "../../helpers";
-
-interface EsriAuthPasswordType {
-  iv: string,
-  encryptedData: string,
-}
-
-export interface EsriAuthSchemaType {
-  username: string,
-  encrypted: EsriAuthPasswordType
-}
+import { EsriAuthPasswordType, EsriAuthSchemaType } from "../../types/esri";
 
 export default function EsriAuthSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;

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

@@ -1,13 +1,7 @@
 import {
   MongooseModule,
 } from "../../helpers";
-
-export interface EsriErrorSchemaType {
-  code: number,
-  error: string,
-  error_description: string,
-  message: string,
-}
+import { EsriErrorSchemaType } from "../../types/esri";
 
 export default function EsriErrorSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;