tabletcommand-backend-models 5.39.5 → 7.0.0

package/src/models/mail-log.ts

@@ -1,20 +1,35 @@
+import { Model, Types } from "mongoose";
 import {
   MongooseModule,
-  createSchema,
-  createModel,
   currentDate,
   retrieveCurrentUnixTime,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
 
-export async function MailLogModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface MailLog {
+  _id: Types.ObjectId,
+  mailId: string,
+  event: string,
+  timestamp: number,
+  recipient: string,
+  recipientDomain: string,
+  tags: string[]
+  deliveryStatus: object,
+  message: object,
+  flags: object,
+  envelope: object,
+  logLevel: string,
+  reason: string,
+  severity: string,
+  modified_unix_date: number,
+  modified: Date,
+}
+
+export default async function MailLogModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<MailLog>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     mailId: {
@@ -77,13 +92,10 @@ export async function MailLogModule(mongoose: MongooseModule) {
       default: currentDate,
     },
   }, {
-    collection: "massive_mail_log",
   });
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "MailLog", modelSchema);
+  return mongoose.model<MailLog>("MailLog", modelSchema, "massive_mail_log", { overwriteModels: true });
 }
 
-export interface MailLog extends ItemTypeFromTypeSchemaFunction<typeof MailLogModule> { }
-export interface MailLogModel extends ModelTypeFromTypeSchemaFunction<MailLog> { }
-export default MailLogModule as ReplaceModelReturnType<typeof MailLogModule, MailLogModel>;
+export interface MailLogModel extends Model<MailLog> { }

package/src/models/managed-incident.ts

@@ -1,28 +1,182 @@
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
 import * as uuid from "uuid";
 import {
-  createModel,
-  createSchema,
   currentDate,
-  DocumentTypeFromSchema,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ModelFromSchema,
-  MongooseDocument,
   MongooseModule,
-  ReplaceModelReturnType,
 } from "../helpers";
 import {
   CADPersonSchema,
+  CADPersonSchemaType,
   RadioChannelSchema,
+  RadioChannelSchemaType,
   RecordSchema,
+  RecordSchemaType,
   ReportNumberSchema,
+  ReportNumberSchemaType,
   SharedSourceSchema,
+  SharedSourceSchemaType,
   SharedToSchema,
+  SharedToSchemaType,
 } from "./schema/shared-incident";
+import { Model, Types } from "mongoose";
 
-export async function ManagedIncidentModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+interface HistoryItemType extends Record<string, unknown> {
+  message: string,
+  entity_type: number,
+  time: number,
+  entity_id: string,
+  user: string,
+}
+
+interface AssignmentItemType {
+  name: string,
+  uuid: string,
+  modified_date: string,
+  modified_unix_date: number,
+  built_in: boolean,
+  isMandatory: boolean,
+  description: string,
+  active: boolean,
+  position: number,
+}
+
+interface IncidentUnitType extends Record<string, unknown> {
+  UnitID: string,
+  active: boolean,
+  air_time: string,
+  assignment: AssignmentItemType,
+  AlarmAtDispatch: number,
+  api_unit_dispatch_number: string,
+  checked: boolean,
+  column_position: number,
+  group_position: number,
+  incident_position: number,
+  isSupervisor: boolean,
+  is_part_of_group: boolean,
+  location_on_map: string,
+  modified_date: string,
+  modified_unix_date: number,
+  note: string,
+  personnelOnScene: number,
+  Personnel: CADPersonSchemaType[],
+  status: string,
+  status_unix_date: number,
+  time: string,
+  warning: number,
+  uuid: string,
+  parent_uuid: string,
+  local_id: string,
+}
+
+interface IncidentGroupType {
+  location_on_map: string,
+  name: string,
+  note: string,
+  position: number,
+  type: number,
+  type_text: string,
+  units: IncidentUnitType[],
+  uuid: string,
+  incident_id: string,
+}
+
+interface IncidentHazardType {
+  location_on_scene: string,
+  name: string,
+  radius: number,
+  time: number,
+  uuid: string,
+  active: boolean,
+  incident_id: string,
+  local_id: string,
+  note: string,
+}
+
+interface IncidentChecklistItemType {
+  active: boolean,
+  checked: boolean,
+  isMandatory: boolean,
+  modified_date: string,
+  name: string,
+  position: number,
+  uuid: string,
+  checklist_uuid: string,
+  description: string,
+  id: string,
+}
+
+interface IncidentChecklistType {
+  active: boolean,
+  built_in: boolean,
+  isMandatory: boolean,
+  items: IncidentChecklistItemType[],
+  modified_date: string,
+  name: string,
+  position: number,
+  uuid: string,
+  local_id: string,
+  id: string,
+}
+export interface ManagedIncident extends Record<string, unknown> {
+  _id: Types.ObjectId,
+  id?: string,
+  departmentId: string,
+  userId: string,
+  uuid: string,
+  start_unix_time: number,
+  end_unix_time: number,
+  par_unix_time: number,
+  watch_unix_start_time: number,
+  watch_unix_pause_time: number,
+  start_time: string,
+  end_time: string,
+  modified_date: string,
+  modified_unix_date: number,
+  modified: Date,
+  channel_owner: string,
+  channel: string,
+  active: boolean,
+  address: string,
+  api_incident_number: string,
+  CallerNumber: string,
+  CommandChannel: string,
+  CommonPlaceName: string,
+  cross_streets: string,
+  deviceTime: string,
+  extended: boolean,
+  FireMap: string,
+  is_closed: boolean,
+  last_view: string,
+  location: string,
+  MapPages: string,
+  managed: number,
+  name: string,
+  preference_location: string,
+  serverTime: string,
+  slave_map_changed: boolean,
+  source: string,
+  TacticalAltChannel: string,
+  TacticalChannel: string,
+  checklists: IncidentChecklistType[]
+  groups: IncidentGroupType[],
+  hazards: IncidentHazardType[],
+  history: HistoryItemType[],
+  notes: HistoryItemType[],
+  units: IncidentUnitType[],
+  simulation: boolean,
+  rts: boolean,
+  local_id: string,
+  AgencyID: string,
+  isMandatory: boolean,
+  radioChannels: RadioChannelSchemaType[],
+  record: RecordSchemaType,
+  ReportNumber: ReportNumberSchemaType[],
+  sharedTo: SharedToSchemaType[],
+  sharedSource: SharedSourceSchemaType,
+}
+
+export default async function ManagedIncidentModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
 
   const CADPerson = CADPersonSchema(mongoose);
   const RadioChannel = RadioChannelSchema(mongoose);
@@ -31,7 +185,7 @@ export async function ManagedIncidentModule(mongoose: MongooseModule) {
   const SharedSource = SharedSourceSchema(mongoose);
   const SharedTo = SharedToSchema(mongoose);
 
-  const HistoryItem = createSchema(Schema, {
+  const HistoryItem = new Schema<HistoryItemType>({
     message: {
       type: String,
       default: "",
@@ -57,7 +211,7 @@ export async function ManagedIncidentModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const AssignmentItem = createSchema(Schema, {
+  const AssignmentItem = new Schema<AssignmentItemType>({
     name: {
       type: String,
       default: "",
@@ -99,7 +253,7 @@ export async function ManagedIncidentModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const IncidentUnit = createSchema(Schema, {
+  const IncidentUnit = new Schema<IncidentUnitType>({
     UnitID: {
       type: String,
       required: true,
@@ -209,7 +363,7 @@ export async function ManagedIncidentModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const IncidentGroup = createSchema(Schema, {
+  const IncidentGroup = new Schema<IncidentGroupType>({
     location_on_map: {
       type: String,
       default: "",
@@ -251,7 +405,7 @@ export async function ManagedIncidentModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const IncidentHazard = createSchema(Schema, {
+  const IncidentHazard = new Schema<IncidentHazardType>({
     location_on_scene: {
       type: String,
       default: "",
@@ -293,7 +447,7 @@ export async function ManagedIncidentModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const IncidentChecklistItem = createSchema(Schema, {
+  const IncidentChecklistItem = new Schema<IncidentChecklistItemType>({
     active: {
       type: Boolean,
       default: true
@@ -338,7 +492,7 @@ export async function ManagedIncidentModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const IncidentChecklist = createSchema(Schema, {
+  const IncidentChecklist = new Schema<IncidentChecklistType>({
     active: {
       type: Boolean,
       default: true
@@ -383,9 +537,9 @@ export async function ManagedIncidentModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<ManagedIncident>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     departmentId: {
@@ -555,29 +709,22 @@ export async function ManagedIncidentModule(mongoose: MongooseModule) {
     sharedSource: {
       type: SharedSource,
     },
-
   }, {
-    collection: "massive_incident_managed",
   });
   modelSchema.set("autoIndex", false);
 
+  modelSchema.virtual("id").get(function (this: ManagedIncident) {
+    return this._id.toHexString();
+  });
+
   modelSchema.set("toJSON", {
     virtuals: true,
     versionKey: false,
-    transform(doc: ModelFromSchema<typeof modelSchema>, ret: DocumentTypeFromSchema<typeof modelSchema>) {
-      ret.id = ret._id;
-    },
   });
 
-  modelSchema.virtual("id").get(function(this: MongooseDocument) {
-    // tslint:disable-next-line: no-unsafe-any
-    return this._id.toString();
-  });
 
   modelSchema.plugin(mongooseLeanVirtuals);
-  return createModel(mongoose, "ManagedIncident", modelSchema);
+  return mongoose.model<ManagedIncident>("ManagedIncident", modelSchema, "massive_incident_managed", { overwriteModels: true });
 }
 
-export interface ManagedIncident extends ItemTypeFromTypeSchemaFunction<typeof ManagedIncidentModule> { }
-export interface ManagedIncidentModel extends ModelTypeFromTypeSchemaFunction<ManagedIncident> { }
-export default ManagedIncidentModule as ReplaceModelReturnType<typeof ManagedIncidentModule, ManagedIncidentModel>;
+export interface ManagedIncidentModel extends Model<ManagedIncident> { }

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

@@ -1,17 +1,36 @@
+import { Model } from "mongoose";
 import {
-  createModel,
-  createSchema,
   currentDate,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseModule,
-  ReplaceModelReturnType,
 } from "../helpers";
 
-export async function Mark43IncidentRetryModule(mongoose: MongooseModule) {
+interface RelatedEventType {
+  mark43Id: number,
+  cadAgencyEventNumber: string,
+}
+
+interface RetryPayloadType {
+  departmentId: number,
+  activityType: string,
+  relatedEvent: RelatedEventType
+}
+export interface Mark43IncidentRetry {
+  departmentId: string,
+  created: Date,
+  modified: Date,
+  active: boolean,
+  attempts: number,
+  retries: number,
+  notificationSent: boolean,
+  retryPayload: RetryPayloadType,
+  mark43IncidentId: number,
+  incidentNumber: string,
+}
+
+export default async function Mark43IncidentRetryModule(mongoose: MongooseModule) {
   const Schema = mongoose.Schema;
-  
-  const RelatedEvent = createSchema(Schema, {
+
+  const RelatedEvent = new Schema<RelatedEventType>({
     mark43Id: {
       type: Number,
       default: 0,
@@ -25,7 +44,7 @@ export async function Mark43IncidentRetryModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const RetryPayload = createSchema(Schema, {
+  const RetryPayload = new Schema<RetryPayloadType>({
     departmentId: {
       type: Number,
       default: 0,
@@ -42,7 +61,7 @@ export async function Mark43IncidentRetryModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<Mark43IncidentRetry>({
     departmentId: {
       type: String,
       default: "",
@@ -84,13 +103,10 @@ export async function Mark43IncidentRetryModule(mongoose: MongooseModule) {
       type: String,
     },
   }, {
-    collection: "massive_mark43_incident_retry",
   });
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "Mark43IncidentRetry", modelSchema);
+  return mongoose.model<Mark43IncidentRetry>("Mark43IncidentRetry", modelSchema, "massive_mark43_incident_retry", { overwriteModels: true });
 }
 
-export interface Mark43IncidentRetry extends ItemTypeFromTypeSchemaFunction<typeof Mark43IncidentRetryModule> { }
-export interface Mark43IncidentRetryModel extends ModelTypeFromTypeSchemaFunction<Mark43IncidentRetry> { }
-export default Mark43IncidentRetryModule as ReplaceModelReturnType<typeof Mark43IncidentRetryModule, Mark43IncidentRetryModel>;
+export interface Mark43IncidentRetryModel extends Model<Mark43IncidentRetry> { }

package/src/models/message.ts

@@ -1,20 +1,39 @@
 import * as uuid from "uuid";
 import {
   MongooseModule,
-  createSchema,
-  createModel,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
   currentDate,
 } from "../helpers";
-import ColorModule from "./schema/color";
+import ColorModule, { ColorSchemaType } from "./schema/color";
+import { Model, Types } from "mongoose";
 
-export async function MessageModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+interface TypeSchemaType {
+  type: string,
+  typeOpts: object
+}
+export interface Message extends Record<string, unknown> {
+  _id: Types.ObjectId,
+  departmentId: string,
+  userId: string,
+  session: string,
+  active: boolean,
+  uuid: string,
+  requestId: string,
+  title: string,
+  body: string,
+  actionTitle: string,
+  created: Date,
+  updated: Date,
+  color: ColorSchemaType,
+  url: string,
+  priority: number,
+  type: TypeSchemaType
+}
+
+export default async function MessageModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
   const Color = ColorModule(mongoose);
 
-  const TypeSchema = createSchema(Schema, {
+  const TypeSchema = new Schema<TypeSchemaType>({
     type: {
       type: String,
       default: "", // generic, support, requestLogs, requestCADLogs, upgradeApp, upgradeOS
@@ -28,9 +47,9 @@ export async function MessageModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<Message>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     departmentId: {
@@ -96,13 +115,10 @@ export async function MessageModule(mongoose: MongooseModule) {
       default: {},
     },
   }, {
-    collection: "massive_message",
   });
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "Message", modelSchema);
+  return mongoose.model<Message>("Message", modelSchema, "massive_message", { overwriteModels: true });
 }
 
-export interface Message extends ItemTypeFromTypeSchemaFunction<typeof MessageModule> { }
-export interface MessageModel extends ModelTypeFromTypeSchemaFunction<Message> { }
-export default MessageModule as ReplaceModelReturnType<typeof MessageModule, MessageModel>;
+export interface MessageModel extends Model<Message> { }

package/src/models/monitor.ts

@@ -1,21 +1,29 @@
+import { Model, Types } from "mongoose";
 import {
-  createModel,
-  createSchema,
   currentDate,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseModule,
-  ReplaceModelReturnType,
   retrieveCurrentUnixTime,
 } from "../helpers";
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
 
-export async function MonitorModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface Monitor {
+  _id: Types.ObjectId,
+  departmentId: string,
+  agencyId: string,
+  notificationType: string,
+  status: string,
+  sentUnixDate: number,
+  sentAt: Date,
+  ticketId: string,
+  count: number,
+}
+
+export default async function MonitorModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<Monitor>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     departmentId: {
@@ -57,7 +65,6 @@ export async function MonitorModule(mongoose: MongooseModule) {
       default: 1,
     },
   }, {
-    collection: "massive_monitor",
   });
   modelSchema.set("toJSON", {
     virtuals: true,
@@ -67,9 +74,7 @@ export async function MonitorModule(mongoose: MongooseModule) {
   modelSchema.plugin(mongooseLeanVirtuals);
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "Monitor", modelSchema);
+  return mongoose.model<Monitor>("Monitor", modelSchema, "massive_monitor", { overwriteModels: true });
 }
 
-export interface Monitor extends ItemTypeFromTypeSchemaFunction<typeof MonitorModule> { }
-export interface MonitorModel extends ModelTypeFromTypeSchemaFunction<Monitor> { }
-export default MonitorModule as ReplaceModelReturnType<typeof MonitorModule, MonitorModel>;
+export interface MonitorModel extends Model<Monitor> { }

package/src/models/personnel-import.ts

@@ -1,18 +1,42 @@
+import { Model, Types } from "mongoose";
 import {
-  createSchema,
-  createModel,
   currentDate,
   MongooseModule,
   retrieveCurrentUnixTime,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
 
+interface RadioType {
+  radioName: string,
+  active: boolean,
+  source: string,
+}
+export interface PersonnelImport {
+  _id: Types.ObjectId,
+  PersonnelID: string,
+  PersonnelName: string,
+  PersonnelRank: string,
+  PersonnelWorkCode: string,
+  PersonnelNote: string,
+  departmentId: string,
+  radioNames: string[],
+  radios: RadioType[],
+  shiftStartTime: number,
+  shiftEndTime: number,
+  shiftStart: Date | string,
+  shiftEnd: Date | string,
+  modified_unix_date: number,
+  modified: Date,
+  active: boolean,
+  agencyName: string,
+  agencyCode: string,
+  agencyId: Types.ObjectId,
+  importNotes: string,
+}
+
 export function PersonnelImportSchema(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+  const { Schema } = mongoose;
 
-  const Radio = createSchema(Schema, {
+  const Radio = new Schema<RadioType>({
     radioName: {
       type: String,
     },
@@ -29,9 +53,9 @@ export function PersonnelImportSchema(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<PersonnelImport>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     PersonnelID: {
@@ -75,11 +99,11 @@ export function PersonnelImportSchema(mongoose: MongooseModule) {
       default: 0,
     },
     shiftStart: {
-      type: Date,
+      type: Date || String,
       default: "",
     },
     shiftEnd: {
-      type: Date,
+      type: Date || String,
       default: "",
     },
 
@@ -105,7 +129,7 @@ export function PersonnelImportSchema(mongoose: MongooseModule) {
       default: ""
     },
     agencyId: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       ref: "Agency",
       default: null,
     },
@@ -114,18 +138,15 @@ export function PersonnelImportSchema(mongoose: MongooseModule) {
       default: "",
     },
   }, {
-    collection: "massive_personnel_import",
   });
   modelSchema.set("autoIndex", false);
 
   return modelSchema;
 }
 
-export async function PersonnelImportModule(mongoose: MongooseModule) {
+export default async function PersonnelImportModule(mongoose: MongooseModule) {
   const modelSchema = PersonnelImportSchema(mongoose);
-  return createModel(mongoose, "PersonnelImport", modelSchema);
+  return mongoose.model<PersonnelImport>("PersonnelImport", modelSchema, "massive_personnel_import", { overwriteModels: true });
 }
 
-export interface PersonnelImport extends ItemTypeFromTypeSchemaFunction<typeof PersonnelImportModule> { }
-export interface PersonnelImportModel extends ModelTypeFromTypeSchemaFunction<PersonnelImport> { }
-export default PersonnelImportModule as ReplaceModelReturnType<typeof PersonnelImportModule, PersonnelImportModel>;
+export interface PersonnelImportModel extends Model<PersonnelImport> { }