tabletcommand-backend-models 5.39.6 → 7.0.0

package/src/models/personnel-known.ts

@@ -1,19 +1,36 @@
 import * as uuid from "uuid";
 
 import {
-  createSchema,
-  createModel,
   MongooseModule,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
   currentDate,
 } from "../helpers";
+import { Model, Types } from "mongoose";
+
+interface RadioType {
+  radioName: string,
+  active: boolean,
+}
+
+export interface PersonnelKnown extends Record<string, unknown> {
+  _id: Types.ObjectId,
+  PersonnelID: string,
+  PersonnelName: string,
+  PersonnelRank: string,
+  PersonnelWorkCode: string,
+  modified: Date,
+  departmentId: string,
+  uuid: string,
+  radios: RadioType[],
+  active: boolean,
+  jurisdiction: string,
+  agencyId: Types.ObjectId,
+  source: string,
+}
 
 export function PersonnelKnownSchema(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+  const { Schema } = mongoose;
 
-  const Radio = createSchema(Schema, {
+  const Radio = new Schema<RadioType>({
     radioName: {
       type: String,
     },
@@ -26,9 +43,9 @@ export function PersonnelKnownSchema(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<PersonnelKnown>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     PersonnelID: {
@@ -74,7 +91,7 @@ export function PersonnelKnownSchema(mongoose: MongooseModule) {
       default: ""
     },
     agencyId: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       ref: "Agency",
       default: null,
     },
@@ -83,7 +100,6 @@ export function PersonnelKnownSchema(mongoose: MongooseModule) {
       default: ""
     },
   }, {
-    collection: "massive_personnel_known",
     timestamps: true,
     autoIndex: false,
   });
@@ -91,11 +107,9 @@ export function PersonnelKnownSchema(mongoose: MongooseModule) {
   return modelSchema;
 }
 
-export async function PersonnelKnownModule(mongoose: MongooseModule) {
+export default async function PersonnelKnownModule(mongoose: MongooseModule) {
   const modelSchema = PersonnelKnownSchema(mongoose);
-  return createModel(mongoose, "PersonnelKnown", modelSchema);
+  return mongoose.model<PersonnelKnown>("PersonnelKnown", modelSchema, "massive_personnel_known", { overwriteModels: true });
 }
 
-export interface PersonnelKnown extends ItemTypeFromTypeSchemaFunction<typeof PersonnelKnownModule> { }
-export interface PersonnelKnownModel extends ModelTypeFromTypeSchemaFunction<PersonnelKnown> { }
-export default PersonnelKnownModule as ReplaceModelReturnType<typeof PersonnelKnownModule, PersonnelKnownModel>;
+export interface PersonnelKnownModel extends Model<PersonnelKnown> { }

package/src/models/personnel-roster.ts

@@ -1,19 +1,31 @@
+import { Model, Types } from "mongoose";
 import {
-  createSchema,
-  createModel,
   MongooseModule,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
   currentDate,
 } from "../helpers";
 
+export interface PersonnelRoster {
+  _id: Types.ObjectId,
+  PersonnelID: string,
+  PersonnelName: string,
+  PersonnelRank: string,
+  PersonnelWorkCode: string,
+  PersonnelUUID: string,
+  departmentId: string,
+  modified: Date,
+  action: string,
+  radioName: string,
+  shiftStart: Date,
+  shiftEnd: Date,
+  active: boolean,
+}
+
 export function PersonnelRosterSchema(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+  const { Schema } = mongoose;
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<PersonnelRoster>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     PersonnelID: {
@@ -67,7 +79,6 @@ export function PersonnelRosterSchema(mongoose: MongooseModule) {
       default: false,
     },
   }, {
-    collection: "massive_personnel_roster",
     autoIndex: false,
     timestamps: true,
   });
@@ -75,11 +86,9 @@ export function PersonnelRosterSchema(mongoose: MongooseModule) {
   return modelSchema;
 }
 
-export async function PersonnelRosterModule(mongoose: MongooseModule) {
+export default async function PersonnelRosterModule(mongoose: MongooseModule) {
   const modelSchema = PersonnelRosterSchema(mongoose);
-  return createModel(mongoose, "PersonnelRoster", modelSchema);
+  return mongoose.model<PersonnelRoster>("PersonnelRoster", modelSchema, "massive_personnel_roster", { overwriteModels: true });
 }
 
-export interface PersonnelRoster extends ItemTypeFromTypeSchemaFunction<typeof PersonnelRosterModule> { }
-export interface PersonnelRosterModel extends ModelTypeFromTypeSchemaFunction<PersonnelRoster> { }
-export default PersonnelRosterModule as ReplaceModelReturnType<typeof PersonnelRosterModule, PersonnelRosterModel>;
+export interface PersonnelRosterModel extends Model<PersonnelRoster> { }

package/src/models/rate-limit.ts

@@ -1,19 +1,24 @@
+import { Model, Types } from "mongoose";
 import {
-  createSchema,
-  createModel,
   currentDate,
   MongooseModule,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
 
-export async function RateLimitModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface RateLimit {
+  _id: Types.ObjectId,
+  username: string,
+  modified_unix_date: number,
+  modified: Date,
+  count: number,
+  remoteAddress: string,
+}
+
+export default async function RateLimitModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<RateLimit>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     username: String,
@@ -34,13 +39,10 @@ export async function RateLimitModule(mongoose: MongooseModule) {
       default: "",
     },
   }, {
-    collection: "massive_rate_limit",
   });
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "RateLimit", modelSchema);
+  return mongoose.model<RateLimit>("RateLimit", modelSchema, "massive_rate_limit", { overwriteModels: true });
 }
 
-export interface RateLimit extends ItemTypeFromTypeSchemaFunction<typeof RateLimitModule> { }
-export interface RateLimitModel extends ModelTypeFromTypeSchemaFunction<RateLimit> { }
-export default RateLimitModule as ReplaceModelReturnType<typeof RateLimitModule, RateLimitModel>;
+export interface RateLimitModel extends Model<RateLimit> { }

package/src/models/release-note.ts

@@ -1,19 +1,25 @@
+import { Model, Types } from "mongoose";
 import {
   MongooseModule,
-  createSchema,
-  createModel,
   currentDate,
-  ModelTypeFromTypeSchemaFunction,
-  ItemTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
 
-export async function ReleaseNoteModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface ReleaseNote extends Record<string, unknown> {
+  _id: Types.ObjectId
+  title: string
+  notes: string
+  version: string
+  releaseDate: Date
+  status: string
+  modified: Date
+}
+
+export default async function ReleaseNoteModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<ReleaseNote>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     title: {
@@ -39,13 +45,8 @@ export async function ReleaseNoteModule(mongoose: MongooseModule) {
       type: Date,
       default: currentDate,
     },
-  }, {
-    collection: "massive_release_note",
-  });
-  modelSchema.set("autoIndex", false);
-  return createModel(mongoose, "ReleaseNote", modelSchema);
+  }, { autoIndex: false });
+  return mongoose.model<ReleaseNote>("ReleaseNote", modelSchema, "massive_release_note", { overwriteModels: true });
 }
 
-export interface ReleaseNote extends ItemTypeFromTypeSchemaFunction<typeof ReleaseNoteModule> { }
-export interface ReleaseNoteModel extends ModelTypeFromTypeSchemaFunction<ReleaseNote> { }
-export default ReleaseNoteModule as ReplaceModelReturnType<typeof ReleaseNoteModule, ReleaseNoteModel>;
+export interface ReleaseNoteModel extends Model<ReleaseNote> { }

package/src/models/remote-log-stream.ts

@@ -1,25 +1,90 @@
 import * as uuid from "uuid";
 import {
   MongooseModule,
-  createSchema,
-  createModel,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
   currentDate,
 } from "../helpers";
+import { Model, Types } from "mongoose";
 
-import RemoteFileSchema from "./schema/remote-file";
+interface FileSchemaType {
+  originalName: string
+  encoding: string
+  mimeType: string
+  fieldname: string
+  localPath: string
+  remotePath: string
+  hostname: string
+  size: number
+  received: Date
+}
 
-export async function RemoteLogStreamModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface RemoteLogStream extends Record<string, unknown> {
+  _id: Types.ObjectId
+  departmentId: string
+  userId: string
+  isCADRequest: boolean
+  session: string
+  requestId: string
+  requested: Date
+  active: boolean
+  uuid: string
+  createdAt: Date
+  updatedAt: Date
+  status: string
+  message: string
+  manifest: string[]
+  userAgent: string
+  appVersion: string
+  file: FileSchemaType
+}
 
-  const RemoteFile = RemoteFileSchema(mongoose);
+export default async function RemoteLogStreamModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
 
-  // This is almost identical to RemoteLog
-  const modelSchema = createSchema(Schema, {
+  const FileSchema = new Schema<FileSchemaType>({
+    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
+    },
+    remotePath: {
+      type: String,
+      default: "", // e.g https://google.com?
+    },
+    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,
+  });
+
+  const modelSchema = new Schema<RemoteLogStream>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     departmentId: {
@@ -88,26 +153,14 @@ export async function RemoteLogStreamModule(mongoose: MongooseModule) {
       default: "",
     },
     file: {
-      type: RemoteFile,
-    },
-    // Google Drive
-    remoteFolderPath: {
-      type: String,
-      default: "", // e.g https://drive.google.com/drive/folders/1efgEFG
-    },
-    remoteFolderId: {
-      type: String,
-      default: "", // e.g 1efgEFG
+      type: FileSchema,
     },
   }, {
     autoIndex: false,
-    collection: "massive_remote_log_stream",
     timestamps: true,
   });
 
-  return createModel(mongoose, "RemoteLogStream", modelSchema);
+  return mongoose.model<RemoteLogStream>("RemoteLogStream", modelSchema, "massive_remote_log_stream", { overwriteModels: true });
 }
 
-export interface RemoteLogStream extends ItemTypeFromTypeSchemaFunction<typeof RemoteLogStreamModule> { }
-export interface RemoteLogStreamModel extends ModelTypeFromTypeSchemaFunction<RemoteLogStream> { }
-export default RemoteLogStreamModule as ReplaceModelReturnType<typeof RemoteLogStreamModule, RemoteLogStreamModel>;
+export interface RemoteLogStreamModel extends Model<RemoteLogStream> { }

package/src/models/remote-log.ts

@@ -1,25 +1,92 @@
 import * as uuid from "uuid";
 import {
   MongooseModule,
-  createSchema,
-  createModel,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
   currentDate,
 } from "../helpers";
+import { Model, Types } from "mongoose";
 
-import RemoteFileSchema from "./schema/remote-file";
+interface FileSchemaType {
+  originalName: string,
+  encoding: string,
+  mimeType: string,
+  localPath: string,
+  remotePath: string,
+  size: number,
+  received: Date,
+  fieldname: string,
+  hostname: string,
+}
 
-export async function RemoteLogModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface RemoteLog {
+  _id: Types.ObjectId,
+  departmentId: string,
+  userId: string,
+  session: string,
+  active: boolean,
+  uuid: string,
+  requestId: string,
+  received: Date,
+  hostname: string,
+  status: string,
+  lastStatusChange: Date,
+  isCADRequest: boolean,
+  createdAt: Date,
+  updatedAt: Date
+  message: string,
+  manifest: string[],
+  userAgent: string,
+  appVersion: string,
+  files: FileSchemaType[],
+}
 
-  const RemoteFile = RemoteFileSchema(mongoose);
+export default async function RemoteLogModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
 
-  // This is almost identical to RemoteLogStream
-  const modelSchema = createSchema(Schema, {
+  const FileSchema = new Schema<FileSchemaType>({
+    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
+    },
+    remotePath: {
+      type: String,
+      default: "", // e.g https://google.com?
+    },
+    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,
+  });
+
+  const modelSchema = new Schema<RemoteLog>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     departmentId: {
@@ -85,27 +152,15 @@ export async function RemoteLogModule(mongoose: MongooseModule) {
       default: "",
     },
     files: {
-      type: [RemoteFile],
+      type: [FileSchema],
       default: [],
     },
-    // Google Drive
-    remoteFolderPath: {
-      type: String,
-      default: "", // e.g https://drive.google.com/drive/folders/1efgEFG
-    },
-    remoteFolderId: {
-      type: String,
-      default: "", // e.g 1efgEFG
-    },
   }, {
     autoIndex: false,
-    collection: "massive_remote_log_stream",
     timestamps: true,
   });
 
-  return createModel(mongoose, "RemoteLog", modelSchema);
+  return mongoose.model<RemoteLog>("RemoteLog", modelSchema, "massive_remote_log_stream", { overwriteModels: true });
 }
 
-export interface RemoteLog extends ItemTypeFromTypeSchemaFunction<typeof RemoteLogModule> { }
-export interface RemoteLogModel extends ModelTypeFromTypeSchemaFunction<RemoteLog> { }
-export default RemoteLogModule as ReplaceModelReturnType<typeof RemoteLogModule, RemoteLogModel>;
+export interface RemoteLogModel extends Model<RemoteLog> { }

package/src/models/schema/agency-cron-config.ts

@@ -1,12 +1,67 @@
 import {
-  createSchema,
   MongooseModule,
 } from "../../helpers";
 
+interface EncryptedDataType {
+  iv: string,
+  encryptedData: string,
+}
+
+export interface CronConfigSourceType extends Record<string, unknown> {
+  protocol: string,
+  username: string,
+  hostname: string,
+  filePath: string,
+}
+
+interface CronConfigAuthType {
+  password: EncryptedDataType | null,
+  sshPrivateKey: EncryptedDataType | null,
+  sshPublicKey: EncryptedDataType | null,
+  useSSHKey: boolean,
+}
+
+interface CronConfigCSVFieldMapType {
+  PersonnelID: string,
+  PersonnelName: string,
+  PersonnelRank: string,
+  PersonnelWorkCode: string,
+  PersonnelNote: string,
+  StartTime: string,
+  EndTime: string,
+  UnitName: string,
+  TimeFormat: string,
+}
+
+interface ReconcileTimeOptionsType {
+  enabled: boolean,
+  startTime: string,
+  endTime: string,
+}
+
+export interface AgencyCronConfigType extends Record<string, unknown> {
+  enabled: boolean
+  source: CronConfigSourceType,
+  auth: CronConfigAuthType
+  processPath: string,
+  completedPath: string,
+  importType: string,
+  timezone: string,
+  customApiPath: string,
+  alterChunkSize: boolean,
+  reconcileEnabled: boolean,
+  reconcileTimeOptions: ReconcileTimeOptionsType,
+  hasLabelCustomization: boolean
+  assignmentOverride: boolean,
+  csvFieldMap: CronConfigCSVFieldMapType
+  useAlternateId: boolean
+  strictAgencyCodeMatch: boolean
+}
+
 export default function AgencyCronSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const EncryptedData = createSchema(Schema, {
+  const EncryptedData = new Schema<EncryptedDataType>({
     iv: {
       type: String,
       default: "",
@@ -20,7 +75,7 @@ export default function AgencyCronSchema(mongoose: MongooseModule) {
     id: false,
   });
 
-  const CronConfigSource = createSchema(Schema, {
+  const CronConfigSource = new Schema<CronConfigSourceType>({
     protocol: {
       type: String,
       default: "",
@@ -49,7 +104,7 @@ export default function AgencyCronSchema(mongoose: MongooseModule) {
     filePath: "",
   };
 
-  const CronConfigAuth = createSchema(Schema, {
+  const CronConfigAuth = new Schema<CronConfigAuthType>({
     password: {
       type: EncryptedData,
       default: null,
@@ -79,7 +134,7 @@ export default function AgencyCronSchema(mongoose: MongooseModule) {
     useSSHKey: false,
   };
 
-  const CronConfigCSVFieldMap = createSchema(Schema, {
+  const CronConfigCSVFieldMap = new Schema<CronConfigCSVFieldMapType>({
     PersonnelID: {
       type: String,
     },
@@ -126,7 +181,7 @@ export default function AgencyCronSchema(mongoose: MongooseModule) {
     TimeFormat: "YYYY-MM-DD HH:mm",
   };
 
-  const ReconcileTimeOptions = createSchema(Schema, {
+  const ReconcileTimeOptions = new Schema<ReconcileTimeOptionsType>({
     enabled: {
       type: Boolean,
     },
@@ -147,7 +202,7 @@ export default function AgencyCronSchema(mongoose: MongooseModule) {
     endTime: "08:00",
   };
 
-  const AgencyCronConfig = createSchema(Schema, {
+  const AgencyCronConfig = new Schema<AgencyCronConfigType>({
     enabled: {
       type: Boolean,
       default: false,

package/src/models/schema/agency-saml.ts

@@ -1,12 +1,20 @@
 import {
-  createSchema,
   MongooseModule,
 } from "../../helpers";
 
+export interface AgencySAMLSchemaType extends Record<string, unknown> {
+  selector: string,
+  idp: string,
+  sp: string,
+  env: string,
+  name: string,
+  jumpPoint: string,
+}
+
 export default function AgencySAMLSchema(mongoose: MongooseModule) {
   const { Schema } = mongoose;
 
-  const AgencySAML = createSchema(Schema, {
+  const AgencySAML = new Schema<AgencySAMLSchemaType>({
     selector: {
       type: String,
       required: true,