tabletcommand-backend-models 7.3.39 → 7.4.1

package/src/models/incident-takeover.ts

@@ -83,4 +83,4 @@ export default async function IncidentTakeoverModule(mongoose: MongooseModule) {
   return mongoose.model<IncidentTakeover>("IncidentTakeover", modelSchema, "massive_incident_takeover", { overwriteModels: true });
 }
 
-export interface IncidentTakeoverModel extends Model<IncidentTakeover> { }
+export interface IncidentTakeoverModel extends Model<IncidentTakeover> { }

package/src/models/location.ts

@@ -49,7 +49,7 @@ export default async function LocationModule(mongoose: MongooseModule) {
       type: String,
       required: true,
     },
-    // GST, SkyTrack, SkyMira, FleetComplete, Samsara, Somewear, 
+    // GST, SkyTrack, SkyMira, FleetComplete, Samsara, Somewear,
     // CAD, Vehicle Modem (Truck), TC, TC Mobile (iOS/Android)
     source: {
       type: String,
@@ -69,7 +69,7 @@ export default async function LocationModule(mongoose: MongooseModule) {
       default: false,
     },
     // TC/TCMobile create duplicate records, with unique session id
-    // If a session is closed, this record should be deletable after 
+    // If a session is closed, this record should be deletable after
     // the record TTL - department.locationStaleMinutes
     // Any update, active or inactive, would set deleteAfterDate to now + locationStaleMinutes
     // If date is set, and in the past, the record can be deleted

package/src/models/mail-log.ts

@@ -88,4 +88,4 @@ export default async function MailLogModule(mongoose: MongooseModule) {
   return mongoose.model<MailLog>("MailLog", modelSchema, "massive_mail_log", { overwriteModels: true });
 }
 
-export interface MailLogModel extends Model<MailLog> { }
+export interface MailLogModel extends Model<MailLog> { }

package/src/models/mark43-incident-retry.ts

@@ -88,4 +88,4 @@ export default async function Mark43IncidentRetryModule(mongoose: MongooseModule
   return mongoose.model<Mark43IncidentRetry>("Mark43IncidentRetry", modelSchema, "massive_mark43_incident_retry", { overwriteModels: true });
 }
 
-export interface Mark43IncidentRetryModel extends Model<Mark43IncidentRetry> { }
+export interface Mark43IncidentRetryModel extends Model<Mark43IncidentRetry> { }

package/src/models/message.ts

@@ -122,4 +122,4 @@ export default async function MessageModule(mongoose: MongooseModule) {
   return mongoose.model<Message>("Message", modelSchema, "massive_message", { overwriteModels: true });
 }
 
-export interface MessageModel extends Model<Message> { }
+export interface MessageModel extends Model<Message> { }

package/src/models/monitor.ts

@@ -80,4 +80,4 @@ export default async function MonitorModule(mongoose: MongooseModule) {
   return mongoose.model<Monitor>("Monitor", modelSchema, "massive_monitor", { overwriteModels: true });
 }
 
-export interface MonitorModel extends Model<Monitor> { }
+export interface MonitorModel extends Model<Monitor> { }

package/src/models/personnel-import.ts

@@ -206,4 +206,4 @@ export default async function PersonnelImportModule(mongoose: MongooseModule) {
   return mongoose.model<PersonnelImport>("PersonnelImport", modelSchema, "massive_personnel_import", { overwriteModels: true });
 }
 
-export interface PersonnelImportModel extends Model<PersonnelImport> { }
+export interface PersonnelImportModel extends Model<PersonnelImport> { }

package/src/models/personnel-known.ts

@@ -20,6 +20,10 @@ export function PersonnelKnownSchema(mongoose: MongooseModule) {
       type: Boolean,
       default: true,
     },
+    source: {
+      type: String,
+      default: "",
+    },
   }, {
     _id: false,
     id: false,
@@ -66,7 +70,7 @@ export function PersonnelKnownSchema(mongoose: MongooseModule) {
       type: Boolean,
       default: false,
     },
-    // Clarify if we'd like to link personnel 
+    // Clarify if we'd like to link personnel
     // to TC agencies or external agencies
     jurisdiction: {
       type: String,
@@ -103,4 +107,4 @@ export default async function PersonnelKnownModule(mongoose: MongooseModule) {
   return mongoose.model<PersonnelKnown>("PersonnelKnown", modelSchema, "massive_personnel_known", { overwriteModels: true });
 }
 
-export interface PersonnelKnownModel extends Model<PersonnelKnown> { }
+export interface PersonnelKnownModel extends Model<PersonnelKnown> { }

package/src/models/personnel-roster.ts

@@ -78,4 +78,4 @@ export default async function PersonnelRosterModule(mongoose: MongooseModule) {
   return mongoose.model<PersonnelRoster>("PersonnelRoster", modelSchema, "massive_personnel_roster", { overwriteModels: true });
 }
 
-export interface PersonnelRosterModel extends Model<PersonnelRoster> { }
+export interface PersonnelRosterModel extends Model<PersonnelRoster> { }

package/src/models/rate-limit.ts

@@ -46,4 +46,4 @@ export default async function RateLimitModule(mongoose: MongooseModule) {
   return mongoose.model<RateLimit>("RateLimit", modelSchema, "massive_rate_limit", { overwriteModels: true });
 }
 
-export interface RateLimitModel extends Model<RateLimit> { }
+export interface RateLimitModel extends Model<RateLimit> { }

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

@@ -61,7 +61,7 @@ export default async function RemoteLogStreamModule(mongoose: MongooseModule) {
     },
     status: {
       type: String,
-      default: "", // local, uploading, synced (uploaded to a remote storage) 
+      default: "", // local, uploading, synced (uploaded to a remote storage)
     },
     // Formerly message.title
     message: {

package/src/models/remote-log.ts

@@ -57,7 +57,7 @@ export default async function RemoteLogModule(mongoose: MongooseModule) {
     },
     status: {
       type: String,
-      default: "", // local, uploading, synced (uploaded to a remote storage) 
+      default: "", // local, uploading, synced (uploaded to a remote storage)
     },
     // Formerly message.title
     message: {
@@ -112,4 +112,4 @@ export default async function RemoteLogModule(mongoose: MongooseModule) {
   return mongoose.model<RemoteLog>("RemoteLog", modelSchema, "massive_remote_log", { overwriteModels: true });
 }
 
-export interface RemoteLogModel extends Model<RemoteLog> { }
+export interface RemoteLogModel extends Model<RemoteLog> { }

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

@@ -46,4 +46,4 @@ export default function AgencySAMLSchema(mongoose: MongooseModule) {
   });
 
   return AgencySAML;
-}
+}

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

@@ -36,51 +36,30 @@ export function CADIncidentSchema(mongoose: MongooseModule) {
   const CADPerson = CADPersonSchema(mongoose);
   CADPerson.set("toJSON", {
     versionKey: false,
-    transform(doc, ret) {
-      strictSchema(doc.schema as typeof modelSchema, ret);
-    }
   });
   const Caller = CallerSchema(mongoose);
   Caller.set("toJSON", {
     versionKey: false,
-    transform(doc, ret) {
-      strictSchema(doc.schema as typeof modelSchema, ret);
-    }
   });
   const RadioChannel = RadioChannelSchema(mongoose);
   RadioChannel.set("toJSON", {
     versionKey: false,
-    transform(doc, ret) {
-      strictSchema(doc.schema as typeof modelSchema, ret);
-    }
   });
   const RecordValue = RecordSchema(mongoose);
   RecordValue.set("toJSON", {
     versionKey: false,
-    transform(doc, ret) {
-      strictSchema(doc.schema as typeof modelSchema, ret);
-    }
   });
   const ReportNumber = ReportNumberSchema(mongoose);
   ReportNumber.set("toJSON", {
     versionKey: false,
-    transform(doc, ret) {
-      strictSchema(doc.schema as typeof modelSchema, ret);
-    }
   });
   const SharedSource = SharedSourceSchema(mongoose);
   SharedSource.set("toJSON", {
     versionKey: false,
-    transform(doc, ret) {
-      strictSchema(doc.schema as typeof modelSchema, ret);
-    }
   });
   const SharedTo = SharedToSchema(mongoose);
   SharedTo.set("toJSON", {
     versionKey: false,
-    transform(doc, ret) {
-      strictSchema(doc.schema as typeof modelSchema, ret);
-    }
   });
 
   // Currently, supporting type: "ack", item: "knife"
@@ -122,9 +101,6 @@ export function CADIncidentSchema(mongoose: MongooseModule) {
   });
   CADComment.set("toJSON", {
     versionKey: false,
-    transform(doc, ret) {
-      strictSchema(doc.schema as typeof modelSchema, ret);
-    }
   });
 
   const CADUnit = new Schema<CADUnitType>({
@@ -184,9 +160,6 @@ export function CADIncidentSchema(mongoose: MongooseModule) {
   });
   CADUnit.set("toJSON", {
     versionKey: false,
-    transform(doc, ret) {
-      strictSchema(doc.schema as typeof modelSchema, ret);
-    }
   });
 
   const APNNotificationType = new Schema<APNNotificationTypeType>({
@@ -202,9 +175,6 @@ export function CADIncidentSchema(mongoose: MongooseModule) {
   });
   APNNotificationType.set("toJSON", {
     versionKey: false,
-    transform(doc, ret) {
-      strictSchema(doc.schema as typeof modelSchema, ret);
-    }
   });
 
   const CADPriorIncident = new Schema<CADPriorIncidentType>({
@@ -235,9 +205,6 @@ export function CADIncidentSchema(mongoose: MongooseModule) {
   });
   CADPriorIncident.set("toJSON", {
     versionKey: false,
-    transform(doc, ret) {
-      strictSchema(doc.schema as typeof modelSchema, ret);
-    }
   });
 
   // Main schema
@@ -567,35 +534,8 @@ export function CADIncidentSchema(mongoose: MongooseModule) {
   modelSchema.set("toJSON", {
     virtuals: true,
     versionKey: false,
-    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);
-    },
   });
 
-
-  const ignoreFields: ReadonlyArray<string> = ["station", "callerNumber"];
-
-  function strictSchema(schema: typeof modelSchema, ret: Record<string, unknown>) {
-    Object.keys(ret).forEach(function(element) {
-      // Don't complain about the virtuals
-      if (element === "id") {
-        return;
-      }
-
-      if (ignoreFields.indexOf(element) !== -1) {
-        delete ret[element];
-        return;
-      }
-      const pathSchema = schema as unknown as { paths: Record<string, string> };
-      if (pathSchema.paths[element] === undefined) {
-        // console.log("backend-models.cad-incident: undefined schema.paths[element]:", element, pathSchema.paths[element]);
-        delete ret[element];
-      }
-    });
-  }
   modelSchema.plugin(mongooseLeanVirtuals);
   return modelSchema;
 }

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

@@ -52,7 +52,7 @@ export function CallerSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
   const Item = new Schema<CallerType>({
-    // Should match 
+    // Should match
     CallerId: {
       type: String,
       default: "",

package/src/models/schema/webhook.ts

@@ -80,10 +80,10 @@ export function WebhookAuthSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
   const WebhookAuthConfig = new Schema<WebhookAuthType>({
-    type: { 
+    type: {
       type: String,
       default: "",
-    },  
+    },
     apikey: {
       type: String,
       default: "",
@@ -137,4 +137,4 @@ export function WebhookSchema(mongoose: MongooseModule) {
   });
 
   return WebhookConfig;
-}
+}

package/src/models/session.ts

@@ -138,4 +138,4 @@ export default async function SessionModule(mongoose: MongooseModule) {
   return mongoose.model<Session>("Session", modelSchema, "sys_login", { overwriteModels: true });
 }
 
-export interface SessionModel extends Model<Session> { }
+export interface SessionModel extends Model<Session> { }

package/src/models/sms-log.ts

@@ -1,64 +1,64 @@
 import { Model } from "mongoose";
 import {
-    MongooseModule,
+  MongooseModule,
 } from "../helpers";
 import { SMSLogType } from "../types/sms-log";
 
 export interface SMSLog extends SMSLogType { }
 
 export default async function SMSLogModule(mongoose: MongooseModule) {
-    const { Schema } = mongoose;
+  const { Schema } = mongoose;
 
-    const modelSchema = new Schema<SMSLogType>({
-        _id: {
-            type: Schema.Types.ObjectId,
-            auto: true,
-        },
-        accountId: {
-            type: String,
-            default: ""
-        },
-        messageId: {
-            type: String,
-            default: "",
-        },
-        status: {
-            type: String,
-            default: "",
-        },
-        createdAt: {
-            type: Date,
-        },
-        sentAt: {
-            type: Date,
-        },
-        from: {
-            type: String,
-            default: "",
-        },
-        to: {
-            type: String,
-            default: "",
-        },
-        errorCode: {
-            type: String,
-            default: "",
-        },
-        errorMessage: {
-            type: String,
-            default: "",
-        },
-    }, {
-        autoIndex: false,
-    });
+  const modelSchema = new Schema<SMSLogType>({
+    _id: {
+      type: Schema.Types.ObjectId,
+      auto: true,
+    },
+    accountId: {
+      type: String,
+      default: ""
+    },
+    messageId: {
+      type: String,
+      default: "",
+    },
+    status: {
+      type: String,
+      default: "",
+    },
+    createdAt: {
+      type: Date,
+    },
+    sentAt: {
+      type: Date,
+    },
+    from: {
+      type: String,
+      default: "",
+    },
+    to: {
+      type: String,
+      default: "",
+    },
+    errorCode: {
+      type: String,
+      default: "",
+    },
+    errorMessage: {
+      type: String,
+      default: "",
+    },
+  }, {
+    autoIndex: false,
+  });
 
-    modelSchema.index({
-        status: 1,
-    }, {
-        name: "status_1",
-    });
+  modelSchema.index({
+    status: 1,
+  }, {
+    name: "status_1",
+  });
 
-    return mongoose.model<SMSLog>("SMSLog", modelSchema, "massive_sms_log", { overwriteModels: true });
+  return mongoose.model<SMSLog>("SMSLog", modelSchema, "massive_sms_log", { overwriteModels: true });
 }
 
-export interface SMSLogModel extends Model<SMSLog> { }
+export interface SMSLogModel extends Model<SMSLog> { }

package/src/models/smtp-unhandled.ts

@@ -34,4 +34,4 @@ export default async function SMTPUnhandledModule(mongoose: MongooseModule) {
   return mongoose.model<SMTPUnhandled>("SMTPUnhandled", modelSchema, "massive_smtp_unhandled", { overwriteModels: true });
 }
 
-export interface SMTPUnhandledModel extends Model<SMTPUnhandled> { }
+export interface SMTPUnhandledModel extends Model<SMTPUnhandled> { }

package/src/models/template.ts

@@ -149,4 +149,4 @@ export default async function TemplateModule(mongoose: MongooseModule) {
   return mongoose.model<Template>("Template", modelSchema, "massive_template", { overwriteModels: true });
 }
 
-export interface TemplateModel extends Model<Template> { }
+export interface TemplateModel extends Model<Template> { }

package/src/models/user-device.ts

@@ -93,7 +93,7 @@ export default async function UserDeviceModule(mongoose: MongooseModule) {
       default: 0
     },
     // Used by Android, to allow changing notification channel setup between releases
-    // Android notification channels are immutable 
+    // Android notification channels are immutable
     // <https://developer.android.com/develop/ui/views/notifications/channels>
     channelId: {
       type: String,
@@ -237,4 +237,4 @@ export default async function UserDeviceModule(mongoose: MongooseModule) {
   return mongoose.model<UserDevice>("UserDevice", modelSchema, "massive_user_device", { overwriteModels: true });
 }
 
-export interface UserDeviceModel extends Model<UserDevice> { }
+export interface UserDeviceModel extends Model<UserDevice> { }

package/src/models/user-registration.ts

@@ -97,4 +97,4 @@ export default async function UserRegistrationModule(mongoose: MongooseModule) {
   return mongoose.model<UserRegistration>("UserRegistration", modelSchema, "massive_user_registration", { overwriteModels: true });
 }
 
-export interface UserRegistrationModel extends Model<UserRegistration> { }
+export interface UserRegistrationModel extends Model<UserRegistration> { }

package/src/models/user.ts

@@ -303,8 +303,8 @@ export function UserSchema(mongoose: MongooseModule) {
   }, {
     name: "departmentId_1_vehicle_1_partial",
     partialFilterExpression: {
-      "vehicle": {
-        "$exists": true
+      vehicle: {
+        $exists: true
       }
     }
   });
@@ -323,7 +323,7 @@ export function UserSchema(mongoose: MongooseModule) {
     unique: true,
   });
 
-  // A field has to be defined as text and weight  
+  // A field has to be defined as text and weight
   modelSchema.index({
     nick: "text",
     email: "text",

package/src/models/validation-report.ts

@@ -73,4 +73,4 @@ export default async function ValidationReportModule(mongoose: MongooseModule) {
   return mongoose.model<ValidationReport>("ValidationReport", modelSchema, "massive_validation_report", { overwriteModels: true });
 }
 
-export interface ValidationReportModel extends Model<ValidationReport> { }
+export interface ValidationReportModel extends Model<ValidationReport> { }

package/src/test/cad-status.ts

@@ -51,7 +51,6 @@ describe("CADStatus", function() {
     } else {
       assert.equal(testItem.options?.length, 1);
       assert.equal(sut.options?.length, 1);
-
     }
   });
 });

package/src/test/csv-import.ts

@@ -41,4 +41,3 @@ describe("CSVImport", function() {
     assert.equal(testItem.sendNotification, sut.sendNotification);
   });
 });
-

package/src/test/device-mapping.ts

@@ -38,7 +38,6 @@ describe("DeviceMapping", function() {
     assert.isFalse(sut.mapHidden);
   });
 
-
   it("is saved with trim", async function() {
     const item = new models.DeviceMapping(testItemForTrim);
     const sut = await item.save();