tabletcommand-backend-models 7.0.0 → 7.0.2

package/src/models/incident-event.ts

@@ -1,4 +1,4 @@
-import { Model, Types } from "mongoose";
+import { Model } from "mongoose";
 import {
   currentDate,
   MongooseDocument,
@@ -6,34 +6,10 @@ import {
   retrieveCurrentUnixTime,
 } from "../helpers";
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
+import { EventUserType, IncidentEventType } from "../types/incident-events";
+
+export interface IncidentEvent extends IncidentEventType { }
 
-interface EventUserType {
-  username: string,
-  email: string,
-  radioName: string,
-  userId: string,
-}
-export interface IncidentEvent {
-  _id: Types.ObjectId,
-  id?: string,
-  departmentId: string,
-  IncidentNumber: string,
-  modified_unix_date: number,
-  modified: Date,
-  message: string,
-  location: {
-    longitude: number,
-    latitude: number,
-  },
-  type: string,
-  user: EventUserType,
-  serverTime: number,
-  userTime: number,
-  uuid: string,
-  ref_uuid: string,
-  opts: object,
-  archived: boolean,
-}
 export function IncidentEventSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
@@ -59,7 +35,7 @@ export function IncidentEventSchema(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = new Schema<IncidentEvent>({
+  const modelSchema = new Schema<IncidentEventType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,
@@ -142,7 +118,7 @@ export function IncidentEventSchema(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/incident-notified.ts

@@ -1,29 +1,11 @@
-import { Model, Types } from "mongoose";
+import { Model } from "mongoose";
 import {
   currentDate,
   MongooseModule,
 } from "../helpers";
+import { IncidentNotifiedType, SentItemType, UnitType } from "../types/incident-events";
 
-interface SentItemType {
-  name: string,
-  type: string,
-  date: Date,
-}
-
-interface UnitType {
-  UnitID: string,
-  UnitDispatchNumber: string,
-}
-export interface IncidentNotified {
-  _id: Types.ObjectId,
-  departmentId: string,
-  IncidentNumber: string,
-  incidentTypes: string[],
-  units: string[],
-  unitsByDispatch: UnitType[],
-  sent: SentItemType[],
-  updated: Date,
-}
+export interface IncidentNotified extends IncidentNotifiedType { }
 
 export default async function IncidentNotifiedModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
@@ -60,7 +42,7 @@ export default async function IncidentNotifiedModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = new Schema<IncidentNotified>({
+  const modelSchema = new Schema<IncidentNotifiedType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,

package/src/models/incident-takeover.ts

@@ -2,28 +2,15 @@ import * as uuid from "uuid";
 import {
   MongooseModule,
 } from "../helpers";
-import { Model, Types } from "mongoose";
+import { Model } from "mongoose";
+import { IncidentTakeoverType } from "../types/incident-events";
 
-export interface IncidentTakeover {
-  _id: Types.ObjectId,
-  departmentId: string,
-  uuid: string,
-  incident_id: string,
-  incident_name: string,
-  incident_number: string,
-  old_owner: string,
-  new_owner: string,
-  owner: string,
-  status: string,
-  request_time: number,
-  last_response_time: number,
-  response_time: number,
-}
+export interface IncidentTakeover extends IncidentTakeoverType { }
 
 export default async function IncidentTakeoverModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const modelSchema = new Schema<IncidentTakeover>({
+  const modelSchema = new Schema<IncidentTakeoverType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,

package/src/models/job-log.ts

@@ -1,27 +1,18 @@
-import { Model, Types } from "mongoose";
+import { Model } from "mongoose";
 import {
   MongooseDocument,
   MongooseModule,
   currentDate,
 } from "../helpers";
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
+import { JobLogType } from "../types/job-log";
 
-export interface JobLog {
-  _id: Types.ObjectId,
-  id?: string,
-  jobName: string,
-  host: string,
-  bidDate: Date,
-  startDate: Date,
-  completedDate: Date,
-  state: string
-  forceClosed: boolean,
-}
+export interface JobLog extends JobLogType { }
 
 export default async function JobLogModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const modelSchema = new Schema<JobLog>({
+  const modelSchema = new Schema<JobLogType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,
@@ -58,7 +49,7 @@ export default async function JobLogModule(mongoose: MongooseModule) {
     versionKey: false,
   });
 
-  modelSchema.virtual("id").get(function (this: MongooseDocument) {
+  modelSchema.virtual("id").get(function(this: MongooseDocument) {
     return this._id.toHexString();
   });
 

package/src/models/location.ts

@@ -1,55 +1,24 @@
 import * as uuid from "uuid";
 import {
-  createSchemaDefinition,
   currentDate,
   MongooseDocument,
   MongooseModule,
 } from "../helpers";
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
-import ColorModule, { ColorSchemaType } from "./schema/color";
-import GeoJSONPointModule, { GeoJSONPointType } from "./schema/geojson-point";
-import { Model, Types } from "mongoose";
+import ColorModule from "./schema/color";
+import GeoJSONPointModule from "./schema/geojson-point";
+import { Model } from "mongoose";
+import { LocationType } from "../types/location";
 
-export interface Location extends Record<string, unknown> {
-  _id: Types.ObjectId,
-  id?: string,
-  departmentId: string,
-  userId: string,
-  uuid: string,
-  username: string,
-  device_type: string,
-  active: boolean,
-  deleteAfterDate: Date,
-  modified: Date,
-  movedAt: Date,
-  propsChangedAt: Date,
-  version: number,
-  session: string,
-  altitude: number,
-  heading: number,
-  speed: number,
-  esriId: number,
-  locationGeoJSON: GeoJSONPointType,
-  opAreaCode: string
-  opAreaName: string,
-  agencyCode: string,
-  agencyName: string,
-  shared: boolean,
-  state: string,
-  sendToCAD: boolean,
-  color: ColorSchemaType,
-  colorChangedAt: Date,
-  source: string,
-  kindType: string,
-  typeDetails: object
-}
+export interface Location extends LocationType, Record<string, unknown> { }
 
 export default async function LocationModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
   const Color = ColorModule(mongoose);
   const GeoJSONPoint = GeoJSONPointModule(mongoose);
 
-  const modelSchemaDefinition = createSchemaDefinition({
+
+  const modelSchema = new Schema<LocationType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,
@@ -203,9 +172,7 @@ export default async function LocationModule(mongoose: MongooseModule) {
       type: Date,
       default: currentDate,
     },
-  });
-
-  const modelSchema = new Schema<Location>(modelSchemaDefinition, {
+  }, {
   });
 
   modelSchema.set("toJSON", {
@@ -213,11 +180,11 @@ export default async function LocationModule(mongoose: MongooseModule) {
     versionKey: false,
   });
 
-  modelSchema.virtual("id").get(function (this: MongooseDocument) {
+  modelSchema.virtual("id").get(function(this: MongooseDocument) {
     return this._id.toHexString();
   });
 
-  modelSchema.virtual("location").get(function (this: { locationGeoJSON: { coordinates: number[] } } | null | undefined) {
+  modelSchema.virtual("location").get(function(this: { locationGeoJSON: { coordinates: number[] } } | null | undefined) {
     const location = {
       latitude: 0,
       longitude: 0

package/src/models/mail-log.ts

@@ -1,33 +1,17 @@
-import { Model, Types } from "mongoose";
+import { Model } from "mongoose";
 import {
   MongooseModule,
   currentDate,
   retrieveCurrentUnixTime,
 } from "../helpers";
+import { MailLogType } from "../types/mail-log";
 
-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 interface MailLog extends MailLogType { }
 
 export default async function MailLogModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const modelSchema = new Schema<MailLog>({
+  const modelSchema = new Schema<MailLogType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,

package/src/models/managed-incident.ts

@@ -6,174 +6,25 @@ import {
 } from "../helpers";
 import {
   CADPersonSchema,
-  CADPersonSchemaType,
   RadioChannelSchema,
-  RadioChannelSchemaType,
   RecordSchema,
-  RecordSchemaType,
   ReportNumberSchema,
-  ReportNumberSchemaType,
   SharedSourceSchema,
-  SharedSourceSchemaType,
   SharedToSchema,
-  SharedToSchemaType,
 } from "./schema/shared-incident";
-import { Model, Types } from "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,
-}
+import { Model } from "mongoose";
+import {
+  HistoryItemType,
+  AssignmentItemType,
+  IncidentUnitType,
+  IncidentGroupType,
+  IncidentHazardType,
+  IncidentChecklistItemType,
+  IncidentChecklistType,
+  ManagedIncidentType,
+} from "../types/managed-incident";
 
-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 interface ManagedIncident extends ManagedIncidentType, Record<string, unknown> { }
 
 export default async function ManagedIncidentModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
@@ -537,7 +388,7 @@ export default async function ManagedIncidentModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = new Schema<ManagedIncident>({
+  const modelSchema = new Schema<ManagedIncidentType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,
@@ -713,7 +564,7 @@ export default async function ManagedIncidentModule(mongoose: MongooseModule) {
   });
   modelSchema.set("autoIndex", false);
 
-  modelSchema.virtual("id").get(function (this: ManagedIncident) {
+  modelSchema.virtual("id").get(function(this: ManagedIncident) {
     return this._id.toHexString();
   });
 

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

@@ -3,29 +3,9 @@ import {
   currentDate,
   MongooseModule,
 } from "../helpers";
+import { Mark43IncidentRetryType, RelatedEventType, RetryPayloadType } from "../types/mark43-incident-retry";
 
-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 interface Mark43IncidentRetry extends Mark43IncidentRetryType { }
 
 export default async function Mark43IncidentRetryModule(mongoose: MongooseModule) {
   const Schema = mongoose.Schema;
@@ -61,7 +41,7 @@ export default async function Mark43IncidentRetryModule(mongoose: MongooseModule
     id: false,
   });
 
-  const modelSchema = new Schema<Mark43IncidentRetry>({
+  const modelSchema = new Schema<Mark43IncidentRetryType>({
     departmentId: {
       type: String,
       default: "",

package/src/models/message.ts

@@ -3,31 +3,11 @@ import {
   MongooseModule,
   currentDate,
 } from "../helpers";
-import ColorModule, { ColorSchemaType } from "./schema/color";
-import { Model, Types } from "mongoose";
+import ColorModule from "./schema/color";
+import { Model } from "mongoose";
+import { MessageType, TypeSchemaType } from "../types/message";
 
-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 interface Message extends MessageType, Record<string, unknown> { }
 
 export default async function MessageModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
@@ -47,7 +27,7 @@ export default async function MessageModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = new Schema<Message>({
+  const modelSchema = new Schema<MessageType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,

package/src/models/monitor.ts

@@ -1,27 +1,18 @@
-import { Model, Types } from "mongoose";
+import { Model } from "mongoose";
 import {
   currentDate,
   MongooseModule,
   retrieveCurrentUnixTime,
 } from "../helpers";
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
+import { MonitorType } from "../types/monitor";
 
-export interface Monitor {
-  _id: Types.ObjectId,
-  departmentId: string,
-  agencyId: string,
-  notificationType: string,
-  status: string,
-  sentUnixDate: number,
-  sentAt: Date,
-  ticketId: string,
-  count: number,
-}
+export interface Monitor extends MonitorType { }
 
 export default async function MonitorModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const modelSchema = new Schema<Monitor>({
+  const modelSchema = new Schema<MonitorType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,

package/src/models/personnel-import.ts

@@ -1,37 +1,12 @@
-import { Model, Types } from "mongoose";
+import { Model } from "mongoose";
 import {
   currentDate,
   MongooseModule,
   retrieveCurrentUnixTime,
 } from "../helpers";
+import { PersonnelImportType, RadioType } from "../types/personnel";
 
-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 interface PersonnelImport extends PersonnelImportType { }
 
 export function PersonnelImportSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
@@ -53,7 +28,7 @@ export function PersonnelImportSchema(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = new Schema<PersonnelImport>({
+  const modelSchema = new Schema<PersonnelImportType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,
@@ -99,12 +74,10 @@ export function PersonnelImportSchema(mongoose: MongooseModule) {
       default: 0,
     },
     shiftStart: {
-      type: Date || String,
-      default: "",
+      type: Date,
     },
     shiftEnd: {
-      type: Date || String,
-      default: "",
+      type: Date,
     },
 
     // Cases matches the other modified_unix_date