tabletcommand-incident 0.1.0

package/definitions/set-incident-type.d.ts

@@ -0,0 +1,20 @@
+import { CADIncident } from "tabletcommand-backend-models";
+export interface IncidentTypeConfiguration {
+    name: string;
+    value: string;
+    callTypeDescription: string[];
+    callType: string[];
+    allowPartialMatch?: boolean;
+}
+export declare type NotificationType = Pick<IncidentTypeConfiguration, "name" | "value">;
+declare function setIncidentTypeAny(incident: Partial<CADIncident>): void;
+declare function setIncidentTypeUsingConfiguration(incident: Partial<CADIncident>, incidentTypes: IncidentTypeConfiguration[]): boolean;
+declare function setIncidentType(incident: Partial<CADIncident>, incidentTypes: IncidentTypeConfiguration[]): void;
+declare const setIncidentTypeModule: {
+    setIncidentTypeAny: typeof setIncidentTypeAny;
+    setIncidentTypeUsingConfiguration: typeof setIncidentTypeUsingConfiguration;
+    setIncidentType: typeof setIncidentType;
+};
+export default setIncidentTypeModule;
+export declare type SetIncidentTypeModule = typeof setIncidentTypeModule;
+//# sourceMappingURL=set-incident-type.d.ts.map

package/definitions/set-incident-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-incident-type.d.ts","sourceRoot":"","sources":["../src/set-incident-type.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAE3D,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,oBAAY,gBAAgB,GAAG,IAAI,CAAC,yBAAyB,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC;AAGjF,iBAAS,kBAAkB,CAAC,QAAQ,EAAE,OAAO,CAAC,WAAW,CAAC,QAmBzD;AA6BD,iBAAS,iCAAiC,CAAC,QAAQ,EAAE,OAAO,CAAC,WAAW,CAAC,EAAE,aAAa,EAAE,yBAAyB,EAAE,WAmCpH;AAqBD,iBAAS,eAAe,CAAC,QAAQ,EAAE,OAAO,CAAC,WAAW,CAAC,EAAE,aAAa,EAAE,yBAAyB,EAAE,QAOlG;AAED,QAAA,MAAM,qBAAqB;;;;CAI1B,CAAC;AAEF,eAAe,qBAAqB,CAAC;AACrC,oBAAY,qBAAqB,GAAG,OAAO,qBAAqB,CAAC"}

package/definitions/store.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="mongoose" />
+import { DepartmentModel, Location, LocationModel, CADVehicleModel, CADVehicle } from "tabletcommand-backend-models";
+import { LocationPayload } from "./types";
+export declare function store(departmentModel: DepartmentModel, locationModel: LocationModel, cadVehicleModel: CADVehicleModel): {
+    getVehicle: (item: LocationPayload, departmentId: string) => Promise<import("mongoose").DocumentDefinition<CADVehicle> | null>;
+    updateVehicle: (item: Partial<CADVehicle>, departmentId: string) => Promise<CADVehicle | null>;
+    updateLocation: (item: Partial<Location>, atDate: Date) => Promise<void>;
+};
+export default store;
+export declare type StoreModule = ReturnType<typeof store>;
+//# sourceMappingURL=store.d.ts.map

package/definitions/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../src/store.ts"],"names":[],"mappings":";AACA,OAAO,EACL,eAAe,EACf,QAAQ,EACR,aAAa,EACb,eAAe,EACf,UAAU,EACX,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EAAkB,eAAe,EAAE,MAAM,SAAS,CAAC;AAE1D,wBAAgB,KAAK,CACnB,eAAe,EAAE,eAAe,EAChC,aAAa,EAAE,aAAa,EAC5B,eAAe,EAAE,eAAe;uBAIA,eAAe,gBAAgB,MAAM;0BAQlC,QAAQ,UAAU,CAAC,gBAAgB,MAAM;2BAaxC,QAAQ,QAAQ,CAAC,UAAU,IAAI;EA0FpE;AACD,eAAe,KAAK,CAAC;AACrB,oBAAY,WAAW,GAAG,UAAU,CAAC,OAAO,KAAK,CAAC,CAAC"}

package/definitions/test/set-incident-type.d.ts

@@ -0,0 +1,2 @@
+import "mocha";
+//# sourceMappingURL=set-incident-type.d.ts.map

package/definitions/test/set-incident-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-incident-type.d.ts","sourceRoot":"","sources":["../../src/test/set-incident-type.ts"],"names":[],"mappings":"AACA,OAAO,OAAO,CAAC"}

package/definitions/types.d.ts

@@ -0,0 +1,35 @@
+import { Location } from "tabletcommand-backend-models";
+export interface LocationPayload {
+    latitude: number | string;
+    longitude: number | string;
+    vehicleId: string;
+    radioName: string;
+    avlTime: string;
+    speed?: number;
+}
+export interface Vehicle {
+    departmentId: string;
+    modifiedDate: number;
+    modified: Date;
+    radioName: string;
+    vehicleId: string;
+}
+export interface decodedLocation {
+    cadAVL: Partial<Location>;
+    isValid: boolean;
+}
+export interface LocationDelta {
+    active?: boolean;
+    agencyCode?: string;
+    agencyName?: string;
+    device_type?: string;
+    opAreaCode?: string;
+    opAreaName?: string;
+    shared?: boolean;
+    state?: string;
+    username?: string;
+}
+export declare type LocationObject = {
+    [P in keyof Location]: Location[P];
+};
+//# sourceMappingURL=types.d.ts.map

package/definitions/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAExD,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAC1B,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,OAAO;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,IAAI,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC1B,OAAO,EAAE,OAAO,CAAA;CACjB;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,oBAAY,cAAc,GAAG;KAC1B,CAAC,IAAI,MAAM,QAAQ,GAAG,QAAQ,CAAC,CAAC,CAAC;CACnC,CAAA"}

package/gulpfile.js

@@ -0,0 +1,19 @@
+const gulp = require("gulp");
+const shell = require("gulp-shell");
+const del = require("del");
+
+gulp.task("clean", function() {
+  return del("build/**", {
+    force: true
+  });
+});
+
+gulp.task("ts", gulp.series("clean", shell.task("tsc -p ./src")));
+
+gulp.task("lint", gulp.series(shell.task("eslint ./src")));
+
+gulp.task("watch", gulp.series("clean", shell.task("tsc -p ./src --watch")));
+
+gulp.task("build", gulp.series("ts"));
+
+gulp.task("default", gulp.series("build"));

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "tabletcommand-incident",
+  "version": "0.1.0",
+  "description": "Tablet Command Incident",
+  "main": "build/index.js",
+  "scripts": {
+    "build": "gulp build",
+    "lint": "eslint src",
+    "test": "npx type-coverage && npx mocha -r ts-node/register --reporter list --recursive src/test/**/*.ts"
+  },
+  "author": "Marius <marius@tabletcommand.com>",
+  "license": "MIT",
+  "types": "definitions/index.d.ts",
+  "dependencies": {
+    "debug": "^4.3.4",
+    "lodash": "~4.17.21",
+    "tabletcommand-backend-models": "~5.35.5"
+  },
+  "devDependencies": {
+    "@types/chai": "^4.3.11",
+    "@types/debug": "^4.1.12",
+    "@types/express": "^4.17.21",
+    "@types/lodash": "^4.14.202",
+    "@types/mocha": "^10.0.6",
+    "@types/mongodb": "~3.6.20",
+    "@types/mongoose": "~5.10.5",
+    "@types/node": "^20.10.6",
+    "@types/uuid": "^9.0.7",
+    "@typescript-eslint/eslint-plugin": "^6.17.0",
+    "@typescript-eslint/parser": "^6.17.0",
+    "bson": "~4.7.0",
+    "chai": "^4.3.10",
+    "cspell": "^7.3.8",
+    "del": "^6.0.0",
+    "eslint": "^8.56.0",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-promise": "^6.1.1",
+    "eslint-plugin-security": "^1.7.1",
+    "gulp": "^4.0.2",
+    "gulp-shell": "^0.8.0",
+    "mocha": "^10.2.0",
+    "mongoose": "~5.10.19",
+    "ts-node": "^10.9.2",
+    "type-coverage": "^2.27.1",
+    "typescript": "~4.7.4"
+  },
+  "typeCoverage": {
+    "atLeast": 99.7,
+    "ignoreCatch": true,
+    "ignoreFiles": [
+      "src/test/**/*.ts"
+    ]
+  }
+}

package/src/index.ts

@@ -0,0 +1,60 @@
+import {
+  DepartmentModel,
+  LocationModel,
+  CADVehicleModel,
+  Department,
+} from "tabletcommand-backend-models";
+import _ from "lodash";
+
+import locationModule from "./location";
+import storeModule from "./store";
+import { LocationPayload } from "./types";
+
+export function indexFile(
+  departmentModel: DepartmentModel,
+  locationModel: LocationModel,
+  cadVehicleModel: CADVehicleModel,
+) {
+  const store = storeModule(departmentModel, locationModel, cadVehicleModel);
+  const location = locationModule(store);
+  // async function processVehicle(department: Partial<Department>, item: Partial<CADVehicle>) {
+  //   // await location.processVehicle()
+  // }
+
+  async function processLocations(department: Partial<Department>, items: LocationPayload[] | null | undefined) {
+    const atDate = new Date();
+
+    if (_.isUndefined(items) || _.isNull(items)) {
+      return [];
+    }
+    if (_.isObject(items) && !_.isArray(items)) {
+      items = [items];
+    }
+    const result = await location.processItems(department, items, atDate);
+    return result;
+  }
+
+  // async function processLocationsOnly(department: Partial<Department>, items: Partial<Location>[] | null | undefined, agency: Partial<Agency>) {
+  //   try {
+  //     if (_.isUndefined(items) || _.isNull(items)) {
+  //       return [];
+  //     }
+  //     if (_.isObject(items) && !_.isArray(items)) {
+  //       items = [items];
+  //     }
+  //     const result = await location.processItemsNoVehicle(department, items, agency);
+  //     return result;
+  //   } catch (err) {
+  //     throw err;
+  //   }
+  // }
+
+  return {
+    // processVehicle,
+    processLocations,
+    // processLocationsOnly,
+  };
+}
+
+export default indexFile;
+export type IncidentModule = ReturnType<typeof indexFile>;

package/src/location.ts

@@ -0,0 +1,167 @@
+import _ from "lodash";
+import debugModule from "debug";
+import mongoose from "mongoose";
+
+import {
+  Department,
+  Location,
+  CADVehicle,
+} from "tabletcommand-backend-models";
+import {
+  LocationPayload, decodedLocation,
+} from "./types";
+import { StoreModule } from "./store";
+
+export function location(store: StoreModule) {
+  const debug = debugModule("tabletcommand-location:location");
+
+  async function decodeCADVehicleStatusToLocation(item: LocationPayload, department: Partial<Department>, atDate: Date): Promise<decodedLocation> {
+    let latitude = 0;
+    let longitude = 0;
+
+    if (_.isFinite(parseFloat(item.latitude.toString()))) {
+      latitude = parseFloat(item.latitude.toString());
+    }
+
+    if (_.isFinite(parseFloat(item.longitude.toString()))) {
+      longitude = parseFloat(item.longitude.toString());
+    }
+
+    if (!_.isString(item.radioName)) {
+      item.radioName = "";
+    }
+
+    if (!_.isString(item.vehicleId)) {
+      item.vehicleId = "";
+    }
+
+    const now = atDate.valueOf() / 1000.0;
+    // Don't save provided AVL time if it's more than 30s in the future
+    const futureTimeLimit = now + 30;
+    // If present, replace the modified unix date with the one provided by the CAD
+    let movedAtUnix = now;
+    if (_.isString(item.avlTime) && _.trim(item.avlTime) !== "") {
+      const checkISODate = (new Date(item.avlTime).valueOf()) / 1000.0;
+      const cadUnixTime = _.isNaN(checkISODate) && _.isString(item.avlTime) ? parseFloat(item.avlTime) : checkISODate;
+
+      if (_.isFinite(cadUnixTime) && cadUnixTime <= futureTimeLimit) {
+        movedAtUnix = cadUnixTime;
+      }
+    }
+
+    const userId = `${item.radioName}-${item.vehicleId}`; // Fake user id radioName - vehicleId
+
+    let sharingEnabled = false;
+    let opAreaName = "";
+    let opAreaCode = "";
+    let deptState = "";
+    let locationStaleMinutes = 31 * 24 * 60; // 31d
+
+    if (_.isObject(department) && _.isObject(department.shareAVL)) {
+      sharingEnabled = department.shareAVL.enabled && department.accountType === "production";
+      opAreaName = department.shareAVL.opAreaName || "";
+      opAreaCode = department.shareAVL.opAreaCode || "";
+    }
+
+    if (_.isObject(department)) {
+      if (_.isObject(department.addressDetails) && _.isString(department.addressDetails.state)) {
+        deptState = department.addressDetails.state || "";
+      }
+      if (_.isNumber(department.locationStaleMinutes) && _.isFinite(department.locationStaleMinutes) && department.locationStaleMinutes > 0) {
+        locationStaleMinutes = department.locationStaleMinutes;
+      }
+    }
+    const deleteAfterDate = new Date(atDate.valueOf() + 1000 * 60 * locationStaleMinutes).toISOString();
+
+    const cadAVL: Partial<Location> = {
+      device_type: "cad",
+      locationGeoJSON: {
+        type: "Point",
+        coordinates: [longitude, latitude]
+      },
+      deleteAfterDate,
+      modified: atDate.toISOString(),
+      movedAt: new Date(movedAtUnix * 1000).toISOString(),
+      active: true,
+      username: item.radioName,
+      userId,
+      departmentId: (department._id as mongoose.Types.ObjectId).toString(),
+      session: userId,
+      version: 2,
+      shared: sharingEnabled,
+      opAreaName,
+      opAreaCode,
+      state: deptState,
+    };
+
+    if (_.isNumber(item.speed)) {
+      const speed = item.speed;
+      cadAVL.speed = speed;
+    }
+
+    const hasCoordinate = Math.abs(latitude) > 0.01 || Math.abs(longitude) > 0.01;
+    const validCoordinate = Math.abs(latitude) < 90 && Math.abs(longitude) < 180;
+    const hasVehicle = _.isString(item.vehicleId) && _.trim(item.vehicleId).length > 0;
+    const hasRadioName = _.isString(item.radioName) && _.trim(item.radioName).length > 0;
+    const isValid = hasCoordinate && validCoordinate && (hasVehicle || hasRadioName);
+
+    return {
+      cadAVL,
+      isValid,
+    };
+  }
+
+  async function processVehicle(departmentExceptions: string[], item: LocationPayload, department: Partial<Department>, atDate: Date) {
+    const departmentId: string = (department._id as mongoose.Types.ObjectId).toString();
+
+    // need function to validate the item (As concerns vehicleId and radioName)
+    const isBidirectionalException = departmentExceptions.indexOf(departmentId) !== -1;
+    // Determine if vehicle is active or not
+    const cadItem = await store.getVehicle(item, departmentId);
+    if (!_.isObject(cadItem) &&
+      department.cadOneWayVehiclesEnabled &&
+      (department.cadBidirectionalEnabled !== true || isBidirectionalException)) {
+      const vehicleItem: Partial<CADVehicle> = {
+        departmentId: departmentId,
+        modifiedDate: atDate.valueOf() / 1000.0,
+        modified: atDate.toISOString(),
+        radioName: item.radioName,
+        vehicleId: item.vehicleId,
+      };
+      await store.updateVehicle(vehicleItem, departmentId);
+    }
+    return cadItem;
+  }
+
+  async function processItems(department: Partial<Department>, items: LocationPayload[], atDate: Date) {
+    for (const item of items) {
+      const decoded = await decodeCADVehicleStatusToLocation(item, department, atDate);
+      debug(`processCADVehicleLocation item: ${JSON.stringify(item)} d:${JSON.stringify(department)} at: ${atDate.toISOString()}.`);
+      if (!decoded.isValid) {
+        return;
+      }
+
+      let active = true;
+      const cadBidirectionalExceptions = [
+        "627d718b8d6145748b30282b" // HMT (2 way comments, 1 way vehicles)
+      ];
+
+      const cadItem = await processVehicle(cadBidirectionalExceptions, item, department, atDate);
+
+      if (_.isObject(cadItem) && _.isBoolean(cadItem.mapHidden)) {
+        active = !cadItem.mapHidden;
+      }
+
+      decoded.cadAVL.active = active;
+      await store.updateLocation(decoded.cadAVL, atDate);
+    }
+  }
+
+  return {
+    processVehicle,
+    processItems,
+  };
+}
+
+export default location;
+export type LocationModule = ReturnType<typeof location>;

package/src/set-incident-type.ts

@@ -0,0 +1,135 @@
+import _ from "lodash";
+import { CADIncident } from "tabletcommand-backend-models";
+
+export interface IncidentTypeConfiguration {
+  name: string,
+  value: string,
+  callTypeDescription: string[],
+  callType: string[],
+  allowPartialMatch?: boolean,
+}
+
+export type NotificationType = Pick<IncidentTypeConfiguration, "name" | "value">;
+
+// Change incident by reference
+function setIncidentTypeAny(incident: Partial<CADIncident>) {
+  if (!_.isArray(incident.notificationType)) {
+    incident.notificationType = [];
+  }
+
+  let foundTypeAny = false;
+  _.map(incident.notificationType, function(t) {
+    if (_.isString(t.value) && t.value === "any") {
+      foundTypeAny = true;
+    }
+    return true;
+  });
+
+  if (!foundTypeAny) {
+    incident.notificationType.push({
+      name: "Any",
+      value: "any"
+    });
+  }
+}
+
+function matchCurrentAgainstTypes(value: string, types: string[] | undefined, allowPartialMatch: boolean | undefined, resolveTo: NotificationType): NotificationType | null {
+  let found: NotificationType | null = null;
+
+  if (value === "") {
+    return found;
+  }
+
+  if (!_.isArray(types)) {
+    return found;
+  }
+
+  types.forEach((callTypeItem) => {
+    // If incident contains that call type, consider it a match
+    // This will address the situations when callTypeDescription has a
+    // dynamic prefix not defined in the call type array
+    const lowerCasedCallTypeItem = callTypeItem.toLowerCase();
+    const containsMatch = value.includes(lowerCasedCallTypeItem);
+    const exactMatch = value === lowerCasedCallTypeItem;
+    const isMatch = exactMatch || (containsMatch && allowPartialMatch === true);
+    if (isMatch) {
+      found = resolveTo;
+    }
+  });
+
+  return found;
+}
+
+function setIncidentTypeUsingConfiguration(incident: Partial<CADIncident>, incidentTypes: IncidentTypeConfiguration[]) {
+  let matched = false;
+  if (!_.isArray(incidentTypes) || _.size(incidentTypes) === 0) {
+    return matched;
+  }
+
+  let incidentCallTypeDescription = "";
+  if (_.isString(incident.AgencyIncidentCallTypeDescription) && incident.AgencyIncidentCallTypeDescription !== "") {
+    incidentCallTypeDescription = incident.AgencyIncidentCallTypeDescription.toLowerCase();
+  }
+
+  let incidentCallType = "";
+  if (_.isString(incident.AgencyIncidentCallType) && incident.AgencyIncidentCallType !== "") {
+    incidentCallType = incident.AgencyIncidentCallType.toLowerCase();
+  }
+
+  _.each(incidentTypes, function(item) {
+    if (incidentCallType !== "") {
+      const foundType = matchCurrentAgainstTypes(incidentCallType, item.callType, item.allowPartialMatch, {
+        name: item.name,
+        value: item.value,
+      });
+      matched = appendNotification(incident, foundType);
+    }
+
+    if (incidentCallTypeDescription !== "") {
+      const foundTypeDescription = matchCurrentAgainstTypes(incidentCallTypeDescription, item.callTypeDescription, item.allowPartialMatch, {
+        name: item.name,
+        value: item.value,
+      });
+      matched = appendNotification(incident, foundTypeDescription);
+    }
+  });
+
+  return matched;
+}
+
+function appendNotification(incident: Partial<CADIncident>, foundType: NotificationType | null): boolean {
+  if (foundType === null) {
+    return false;
+  }
+
+  if (!_.isArray(incident.notificationType)) {
+    incident.notificationType = [];
+  }
+
+  const existingMatches = incident.notificationType.filter((n) => n.value === foundType.value);
+  // This item was already added
+  if (existingMatches.length > 0) {
+    return false;
+  }
+
+  incident.notificationType.push(foundType);
+  return true;
+}
+
+function setIncidentType(incident: Partial<CADIncident>, incidentTypes: IncidentTypeConfiguration[]) {
+  setIncidentTypeAny(incident);
+
+  const hasDatabaseConfiguration = _.isArray(incidentTypes) && incidentTypes.length > 0;
+  if (hasDatabaseConfiguration) {
+    setIncidentTypeUsingConfiguration(incident, incidentTypes);
+  }
+}
+
+const setIncidentTypeModule = {
+  setIncidentTypeAny,
+  setIncidentTypeUsingConfiguration,
+  setIncidentType
+};
+
+export default setIncidentTypeModule;
+export type SetIncidentTypeModule = typeof setIncidentTypeModule;

package/src/store.ts

@@ -0,0 +1,133 @@
+import debugModule from "debug";
+import {
+  DepartmentModel,
+  Location,
+  LocationModel,
+  CADVehicleModel,
+  CADVehicle,
+} from "tabletcommand-backend-models";
+import _ from "lodash";
+
+import { LocationObject, LocationPayload } from "./types";
+
+export function store(
+  departmentModel: DepartmentModel,
+  locationModel: LocationModel,
+  cadVehicleModel: CADVehicleModel,  
+) {
+  const debug = debugModule("tabletcommand-location:location:store");
+    
+  async function getVehicle(item: LocationPayload, departmentId: string) {
+    const query = {
+      vehicleId: item.vehicleId,
+      departmentId,
+    };
+    return cadVehicleModel.findOne(query).lean();
+  }
+
+  async function updateVehicle(item: Partial<CADVehicle>, departmentId: string) {
+    const query = {
+        departmentId,
+        vehicleId: item.vehicleId,
+    };
+    const options = {
+        upsert: true,
+        setDefaultsOnInsert: true,
+        new: true
+    };   
+    return await cadVehicleModel.findOneAndUpdate(query, item, options);
+  }
+
+  async function updateLocation(item: Partial<Location>, atDate: Date) {
+      const modelItem = new locationModel(item);     
+      const query = {
+          device_type: modelItem.device_type,
+          departmentId: modelItem.departmentId,
+          username: modelItem.username
+      };   
+      debug(`Location.findOne: ${JSON.stringify(query)}`);
+      const dbItem = await locationModel.findOne(query).lean().exec() as Partial<LocationObject>;   
+      const cloneItem = { ...dbItem };
+      let updatedItem = propagateLocation(modelItem, dbItem);
+      debug(`Location.save: ${JSON.stringify(updatedItem)}`);  
+      if (cloneItem._id) {
+          const locationDelta = generateLocationDelta(cloneItem, updatedItem, atDate);
+          updatedItem = locationDelta;
+          debug(`Location.delta: ${JSON.stringify(locationDelta)}`);
+      } else {
+          // if new location record - Attempt to reconcile agency name and code to resources
+          // this is going to be resolved by the bin/cron-cleanup-minute cron
+      }    
+      await locationModel.updateOne(query, {
+          $set: updatedItem,
+      }, {
+          upsert: true,
+      });
+  }
+
+  function propagateLocation(modelItem: Location, dbItem: Partial<LocationObject>) {
+    if (!_.isObject(dbItem)) {
+      return modelItem;
+    }
+
+    // We keep the same value for _id, uuid, departmentId
+    dbItem.active = modelItem.active;
+    dbItem.altitude = modelItem.altitude;
+    dbItem.device_type = modelItem.device_type;
+    dbItem.heading = modelItem.heading;
+    dbItem.modified = modelItem.modified;
+    dbItem.movedAt = modelItem.movedAt;
+    dbItem.session = modelItem.session;
+    dbItem.speed = modelItem.speed;
+    dbItem.userId = modelItem.userId;
+    dbItem.username = modelItem.username;
+    dbItem.version = modelItem.version;
+    dbItem.locationGeoJSON = modelItem.locationGeoJSON;
+
+    // Propagate sharedAVL items
+    dbItem.opAreaCode = modelItem.opAreaCode;
+    dbItem.opAreaName = modelItem.opAreaName;
+    dbItem.shared = modelItem.shared;
+    dbItem.state = modelItem.state;
+
+    return dbItem;
+  }
+
+  function generateLocationDelta(locationRecord: Partial<LocationObject>, updateObject: Partial<LocationObject>, atDate: Date) {
+    if (!_.isObject(locationRecord)) {
+      return updateObject;
+    }
+    const locationDelta: Partial<LocationObject> = {};
+    for (const [key, value] of Object.entries(updateObject)) {
+      if (JSON.stringify(value) !== JSON.stringify(locationRecord[key])) {
+        locationDelta[key] = value;
+      }
+    }
+
+    const updatedKeys = Object.keys(locationDelta);
+    const propsKeys = [
+      "active",
+      "agencyCode",
+      "agencyName",
+      "device_type",
+      "opAreaCode",
+      "opAreaName",
+      "shared",
+      "state",
+      "username",
+    ];
+    if (_.intersection(updatedKeys, propsKeys).length > 0) {
+      locationDelta.propsChangedAt = atDate.toISOString();
+    }
+
+    return locationDelta;
+  }
+
+  return {
+      getVehicle,
+      updateVehicle,
+      updateLocation,
+  };
+}
+export default store;
+export type StoreModule = ReturnType<typeof store>;