@7365admin1/layer-common 3.2.0 → 3.2.1-staging.59

package/plugins/secure-member.client.ts

@@ -12,75 +12,40 @@ export default defineNuxtPlugin(() => {
 
   const { userAppRole, id, orgNature } = useLocalSetup();
 
-  router.afterEach(async (to) => {
+  router.beforeEach(async (to) => {
     const isMember = to.meta?.memberOnly;
 
     if (!isMember) return;
 
     const APP = useRuntimeConfig().public.APP;
-    const org = computed(
-      () =>
-        (to.params.org as string) || (to.params.organization as string) || ""
-    );
+    const org =
+      (to.params.org as string) || (to.params.organization as string) || "";
 
-    console.log('[secure-member-plugin', 'org', org.value)
-
-    if (!hexSchema.safeParse(org.value).success) {
-      return router.replace({ name: "require-organization-membership" });
+    if (!hexSchema.safeParse(org).success) {
+      return { name: "require-organization-membership" };
     }
 
-    const userId = computed(() => useCookie("user").value ?? "");
-
-    const { data: userMemberData, error: userMemberError } =
-      await useLazyAsyncData(
-        "plugin-get-member-by-id-" + userId.value + "-" + APP + "-" + org.value,
-        () => getByUserType(userId.value, APP, org.value),
-        { watch: [userId] }
-      );
-
-    watchEffect(() => {
-      if (userMemberError.value) {
-        console.log('running-secure-member-redirect-plugin')
-        navigateTo(
-          {
-            name: "index",
-          },
-          { replace: true }
-        );
-      }
-    });
-
-    const roleId = ref("roleId");
+    const userId = useCookie("user").value ?? "";
+    if (!userId) return { name: "index" };
 
-    watchEffect(() => {
-      if (userMemberData.value) {
-        id.value = userMemberData.value.org ?? "";
-        roleId.value = userMemberData.value.role ?? "roleId";
-      }
-    });
+    try {
+      const userMemberData = await getByUserType(userId, APP, org);
+      id.value = userMemberData.org ?? "";
 
-    const { data: getOrgByIdReq } = await useLazyAsyncData(
-      "plugin-get-org-by-id-" + org.value,
-      () => getById(org.value),
-      { watch: [org] }
-    );
+      const [orgResult, roleResult] = await Promise.allSettled([
+        getById(org),
+        userMemberData.role ? getRoleById(userMemberData.role) : null,
+      ]);
 
-    watchEffect(() => {
-      if (getOrgByIdReq.value) {
-        orgNature.value = getOrgByIdReq.value.nature ?? "";
+      if (orgResult.status === "fulfilled" && orgResult.value) {
+        orgNature.value = orgResult.value.nature ?? "";
       }
-    });
 
-    const { data: getRoleByIdReq } = await useLazyAsyncData(
-      "plugin-get-role-by-id-" + roleId.value,
-      () => getRoleById(roleId.value),
-      { watch: [roleId] }
-    );
-
-    watchEffect(() => {
-      if (getRoleByIdReq.value) {
-        userAppRole.value = getRoleByIdReq.value;
+      if (roleResult.status === "fulfilled" && roleResult.value) {
+        userAppRole.value = roleResult.value;
       }
-    });
+    } catch (error) {
+      return { name: "index" };
+    }
   });
 });

package/types/site.d.ts

@@ -1,5 +1,76 @@
 declare type TSiteCreate = Pick<TSite, "name" | "description" | "orgId">;
 
+declare type THidQrCodeFormat = "0" | "1" | "2";
+
+declare type THidPermissionCategory =
+  | "resident"
+  | "property_management"
+  | "service_provider";
+
+declare type THidPermissionAssignment = {
+  subjectId: string;
+  category: THidPermissionCategory;
+  name: string;
+  subtitle?: string;
+  intercom: boolean;
+  readerId?: string;
+  location?: string;
+  locationKey?: string;
+};
+
+declare type THidSitePermissions = {
+  orgId: string;
+  site: string;
+  readerId: string;
+  location: string;
+  assignments: THidPermissionAssignment[];
+  counts: {
+    resident: number;
+    propertyManagement: number;
+    serviceProvider: number;
+    intercom: number;
+  };
+};
+
+declare type THidPermissionCandidate = THidPermissionAssignment & {
+  selected: boolean;
+};
+
+declare type THidQrCodePassConfig = {
+  enabled: boolean;
+  onlineMode?: boolean;
+  readerId: string;
+  qrFormat: THidQrCodeFormat;
+  identificationMethods?: {
+    facial: boolean;
+    card: boolean;
+    qrCode: boolean;
+    idPassword: boolean;
+    pin: boolean;
+    bluetooth: boolean;
+  };
+  printer: {
+    vendorId: string;
+    productId: string;
+  };
+  template: {
+    header: string;
+    subtext: string;
+  };
+  validityMinutes: number | null;
+  updatedAt?: string;
+};
+
+declare type TSiteMetadata = {
+  block?: number;
+  guardPosts?: number;
+  gracePeriod?: number;
+  incidentCounter?: number;
+  incidentLogo?: string;
+  services?: Record<string, unknown>[];
+  hidQrCodePass?: THidQrCodePassConfig;
+};
+
 
 declare type TSite = {
   _id?: string;

package/utils/camera-wall.test.ts

@@ -0,0 +1,149 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import {
+  capabilityView,
+  isDenseLayout,
+  tileView,
+  wallCameras,
+  wallLayout,
+  wallTiles,
+} from "./camera-wall.ts";
+
+const ip = (over: Record<string, unknown> = {}) => ({
+  _id: "c1",
+  name: "GYM AREA",
+  type: "ip",
+  status: "active",
+  host: "https://example.invalid/4",
+  ...over,
+});
+
+/* ---------------------------------------------------------------- rule 1 */
+
+test("an ANPR camera can never reach the wall", () => {
+  const items = [ip(), { _id: "c2", type: "anpr", host: "http://example.invalid:1234" }];
+  const kept = wallCameras(items);
+  assert.equal(kept.length, 1);
+  assert.equal(kept[0]._id, "c1");
+});
+
+test("a junk response is an empty wall, not a crash", () => {
+  assert.deepEqual(wallCameras(undefined), []);
+  assert.deepEqual(wallCameras([null, 3, "x"]), []);
+});
+
+/* ---------------------------------------------------------- layout + order */
+
+test("an unknown layout key falls back to four tiles", () => {
+  assert.equal(wallLayout("7x7").tiles, 4);
+  assert.equal(isDenseLayout("3x3"), true);
+  assert.equal(isDenseLayout("2x2"), false);
+});
+
+test("no selection means the site's own order, not a blank wall", () => {
+  const cams = [ip({ _id: "a" }), ip({ _id: "b" })];
+  const tiles = wallTiles(cams, [], "2x2");
+  assert.equal(tiles.length, 4);
+  assert.equal(tiles[0]._id, "a");
+  assert.equal(tiles[1]._id, "b");
+  assert.equal(tiles[2], null);
+});
+
+test("a selection sets the order, and a stale id is dropped rather than drawn", () => {
+  const cams = [ip({ _id: "a" }), ip({ _id: "b" })];
+  const tiles = wallTiles(cams, ["b", "gone", "a"], "1x1");
+  assert.equal(tiles.length, 1);
+  assert.equal(tiles[0]._id, "b");
+});
+
+/* ---------------------------------------------------------------- rule 2/3 */
+
+test("no descriptor at all counts as NOT available", () => {
+  const v = capabilityView(ip(), "ptz");
+  assert.equal(v.available, false);
+  assert.equal(v.tag, "Not checked yet");
+  assert.match(v.detail, /has not been asked/);
+});
+
+test("the server's own sentence is shown, never rewritten", () => {
+  const cam = ip({
+    capabilities: {
+      playback: {
+        state: "unsupported",
+        detail: "No direct connection to this camera's recorder is configured on this server.",
+      },
+    },
+  });
+  const v = capabilityView(cam, "playback");
+  assert.equal(v.tag, "Not set up yet");
+  assert.equal(
+    v.detail,
+    "No direct connection to this camera's recorder is configured on this server."
+  );
+});
+
+test("a supported capability wears no tag", () => {
+  const cam = ip({ capabilities: { playback: { state: "supported", detail: null } } });
+  assert.equal(capabilityView(cam, "playback").available, true);
+  assert.equal(capabilityView(cam, "playback").tag, null);
+});
+
+/* ------------------------------------------------------------------ rule 4 */
+
+test("a page that has not loaded is Connecting, never Live", () => {
+  assert.equal(tileView(ip(), { player: "loading" }).state, "connecting");
+  assert.equal(tileView(ip(), { player: "ready" }).label, "Live");
+  assert.equal(tileView(ip(), { player: "timeout" }).state, "no-signal");
+});
+
+test("the browser being offline outranks everything and says so differently", () => {
+  assert.equal(tileView(ip(), { online: false, player: "ready" }).label, "No connection");
+  assert.equal(tileView(ip(), { player: "timeout" }).label, "No signal");
+});
+
+test("an inactive camera, a camera with no address, and an empty tile all explain themselves", () => {
+  assert.match(tileView(ip({ status: "inactive" })).detail, /not active/);
+  assert.match(tileView(ip({ host: "" })).detail, /no address/);
+  assert.match(tileView(null).detail, /No camera in this position/);
+  assert.equal(tileView(ip({ host: "" })).showPlayer, false);
+});
+
+test("a server that says live video is unsupported is believed", () => {
+  const cam = ip({
+    capabilities: {
+      liveVideo: { state: "unsupported", detail: "This camera is not active." },
+    },
+  });
+  const v = tileView(cam, { player: "ready" });
+  assert.equal(v.showPlayer, false);
+  assert.equal(v.detail, "This camera is not active.");
+});
+
+/* ------------------------------------------- the server's reason wins */
+
+test("the server's own refusal is shown verbatim, not replaced with a guess", () => {
+  // The one that matters: the browser cannot know this, and until the API host
+  // is configured it is the true answer for every camera in the estate.
+  const noRecorder = "No recorder is configured for this camera's relay.";
+  const view = tileView(ip({ unavailableReason: noRecorder }));
+  assert.equal(view.detail, noRecorder);
+  assert.equal(view.state, "unavailable");
+  assert.equal(view.showPlayer, false);
+});
+
+test("the server's reason beats the reasons the wall could work out itself", () => {
+  const reason = "This camera has no address configured.";
+  assert.equal(tileView(ip({ status: "inactive", unavailableReason: reason })).detail, reason);
+});
+
+test("an absent or blank reason changes nothing", () => {
+  assert.equal(tileView(ip({ unavailableReason: null })).state, "connecting");
+  assert.equal(tileView(ip({ unavailableReason: "   " })).state, "connecting");
+  assert.equal(tileView(ip()).state, "connecting");
+});
+
+test("being offline still explains every tile at once, ahead of the server's reason", () => {
+  const view = tileView(ip({ unavailableReason: "Something server-side." }), { online: false });
+  assert.equal(view.state, "offline");
+});

package/utils/camera-wall.ts

@@ -0,0 +1,299 @@
+/**
+ * THE CAMERA WALL'S RULES, WITH NO MARKUP IN THEM.
+ *
+ * `CameraWall.vue` draws the wall; this file decides what it is allowed to draw.
+ * Keeping the two apart is not tidiness — every rule below is one somebody can
+ * get wrong in a way nobody notices until a supervisor is looking at the wrong
+ * picture, so each one is stated once, here, and pinned by `camera-wall.test.ts`.
+ *
+ * ## The four rules
+ *
+ * 1. **Only `type: "ip"` cameras go on a wall.** An ANPR unit belongs to visitor
+ *    and vehicle management: it is pointed at a number plate, it is wired to a
+ *    barrier, and its record carries a real device address and a real credential.
+ *    Putting one on a monitoring wall is a defect, not a feature. The request
+ *    already asks the server for `type=ip`; `wallCameras()` filters again on the
+ *    way in, because "the caller passed the right query" is an assumption and
+ *    this is the rule.
+ * 2. **A capability we have not been told about is NOT available.** An absent or
+ *    malformed descriptor reads as `unknown`, and `unknown` counts as no — so a
+ *    browser talking to an older API cannot draw a control that would do nothing.
+ * 3. **A control that is off is drawn, dimmed, and says why** — never hidden. The
+ *    sentence shown is the SERVER'S own sentence, never rewritten here, so a
+ *    camera cannot explain itself two different ways on two screens.
+ * 4. **"Live" means a picture is arriving**, not "we asked for one". The tile
+ *    says `Connecting…` until the player page is actually up, and `No signal`
+ *    when it never comes.
+ *
+ * These match the iSecure365 mobile monitoring build one for one, deliberately:
+ * the same product should not answer the same question differently on a phone
+ * and on a laptop.
+ */
+
+/** One capability's answer, as the API returns it (core's `CameraCapabilityEntry`). */
+export type TWallCapability = {
+  state?: "supported" | "unsupported" | "unknown";
+  transport?: string | null;
+  reason?: string | null;
+  /** The server's own sentence. Displayed verbatim; never rewritten here. */
+  detail?: string | null;
+};
+
+/** A camera as the wall needs it. Extra fields on the record are ignored. */
+export type TWallCamera = {
+  _id: string;
+  name?: string;
+  /**
+   * The stored address. For a `type: "ip"` camera this is a complete, directly
+   * renderable live-video page — it is the picture, not a fragment to resolve.
+   */
+  host?: string;
+  type?: string;
+  status?: string;
+  capabilities?: Record<string, TWallCapability>;
+  /**
+   * The server's own sentence for why this camera cannot show a picture, or
+   * `null`/absent when it can. Answered from the record before anything is
+   * requested, so it costs no device traffic.
+   *
+   * **Preferred over anything worked out here.** The server knows things the
+   * browser cannot — that no recorder is configured for this camera's relay, for
+   * instance, which is the true answer for every camera until the API host is
+   * configured. Replacing it with our own wording hides that.
+   */
+  unavailableReason?: string | null;
+};
+
+/* -------------------------------------------------------------------------- */
+/* Layouts                                                                     */
+/* -------------------------------------------------------------------------- */
+
+/**
+ * The three wall sizes.
+ *
+ * Square only, and only three of them. A VMS layout picker exists so a
+ * supervisor can change what they are watching in one click; a list of eleven
+ * arrangements is a settings screen wearing a toolbar's clothes.
+ */
+export const WALL_LAYOUTS = [
+  { key: "1x1", columns: 1, tiles: 1, label: "Single" },
+  { key: "2x2", columns: 2, tiles: 4, label: "Four" },
+  { key: "3x3", columns: 3, tiles: 9, label: "Nine" },
+] as const;
+
+export type TWallLayoutKey = (typeof WALL_LAYOUTS)[number]["key"];
+
+/** Four tiles: enough to be a wall, small enough to still be readable. */
+export const DEFAULT_WALL_LAYOUT: TWallLayoutKey = "2x2";
+
+export function wallLayout(key: string | undefined) {
+  return WALL_LAYOUTS.find((l) => l.key === key) ?? WALL_LAYOUTS[1];
+}
+
+/**
+ * At three columns a tile is small enough that the chrome starts eating the
+ * picture, so the tile drops its status WORD and keeps the dot.
+ */
+export function isDenseLayout(key: string | undefined) {
+  return wallLayout(key).columns >= 3;
+}
+
+/* -------------------------------------------------------------------------- */
+/* Which cameras, and in what order                                            */
+/* -------------------------------------------------------------------------- */
+
+/** Rule 1. Only `type: "ip"`. See the note at the top of this file. */
+export function wallCameras(items: unknown): TWallCamera[] {
+  if (!Array.isArray(items)) return [];
+  return items.filter(
+    (c): c is TWallCamera => !!c && typeof c === "object" && (c as TWallCamera).type === "ip"
+  );
+}
+
+/**
+ * The tiles, in order, padded with `null` to the layout's size.
+ *
+ * An empty selection is **not** "no cameras" — it is "nobody has chosen yet",
+ * and the wall falls back to the site's own order. A supervisor who clears the
+ * picker gets their site back, not a black screen.
+ */
+export function wallTiles(
+  cameras: TWallCamera[],
+  selectedIds: string[] | undefined,
+  layoutKey: string | undefined
+): Array<TWallCamera | null> {
+  const { tiles } = wallLayout(layoutKey);
+  const byId = new Map(cameras.map((c) => [c._id, c]));
+  const chosen =
+    selectedIds && selectedIds.length
+      ? selectedIds.map((id) => byId.get(id)).filter((c): c is TWallCamera => !!c)
+      : cameras;
+
+  const out: Array<TWallCamera | null> = chosen.slice(0, tiles);
+  while (out.length < tiles) out.push(null);
+  return out;
+}
+
+/* -------------------------------------------------------------------------- */
+/* Capabilities                                                                */
+/* -------------------------------------------------------------------------- */
+
+/**
+ * The two words a switched-off control wears.
+ *
+ * Lifted unchanged from the mobile build, and the "yet" is the whole point: it
+ * is the difference between a feature that is broken and a feature that is
+ * waiting on something somebody has to switch on.
+ */
+export const CAPABILITY_TAGS = {
+  unsupported: "Not set up yet",
+  unknown: "Not checked yet",
+} as const;
+
+/**
+ * What a client with no descriptor at all should say. This is the server's own
+ * `device-not-probed` sentence, reused rather than reinvented, so an older API
+ * that sends no descriptor still explains itself in the product's own words.
+ */
+const NOT_PROBED = "This camera has not been asked what it can do yet.";
+
+/** The four capabilities the wall draws a control for, and their plain names. */
+export const WALL_CAPABILITY_CONTROLS = [
+  { key: "playback", title: "Recorded footage" },
+  { key: "events", title: "Events and alarms" },
+  { key: "ptz", title: "Move camera" },
+  { key: "presets", title: "Stored positions" },
+] as const;
+
+export type TCapabilityView = {
+  state: "supported" | "unsupported" | "unknown";
+  available: boolean;
+  /** `null` when the capability works — a working control needs no tag. */
+  tag: string | null;
+  /** The server's sentence, or the not-probed one. Never empty. */
+  detail: string;
+};
+
+/** Rule 2 and rule 3, in one place. */
+export function capabilityView(
+  camera: TWallCamera | null | undefined,
+  key: string
+): TCapabilityView {
+  const entry = camera?.capabilities?.[key];
+  const state =
+    entry?.state === "supported" || entry?.state === "unsupported"
+      ? entry.state
+      : "unknown";
+
+  return {
+    state,
+    available: state === "supported",
+    tag: state === "supported" ? null : CAPABILITY_TAGS[state],
+    detail: (entry?.detail || "").trim() || NOT_PROBED,
+  };
+}
+
+/* -------------------------------------------------------------------------- */
+/* Tile state                                                                  */
+/* -------------------------------------------------------------------------- */
+
+/**
+ * How long a player page may take to load before the tile stops claiming it is
+ * coming. Deliberately generous — lifted from the mobile build, where the
+ * argument is that reporting a working video service as dead is the worse of
+ * the two mistakes.
+ */
+export const LIVE_CONNECT_TIMEOUT_MS = 15_000;
+
+export type TTileState =
+  | "live"
+  | "connecting"
+  | "no-signal"
+  | "offline"
+  | "unavailable";
+
+/**
+ * The four words a tile may say about itself.
+ *
+ * `offline` and `no-signal` are two different facts and used to share one word:
+ * "Offline" on every tile at once means the BROWSER lost the network; "No
+ * signal" on one tile means that camera is not answering. A supervisor needs to
+ * know which of those they are looking at.
+ */
+export const TILE_LABELS = {
+  live: "Live",
+  connecting: "Connecting…",
+  "no-signal": "No signal",
+  offline: "No connection",
+  unavailable: "Not set up yet",
+} as const;
+
+/** What the browser knows about the embedded player page. */
+export type TPlayerState = "loading" | "ready" | "timeout";
+
+export type TTileView = {
+  state: TTileState;
+  label: string;
+  /** A sentence for the states that need explaining; `null` when live. */
+  detail: string | null;
+  /** Whether the player page may be embedded at all. */
+  showPlayer: boolean;
+};
+
+/**
+ * Rule 4, plus every reason a tile may have nothing to show.
+ *
+ * Order matters: the browser being offline beats everything (it explains every
+ * tile at once), then the record's own problems, then the server's verdict on
+ * live video, and only then what the embedded page is actually doing.
+ */
+export function tileView(
+  camera: TWallCamera | null | undefined,
+  opts: { online?: boolean; player?: TPlayerState } = {}
+): TTileView {
+  const online = opts.online !== false;
+  const dead = (state: TTileState, detail: string | null): TTileView => ({
+    state,
+    label: TILE_LABELS[state],
+    detail,
+    showPlayer: false,
+  });
+
+  if (!camera) return dead("unavailable", "No camera in this position.");
+  if (!online)
+    return dead("offline", "This browser has no internet connection.");
+  // The server's refusal wins over anything reconstructed here. It covers the
+  // same two cases below AND the ones only it can know — chiefly "no recorder is
+  // configured for this camera's relay", which is the honest answer for every
+  // camera until the API host is configured, and which used to be replaced by
+  // our own guess.
+  const reason = camera.unavailableReason?.trim();
+  if (reason) return dead("unavailable", reason);
+  if (camera.status && camera.status !== "active")
+    return dead("unavailable", "This camera is not active.");
+  if (!camera.host) return dead("unavailable", "This camera has no address configured.");
+
+  const live = capabilityView(camera, "liveVideo");
+  if (live.state === "unsupported") return dead("unavailable", live.detail);
+
+  const player = opts.player ?? "loading";
+  if (player === "timeout")
+    return {
+      state: "no-signal",
+      label: TILE_LABELS["no-signal"],
+      // Invented: only the browser can know the page never loaded, so the
+      // server has no reason code for it. Worded as a fact, not a diagnosis —
+      // we genuinely cannot tell a dead camera from a dead video service.
+      detail: "The live view did not load. The camera or the video service may be down.",
+      showPlayer: true,
+    };
+  if (player === "loading")
+    return {
+      state: "connecting",
+      label: TILE_LABELS.connecting,
+      detail: null,
+      showPlayer: true,
+    };
+
+  return { state: "live", label: TILE_LABELS.live, detail: null, showPlayer: true };
+}