tabletcommand-backend-models 5.39.6 → 7.0.0

package/src/models/chart-incident.ts

@@ -1,20 +1,29 @@
+import { Model, Types } from "mongoose";
 import {
   MongooseModule,
   MongooseDocument,
-  createSchema,
-  createModel,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
 
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
 const defaultDate = new Date("2013-01-01T00:26:40.000Z"); // Chart fallback date, before sync
 
-export async function ChartIncidentModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+interface ChartItemType {
+  item: string,
+  dateAt: Date,
+}
+export interface ChartIncident {
+  _id: Types.ObjectId,
+  id?: string,
+  dateAt: Date,
+  departmentId: string,
+  count: number,
+  items: ChartItemType[]
+}
+
+export default async function ChartIncidentModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
 
-  const ChartItem = createSchema(Schema, {
+  const ChartItem = new Schema<ChartItemType>({
     item: {
       type: String,
       default: "",
@@ -28,9 +37,9 @@ export async function ChartIncidentModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<ChartIncident>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     dateAt: {
@@ -52,7 +61,6 @@ export async function ChartIncidentModule(mongoose: MongooseModule) {
       default: [],
     },
   }, {
-    collection: "massive_chart_incident",
   });
   modelSchema.set("autoIndex", false);
 
@@ -61,16 +69,14 @@ export async function ChartIncidentModule(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();
   });
 
   modelSchema.plugin(mongooseLeanVirtuals);
 
-  return createModel(mongoose, "ChartIncident", modelSchema);
+  return mongoose.model<ChartIncident>("ChartIncident", modelSchema, "massive_chart_incident", { overwriteModels: true });
 }
 
-export interface ChartIncident extends ItemTypeFromTypeSchemaFunction<typeof ChartIncidentModule> { }
-export interface ChartIncidentModel extends ModelTypeFromTypeSchemaFunction<ChartIncident> { }
-export default ChartIncidentModule as ReplaceModelReturnType<typeof ChartIncidentModule, ChartIncidentModel>;
+export interface ChartIncidentModel extends Model<ChartIncident> { }

package/src/models/chart-managed-incident.ts

@@ -1,21 +1,30 @@
+import { Model, Types } from "mongoose";
 import {
   MongooseModule,
   MongooseDocument,
-  createSchema,
-  createModel,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
 
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
 
 const defaultDate = new Date("2013-01-01T00:26:40.000Z"); // Chart fallback date, before sync
+interface ChartItemType {
+  item: string,
+  dateAt: Date,
+}
+export interface ChartManagedIncident {
+  _id: Types.ObjectId,
+  id?: string,
+  dateAt: Date,
+  departmentId: string,
+  userId: string,
+  count: number,
+  items: ChartItemType[]
+}
 
-export async function ChartManagedIncidentModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export default async function ChartManagedIncidentModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
 
-  const ChartItem = createSchema(Schema, {
+  const ChartItem = new Schema<ChartItemType>({
     item: {
       type: String,
       default: "",
@@ -29,9 +38,9 @@ export async function ChartManagedIncidentModule(mongoose: MongooseModule) {
     id: false,
   });
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<ChartManagedIncident>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     dateAt: {
@@ -58,7 +67,6 @@ export async function ChartManagedIncidentModule(mongoose: MongooseModule) {
       default: [],
     },
   }, {
-    collection: "massive_chart_managed_incident",
   });
   modelSchema.set("autoIndex", false);
 
@@ -67,16 +75,14 @@ export async function ChartManagedIncidentModule(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();
   });
 
   modelSchema.plugin(mongooseLeanVirtuals);
 
-  return createModel(mongoose, "ChartManagedIncident", modelSchema);
+  return mongoose.model<ChartManagedIncident>("ChartManagedIncident", modelSchema, "massive_chart_managed_incident", { overwriteModels: true });
 }
 
-export interface ChartManagedIncident extends ItemTypeFromTypeSchemaFunction<typeof ChartManagedIncidentModule> { }
-export interface ChartManagedIncidentModel extends ModelTypeFromTypeSchemaFunction<ChartManagedIncident> { }
-export default ChartManagedIncidentModule as ReplaceModelReturnType<typeof ChartManagedIncidentModule, ChartManagedIncidentModel>;
+export interface ChartManagedIncidentModel extends Model<ChartManagedIncident> { }

package/src/models/chart-user.ts

@@ -1,22 +1,27 @@
+import { Model, Types } from "mongoose";
 import {
   MongooseModule,
   MongooseDocument,
-  createSchema,
-  createModel,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
 
 import * as mongooseLeanVirtuals from "mongoose-lean-virtuals";
 const defaultDate = new Date("2013-01-01T00:26:40.000Z"); // Chart fallback date, before sync
 
-export async function ChartUserModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+export interface ChartUser {
+  _id: Types.ObjectId,
+  id?: string,
+  dateAt: Date,
+  departmentId: string,
+  count: number,
+  items: string[],
+}
+
+export default async function ChartUserModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<ChartUser>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     dateAt: {
@@ -38,7 +43,6 @@ export async function ChartUserModule(mongoose: MongooseModule) {
       default: [],
     },
   }, {
-    collection: "massive_chart_user",
   });
   modelSchema.set("autoIndex", false);
 
@@ -47,16 +51,14 @@ export async function ChartUserModule(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();
   });
 
   modelSchema.plugin(mongooseLeanVirtuals);
 
-  return createModel(mongoose, "ChartUser", modelSchema);
+  return mongoose.model<ChartUser>("ChartUser", modelSchema, "massive_chart_user", { overwriteModels: true });
 }
 
-export interface ChartUser extends ItemTypeFromTypeSchemaFunction<typeof ChartUserModule> { }
-export interface ChartUserModel extends ModelTypeFromTypeSchemaFunction<ChartUser> { }
-export default ChartUserModule as ReplaceModelReturnType<typeof ChartUserModule, ChartUserModel>;
+export interface ChartUserModel extends Model<ChartUser> { }

package/src/models/checklist-item.ts

@@ -3,25 +3,33 @@ import * as uuid from "uuid";
 import {
   MongooseModule,
   MongooseDocument,
-  createSchema,
-  DocumentTypeFromSchema,
-  ModelFromSchema,
-  createModel,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
   retrieveCurrentUnixTime
 } from "../helpers";
+import { Model, Types } from "mongoose";
+
+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 function ChecklistItemSchema(mongoose: MongooseModule) {
-  const {
-    Schema,
-    Types,
-  } = mongoose;
+  const { Schema } = mongoose;
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<ChecklistItem>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     position: {
@@ -68,31 +76,26 @@ export function ChecklistItemSchema(mongoose: MongooseModule) {
       default: ""
     }
   }, {
-    collection: "massive_checklist_item_sync",
   });
   modelSchema.set("autoIndex", false);
   return modelSchema;
 }
 
-export async function ChecklistItemModule(mongoose: MongooseModule) {
+export default async function ChecklistItemModule(mongoose: MongooseModule) {
   const modelSchema = ChecklistItemSchema(mongoose);
 
+  modelSchema.virtual("id").get(function (this: MongooseDocument) {
+    // tslint:disable-next-line: no-unsafe-any
+    return this._id.toString();
+  });
+
   modelSchema.set("toJSON", {
     virtuals: true,
     versionKey: false,
-    transform(doc: ModelFromSchema<typeof modelSchema>, ret: DocumentTypeFromSchema<typeof modelSchema>) {
-      ret.id = ret._id;
-    },
   });
 
-  modelSchema.virtual("id").get(function (this: MongooseDocument) {
-    // tslint:disable-next-line: no-unsafe-any
-    return this._id.toString();
-  });
 
-  return createModel(mongoose, "ChecklistItem", modelSchema);
+  return mongoose.model<ChecklistItem>("ChecklistItem", modelSchema, "massive_checklist_item_sync", { overwriteModels: true });
 }
 
-export interface ChecklistItem extends ItemTypeFromTypeSchemaFunction<typeof ChecklistItemModule> { }
-export interface ChecklistItemModel extends ModelTypeFromTypeSchemaFunction<ChecklistItem> { }
-export default ChecklistItemModule as ReplaceModelReturnType<typeof ChecklistItemModule, ChecklistItemModel>;
+export interface ChecklistItemModel extends Model<ChecklistItem> { }

package/src/models/checklist.ts

@@ -3,27 +3,38 @@ import * as uuid from "uuid";
 import {
   MongooseModule,
   MongooseDocument,
-  createSchema,
   currentDate,
-  DocumentTypeFromSchema,
-  ModelFromSchema,
-  createModel,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
   retrieveCurrentUnixTime
 } from "../helpers";
 
-import { ChecklistItemSchema } from "./checklist-item";
+import { ChecklistItemSchema, ChecklistItem } from "./checklist-item";
+import { Model, Types } from "mongoose";
+
+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 function ChecklistSchema(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+  const { Schema } = mongoose;
 
   const ChecklistItem = ChecklistItemSchema(mongoose);
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<Checklist>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     position: {
@@ -67,7 +78,7 @@ export function ChecklistSchema(mongoose: MongooseModule) {
       required: true
     },
     agencyId: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       ref: "Agency",
       default: null,
     },
@@ -76,30 +87,25 @@ export function ChecklistSchema(mongoose: MongooseModule) {
       default: [],
     }
   }, {
-    collection: "massive_checklist_sync",
   });
   modelSchema.set("autoIndex", false);
+  modelSchema.virtual("id").get(function (this: MongooseDocument) {
+    // tslint:disable-next-line: no-unsafe-any
+    return this._id.toString();
+  });
+
   modelSchema.set("toJSON", {
     virtuals: true,
     versionKey: false,
-    transform(doc: ModelFromSchema<typeof modelSchema>, ret: DocumentTypeFromSchema<typeof modelSchema>) {
-      ret.id = ret._id;
-    },
   });
 
-  modelSchema.virtual("id").get(function (this: MongooseDocument) {
-    // tslint:disable-next-line: no-unsafe-any
-    return this._id.toString();
-  });
 
   return modelSchema;
 }
 
-export async function ChecklistModule(mongoose: MongooseModule) {
+export default async function ChecklistModule(mongoose: MongooseModule) {
   const modelSchema = ChecklistSchema(mongoose);
-  return createModel(mongoose, "Checklist", modelSchema);
+  return mongoose.model<Checklist>("Checklist", modelSchema, "massive_checklist_sync", { overwriteModels: true });
 }
 
-export interface Checklist extends ItemTypeFromTypeSchemaFunction<typeof ChecklistModule> { }
-export interface ChecklistModel extends ModelTypeFromTypeSchemaFunction<Checklist> { }
-export default ChecklistModule as ReplaceModelReturnType<typeof ChecklistModule, ChecklistModel>;
+export interface ChecklistModel extends Model<Checklist> { }

package/src/models/csv-import.ts

@@ -1,19 +1,34 @@
+import { Model, Types } from "mongoose";
 import {
-  createSchema,
-  createModel,
   currentDate,
   MongooseModule,
-  ItemTypeFromTypeSchemaFunction,
-  ModelTypeFromTypeSchemaFunction,
-  ReplaceModelReturnType,
 } from "../helpers";
 
-export async function CSVImportModule(mongoose: MongooseModule) {
-  const { Schema, Types } = mongoose;
+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 default async function CSVImportModule(mongoose: MongooseModule) {
+  const { Schema } = mongoose;
 
-  const modelSchema = createSchema(Schema, {
+  const modelSchema = new Schema<CSVImport>({
     _id: {
-      type: Types.ObjectId,
+      type: Schema.Types.ObjectId,
       auto: true,
     },
     batchId: {
@@ -69,13 +84,10 @@ export async function CSVImportModule(mongoose: MongooseModule) {
       default: false
     },
   }, {
-    collection: "massive_csv_import",
   });
   modelSchema.set("autoIndex", false);
 
-  return createModel(mongoose, "CSVImport", modelSchema);
+  return mongoose.model<CSVImport>("CSVImport", modelSchema, "massive_csv_import", { overwriteModels: true });
 }
 
-export interface CSVImport extends ItemTypeFromTypeSchemaFunction<typeof CSVImportModule> { }
-export interface CSVImportModel extends ModelTypeFromTypeSchemaFunction<CSVImport> { }
-export default CSVImportModule as ReplaceModelReturnType<typeof CSVImportModule, CSVImportModel>;
+export interface CSVImportModel extends Model<CSVImport> { }