tabletcommand-backend-models 7.0.0 → 7.0.1

package/src/models/checklist-item.ts

@@ -5,29 +5,15 @@ import {
   MongooseDocument,
   retrieveCurrentUnixTime
 } from "../helpers";
-import { Model, Types } from "mongoose";
+import { Model } from "mongoose";
+import { ChecklistItemType } from "../types/checklist";
 
-export interface ChecklistItem extends Record<string, unknown> {
-  _id: Types.ObjectId,
-  id?: string,
-  position: number,
-  userId: string,
-  uuid: string,
-  checklist_uuid: string,
-  api_checklist_id: string,
-  isMandatory: boolean,
-  modified_date: string,
-  modified_unix_date: number,
-  departmentId: string,
-  active: boolean,
-  name: string,
-  description: string,
-}
+export interface ChecklistItem extends ChecklistItemType, Record<string, unknown> { }
 
 export function ChecklistItemSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const modelSchema = new Schema<ChecklistItem>({
+  const modelSchema = new Schema<ChecklistItemType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,
@@ -84,7 +70,7 @@ export function ChecklistItemSchema(mongoose: MongooseModule) {
 export default async function ChecklistItemModule(mongoose: MongooseModule) {
   const modelSchema = ChecklistItemSchema(mongoose);
 
-  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/checklist.ts

@@ -7,32 +7,18 @@ import {
   retrieveCurrentUnixTime
 } from "../helpers";
 
-import { ChecklistItemSchema, ChecklistItem } from "./checklist-item";
-import { Model, Types } from "mongoose";
+import { ChecklistItemSchema } from "./checklist-item";
+import { Model } from "mongoose";
+import { ChecklistType } from "../types/checklist";
 
-export interface Checklist extends Record<string, unknown> {
-  _id: Types.ObjectId,
-  id?: string,
-  position: number,
-  userId: string,
-  uuid: string,
-  isMandatory: boolean,
-  modified_date: string,
-  modified_unix_date: number,
-  modified: Date,
-  departmentId: string,
-  active: boolean,
-  name: string,
-  agencyId: Types.ObjectId
-  items: ChecklistItem[]
-}
+export interface Checklist extends ChecklistType, Record<string, unknown> { }
 
 export function ChecklistSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
   const ChecklistItem = ChecklistItemSchema(mongoose);
 
-  const modelSchema = new Schema<Checklist>({
+  const modelSchema = new Schema<ChecklistType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,
@@ -89,7 +75,7 @@ export function ChecklistSchema(mongoose: MongooseModule) {
   }, {
   });
   modelSchema.set("autoIndex", 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/csv-import.ts

@@ -1,32 +1,16 @@
-import { Model, Types } from "mongoose";
+import { Model } from "mongoose";
 import {
   currentDate,
   MongooseModule,
 } from "../helpers";
+import { CSVImportType } from "../types/csv-import";
 
-export interface CSVImport {
-  _id: Types.ObjectId,
-  batchId: string,
-  importCreated: Date,
-  importEnded: Date,
-  status: string,
-  departmentId: string,
-  agencyId: string,
-  importType: string,
-  fileType: string,
-  fileName: string,
-  fileSize: string,
-  fileLastModified: Date,
-  records: object[],
-  modifiedDate: Date,
-  userId: string,
-  sendNotification: boolean
-}
+export interface CSVImport extends CSVImportType { }
 
 export default async function CSVImportModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const modelSchema = new Schema<CSVImport>({
+  const modelSchema = new Schema<CSVImportType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,

package/src/models/department.ts

@@ -6,339 +6,43 @@ import {
   MongooseModule,
   retrieveCurrentUnixTime,
 } from "../helpers";
-import ColorModule, { ColorSchemaType } from "./schema/color";
-import PubNubTokenSchema, { PubNubTokenSchemaType } from "./schema/pubnub-token";
-import { Model, Types } from "mongoose";
-
-interface Mark43StatusConfigType {
-  TimeDispatched: string[],
-  TimeEnroute: string[],
-  TimeStaged: string[],
-  TimeCleared: string[],
-  TimeAtHospital: string[],
-  TimeTransporting: string[],
-  TimeArrived: string[],
-}
-
-interface Mark43ProcessLocationConfigType {
-  enabled: boolean,
-  locationUrl: string,
-}
-
-interface Mark43ProcessCommentConfigType {
-  enabled: boolean,
-  commentUrl: string,
-  usersUrl: string,
-  defaultUserId: number,
-}
-
-interface Mark43ProcessVehicleStatusConfigType {
-  enabled: boolean,
-  vehicleStatusUrl: string,
-  vehicleStatusListUrl: string,
-}
-
-interface Mark43ProcessConfigType {
-  location: Mark43ProcessLocationConfigType
-  comment: Mark43ProcessCommentConfigType
-  vehicleStatus: Mark43ProcessVehicleStatusConfigType
-}
-
-interface Mark43ConfigType {
-  baseUrl: string,
-  authToken: string,
-  apiToken: string,
-  userId: number,
-  enabled: boolean,
-  unitStatusCodes: Mark43StatusConfigType,
-  process: Mark43ProcessConfigType
-}
-
-interface IntterraFieldsType {
-  key: string,
-  value: string,
-  transformationRequired: boolean,
-  required: boolean,
-  enabled: boolean,
-}
-
-interface IntterraConnectionType {
-  active: boolean,
-  fields: IntterraFieldsType[],
-  callTypes: string[],
-  authKey: string,
-  authKeySecret: string,
-  agency: string,
-  description: string,
-}
-
-interface IntterraConfigType {
-  enabled: boolean,
-  connections: IntterraConnectionType[],
-}
-
-interface SkymiraConfigType {
-  enabled: boolean,
-  token: string,
-  locationsUrl: string,
-}
-
-interface SkytracConfigType {
-  enabled: boolean
-  licenseKey: string,
-  username: string,
-  secret: string,
-  serviceUrl: string,
-  configTag: string,
-}
-interface SimpleSenseConfigType {
-  token: string,
-}
-
-interface StatusMappingObjectConfigType {
-  status: string,
-  statusCode: string,
-}
-
-interface StatusMappingConfigType {
-  TimeDispatched: StatusMappingObjectConfigType
-  TimeEnroute: StatusMappingObjectConfigType
-  TimeStaged: StatusMappingObjectConfigType
-  TimeArrived: StatusMappingObjectConfigType
-  TimeCleared: StatusMappingObjectConfigType
-  TimeAtHospital: StatusMappingObjectConfigType
-  TimePatient: StatusMappingObjectConfigType
-  TimeTransporting: StatusMappingObjectConfigType
-  TimeTransportComplete: StatusMappingObjectConfigType
-}
-
-interface IncidentVehicleStatusConfigType {
-  enabled: boolean
-  statusMappings: StatusMappingConfigType
-  statusExclusions: string[]
-}
-
-interface FirstArrivingConfigType {
-  token: string,
-  apiUrl: string
-}
-
-interface SafetyPriorityKeywordType {
-  priority: number,
-  keywords: string[],
-  hexColor: string,
-}
-
-interface WebDisclaimerType {
-  message: string,
-  enabled: boolean,
-}
-
-interface AudioStreamType {
-  description: string,
-  channel: string,
-  url: string,
-  order: number,
-}
-
-interface AudioStreamGroupType {
-  group: string,
-  streams: AudioStreamType[],
-  order: number,
-}
-
-interface RestrictedCommentsType {
-  enabled: boolean,
-  callTypesAllowed: string[],
-  statusesAllowed: string[],
-  restrictedFields: string[],
-  restrictedMessage: string,
-}
-
-interface CustomButtonsType {
-  name: string,
-  url: string,
-  order: number,
-  allowExternal: boolean,
-  defaultExternal: boolean,
-  allowFloating: boolean,
-  color: ColorSchemaType,
-}
-
-interface FireMapperLayerType {
-  pathname: string,
-  name: string,
-}
-
-interface FireMapperOutlineType {
-  uuid: string,
-  layer: FireMapperLayerType[],
-}
-
-interface SamsaraConfigurationType {
-  enabled: boolean,
-  token: string,
-}
-
-interface FireMapperConfigurationType {
-  enabled: boolean,
-  layerRefreshInterval: number,
-  proLicenseCount: number,
-  host: string,
-  layer: FireMapperLayerType[],
-  staticLayer: FireMapperOutlineType[],
-}
-
-interface LicensingType {
-  tcPro2Way: number,
-  tcPro1Way: number,
-  tcMobile: number,
-  tcWeb: number,
-  fireMapperPro: number,
-  sendToCAD: number,
-  tcStreams: number,
-}
-
-interface IncidentTypeType {
-  name: string,
-  value: string,
-  allowPartialMatch: boolean,
-  callTypeDescription: string[],
-  callType: string[],
-}
-
-interface ShareIncidentRuleType {
-  ruleType: string,
-  departmentId: string,
-  departmentName: string,
-  configuration: object,
-}
-
-export interface Department extends Record<string, unknown> {
-  _id: Types.ObjectId,
-  id?: string,
-  uuid: string,
-  department: string,
-  fdid: string,
-  addressDetails: {
-    address: string,
-    city: string,
-    state: string,
-    zipCode: string,
-    country: string,
-  },
-  contact: {
-    department: string,
-    name: string,
-    phone: string,
-    email: string,
-  },
-  modified_unix_date: number,
-  modified: Date,
-  active: boolean,
-  apikey: string,
-  partialApiKey: string,
-  cadEmailUsername: string,
-  notificationEmails: string[]
-  rosteringEnabled: boolean,
-  externalNotificationsEnabled: boolean,
-  cadBidirectionalEnabled: boolean,
-  cadOneWayVehiclesEnabled: boolean,
-  cadAllowedIPAddresses: string[]
-  cadGetLocationEnabled: boolean,
-  cadAllowIgnoreAfterDays: number,
-  connectivity: {
-    incident: {
-      enabled: boolean,
-      staleMinutes: number,
-      heartbeatMinutes: number,
-    },
-    location: {
-      enabled: boolean,
-      staleMinutes: number,
-      heartbeatMinutes: number,
-    },
-    status: {
-      enabled: boolean,
-      staleMinutes: number,
-      heartbeatMinutes: number,
-      ackUnitsCount: number,
-    }
-  },
-  selfAssignmentEnabled: boolean,
-  userContributionEnabled: boolean,
-  vehicleSwapEnabled: boolean,
-  personnelStaffingEnabled: boolean,
-  authSource: string[],
-  defaultMapPosition: {
-    longitude: number,
-    latitude: number,
-  },
-  fireMapPDFReader: string,
-  locationStaleMinutes: number,
-  beaconEnabled: boolean,
-  firstArrivingEnabled: boolean,
-  firstArriving: FirstArrivingConfigType,
-  simpleSenseEnabled: boolean,
-  simpleSense: SimpleSenseConfigType,
-  incidentVehicleStatusEnabled: boolean,
-  fireMapperEnabled: boolean,
-  fireMapperRefreshInterval: number,
-  fireMapperProLicenses: number,
-  fireMapper: FireMapperConfigurationType,
-  arcGISMapsEnabled: boolean,
-  beansAIEnabled: boolean,
-  mowsEnabled: boolean,
-  rtsEnabled: boolean,
-  rtsChannelPrefix: string,
-  pubNubV3: PubNubTokenSchemaType,
-  socketIO: PubNubTokenSchemaType,
-  esriGeoJSONFilename: string,
-  incidentTypes: IncidentTypeType[],
-  ackDelimiter: string,
-  callTypeBlock: string[]
-  agencyIds: Types.ObjectId[],
-  signupKey: string,
-  signupDomains: string[],
-  safetyPriorityKeywords: SafetyPriorityKeywordType[],
-  shareLocationPhones: boolean,
-  shareLocationTablets: boolean,
-  shareAVL: {
-    enabled: boolean,
-    opAreaName: string,
-    opAreaCode: string,
-    fadeZoomLevel: number,
-  },
-  shareIncident: {
-    enabled: boolean,
-    rules: ShareIncidentRuleType[],
-  },
-  speedReportingEnabled: boolean,
-  accountType: string,
-  timeZone: string,
-  remoteLoggingEnabled: boolean,
-  logOffEnabled: boolean,
-  licensing: LicensingType,
-  webDisclaimer: WebDisclaimerType,
-  addUserInstructions: string,
-  restrictedComments: RestrictedCommentsType,
-  customButtons: CustomButtonsType[],
-  reportNumberEnabled: boolean,
-  audioConfiguration: AudioStreamGroupType[]
-  minPasswordLength: number,
-  zonehaven: {
-    enabled: boolean,
-    visible: boolean,
-    layerUrl: string,
-    fadeZoomLevel: number,
-  },
-  activeUserCount: number,
-  samsara: SamsaraConfigurationType
-  mark43: Mark43ConfigType
-  intterra: IntterraConfigType
-  vehicleRadioNameIsStable: boolean,
-  cadIncidentHistoryType: number[],
-}
+import ColorModule from "./schema/color";
+import PubNubTokenSchema from "./schema/pubnub-token";
+import { Model } from "mongoose";
+import {
+  AudioStreamGroupType,
+  AudioStreamType,
+  CustomButtonsType,
+  DepartmentType,
+  FireMapperConfigurationType,
+  FireMapperLayerType,
+  FireMapperOutlineType,
+  FirstArrivingConfigType,
+  IncidentTypeType,
+  IncidentVehicleStatusConfigType,
+  IntterraConfigType,
+  IntterraConnectionType,
+  IntterraFieldsType,
+  LicensingType,
+  Mark43ConfigType,
+  Mark43ProcessCommentConfigType,
+  Mark43ProcessConfigType,
+  Mark43ProcessLocationConfigType,
+  Mark43ProcessVehicleStatusConfigType,
+  Mark43StatusConfigType,
+  RestrictedCommentsType,
+  SafetyPriorityKeywordType,
+  SamsaraConfigurationType,
+  ShareIncidentRuleType,
+  SimpleSenseConfigType,
+  SkymiraConfigType,
+  SkytracConfigType,
+  StatusMappingConfigType,
+  StatusMappingObjectConfigType,
+  WebDisclaimerType
+} from "../types/department";
+
+export interface Department extends DepartmentType, Record<string, unknown> { }
 
 const Mark43StatusConfigDefault = {
   TimeDispatched: ["D"],
@@ -1219,7 +923,7 @@ export default async function DepartmentModule(mongoose: MongooseModule) {
   });
 
   // Main schema
-  const modelSchema = new Schema<Department>({
+  const modelSchema = new Schema<DepartmentType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,
@@ -1459,10 +1163,6 @@ export default async function DepartmentModule(mongoose: MongooseModule) {
       type: SimpleSenseConfig,
       default: SimpleSenseConfigDefault,
     },
-    incidentVehicleStatusEnabled: {
-      type: Boolean,
-      default: false
-    },
     incidentVehicleStatus: {
       type: IncidentVehicleStatusConfig,
     },
@@ -1709,7 +1409,7 @@ export default async function DepartmentModule(mongoose: MongooseModule) {
     updatedAt: "modified",
   });
 
-  modelSchema.virtual("id").get(function (this: Department) {
+  modelSchema.virtual("id").get(function(this: Department) {
     return this._id.toHexString();
   });
 

package/src/models/device-mapping.ts

@@ -3,32 +3,15 @@ import {
   currentDate,
   MongooseModule,
 } from "../helpers";
-import { Model, Types } from "mongoose";
+import { Model } from "mongoose";
+import { DeviceMappingType } from "../types/device-mapping";
 
-export interface DeviceMapping {
-  _id: Types.ObjectId,
-  departmentId: string,
-  userId: string,
-  deviceType: string,
-  mapId: string,
-  deviceId: string,
-  location: {
-    longitude: number,
-    latitude: number,
-  },
-  modified_unix_date: number,
-  modified: Date,
-  active: boolean,
-  remoteAddress: string,
-  uuid: string,
-  note: string,
-  mapHidden: boolean,
-}
+export interface DeviceMapping extends DeviceMappingType { }
 
 export default async function DeviceMappingModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const modelSchema = new Schema<DeviceMapping>({
+  const modelSchema = new Schema<DeviceMappingType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,

package/src/models/esri.ts

@@ -1,34 +1,15 @@
 // import * as uuid from "uuid";
-import { Model, Types } from "mongoose";
+import { Model } from "mongoose";
 import {
   MongooseModule,
 } from "../helpers";
-import EsriAuthModule, { EsriAuthSchemaType } from "./schema/esri-auth";
-import EsriErrorModule, { EsriErrorSchemaType } from "./schema/esri-error";
-import EsriMapModule, { EsriMapType } from "./schema/esri-map";
-import FireMapperAuthModule, { FireMapperAuthType } from "./schema/firemapper-auth";
+import EsriAuthModule from "./schema/esri-auth";
+import EsriErrorModule from "./schema/esri-error";
+import EsriMapModule from "./schema/esri-map";
+import FireMapperAuthModule from "./schema/firemapper-auth";
+import { EsriType, MapPropertiesType } from "../types/esri";
 
-interface MapPropertiesType {
-  itemId: string,
-  download: boolean,
-}
-export interface Esri {
-  _id: Types.ObjectId,
-  id?: string,
-  runAt: Date,
-  departmentId: Types.ObjectId
-  auth: EsriAuthSchemaType,
-  authError: EsriErrorSchemaType,
-  fireMapperAuth: FireMapperAuthType,
-  arcGISGroupIds: string[],
-  arcGISAuth: EsriAuthSchemaType,
-  arcGISMigrated: boolean,
-  review: object,
-  reviewRunAt: Date,
-  maps: EsriMapType[],
-  mapsProperties: MapPropertiesType[],
-  mapLastUpdated: Date,
-}
+export interface Esri extends EsriType { }
 
 export function EsriSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
@@ -52,7 +33,7 @@ export function EsriSchema(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = new Schema<Esri>({
+  const modelSchema = new Schema<EsriType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,
@@ -131,7 +112,7 @@ export function EsriSchema(mongoose: MongooseModule) {
   modelSchema.set("autoIndex", false);
 
   // Deprecated. Check which apps rely on .id instead of using ._id.
-  modelSchema.virtual("id").get(function (this: Esri) {
+  modelSchema.virtual("id").get(function(this: Esri) {
     return this._id.toHexString();
   });
 

package/src/models/gst-mapping.ts

@@ -4,31 +4,15 @@ import {
   MongooseModule,
   retrieveCurrentUnixTime,
 } from "../helpers";
-import { Model, Types } from "mongoose";
+import { Model } from "mongoose";
+import { GSTMappingType } from "../types/gst-mapping";
 
-export interface GSTMapping {
-  _id: Types.ObjectId,
-  departmentId: string,
-  gstAgency: string,
-  deviceType: string,
-  unitId: string,
-  location: {
-    longitude: number,
-    latitude: number,
-  },
-  modified_unix_date: number,
-  modified: Date,
-  active: boolean,
-  mapHidden: boolean,
-  remoteAddress: string,
-  uuid: string,
-  note: string,
-}
+export interface GSTMapping extends GSTMappingType { }
 
 export default async function GSTMappingModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const modelSchema = new Schema<GSTMapping>({
+  const modelSchema = new Schema<GSTMappingType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,