tabletcommand-location 1.0.1

package/cspell.json

@@ -0,0 +1,57 @@
+// cSpell Settings
+{
+  "$schema": "https://raw.githubusercontent.com/streetsidesoftware/cspell/main/cspell.schema.json",
+  "version": "0.2",
+  // language - current active spelling language
+  "language": "en-US",
+  // words - list of words to be always considered correct
+  "words": [
+    "backend",
+    "bamse",
+    "devops",
+    "dmon",
+    "helloworld",
+    "mget",
+    "mockgoose",
+    "signup",
+    "stacktraces",
+    "tabletcommand",
+    "tyrion",
+    "unixtime",
+    "Ursache",
+    "personnelapi",
+    "agencypersonnelapi",
+    "expireat",
+    "agencyapi",
+    "accesslog",
+    "hincrby",
+    "hgetall",
+    "myhash",
+    "virtuals",
+    "apikey",
+    "personnelapikey",
+    "signupkey",
+    "fdid",
+    "flushall",
+    "zonehaven"
+  ],
+  // flagWords - list of words to be always considered incorrect
+  // This is useful for offensive words and common spelling errors.
+  // For example "hte" should be "the"
+  "flagWords": [
+    "hte"
+  ],
+  "ignoreWords": [],
+  "languageSettings": [{
+    "languageId": "*",
+    "dictionaries": []
+  }],
+  "ignorePaths": [
+    "node_modules",
+    "src/**/*.svg",
+    "/project-words.txt"
+  ],
+  "files": [
+    "src/**"
+  ]
+}

package/definitions/index.d.ts

@@ -0,0 +1,8 @@
+import { DepartmentModel, LocationModel, CADVehicleModel, Department } from "tabletcommand-backend-models";
+import { LocationPayload } from "./types";
+export declare function lib(departmentModel: DepartmentModel, locationModel: LocationModel, cadVehicleModel: CADVehicleModel): {
+    processLocations: (department: Partial<Department>, items: LocationPayload[] | null | undefined) => Promise<void | never[]>;
+};
+export default lib;
+export declare type LibModule = ReturnType<typeof lib>;
+//# sourceMappingURL=index.d.ts.map

package/definitions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,eAAe,EACf,aAAa,EACb,eAAe,EAGf,UAAU,EAEX,MAAM,8BAA8B,CAAC;AAEtC,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC1C,wBAAgB,GAAG,CACjB,eAAe,EAAE,eAAe,EAChC,aAAa,EAAE,aAAa,EAC5B,eAAe,EAAE,eAAe;mCAQY,QAAQ,UAAU,CAAC,SAAS,eAAe,EAAE,GAAG,IAAI,GAAG,SAAS;EAoC7G;AAED,eAAe,GAAG,CAAC;AACnB,oBAAY,SAAS,GAAG,UAAU,CAAC,OAAO,GAAG,CAAC,CAAC"}

package/definitions/location.d.ts

@@ -0,0 +1,10 @@
+import { Department, CADVehicle } from "tabletcommand-backend-models";
+import { LocationPayload } from "./types";
+import { StoreModule } from "./store";
+export declare function location(store: StoreModule): {
+    processVehicle: (departmentExceptions: string[], item: LocationPayload, department: Partial<Department>, atDate: Date) => Promise<import("mongoose").DocumentDefinition<CADVehicle> | null>;
+    processItems: (department: Partial<Department>, items: LocationPayload[], atDate: Date) => Promise<void>;
+};
+export default location;
+export declare type LocationModule = ReturnType<typeof location>;
+//# sourceMappingURL=location.d.ts.map

package/definitions/location.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"location.d.ts","sourceRoot":"","sources":["../src/location.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,UAAU,EAEV,UAAU,EACX,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,eAAe,EAChB,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEtC,wBAAgB,QAAQ,CAAC,KAAK,EAAE,WAAW;2CA8FW,MAAM,EAAE,QAAQ,eAAe,cAAc,QAAQ,UAAU,CAAC,UAAU,IAAI;+BAoB1F,QAAQ,UAAU,CAAC,SAAS,eAAe,EAAE,UAAU,IAAI;EA4BpG;AAED,eAAe,QAAQ,CAAC;AACxB,oBAAY,cAAc,GAAG,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC"}

package/definitions/store.d.ts

@@ -0,0 +1,10 @@
+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,EAEf,QAAQ,EACR,aAAa,EACb,eAAe,EACf,UAAU,EACX,MAAM,8BAA8B,CAAC;AAEtC,OAAO,EAAiC,eAAe,EAAW,MAAM,SAAS,CAAC;AAElF,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/location.d.ts

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

package/definitions/test/location.d.ts.map

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

package/definitions/test/mock.d.ts

@@ -0,0 +1,63 @@
+import * as mongoose from "mongoose";
+import "mocha";
+import { BackendModels, Agency, Department } from "tabletcommand-backend-models";
+export default function (modelsModule: typeof import("tabletcommand-backend-models")): {
+    department: Partial<Department>;
+    agency: Partial<Agency>;
+    clearTestData: (mods: BackendModels) => Promise<void>;
+    prepareTestData: (mods: BackendModels) => Promise<void>;
+    before: () => Promise<{
+        ActionLog: import("tabletcommand-backend-models").ActionLogModel;
+        Agency: import("tabletcommand-backend-models").AgencyModel;
+        ArcGISGroup: import("tabletcommand-backend-models").ArcGISGroupModel;
+        Assignment: import("tabletcommand-backend-models").AssignmentModel;
+        Battalion: import("tabletcommand-backend-models").BattalionModel;
+        BeaconLog: import("tabletcommand-backend-models").BeaconLogModel;
+        CADIncident: import("tabletcommand-backend-models").CADIncidentModel;
+        CADIncidentBlock: import("tabletcommand-backend-models").CADIncidentBlockModel;
+        CADIncidentDelta: import("tabletcommand-backend-models").CADIncidentDeltaModel;
+        CADIncidentFlat: import("tabletcommand-backend-models").CADIncidentFlatModel;
+        CADIncidentStream: import("tabletcommand-backend-models").CADIncidentStreamModel;
+        CADStatus: import("tabletcommand-backend-models").CADStatusModel;
+        CADStatusMap: import("tabletcommand-backend-models").CADStatusMapModel;
+        CADVehicle: import("tabletcommand-backend-models").CADVehicleModel;
+        CADVehicleStatus: import("tabletcommand-backend-models").CADVehicleStatusModel;
+        CADVehicleStatusHistory: import("tabletcommand-backend-models").CADVehicleStatusHistoryModel;
+        ChartDeviceStats: import("tabletcommand-backend-models").ChartDeviceStatsModel;
+        ChartIncident: import("tabletcommand-backend-models").ChartIncidentModel;
+        ChartManagedIncident: import("tabletcommand-backend-models").ChartManagedIncidentModel;
+        ChartUser: import("tabletcommand-backend-models").ChartUserModel;
+        Checklist: import("tabletcommand-backend-models").ChecklistModel;
+        ChecklistItem: import("tabletcommand-backend-models").ChecklistItemModel;
+        CSVImport: import("tabletcommand-backend-models").CSVImportModel;
+        Department: import("tabletcommand-backend-models").DepartmentModel;
+        DeviceMapping: import("tabletcommand-backend-models").DeviceMappingModel;
+        Esri: import("tabletcommand-backend-models").EsriModel;
+        GSTMapping: import("tabletcommand-backend-models").GSTMappingModel;
+        IncidentEvent: import("tabletcommand-backend-models").IncidentEventModel;
+        IncidentNotified: import("tabletcommand-backend-models").IncidentNotifiedModel;
+        IncidentTakeover: import("tabletcommand-backend-models").IncidentTakeoverModel;
+        JobLog: import("tabletcommand-backend-models").JobLogModel;
+        Location: import("tabletcommand-backend-models").LocationModel;
+        MailLog: import("tabletcommand-backend-models").MailLogModel;
+        ManagedIncident: import("tabletcommand-backend-models").ManagedIncidentModel;
+        Message: import("tabletcommand-backend-models").MessageModel;
+        Monitor: import("tabletcommand-backend-models").MonitorModel;
+        PersonnelImport: import("tabletcommand-backend-models").PersonnelImportModel;
+        RateLimit: import("tabletcommand-backend-models").RateLimitModel;
+        RemoteLog: import("tabletcommand-backend-models").RemoteLogModel;
+        Session: import("tabletcommand-backend-models").SessionModel;
+        SMTPUnhandled: import("tabletcommand-backend-models").SMTPUnhandledModel;
+        Template: import("tabletcommand-backend-models").TemplateModel;
+        User: import("tabletcommand-backend-models").UserModel;
+        UserDevice: import("tabletcommand-backend-models").UserDeviceModel;
+        UserRegistration: import("tabletcommand-backend-models").UserRegistrationModel;
+        ValidationReport: import("tabletcommand-backend-models").ValidationReportModel;
+    }>;
+    beforeEach: () => Promise<void>;
+    after: () => Promise<void>;
+    afterEach: () => Promise<void>;
+    getModels: () => BackendModels;
+    getConnection: () => typeof mongoose;
+};
+//# sourceMappingURL=mock.d.ts.map

package/definitions/test/mock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock.d.ts","sourceRoot":"","sources":["../../src/test/mock.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AACrC,OAAO,OAAO,CAAC;AAEf,OAAO,EACL,aAAa,EACb,MAAM,EACN,UAAU,EACX,MAAM,8BAA8B,CAAC;AAEtC,MAAM,CAAC,OAAO,WAAW,YAAY,EAAE,cAAc,8BAA8B,CAAC;;;0BAkE/C,aAAa;4BAQX,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoD5B,aAAa;yBAIT,eAAe;EAgB1C"}

package/definitions/types.d.ts

@@ -0,0 +1,33 @@
+import { Location } from "tabletcommand-backend-models";
+export interface LocationPayload extends Location {
+    latitude: number | string;
+    longitude: number | string;
+    vehicleId: string;
+    radioName: string;
+}
+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,eAAgB,SAAQ,QAAQ;IAC7C,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAC1B,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,OAAO;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,IAAI,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,eAAe;IAC5B,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC1B,OAAO,EAAE,OAAO,CAAA;CACnB;AAED,MAAM,WAAW,aAAa;IAC1B,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;CACrB;AAED,oBAAY,cAAc,GAAG;KACxB,CAAC,IAAI,MAAM,QAAQ,GAAG,QAAQ,CAAC,CAAC,CAAC;CACrC,CAAC"}

package/gulpfile.js

@@ -0,0 +1,20 @@
+const gulp = require("gulp");
+const shell = require("gulp-shell");
+const mocha = require("gulp-mocha");
+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,56 @@
+{
+  "name": "tabletcommand-location",
+  "version": "1.0.1",
+  "description": "Tablet Command Location",
+  "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": "Joe Goeman <joe@tabletcommand.com>",
+  "license": "MIT",
+  "types": "definitions/index.d.ts",
+  "dependencies": {
+    "debug": "^4.3.4",
+    "lodash": "~4.17.21",
+    "tabletcommand-backend-models": "~5.35.2"
+  },
+  "devDependencies": {
+    "@types/chai": "^4.3.10",
+    "@types/debug": "^4.1.12",
+    "@types/express": "^4.17.21",
+    "@types/lodash": "^4.14.201",
+    "@types/mocha": "^10.0.4",
+    "@types/mongodb": "~3.6.20",
+    "@types/mongoose": "~5.10.5",
+    "@types/node": "^20.9.2",
+    "@types/uuid": "^9.0.7",
+    "@typescript-eslint/eslint-plugin": "^6.11.0",
+    "@typescript-eslint/parser": "^6.11.0",
+    "bson": "~4.7.0",
+    "chai": "^4.3.10",
+    "cspell": "^7.3.8",
+    "del": "^6.0.0",
+    "eslint": "^8.54.0",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-promise": "^6.1.1",
+    "eslint-plugin-security": "^1.7.1",
+    "gulp": "^4.0.2",
+    "gulp-mocha": "^8.0.0",
+    "gulp-shell": "^0.8.0",
+    "mocha": "^10.2.0",
+    "mongoose": "~5.10.19",
+    "ts-node": "^10.9.1",
+    "type-coverage": "^2.27.0",
+    "typescript": "~4.7.4"
+  },
+  "typeCoverage": {
+    "atLeast": 99.9,
+    "ignoreCatch": true,
+    "ignoreFiles": [
+      "src/test/**/*.ts"
+    ],
+    "suppressError": true
+  }
+}

package/src/index.ts

@@ -0,0 +1,65 @@
+import locationModule from "./location";
+import storeModule from "./store";
+import { 
+  AgencyModel, 
+  DepartmentModel, 
+  LocationModel, 
+  CADVehicleModel, 
+  CADVehicle, 
+  Location, 
+  Department, 
+  Agency 
+} from "tabletcommand-backend-models";
+import _ from "lodash";
+import { LocationPayload } from "./types";
+export function lib(
+  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();
+    try {
+      if (_.isUndefined(items) || _.isNull(items)) {
+        return [];
+      }
+      if (_.isObject(items) && !_.isArray(items)) {
+        items = [items];
+      }
+      const result = await location.processItems(department, items, atDate);
+      return result;
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  // 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 lib;
+export type LibModule = ReturnType<typeof lib>;

package/src/location.ts

@@ -0,0 +1,161 @@
+import _ from "lodash";
+import {
+  DepartmentModel,
+  LocationModel,
+  CADVehicleModel,
+  Department,
+  Location,
+  CADVehicle,
+} from "tabletcommand-backend-models";
+import {
+  LocationPayload, Vehicle, decodedLocation,
+} from "./types";
+import debugModule from "debug";
+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 (_.isString(item.latitude) && _.isFinite(parseFloat(item.latitude))) {
+      latitude = parseFloat(item.latitude);
+    }
+
+    if (_.isString(item.longitude) && _.isFinite(parseFloat(item.longitude))) {
+      longitude = parseFloat(item.longitude);
+    }
+
+    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,
+      session: userId,
+      version: 2,
+      shared: sharingEnabled,
+      opAreaName,
+      opAreaCode,
+      state: deptState
+    };
+
+    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) {
+    // need function to validate the item (As concerns vehicleId and radioName)
+    const isBidirectionalException = departmentExceptions.indexOf(department._id) !== -1;
+    // Determine if vehicle is active or not
+    const cadItem = await store.getVehicle(item, department._id);
+    if (!_.isObject(cadItem) &&
+      department.cadOneWayVehiclesEnabled &&
+      (department.cadBidirectionalEnabled !== true || isBidirectionalException)) {
+      const vehicleItem: Partial<CADVehicle> = {
+        departmentId: department._id,
+        modifiedDate: atDate.valueOf() / 1000.0,
+        modified: atDate.toISOString(),
+        radioName: item.radioName,
+        vehicleId: item.vehicleId,
+      };
+      await store.updateVehicle(vehicleItem, department._id);
+    }
+    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;
+      return await store.updateLocation(decoded.cadAVL, atDate);
+    }
+  }
+
+  return {
+    processVehicle,
+    processItems,
+  };
+}
+
+export default location;
+export type LocationModule = ReturnType<typeof location>;

package/src/store.ts

@@ -0,0 +1,133 @@
+import debugModule from "debug";
+import {
+  DepartmentModel,
+  Department,
+  Location,
+  LocationModel,
+  CADVehicleModel,
+  CADVehicle,
+} from "tabletcommand-backend-models";
+import _ from "lodash";
+import { LocationDelta, LocationObject, LocationPayload, Vehicle } 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>;