tabletcommand-backend-models 7.0.0 → 7.0.2

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

@@ -1,45 +1,7 @@
 import {
   MongooseModule,
 } from "../../helpers";
-
-interface MapLayerType {
-  layerId: string,
-  itemId: string,
-  title: string,
-  layerType: string,
-  url: string,
-  visibility: boolean,
-  opacity: number,
-  access: string,
-  owner: string,
-}
-
-interface BaseMapType {
-  baseMapLayers: MapLayerType[],
-  title: string,
-}
-
-interface SimpleMapSchemaType {
-  itemId: string,
-  title: string,
-  url: string,
-  access: string,
-  owner: string,
-  type: string,
-  modified: number,
-  modifiedAt: Date,
-}
-
-interface OfflineMapType extends SimpleMapSchemaType { status: string }
-
-export interface EsriMapType extends SimpleMapSchemaType {
-  mapLayers: MapLayerType[]
-  baseMap: BaseMapType
-  offline: OfflineMapType[]
-  tags: string[],
-  development: boolean,
-  size: number,
-}
+import { MapLayerType, BaseMapType, OfflineMapType, EsriMapType } from "../../types/esri";
 
 export default function EsriMapSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;

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

@@ -1,17 +1,7 @@
 import {
   MongooseModule,
 } from "../../helpers";
-
-interface FireMapperEncryptedType {
-  iv: string,
-  encryptedData: string,
-}
-
-export interface FireMapperAuthType {
-  username: string,
-  encrypted: FireMapperEncryptedType
-  encryptedAccessCode: FireMapperEncryptedType
-}
+import { FireMapperEncryptedType, FireMapperAuthType } from "../../types/firemapper-auth";
 
 export default function FireMapperAuthSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;

package/src/models/schema/geojson-point.ts

@@ -1,11 +1,7 @@
 import {
   MongooseModule,
 } from "../../helpers";
-
-export interface GeoJSONPointType {
-  type: string
-  coordinates: number[]
-}
+import { GeoJSONPointType } from "../../types/geojson-point";
 
 export default function GeoJSONPointSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;

package/src/models/schema/oauth.ts

@@ -1,12 +1,7 @@
 import {
   MongooseModule,
 } from "../../helpers";
-
-export interface OAuthSchemaType {
-  accessToken: string,
-  refreshToken: string,
-  expireAt: Date,
-}
+import { OAuthSchemaType } from "../../types/oauth";
 
 export default function OAuthSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;

package/src/models/schema/pubnub-token.ts

@@ -2,12 +2,7 @@ import {
   MongooseModule,
   currentDate,
 } from "../../helpers";
-
-export interface PubNubTokenSchemaType {
-  token: string,
-  expireAt: Date,
-  runAt: Date | string,
-}
+import { PubNubTokenSchemaType } from "../../types/pubnub-token";
 
 export default function PubNubTokenSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
@@ -22,8 +17,7 @@ export default function PubNubTokenSchema(mongoose: MongooseModule) {
       default: currentDate,
     },
     runAt: {
-      type: Date || String,
-      default: "",
+      type: Date,
     },
   }, {
     _id: false,

package/src/models/schema/remote-file.ts

@@ -0,0 +1,53 @@
+import {
+  MongooseModule,
+  currentDate,
+} from "../../helpers";
+import { RemoteFileSchemaType } from "../../types/remote-file";
+
+export default function RemoteFileSchema(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
+
+  const Item = new Schema<RemoteFileSchemaType>({
+    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
+    },
+    remoteFilePath: {
+      type: String,
+      default: "", // e.g https://drive.google.com/file/d/1abcABC/view?usp=drivesdk
+    },
+    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,
+  });
+
+  return Item;
+}

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

@@ -2,56 +2,19 @@ import {
   MongooseModule,
   currentDate,
 } from "../../helpers";
+import {
+  CADPersonSchemaType,
+  RadioChannelSchemaType,
+  RecordSchemaType,
+  ReportNumberSchemaType,
+  ShareReasonSchemaType,
+  SharedToSchemaType,
+  SharedSourceSchemaType
+} from "../../types/shared-incident";
 
 // Properties shared between CAD and Managed Incident
 // They are copied on iOS
 
-export interface CADPersonSchemaType {
-  PersonnelID: string,
-  PersonnelName: string,
-  PersonnelRank: string,
-  PersonnelWorkCode: string,
-  PersonnelNote: string,
-}
-
-export interface RadioChannelSchemaType extends Record<string, unknown> {
-  name: string,
-  channel: string,
-  url: string,
-  channelDescription: string,
-}
-
-export interface RecordSchemaType {
-  name: string,
-  value: string,
-}
-
-export interface ReportNumberSchemaType {
-  name: string,
-  number: string,
-}
-
-export interface ShareReasonSchemaType {
-  name: string,
-  date: Date,
-}
-
-export interface SharedToSchemaType extends Record<string, unknown> {
-  departmentId: string,
-  name: string,
-  startAt: Date,
-  expireAt: Date,
-  active: boolean,
-  reasons: ShareReasonSchemaType[],
-}
-
-export interface SharedSourceSchemaType extends Record<string, unknown> {
-  name: string,
-  isExternal: boolean,
-  startAt?: Date,
-  expireAt?: Date,
-  reasons: ShareReasonSchemaType[]
-}
 
 export function CADPersonSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;

package/src/models/schema/validation-error-item.ts

@@ -2,14 +2,7 @@ import {
   MongooseModule,
   currentDate,
 } from "../../helpers";
-
-export interface ValidationErrorItemSchemaType {
-  message: string,
-  firstSeenAt: Date,
-  lastSeenAt: Date,
-  clearedAt: Date,
-  payload: object,
-}
+import { ValidationErrorItemSchemaType } from "../../types/validation";
 
 export default function ValidationErrorItemSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;

package/src/models/session.ts

@@ -3,28 +3,11 @@ import {
 } from "../helpers";
 import * as uuid from "uuid";
 
-import OAuthSchema, { OAuthSchemaType } from "./schema/oauth";
+import OAuthSchema from "./schema/oauth";
 import { Model } from "mongoose";
+import { SessionType } from "../types/session";
 
-export interface Session {
-  _id: string,
-  id?: string,
-  nick: string,
-  email: string,
-  user: string,
-  active: boolean,
-  token: string,
-  source: string,
-  departmentId: string,
-  why: string,
-  when: string,
-  ended: string,
-  userAgent: string,
-  remoteAddress: string,
-  deviceId: string,
-  authSource: string,
-  oAuth: OAuthSchemaType,
-}
+export interface Session extends SessionType { }
 
 export default async function SessionModule(mongoose: MongooseModule) {
   const Schema = mongoose.Schema;
@@ -35,7 +18,7 @@ export default async function SessionModule(mongoose: MongooseModule) {
     return typeof this.departmentId === "string";
   }
 
-  const modelSchema = new Schema<Session>({
+  const modelSchema = new Schema<SessionType>({
     _id: {
       type: String,
       default: uuid.v4,
@@ -92,11 +75,11 @@ export default async function SessionModule(mongoose: MongooseModule) {
   });
   modelSchema.set("autoIndex", false);
 
-  modelSchema.pre("save", function (next) {
+  modelSchema.pre("save", function(next) {
     this._id = this.get("token"); // Copy _id from token
     next();
   });
-  modelSchema.virtual("id").get(function (this: Session) {
+  modelSchema.virtual("id").get(function(this: Session) {
     return this._id.toString();
   });
 

package/src/models/smtp-unhandled.ts

@@ -1,21 +1,17 @@
-import { Model, Types } from "mongoose";
+import { Model } from "mongoose";
 import {
   MongooseDocument,
   MongooseModule,
 } from "../helpers";
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
+import { SMTPUnhandledType } from "../types/smtp-unhandled";
 
-export interface SMTPUnhandled {
-  _id: Types.ObjectId,
-  id?: string,
-  email: string,
-  message: string,
-}
+export interface SMTPUnhandled extends SMTPUnhandledType { }
 
 export default async function SMTPUnhandledModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const modelSchema = new Schema<SMTPUnhandled>({
+  const modelSchema = new Schema<SMTPUnhandledType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,
@@ -37,7 +33,7 @@ export default async function SMTPUnhandledModule(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/template.ts

@@ -5,35 +5,10 @@ import {
   MongooseModule,
   retrieveCurrentUnixTime
 } from "../helpers";
-import { Model, Types } from "mongoose";
+import { Model } from "mongoose";
+import { ChecklistOptionType, GroupOptionType, TemplateType } from "../types/template";
 
-interface ChecklistOptionType {
-  name: string,
-  position: number,
-  id: string,
-}
-
-interface GroupOptionType {
-  name: string,
-  position: number,
-  uuid: string,
-}
-export interface Template extends Record<string, unknown> {
-  _id: Types.ObjectId,
-  id?: string,
-  position: number,
-  userId: string,
-  uuid: string,
-  isMandatory: boolean,
-  modified_unix_date: number,
-  modified: Date,
-  departmentId: string,
-  active: boolean,
-  name: string,
-  checklist: ChecklistOptionType[],
-  group: GroupOptionType[],
-  agencyId: Types.ObjectId
-}
+export interface Template extends TemplateType, Record<string, unknown> { }
 
 export function TemplateSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
@@ -74,7 +49,7 @@ export function TemplateSchema(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = new Schema<Template>({
+  const modelSchema = new Schema<TemplateType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,
@@ -129,7 +104,7 @@ export function TemplateSchema(mongoose: MongooseModule) {
   }, {
   });
   modelSchema.set("autoIndex", false);
-  modelSchema.virtual("id").get(function (this: Template) {
+  modelSchema.virtual("id").get(function(this: Template) {
     return this._id.toHexString();
   });
 
@@ -143,7 +118,7 @@ export function TemplateSchema(mongoose: MongooseModule) {
 
 
   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/user-device.ts

@@ -1,63 +1,12 @@
-import { Model, Types } from "mongoose";
+import { Model } from "mongoose";
 import {
   currentDate,
   MongooseModule,
   retrieveCurrentUnixTime,
 } from "../helpers";
+import { UnitSettingType, IncidentSettingType, DeviceSchemaType, SoundSchemaItemType, SoundSchemaType, UserDeviceType } from "../types/user";
 
-interface UnitSettingType {
-  radioName: string,
-  notificationType: string,
-  notificationMode: string,
-}
-interface IncidentSettingType {
-  incidentType: string,
-  notificationType: string,
-  notificationMode: string,
-}
-
-interface DeviceSchemaType {
-  token: string,
-  env: string,
-  ver: string,
-  ua: string,
-  time: number,
-  t: Date,
-  drift: number,
-  channelId: string,
-  bundleIdentifier: string,
-  silentEnabled: boolean,
-  criticalAlertsEnabled: boolean,
-  session: string,
-  active: boolean,
-  offDuty: boolean,
-}
-
-interface SoundSchemaItemType {
-  sound: string,
-  soundType: string,
-  os: string,
-}
-
-interface SoundSchemaType {
-  ios: SoundSchemaItemType,
-  android: SoundSchemaItemType,
-}
-
-export interface UserDevice {
-  _id: Types.ObjectId,
-  userId: string,
-  departmentId: string,
-  devices: DeviceSchemaType[],
-  notificationCount: number,
-  notificationUnitSettings: UnitSettingType[],
-  notificationIncidentSettings: IncidentSettingType[],
-  notificationSounds: SoundSchemaType
-  offDuty: boolean,
-  criticalAlertsVolume: string,
-  allowInStaging: boolean,
-  restrictedCommentsEnabled: boolean,
-}
+export interface UserDevice extends UserDeviceType { }
 
 export default async function UserDeviceModule(mongoose: MongooseModule) {
   const { Schema } = mongoose;
@@ -193,7 +142,7 @@ export default async function UserDeviceModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = new Schema<UserDevice>({
+  const modelSchema = new Schema<UserDeviceType>({
     _id: {
       type: Schema.Types.ObjectId,
       auto: true,

package/src/models/user-registration.ts

@@ -3,31 +3,14 @@ import {
   currentDate,
   MongooseModule,
 } from "../helpers";
+import { UserRegistrationType } from "../types/user";
 
-export interface UserRegistration {
-  email: string,
-  name: string,
-  firstName: string,
-  lastName: string,
-  department: string,
-  title: string,
-  status: string,
-  modifiedDate: number,
-  modified: Date,
-  presentedAt: number,
-  managedIncidentsCount: number,
-  checklistsCount: number,
-  stage: string,
-  firstIncidentUnixTime: number,
-  lastIncidentLocation: string,
-  lastIncidentUnixTime: number,
-  syncedToHubSpot: boolean,
-}
+export interface UserRegistration extends UserRegistrationType { }
 
 export default async function UserRegistrationModule(mongoose: MongooseModule) {
   const Schema = mongoose.Schema;
 
-  const modelSchema = new Schema<UserRegistration>({
+  const modelSchema = new Schema<UserRegistrationType>({
     email: {
       type: String,
       default: "",

package/src/models/user.ts

@@ -4,72 +4,13 @@ import {
   MongooseDocument,
   currentDate,
 } from "../helpers";
-import EsriAuthSchema, { EsriAuthSchemaType } from "./schema/esri-auth";
-import EsriErrorSchema, { EsriErrorSchemaType } from "./schema/esri-error";
-import PubNubTokenSchema, { PubNubTokenSchemaType } from "./schema/pubnub-token";
+import EsriAuthSchema from "./schema/esri-auth";
+import EsriErrorSchema from "./schema/esri-error";
+import PubNubTokenSchema from "./schema/pubnub-token";
 import { Model, Types } from "mongoose";
+import { UserType, VehicleSchemaType } from "../types/user";
 
-interface VehicleSchemaType {
-  radioName: string,
-  vehicleId: string,
-}
-
-export interface User extends Record<string, unknown> {
-  _id: Types.ObjectId,
-  id?: string, // Coming from virtuals
-  nick: string,
-  email: string,
-  name: string,
-  uuid: string,
-  departmentId: string,
-  modified_date: Date,
-  when: Date,
-  agencyId: Types.ObjectId,
-  managedAgencies: Types.ObjectId[],
-  active: boolean,
-  admin: boolean,
-  superuser: boolean,
-  isPro: boolean,
-  isIncidentManager: boolean,
-  mobileAccess: boolean,
-  webAccess: boolean,
-  cadSimulatorAccess: boolean,
-  canAddRemoveVehicle: boolean,
-  beaconEnabled: boolean,
-  userContributionEnabled: boolean,
-  syncLoggingExpireDate: Date,
-  beacons: string[],
-  salt: string,
-  pass: string,
-  auth: string[],
-  mapHidden: boolean,
-  mapId: string,
-  vehicle: VehicleSchemaType,
-  sessionCountiPhone: number,
-  sessionCountiPad: number,
-  rtsAuthKey: string,
-  pubNubV2: PubNubTokenSchemaType
-  pubNubV3: PubNubTokenSchemaType
-  socketIO: PubNubTokenSchemaType,
-  token: string,
-  tokenExpireAt: Date,
-  shareLocationPhone: boolean,
-  shareLocationTablet: boolean,
-  offlineMapsEnabled: boolean,
-  fireMapperProEnabled: boolean,
-  arcGISAuth: EsriAuthSchemaType,
-  arcGISAuthError: EsriErrorSchemaType,
-  offDutyEnabled: boolean,
-  webMapSettings: {
-    defaultZoomLevel: number,
-    defaultCenter: number[],
-    defaultMap: string,
-  },
-  locationToCAD: boolean,
-  logOffEnabled: boolean,
-  restrictedCommentsEnabled: boolean,
-  superUserReadOnly: boolean
-}
+export interface User extends UserType, Record<string, unknown> { }
 
 export function UserSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
@@ -91,7 +32,7 @@ export function UserSchema(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = new Schema<User>({
+  const modelSchema = new Schema<UserType>({
     nick: {
       type: String,
       default: "",
@@ -327,7 +268,7 @@ export function UserSchema(mongoose: MongooseModule) {
   });
 
   // NO _id on User schema?
-  modelSchema.virtual("id").get(function (this: MongooseDocument) {
+  modelSchema.virtual("id").get(function(this: MongooseDocument) {
     return this._id.toHexString();
   });
 

package/src/models/validation-report.ts

@@ -1,22 +1,12 @@
-import { Model, Types } from "mongoose";
+import { Model } from "mongoose";
 import {
   currentDate,
   MongooseModule,
 } from "../helpers";
-import ValidationErrorItemModule, { ValidationErrorItemSchemaType } from "./schema/validation-error-item";
+import ValidationErrorItemModule from "./schema/validation-error-item";
+import { ValidationReportType } from "../types/validation";
 
-export interface ValidationReport {
-  _id: Types.ObjectId,
-  departmentId: Types.ObjectId,
-  location: ValidationErrorItemSchemaType[],
-  statusMap: ValidationErrorItemSchemaType[],
-  status: ValidationErrorItemSchemaType[],
-  vehicleStatus: ValidationErrorItemSchemaType[],
-  vehicle: ValidationErrorItemSchemaType[],
-  incident: ValidationErrorItemSchemaType[],
-  personnel: ValidationErrorItemSchemaType[],
-  modified: Date,
-}
+export interface ValidationReport extends ValidationReportType { }
 
 export function ValidationReportSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;

package/src/test/arcgis-group.ts

@@ -8,12 +8,12 @@ import { url as mongoURL } from "./config";
 import { connect } from "..";
 // import MockModule from "./mock";
 
-describe("ArcGISGroup", function () {
+describe("ArcGISGroup", function() {
   // let models, 
   //   mongoose: typeof import("mongoose"),
   //   mock;
 
-  beforeEach(async function () {
+  beforeEach(async function() {
     const result = await connect(mongoURL);
     console.log(result);
     // models = result.models;
@@ -32,7 +32,7 @@ describe("ArcGISGroup", function () {
     // await mongoose.disconnect();
   });
 
-  it("is saved", async function () {
+  it("is saved", async function() {
     assert.isTrue(true);
   });
 });

package/src/tsconfig.json

@@ -11,6 +11,7 @@
     "noImplicitReturns": true,
     "noUncheckedIndexedAccess": true,
     "outDir": "../build",
+    "typeRoots": ["./types", "node_modules/@types"],
     "resolveJsonModule": true,
     "sourceMap": true,
     "strict": true,