tabletcommand-location 2.4.0 → 2.4.2

package/src/audience.ts

@@ -0,0 +1,54 @@
+import {
+  AccountIndustry,
+} from "tabletcommand-backend-models";
+
+export type AvlAudienceKind = "always" | "near" | "geo";
+
+export interface AvlNearArea {
+  /** Radius around an anchor incident. Per-pair — deliberately not a shared constant. */
+  radiusMeters: number;
+}
+
+export type AvlAudienceEntry =
+  | { kind: "always" }
+  | { kind: "near"; area: AvlNearArea }   // area required exactly when near
+  | { kind: "geo" };                      // geometry comes from the OWNER's shareAVL.area
+
+/** owner industry -> reader industry -> entry, or null for denied. Every pair present. */
+export type AvlAudienceMatrix = Record<AccountIndustry, Record<AccountIndustry, AvlAudienceEntry | null>>;
+
+const ALWAYS: AvlAudienceEntry = { kind: "always" };
+// eslint-ignore-next-line
+// const GEO: AvlAudienceEntry = { kind: "geo" };
+const DENY = null;
+const NEAR: AvlAudienceEntry = { kind: "near", area: { radiusMeters: 5000 } }; // 5km ~ 3.1mi
+
+export const AVL_AUDIENCE_MATRIX: AvlAudienceMatrix = {
+  //  owner => reader
+  [AccountIndustry.Fire]: {
+    [AccountIndustry.Fire]: ALWAYS,
+    [AccountIndustry.Law]: ALWAYS,
+    [AccountIndustry.Campus]: DENY,
+    [AccountIndustry.Utility]: NEAR,
+  },
+  [AccountIndustry.Law]: {
+    [AccountIndustry.Fire]: NEAR,
+    [AccountIndustry.Law]: ALWAYS,
+    [AccountIndustry.Campus]: DENY,
+    [AccountIndustry.Utility]: DENY,
+  },
+  [AccountIndustry.Campus]: {
+    [AccountIndustry.Fire]: ALWAYS,
+    [AccountIndustry.Law]: ALWAYS,
+    [AccountIndustry.Campus]: DENY,   // deliberate — see above
+    [AccountIndustry.Utility]: DENY,
+  },
+  [AccountIndustry.Utility]: {
+    [AccountIndustry.Fire]: NEAR,
+    [AccountIndustry.Law]: DENY,
+    [AccountIndustry.Campus]: DENY,
+    [AccountIndustry.Utility]: ALWAYS,
+  },
+};
+
+// Unused/Incomplete

package/src/index.ts

@@ -23,6 +23,11 @@ export {
   LocationVisibility,
 };
 
+// When used externally
+// import { query } from "tabletcommand-location";
+// query.adminListLocations({ departmentId, movedAt });
+export * as query from "./query";
+
 export function lib(
   departmentModel: DepartmentModel,
   locationModel: LocationModel,
@@ -31,9 +36,6 @@ export function lib(
 ) {
   const store = storeModule(departmentModel, locationModel, cadVehicleModel, deviceMappingModel);
   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();
@@ -69,26 +71,9 @@ export function lib(
     }
   }
 
-  // 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,
     processLocationsDeviceMapping,
-    // processLocationsOnly,
   };
 }
 

package/src/location.ts

@@ -1,5 +1,6 @@
 import _ from "lodash";
 import {
+  AccountIndustry,
   Department,
   Location,
   CADVehicle,
@@ -88,6 +89,7 @@ export function location(store: StoreModule) {
     const deleteAfterDate = new Date(atDate.valueOf() + 1000 * 60 * locationStaleMinutes);
     const personnelUUID = _.isString(item.personnelUUID) ? item.personnelUUID : "";
     const transponderUUID = _.isString(item.transponderUUID) ? item.transponderUUID : "";
+    const industry: AccountIndustry = department?.industry ?? AccountIndustry.Fire; // If not set, fallback to fire
 
     const cadAVL: Partial<Location> = {
       device_type: deviceType,
@@ -114,6 +116,7 @@ export function location(store: StoreModule) {
       visibility: [], // will be updated after .active is set
       personnelUUID,
       transponderUUID,
+      industry,
     };
 
     if (_.isNumber(item.speed)) {

package/src/query.ts

@@ -0,0 +1,497 @@
+import {
+  FilterQuery,
+  ProjectionType,
+  SortOrder,
+} from "mongoose";
+
+import {
+  Location,
+} from "tabletcommand-backend-models";
+
+export type MQP = {
+  list: FilterQuery<Location>,
+  projection: ProjectionType<Location>,
+  sortBy?: Record<string, SortOrder>,
+};
+
+export type AdminListLocationParams1 = {
+  departmentId: string,
+  movedAt: Date,
+  showAll?: boolean,
+};
+
+export type AdminListLocationParams2 = {
+  departmentId: string,
+  movedAt: Date,
+  longitude: number,
+  latitude: number,
+  diagonal: number,
+  showAll?: boolean,
+};
+
+export type SyncModifiedDate = {
+  modifiedDate: Date,
+};
+
+export const metersToRadians = 6378100; // The equatorial radius of the Earth in meters
+
+function centerSphereFilter(longitude: number, latitude: number, diagonal: number) {
+  return {
+    $geoWithin: {
+      $centerSphere: [
+        [longitude, latitude],
+        diagonal / metersToRadians,
+      ] as [[number, number], number],
+    },
+  };
+}
+
+// Transponder-tracked person records carry an empty personnelUUID;
+// they surface via the person/responder feeds, never in unit/vehicle lists
+const excludePersonAndTransponderRecords = [
+  {
+    $or: [
+      { personnelUUID: "" },
+      { personnelUUID: { $exists: false } }, // TODO: Remove $exists check once all location services are running the latest
+    ],
+  },
+  {
+    $or: [
+      { transponderUUID: "" },
+      { transponderUUID: { $exists: false } },
+    ],
+  },
+];
+
+// Same fields defined in the frontend
+// api/a1/location/units and api/a1/location/units-shared
+const projectionAdmin = {
+  _id: 1,
+  active: 1,
+  altitude: 1,
+  color: 1,
+  device_type: 1,
+  industry: 1,
+  kindType: 1,
+  location: 1,
+  locationGeoJSON: 1,
+  modified: 1,
+  movedAt: 1,
+  sendToCAD: 1,
+  source: 1,
+  speed: 1,
+  uuid: 1, // Legacy, remove later
+};
+
+export function adminListLocations(params: AdminListLocationParams1): MQP {
+  const {
+    departmentId,
+    movedAt,
+    showAll,
+  } = params;
+
+  const query: FilterQuery<Location> = {
+    // TODO: Replace models.Location active: true with visibility in "visible"
+    active: true,
+    departmentId,
+    $and: excludePersonAndTransponderRecords,
+    kindType: {
+      $ne: "uav",
+    },
+    // 03/14/23 (Joe) - Trying movedAt only [sc-11794] - determined modified was being overwritten by cad vehicle status updates
+    movedAt: {
+      $gte: movedAt,
+    },
+  };
+  if (showAll) {
+    delete query.active;
+  }
+
+  return {
+    list: query,
+    projection: projectionAdmin,
+  };
+}
+
+export function adminListPersonLocations(params: AdminListLocationParams1): MQP {
+  const {
+    departmentId,
+    movedAt,
+    showAll
+  } = params;
+
+  const query: FilterQuery<Location> = {
+    active: true,
+    departmentId,
+    kindType: "person",
+    movedAt: {
+      $gte: movedAt,
+    },
+  };
+  if (showAll) {
+    delete query.active;
+  }
+
+  // Same fields defined in the frontend
+  // api/a1/location/person
+  const projection = {
+    _id: 1,
+    active: 1,
+    altitude: 1,
+    color: 1,
+    device_type: 1,
+    industry: 1,
+    kindType: 1,
+    location: 1,
+    locationGeoJSON: 1,
+    modified: 1,
+    movedAt: 1,
+    personnelUUID: 1,
+    sendToCAD: 1,
+    source: 1,
+    speed: 1,
+    transponderUUID: 1,
+    uuid: 1, // Legacy, remove later
+  };
+
+  return {
+    list: query,
+    projection,
+  };
+}
+
+export function adminListUAVLocations(params: AdminListLocationParams1): MQP {
+  const {
+    departmentId,
+    movedAt,
+    showAll,
+  } = params;
+
+  const query: FilterQuery<Location> = {
+    active: true,
+    departmentId,
+    kindType: "uav",
+    movedAt: {
+      $gte: movedAt,
+    },
+  };
+  if (showAll) {
+    delete query.active;
+  }
+
+  const projection = {
+    _id: 1,
+    active: 1,
+    agencyCode: 1,
+    agencyName: 1,
+    altitude: 1,
+    color: 1,
+    device_type: 1,
+    heading: 1,
+    industry: 1,
+    kindType: 1,
+    locationGeoJSON: 1,
+    modified: 1,
+    movedAt: 1,
+    opAreaCode: 1,
+    opAreaName: 1,
+    sendToCAD: 1,
+    source: 1,
+    speed: 1,
+    state: 1,
+    userId: 1,
+    username: 1,
+    uuid: 1, // Legacy, remove later
+    vehicleId: 1,
+  };
+
+  return {
+    list: query,
+    projection,
+  };
+}
+
+export function adminListAircraftLocations(params: AdminListLocationParams2): MQP {
+  const {
+    departmentId,
+    movedAt,
+    longitude,
+    latitude,
+    diagonal
+  } = params;
+
+  const list = {
+    shared: true,
+    active: true,
+    source: "ADSB",
+    kindType: {
+      $in: ["fixed-wing", "helicopter"],
+    },
+    departmentId: {
+      $ne: departmentId,
+    },
+    movedAt: {
+      $gte: movedAt.toISOString(),
+    },
+    locationGeoJSON: centerSphereFilter(longitude, latitude, diagonal),
+  };
+
+  return {
+    list,
+    projection: projectionAdmin,
+  };
+}
+
+export function adminListSharedLocations(params: AdminListLocationParams2): MQP {
+  const {
+    departmentId,
+    movedAt,
+    longitude,
+    latitude,
+    diagonal
+  } = params;
+
+  const listSharedAVLQuery = {
+    shared: true,
+    active: true,
+    source: {
+      $ne: "ADSB"
+    },
+    departmentId: {
+      $ne: departmentId,
+    },
+    kindType: {
+      $ne: "uav",
+    },
+    movedAt: {
+      $gte: movedAt.toISOString(),
+    },
+    locationGeoJSON: centerSphereFilter(longitude, latitude, diagonal),
+  };
+
+  return {
+    list: listSharedAVLQuery,
+    projection: projectionAdmin,
+  };
+}
+
+export function adminListFocusedLocations(params: AdminListLocationParams2): MQP {
+  const {
+    departmentId,
+    movedAt,
+    longitude,
+    latitude,
+    diagonal,
+    showAll
+  } = params;
+
+  const listFocusedAVLQuery: FilterQuery<Location> = {
+    active: true,
+    departmentId,
+    movedAt: {
+      $gte: movedAt.toISOString(),
+    },
+    locationGeoJSON: centerSphereFilter(longitude, latitude, diagonal),
+  };
+
+  if (showAll) {
+    delete listFocusedAVLQuery.locationGeoJSON;
+  }
+
+  return {
+    list: listFocusedAVLQuery,
+    projection: projectionAdmin,
+  };
+}
+
+// Sync queries
+
+const projectionSync: ProjectionType<Location> = {
+  active: 1,
+  departmentId: 1,
+  device_type: 1, // used in web ui
+  location: 1,
+  locationGeoJSON: 1,
+  modified: 1,
+  userId: 1,
+  username: 1,
+  uuid: 1, // used in iOS
+  // both used by AVL sharing
+  opAreaName: 1,
+  opAreaCode: 1,
+  shared: 1,
+  state: 1,
+  // v3
+  altitude: 1,
+  speed: 1,
+  movedAt: 1,
+  agencyName: 1,
+  agencyCode: 1,
+  // v4
+  color: 1,
+  colorChangedAt: 1,
+  propsChangedAt: 1,
+  heading: 1,
+  // v4 extra
+  kindType: 1,
+  source: 1,
+  personnelUUID: 1,
+  transponderUUID: 1,
+  // v4 kind/type/locationType
+  kind: 1,
+  type: 1,
+  locationType: 1,
+  kindColor: 1,
+  // v4
+  industry: 1,
+};
+
+export function syncListSharedLocations(params: AdminListLocationParams2 & SyncModifiedDate): MQP {
+  const {
+    departmentId,
+    modifiedDate,
+    movedAt,
+    longitude,
+    latitude,
+    diagonal,
+  } = params;
+
+  const list: FilterQuery<Location> = {
+    shared: true,
+    source: {
+      $nin: ["ADSB", "DroneSense"]
+    },
+    departmentId: {
+      $ne: departmentId,
+    },
+    modified: {
+      $gte: modifiedDate.toISOString(),
+    },
+    movedAt: {
+      $gte: movedAt.toISOString(),
+    },
+    locationGeoJSON: centerSphereFilter(longitude, latitude, diagonal),
+  };
+
+  return {
+    list,
+    projection: projectionSync,
+  };
+}
+
+export function syncListLocations(params: AdminListLocationParams1 & SyncModifiedDate): MQP {
+  const {
+    departmentId,
+    modifiedDate,
+    movedAt,
+  } = params;
+
+  const list: FilterQuery<Location> = {
+    departmentId,
+    $and: excludePersonAndTransponderRecords,
+    kindType: {
+      $ne: "uav"
+    },
+    modified: {
+      $gte: modifiedDate.toISOString(),
+    },
+    movedAt: {
+      $gte: movedAt.toISOString(),
+    }
+  };
+
+  return {
+    list,
+    projection: projectionSync,
+  };
+}
+
+export function syncListPersonLocations(params: AdminListLocationParams1 & SyncModifiedDate): MQP {
+  const {
+    departmentId,
+    modifiedDate,
+    movedAt,
+  } = params;
+
+  const list: FilterQuery<Location> = {
+    departmentId,
+    kindType: "person",
+    modified: {
+      $gte: modifiedDate.toISOString(),
+    },
+    movedAt: {
+      $gte: movedAt.toISOString(),
+    },
+  };
+
+  return {
+    list,
+    projection: projectionSync,
+  };
+}
+
+export function syncListAircraftLocations(params: AdminListLocationParams2 & SyncModifiedDate): MQP {
+  const {
+    departmentId,
+    movedAt,
+    modifiedDate,
+    // Possibly missing
+    longitude,
+    latitude,
+    diagonal
+  } = params;
+
+  const list: FilterQuery<Location> = {
+    shared: true,
+    source: "ADSB",
+    kindType: {
+      $in: ["fixed-wing", "helicopter"]
+    },
+    departmentId: {
+      $ne: departmentId,
+    },
+    modified: {
+      $gte: modifiedDate.toISOString(),
+    },
+    movedAt: {
+      $gte: movedAt.toISOString(),
+    }
+  };
+
+  const hasCoordinate = Math.abs(latitude) > 0.01 || Math.abs(longitude) > 0.01;
+  const validCoordinate = Math.abs(latitude) < 90 && Math.abs(longitude) < 180;
+  const filterOnLocation = hasCoordinate && validCoordinate;
+  if (filterOnLocation) {
+    list.locationGeoJSON = centerSphereFilter(longitude, latitude, diagonal);
+  }
+
+  return {
+    list,
+    projection: projectionSync,
+  };
+}
+
+export function syncListUAVLocations(params: AdminListLocationParams1 & SyncModifiedDate): MQP {
+  const {
+    departmentId,
+    modifiedDate,
+    movedAt,
+
+  } = params;
+
+  const list: FilterQuery<Location> = {
+    departmentId,
+    kindType: "uav",
+    modified: {
+      $gte: modifiedDate.toISOString(),
+    },
+    movedAt: {
+      $gte: movedAt.toISOString(),
+    },
+  };
+
+  return {
+    list,
+    projection: projectionSync,
+  };
+}

package/src/store.ts

@@ -125,6 +125,7 @@ export function store(
     dbItem.locationGeoJSON = modelItem.locationGeoJSON;
     dbItem.source = modelItem.source;
     dbItem.kindType = modelItem.kindType;
+    dbItem.industry = modelItem.industry;
     // Carry person/category fields on the update path; only overwrite when the
     // incoming payload actually provides a value, so sources that don't send
     // these fields don't wipe values written by other sources.
@@ -183,6 +184,7 @@ export function store(
       "shared",
       "state",
       "username",
+      "industry",
     ];
     if (_.intersection(updatedKeys, propsKeys).length > 0) {
       locationDelta.propsChangedAt = atDate;

package/src/test/location.ts

@@ -5,7 +5,7 @@ import storeModule, { StoreModule } from "../store";
 import mockModule from "./mock";
 import locationModule, { LocationModule } from "../location";
 import { LocationPayload } from "../types";
-import { BackendModels } from "tabletcommand-backend-models";
+import { AccountIndustry, BackendModels } from "tabletcommand-backend-models";
 
 let location: LocationModule;
 let store: StoreModule;
@@ -429,5 +429,57 @@ describe("location", () => {
       assert.equal(recs[0]?.kindColor?.text, "#FFFFFF");
       assert.instanceOf(recs[0]?.kindColorChangedAt, Date);
     });
+    it("stamps the department's industry on the saved location", async () => {
+      const atDate = new Date();
+      const session = "item-with-industry-utility";
+      const items = [{
+        vehicleId: "BEEDOO1",
+        radioName: "BEEDOO1",
+        latitude: 34.35264,
+        longitude: -119.0669,
+        avlTime: "1602563494",
+        session,
+      }] as unknown as LocationPayload[];
+      await location.processItems(mockDepartment, items, atDate);
+      const sut = await models.Location.findOne({ session });
+      assert.equal(sut?.industry, AccountIndustry.Utility);
+    });
+    it("falls back to fire industry when the department has none set", async () => {
+      const atDate = new Date();
+      const session = "item-with-industry-fallback";
+      const department = { ...mockDepartment, industry: undefined };
+      const items = [{
+        vehicleId: "BEEDOO1",
+        radioName: "BEEDOO1",
+        latitude: 34.35264,
+        longitude: -119.0669,
+        avlTime: "1602563494",
+        session,
+      }] as unknown as LocationPayload[];
+      await location.processItems(department, items, atDate);
+      const sut = await models.Location.findOne({ session });
+      assert.equal(sut?.industry, AccountIndustry.Fire);
+    });
+    it("updates industry in place and stamps propsChangedAt when it changes", async () => {
+      const base = {
+        vehicleId: "BEEDOO1",
+        radioName: "BEEDOO1",
+        latitude: 34.35264,
+        longitude: -119.0669,
+        avlTime: "1602563494",
+      } as unknown as LocationPayload;
+      await location.processItems(mockDepartment, [base], new Date());
+      const initial = await models.Location.find({});
+      assert.equal(initial[0]?.industry, AccountIndustry.Utility);
+      const initialPropsChangedAt = initial[0]?.propsChangedAt;
+      assert.instanceOf(initialPropsChangedAt, Date);
+
+      const lawDepartment = { ...mockDepartment, industry: AccountIndustry.Law };
+      await location.processItems(lawDepartment, [base], new Date());
+      const recs = await models.Location.find({});
+      assert.equal(recs.length, 1);
+      assert.equal(recs[0]?.industry, AccountIndustry.Law);
+      assert.isAbove(recs[0]!.propsChangedAt.valueOf(), initialPropsChangedAt!.valueOf());
+    });
   });
 });