tabletcommand-backend-models 5.27.1 → 5.28.1

package/definitions/models/schema/cad-incident.d.ts

@@ -0,0 +1,508 @@
+/// <reference types="mongoose" />
+import { currentDate, MongooseModule } from "../../helpers";
+import * as uuid from "uuid";
+export declare function CADIncidentSchema(mongoose: MongooseModule): import("mongoose").Schema<any> & {
+    _interface: import("../../helpers").MongooseInterface<{
+        _id: {
+            type: import("mongoose").Types.ObjectIdConstructor;
+            auto: boolean;
+        };
+        uuid: {
+            type: StringConstructor;
+            default: (<T extends ArrayLike<number>>(options: uuid.V4Options | null | undefined, buffer: T, offset?: number | undefined) => T) & ((options?: uuid.V4Options | undefined) => string);
+        };
+        departmentId: {
+            type: StringConstructor;
+            default: string;
+            required: boolean;
+            index: true;
+        };
+        AgencyID: {
+            type: StringConstructor;
+            default: string;
+        };
+        IncidentNumber: {
+            type: StringConstructor;
+            required: boolean;
+        };
+        TransactionID: {
+            type: StringConstructor;
+            default: string;
+        };
+        AgencyIncidentCallTypeDescription: {
+            type: StringConstructor;
+        };
+        AgencyIncidentCallType: {
+            type: StringConstructor;
+        };
+        AgencyIncidentCallSubTypeDescription: {
+            type: StringConstructor;
+        };
+        AgencyIncidentCallSubType: {
+            type: StringConstructor;
+        };
+        AgencyIncidentPriorityDescription: {
+            type: StringConstructor;
+        };
+        PulsePointIncidentCallType: {
+            type: StringConstructor;
+        };
+        PulsePointDeterminantCode: {
+            type: StringConstructor;
+        };
+        AlarmLevel: {
+            type: StringConstructor;
+        };
+        CommandName: {
+            type: StringConstructor;
+        };
+        FireMap: {
+            type: StringConstructor;
+        };
+        TBMap: {
+            type: StringConstructor;
+        };
+        MapPages: {
+            type: StringConstructor;
+        };
+        TacticalChannel: {
+            type: StringConstructor;
+        };
+        TacticalAltChannel: {
+            type: StringConstructor;
+        };
+        CommandChannel: {
+            type: StringConstructor;
+        };
+        EntryDateTime: {
+            type: StringConstructor;
+        };
+        ClosedDateTime: {
+            type: StringConstructor;
+        };
+        CallReceivedDateTime: {
+            type: StringConstructor;
+        };
+        DispatchDateTime: {
+            type: StringConstructor;
+        };
+        IncidentLastUpdate: {
+            type: StringConstructor;
+        };
+        EnrouteDateTime: {
+            type: StringConstructor;
+        };
+        OnSceneDateTime: {
+            type: StringConstructor;
+        };
+        modified_date: {
+            type: StringConstructor;
+        };
+        modified_unix_date: {
+            type: NumberConstructor;
+        };
+        modified: {
+            type: DateConstructor;
+            default: typeof currentDate;
+        };
+        start_unix_date: {
+            type: NumberConstructor;
+        };
+        closed_unix_date: {
+            type: NumberConstructor;
+        };
+        queued_at: {
+            type: NumberConstructor;
+        };
+        scheduled_at: {
+            type: NumberConstructor;
+        };
+        ignored: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        expiration_date: {
+            type: DateConstructor;
+            default: null;
+        };
+        StreetName: {
+            type: StringConstructor;
+        };
+        StreetSuffix: {
+            type: StringConstructor;
+        };
+        Predirectional: {
+            type: StringConstructor;
+        };
+        Postdirectional: {
+            type: StringConstructor;
+        };
+        CityOrLocality: {
+            type: StringConstructor;
+        };
+        StateOrProvince: {
+            type: StringConstructor;
+        };
+        StateOfProvince: {
+            type: StringConstructor;
+        };
+        CommonPlaceName: {
+            type: StringConstructor;
+        };
+        CrossStreet1: {
+            type: StringConstructor;
+        };
+        CrossStreet2: {
+            type: StringConstructor;
+        };
+        StreetNumber: {
+            type: StringConstructor;
+        };
+        Building: {
+            type: StringConstructor;
+        };
+        Floor: {
+            type: StringConstructor;
+        };
+        Suite: {
+            type: StringConstructor;
+        };
+        City: {
+            type: StringConstructor;
+        };
+        County: {
+            type: StringConstructor;
+        };
+        PostalCode: {
+            type: StringConstructor;
+        };
+        CrossStreetName: {
+            type: StringConstructor;
+        };
+        LocationComment: {
+            type: StringConstructor;
+        };
+        full_address: {
+            type: StringConstructor;
+        };
+        address: {
+            type: StringConstructor;
+        };
+        cross_streets: {
+            type: StringConstructor;
+        };
+        PriorIncidentChanged: {
+            type: BooleanConstructor;
+        };
+        PriorIncident: {
+            type: (import("mongoose").Schema<any> & {
+                _interface: import("../../helpers").MongooseInterface<{
+                    Address: {
+                        type: StringConstructor;
+                    };
+                    Comment: {
+                        type: (import("mongoose").Schema<any> & {
+                            _interface: import("../../helpers").MongooseInterface<{
+                                Comment: {
+                                    type: StringConstructor;
+                                };
+                                CommentSource: {
+                                    type: StringConstructor;
+                                };
+                                CommentDateTime: {
+                                    type: StringConstructor;
+                                };
+                                CommentConfidential: {
+                                    type: BooleanConstructor;
+                                    default: boolean;
+                                };
+                            }>;
+                            _methods: unknown;
+                        })[];
+                    };
+                    IncidentDateTime: {
+                        type: StringConstructor;
+                    };
+                    IncidentNumber: {
+                        type: StringConstructor;
+                    };
+                    Jurisdiction: {
+                        type: StringConstructor;
+                    };
+                    Problem: {
+                        type: StringConstructor;
+                    };
+                    Suite: {
+                        type: StringConstructor;
+                    };
+                }>;
+                _methods: unknown;
+            })[];
+            default: never[];
+        };
+        CallerNumber: {
+            type: StringConstructor;
+            default: string;
+        };
+        ReportNumber: {
+            type: (import("mongoose").Schema<any> & {
+                _interface: import("../../helpers").MongooseInterface<{
+                    name: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    number: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                }>;
+                _methods: unknown;
+            })[];
+            default: never[];
+        };
+        radioChannels: {
+            type: (import("mongoose").Schema<any> & {
+                _interface: import("../../helpers").MongooseInterface<{
+                    name: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    channel: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                }>;
+                _methods: unknown;
+            })[];
+            default: never[];
+        };
+        Latitude: {
+            type: NumberConstructor;
+        };
+        Longitude: {
+            type: NumberConstructor;
+        };
+        Comment: {
+            type: (import("mongoose").Schema<any> & {
+                _interface: import("../../helpers").MongooseInterface<{
+                    Comment: {
+                        type: StringConstructor;
+                    };
+                    CommentSource: {
+                        type: StringConstructor;
+                    };
+                    CommentDateTime: {
+                        type: StringConstructor;
+                    };
+                    CommentConfidential: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>;
+                _methods: unknown;
+            })[];
+            default: never[];
+        };
+        units: {
+            type: (import("mongoose").Schema<any> & {
+                _interface: import("../../helpers").MongooseInterface<{
+                    UnitID: {
+                        type: StringConstructor;
+                        required: boolean;
+                    };
+                    UnitDispatchNumber: {
+                        type: StringConstructor;
+                        required: boolean;
+                    };
+                    AlarmAtDispatch: {
+                        type: StringConstructor;
+                    };
+                    TimeDispatched: {
+                        type: StringConstructor;
+                    };
+                    TimeEnroute: {
+                        type: StringConstructor;
+                    };
+                    TimeArrived: {
+                        type: StringConstructor;
+                    };
+                    TimeStaged: {
+                        type: StringConstructor;
+                    };
+                    TimeCleared: {
+                        type: StringConstructor;
+                    };
+                    TimeAtHospital: {
+                        type: StringConstructor;
+                    };
+                    TimePatient: {
+                        type: StringConstructor;
+                    };
+                    TimeTransport: {
+                        type: StringConstructor;
+                    };
+                    TimeTransporting: {
+                        type: StringConstructor;
+                    };
+                    PersonnelCount: {
+                        type: NumberConstructor;
+                    };
+                    Personnel: (import("mongoose").Schema<any> & {
+                        _interface: import("../../helpers").MongooseInterface<{
+                            PersonnelID: {
+                                type: StringConstructor;
+                            };
+                            PersonnelName: {
+                                type: StringConstructor;
+                            };
+                            PersonnelRank: {
+                                type: StringConstructor;
+                            };
+                            PersonnelWorkCode: {
+                                type: StringConstructor;
+                            };
+                            PersonnelNote: {
+                                type: StringConstructor;
+                            };
+                        }>;
+                        _methods: unknown;
+                    })[];
+                }>;
+                _methods: unknown;
+            })[];
+            default: never[];
+        };
+        events: {
+            type: (import("mongoose").Schema<any> & {
+                _interface: import("../../helpers").MongooseInterface<{
+                    _id: {
+                        type: import("mongoose").Types.ObjectIdConstructor;
+                        auto: boolean;
+                    };
+                    departmentId: {
+                        type: StringConstructor;
+                        default: string;
+                        required: boolean;
+                        index: true;
+                    };
+                    IncidentNumber: {
+                        type: StringConstructor;
+                        default: string;
+                        required: boolean;
+                        index: true;
+                    };
+                    modified_unix_date: {
+                        type: NumberConstructor;
+                        default: typeof import("../../helpers").retrieveCurrentUnixTime;
+                    };
+                    modified: {
+                        type: DateConstructor;
+                        default: typeof currentDate;
+                    };
+                    message: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    location: {
+                        longitude: {
+                            type: NumberConstructor;
+                            default: number;
+                        };
+                        latitude: {
+                            type: NumberConstructor;
+                            default: number;
+                        };
+                    };
+                    type: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    user: {
+                        type: import("mongoose").Schema<any> & {
+                            _interface: import("../../helpers").MongooseInterface<{
+                                username: {
+                                    type: StringConstructor;
+                                    default: string;
+                                };
+                                email: {
+                                    type: StringConstructor;
+                                    default: string;
+                                };
+                                radioName: {
+                                    type: StringConstructor;
+                                    default: string;
+                                };
+                                userId: {
+                                    type: StringConstructor;
+                                    default: string;
+                                };
+                            }>;
+                            _methods: unknown;
+                        };
+                        default: {};
+                    };
+                    serverTime: {
+                        type: NumberConstructor;
+                        default: typeof import("../../helpers").retrieveCurrentUnixTime;
+                        min: number;
+                    };
+                    userTime: {
+                        type: NumberConstructor;
+                        required: boolean;
+                        default: number;
+                        min: number;
+                    };
+                    uuid: {
+                        type: StringConstructor;
+                        require: boolean;
+                    };
+                    ref_uuid: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    opts: {
+                        type: ObjectConstructor;
+                        default: {};
+                    };
+                    archived: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>;
+                _methods: unknown;
+            })[];
+            default: never[];
+        };
+        preference_location: {
+            type: StringConstructor;
+        };
+        simulation: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        notify: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        rts: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        notificationType: {
+            type: (import("mongoose").Schema<any> & {
+                _interface: import("../../helpers").MongooseInterface<{
+                    name: {
+                        type: StringConstructor;
+                    };
+                    value: {
+                        type: StringConstructor;
+                    };
+                }>;
+                _methods: unknown;
+            })[];
+            default: never[];
+        };
+    }>;
+    _methods: unknown;
+};
+//# sourceMappingURL=cad-incident.d.ts.map

package/definitions/models/schema/cad-incident.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cad-incident.d.ts","sourceRoot":"","sources":["../../../src/models/schema/cad-incident.ts"],"names":[],"mappings":";AAAA,OAAO,EAEL,WAAW,EAKX,cAAc,EACf,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAI7B,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4ezD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tabletcommand-backend-models",
-  "version": "5.27.1",
+  "version": "5.28.1",
   "description": "Tablet Command Backend Models",
   "scripts": {
     "test": "gulp",
@@ -27,21 +27,21 @@
   "devDependencies": {
     "@types/bluebird": "^3.5.37",
     "@types/chai": "^4.3.4",
-    "@types/lodash": "^4.14.190",
+    "@types/lodash": "^4.14.191",
     "@types/mocha": "^9.1.1",
     "@types/mongodb": "^3.6.20",
     "@types/mongoose": "~5.10.5",
     "@types/uuid": "~8.3.4",
-    "@typescript-eslint/eslint-plugin": "~5.38.1",
-    "@typescript-eslint/parser": "~5.38.1",
-    "chai": "^4.3.6",
-    "cspell": "^6.15.0",
+    "@typescript-eslint/eslint-plugin": "~5.45.1",
+    "@typescript-eslint/parser": "~5.45.1",
+    "chai": "^4.3.7",
+    "cspell": "^6.17.0",
     "del": "^6.1.1",
-    "eslint": "^8.24.0",
+    "eslint": "^8.29.0",
     "gulp": "^4.0.2",
     "gulp-mocha": "^8.0.0",
     "gulp-shell": "^0.8.0",
-    "mocha": "^10.0.0",
+    "mocha": "^10.1.0",
     "ts-node": "^10.9.1",
     "type-coverage": "^2.24.1",
     "typescript": "~4.7.4",

package/src/index.ts

@@ -17,6 +17,7 @@ async function wireModels(mongoose: MongooseModule) {
     Battalion: await getModel(import("./models/battalion")),
     BeaconLog: await getModel(import("./models/beacon-log")),
     CADIncident: await getModel(import("./models/cad-incident")),
+    CADIncidentFlat: await getModel(import("./models/cad-incident-flat")),
     CADIncidentStream: await getModel(import("./models/cad-incident-stream")),
     CADStatus: await getModel(import("./models/cad-status")),
     CADStatusMap: await getModel(import("./models/cad-status-map")),
@@ -62,6 +63,7 @@ export { Assignment, AssignmentModel } from "./models/assignment";
 export { Battalion, BattalionModel } from "./models/battalion";
 export { BeaconLog, BeaconLogModel } from "./models/beacon-log";
 export { CADIncident, CADIncidentModel } from "./models/cad-incident";
+export { CADIncidentFlat, CADIncidentFlatModel } from "./models/cad-incident-flat";
 export { CADIncidentStream, CADIncidentStreamModel } from "./models/cad-incident-stream";
 export { CADStatus, CADStatusModel } from "./models/cad-status";
 export { CADStatusMap, CADStatusMapModel } from "./models/cad-status-map";

package/src/models/battalion.ts

@@ -170,7 +170,7 @@ export function BattalionSchema(mongoose: MongooseModule) {
 
       const pathSchema = schema as unknown as { paths: Record<string, string> };
       if (pathSchema.paths[element] === undefined) {
-        // console.log("backend-models.cad-incident: undefined schema.paths[element]:", element, pathSchema.paths[element]);
+        // console.log("backend-models.battalion: undefined schema.paths[element]:", element, pathSchema.paths[element]);
         delete ret[element];
       }
     });

package/src/models/cad-incident-flat.ts

@@ -0,0 +1,20 @@
+import {
+  createModel,
+  ItemTypeFromTypeSchemaFunction,
+  ModelTypeFromTypeSchemaFunction,
+  MongooseModule,
+  ReplaceModelReturnType,
+} from "../helpers";
+
+import { CADIncidentSchema } from "./schema/cad-incident";
+
+export async function CADIncidentFlatModule(mongoose: MongooseModule) {
+  const modelSchema = CADIncidentSchema(mongoose);
+  modelSchema.set("collection", "massive_cad_incident_flat");
+  modelSchema.set("strict", true);
+  return createModel(mongoose, "CADIncidentFlat", modelSchema);
+}
+
+export interface CADIncidentFlat extends ItemTypeFromTypeSchemaFunction<typeof CADIncidentFlatModule> { }
+export interface CADIncidentFlatModel extends ModelTypeFromTypeSchemaFunction<CADIncidentFlat> { }
+export default CADIncidentFlatModule as ReplaceModelReturnType<typeof CADIncidentFlatModule, CADIncidentFlatModel>;