tabletcommand-backend-models 5.39.5 → 7.0.0

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

@@ -1,16 +1,62 @@
 import {
   MongooseModule,
-  createSchema,
   currentDate,
 } from "../../helpers";
 
 // 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;
 
-  const Person = createSchema(Schema, {
+  const Person = new Schema<CADPersonSchemaType>({
     PersonnelID: {
       type: String,
     },
@@ -40,7 +86,7 @@ export function CADPersonSchema(mongoose: MongooseModule) {
 export function RadioChannelSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const RadioChannel = createSchema(Schema, {
+  const RadioChannel = new Schema<RadioChannelSchemaType>({
     name: {
       type: String,
       default: "",
@@ -71,7 +117,7 @@ export function RadioChannelSchema(mongoose: MongooseModule) {
 export function RecordSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const Record = createSchema(Schema, {
+  const Record = new Schema<RecordSchemaType>({
     name: {
       type: String,
       default: ""
@@ -94,7 +140,7 @@ export function RecordSchema(mongoose: MongooseModule) {
 export function ReportNumberSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const ReportNumber = createSchema(Schema, {
+  const ReportNumber = new Schema<ReportNumberSchemaType>({
     name: {
       type: String,
       default: "",
@@ -117,7 +163,7 @@ export function ReportNumberSchema(mongoose: MongooseModule) {
 export function ShareReasonSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const ShareReason = createSchema(Schema, {
+  const ShareReason = new Schema<ShareReasonSchemaType>({
     name: {
       type: String,
       default: "",
@@ -141,7 +187,7 @@ export function SharedToSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
   const ShareReason = ShareReasonSchema(mongoose);
 
-  const SharedTo = createSchema(Schema, {
+  const SharedTo = new Schema<SharedToSchemaType>({
     departmentId: {
       type: String,
       default: "",
@@ -182,7 +228,7 @@ export function SharedSourceSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
   const ShareReason = ShareReasonSchema(mongoose);
 
-  const SharedSource = createSchema(Schema, {
+  const SharedSource = new Schema<SharedSourceSchemaType>({
     // Department Name (always matches record .departmentId)
     name: {
       type: String,

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

@@ -1,13 +1,20 @@
 import {
   MongooseModule,
-  createSchema,
   currentDate,
 } from "../../helpers";
 
+export interface ValidationErrorItemSchemaType {
+  message: string,
+  firstSeenAt: Date,
+  lastSeenAt: Date,
+  clearedAt: Date,
+  payload: object,
+}
+
 export default function ValidationErrorItemSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const Item = createSchema(Schema, {
+  const Item = new Schema<ValidationErrorItemSchemaType>({
     message: {
       type: String,
       default: "",

package/src/models/session.ts

@@ -1,27 +1,41 @@
 import {
-  createModel,
-  createSchema,
-  DocumentTypeFromSchema,
-  FieldsOfDocument,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseModule,
-  ReplaceModelReturnType,
 } from "../helpers";
 import * as uuid from "uuid";
 
-import OAuthSchema from "./schema/oauth";
+import OAuthSchema, { OAuthSchemaType } from "./schema/oauth";
+import { Model } from "mongoose";
 
-export async function SessionModule(mongoose: MongooseModule) {
+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 default async function SessionModule(mongoose: MongooseModule) {
   const Schema = mongoose.Schema;
   const OAuthToken = OAuthSchema(mongoose);
 
-  function requiredButAllowEmptyString(this: { myField: unknown }) {
+  function requiredButAllowEmptyString(this: Session) {
     // Workaround to set required, and allow empty id
-    return typeof this.myField === "string";
+    return typeof this.departmentId === "string";
   }
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<Session>({
     _id: {
       type: String,
       default: uuid.v4,
@@ -75,30 +89,24 @@ export async function SessionModule(mongoose: MongooseModule) {
       default: null,
     },
   }, {
-    collection: "sys_login",
   });
   modelSchema.set("autoIndex", false);
 
-  modelSchema.pre("save", function(next) {
-    this._id = this.get("token") as string; // Copy _id from token
+  modelSchema.pre("save", function (next) {
+    this._id = this.get("token"); // Copy _id from token
     next();
   });
+  modelSchema.virtual("id").get(function (this: Session) {
+    return this._id.toString();
+  });
 
   modelSchema.set("toJSON", {
     virtuals: true,
     versionKey: false,
-    transform(doc: DocumentTypeFromSchema<typeof modelSchema>, ret: FieldsOfDocument<DocumentTypeFromSchema<typeof modelSchema>>) {
-      ret.id = ret._id;
-    },
   });
 
-  modelSchema.virtual("id").get(function(this: DocumentTypeFromSchema<typeof modelSchema>) {
-    return this._id.toString();
-  });
 
-  return createModel(mongoose, "Session", modelSchema);
+  return mongoose.model<Session>("Session", modelSchema, "sys_login", { overwriteModels: true });
 }
 
-export interface Session extends ItemTypeFromTypeSchemaFunction<typeof SessionModule> { }
-export interface SessionModel extends ModelTypeFromTypeSchemaFunction<Session> { }
-export default SessionModule as ReplaceModelReturnType<typeof SessionModule, SessionModel>;
+export interface SessionModel extends Model<Session> { }

package/src/models/smtp-unhandled.ts

@@ -1,20 +1,23 @@
+import { Model, Types } from "mongoose";
 import {
-  createModel,
-  createSchema,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseDocument,
   MongooseModule,
-  ReplaceModelReturnType,
 } from "../helpers";
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
 
-export async function SMTPUnhandledModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface SMTPUnhandled {
+  _id: Types.ObjectId,
+  id?: string,
+  email: string,
+  message: string,
+}
+
+export default async function SMTPUnhandledModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<SMTPUnhandled>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     email: {
@@ -28,23 +31,20 @@ export async function SMTPUnhandledModule(mongoose: MongooseModule) {
       required: true,
     },
   }, {
-    collection: "massive_smtp_unhandled",
   });
   modelSchema.set("toJSON", {
     virtuals: true,
     versionKey: false,
   });
 
-  modelSchema.virtual("id").get(function(this: MongooseDocument) {
+  modelSchema.virtual("id").get(function (this: MongooseDocument) {
     return this._id.toHexString();
   });
 
   modelSchema.plugin(mongooseLeanVirtuals);
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "SMTPUnhandled", modelSchema);
+  return mongoose.model<SMTPUnhandled>("SMTPUnhandled", modelSchema, "massive_smtp_unhandled", { overwriteModels: true });
 }
 
-export interface SMTPUnhandled extends ItemTypeFromTypeSchemaFunction<typeof SMTPUnhandledModule> { }
-export interface SMTPUnhandledModel extends ModelTypeFromTypeSchemaFunction<SMTPUnhandled> { }
-export default SMTPUnhandledModule as ReplaceModelReturnType<typeof SMTPUnhandledModule, SMTPUnhandledModel>;
+export interface SMTPUnhandledModel extends Model<SMTPUnhandled> { }

package/src/models/template.ts

@@ -1,23 +1,44 @@
 import * as uuid from "uuid";
 
 import {
-  createModel,
-  createSchema,
   currentDate,
-  DocumentTypeFromSchema,
-  ItemTypeFromTypeSchemaFunction,
-  ModelFromSchema,
-  ModelTypeFromTypeSchemaFunction,
-  MongooseDocument,
   MongooseModule,
-  ReplaceModelReturnType,
   retrieveCurrentUnixTime
 } from "../helpers";
+import { Model, Types } from "mongoose";
+
+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 function TemplateSchema(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+  const { Schema } = mongoose;
 
-  const ChecklistOption = createSchema(Schema, {
+  const ChecklistOption = new Schema<ChecklistOptionType>({
     name: {
       type: String,
       default: "",
@@ -35,7 +56,7 @@ export function TemplateSchema(mongoose: MongooseModule) {
     id: false,
   });
 
-  const GroupOption = createSchema(Schema, {
+  const GroupOption = new Schema<GroupOptionType>({
     name: {
       type: String,
       default: "",
@@ -53,9 +74,9 @@ export function TemplateSchema(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<Template>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     position: {
@@ -101,26 +122,25 @@ export function TemplateSchema(mongoose: MongooseModule) {
       default: []
     },
     agencyId: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       ref: "Agency",
       default: null,
     },
   }, {
-    collection: "massive_template",
   });
   modelSchema.set("autoIndex", false);
+  modelSchema.virtual("id").get(function (this: Template) {
+    return this._id.toHexString();
+  });
+
   modelSchema.set("toJSON", {
     virtuals: true,
     versionKey: false,
-    transform(doc: ModelFromSchema<typeof modelSchema>, ret: DocumentTypeFromSchema<typeof modelSchema>) {
+    transform(doc, ret) {
       strictSchema(doc.schema as typeof modelSchema, ret);
-      ret.id = ret._id;
     },
   });
 
-  modelSchema.virtual("id").get(function (this: MongooseDocument) {
-    return this._id.toHexString();
-  });
 
   function strictSchema(schema: typeof modelSchema, ret: Record<string, unknown>) {
     Object.keys(ret).forEach(function (element) {
@@ -139,11 +159,9 @@ export function TemplateSchema(mongoose: MongooseModule) {
   return modelSchema;
 }
 
-export async function TemplateModule(mongoose: MongooseModule) {
+export default async function TemplateModule(mongoose: MongooseModule) {
   const modelSchema = TemplateSchema(mongoose);
-  return createModel(mongoose, "Template", modelSchema);
+  return mongoose.model<Template>("Template", modelSchema, "massive_template", { overwriteModels: true });
 }
 
-export interface Template extends ItemTypeFromTypeSchemaFunction<typeof TemplateModule> { }
-export interface TemplateModel extends ModelTypeFromTypeSchemaFunction<Template> { }
-export default TemplateModule as ReplaceModelReturnType<typeof TemplateModule, TemplateModel>;
+export interface TemplateModel extends Model<Template> { }

package/src/models/user-device.ts

@@ -1,18 +1,68 @@
+import { Model, Types } from "mongoose";
 import {
-  createSchema,
-  createModel,
   currentDate,
   MongooseModule,
   retrieveCurrentUnixTime,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
 
-export async function UserDeviceModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+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 default async function UserDeviceModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
 
-  const UnitSetting = createSchema(Schema, {
+  const UnitSetting = new Schema<UnitSettingType>({
     radioName: {
       type: String,
       default: "",
@@ -30,7 +80,7 @@ export async function UserDeviceModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const IncidentSetting = createSchema(Schema, {
+  const IncidentSetting = new Schema<IncidentSettingType>({
     incidentType: {
       type: String,
       default: "",
@@ -48,7 +98,7 @@ export async function UserDeviceModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const deviceSchema = createSchema(Schema, {
+  const deviceSchema = new Schema<DeviceSchemaType>({
     token: {
       type: String,
       default: "",
@@ -115,7 +165,7 @@ export async function UserDeviceModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const soundSchemaItem = createSchema(Schema, {
+  const soundSchemaItem = new Schema<SoundSchemaItemType>({
     sound: {
       type: String,
     },
@@ -131,7 +181,7 @@ export async function UserDeviceModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const soundSchema = createSchema(Schema, {
+  const soundSchema = new Schema<SoundSchemaType>({
     ios: {
       type: soundSchemaItem,
     },
@@ -143,9 +193,9 @@ export async function UserDeviceModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<UserDevice>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     userId: {
@@ -196,13 +246,10 @@ export async function UserDeviceModule(mongoose: MongooseModule) {
       default: false,
     },
   }, {
-    collection: "massive_user_device",
   });
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "UserDevice", modelSchema);
+  return mongoose.model<UserDevice>("UserDevice", modelSchema, "massive_user_device", { overwriteModels: true });
 }
 
-export interface UserDevice extends ItemTypeFromTypeSchemaFunction<typeof UserDeviceModule> { }
-export interface UserDeviceModel extends ModelTypeFromTypeSchemaFunction<UserDevice> { }
-export default UserDeviceModule as ReplaceModelReturnType<typeof UserDeviceModule, UserDeviceModel>;
+export interface UserDeviceModel extends Model<UserDevice> { }

package/src/models/user-registration.ts

@@ -1,17 +1,33 @@
+import { Model } from "mongoose";
 import {
-  createModel,
-  createSchema,
   currentDate,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
   MongooseModule,
-  ReplaceModelReturnType,
 } from "../helpers";
 
-export async function UserRegistrationModule(mongoose: MongooseModule) {
+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 default async function UserRegistrationModule(mongoose: MongooseModule) {
   const Schema = mongoose.Schema;
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<UserRegistration>({
     email: {
       type: String,
       default: "",
@@ -87,13 +103,10 @@ export async function UserRegistrationModule(mongoose: MongooseModule) {
       default: false,
     },
   }, {
-    collection: "massive_user_registration",
+    autoIndex: false
   });
-  modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "UserRegistration", modelSchema);
+  return mongoose.model<UserRegistration>("UserRegistration", modelSchema, "massive_user_registration", { overwriteModels: true });
 }
 
-export interface UserRegistration extends ItemTypeFromTypeSchemaFunction<typeof UserRegistrationModule> { }
-export interface UserRegistrationModel extends ModelTypeFromTypeSchemaFunction<UserRegistration> { }
-export default UserRegistrationModule as ReplaceModelReturnType<typeof UserRegistrationModule, UserRegistrationModel>;
+export interface UserRegistrationModel extends Model<UserRegistration> { }