@7365admin1/layer-common 3.1.4-staging.55 → 3.1.4-staging.57

package/composables/useHidAmico.ts

@@ -48,6 +48,26 @@ type HidPermissionListResponse = {
   limit: number;
 };
 
+type HidFacialEnrollmentResult = {
+  user_id?: number;
+  success?: boolean;
+  scores?: Record<string, unknown>;
+  errors?: Array<{ code?: number; message?: string }>;
+};
+
+export type HidSipAccountData = {
+  orgId: string;
+  site: string;
+  userId: string;
+  extension: string;
+  username: string;
+  password: string;
+  sipAddress: string;
+  websocketUrl: string;
+  status: "active";
+  provisionedAt: string;
+};
+
 export default function useHidAmico() {
   const basePath = "/api/access-management/hid";
 
@@ -142,6 +162,33 @@ export default function useHidAmico() {
     });
   }
 
+  function setUserImage(
+    readerId: string,
+    hidUserId: string | number,
+    image: Blob,
+    options: { timestamp?: number; match?: boolean } = {},
+  ) {
+    return useNuxtApp().$api<{ data: HidFacialEnrollmentResult }>(
+      `${basePath}/readers/${readerId}/users/${hidUserId}/image`,
+      {
+        method: "PUT",
+        query: {
+          ...(options.timestamp ? { timestamp: options.timestamp } : {}),
+          match: options.match ?? true,
+        },
+        headers: { "Content-Type": "application/octet-stream" },
+        body: image,
+      },
+    );
+  }
+
+  function deleteUserImage(readerId: string, hidUserId: string | number) {
+    return useNuxtApp().$api<Record<string, unknown>>(
+      `${basePath}/readers/${readerId}/users/${hidUserId}/image`,
+      { method: "DELETE" },
+    );
+  }
+
   function createIdentity(readerId: string, payload: HidIdentityPayload) {
     return useNuxtApp().$api<Record<string, any>>(`${basePath}/readers/${readerId}/identities`, {
       method: "POST",
@@ -181,16 +228,25 @@ export default function useHidAmico() {
     });
   }
 
-  function getSitePermissions(siteId: string) {
+  function getSitePermissions(siteId: string, orgId: string, readerId: string) {
     return useNuxtApp().$api<{ data: THidSitePermissions }>(
       `${basePath}/sites/${siteId}/permissions`,
-      { method: "GET" },
+      { method: "GET", query: { orgId, readerId } },
+    );
+  }
+
+  function ensureSipAccount(siteId: string, orgId: string) {
+    return useNuxtApp().$api<{ data: HidSipAccountData }>(
+      `${basePath}/sites/${siteId}/intercom/sip-account`,
+      { method: "POST", body: { orgId } },
     );
   }
 
   function getPermissionCandidates(
     siteId: string,
     query: {
+      orgId: string;
+      readerId: string;
       category: THidPermissionCategory | "intercom";
       search?: string;
       page?: number;
@@ -205,11 +261,13 @@ export default function useHidAmico() {
 
   function updateSitePermissions(
     siteId: string,
+    orgId: string,
+    readerId: string,
     assignments: Array<Pick<THidPermissionAssignment, "subjectId" | "category" | "intercom">>,
   ) {
     return useNuxtApp().$api<{ data: THidSitePermissions; message: string }>(
       `${basePath}/sites/${siteId}/permissions`,
-      { method: "PUT", body: { assignments } },
+      { method: "PUT", body: { orgId, readerId, assignments } },
     );
   }
 
@@ -226,6 +284,8 @@ export default function useHidAmico() {
     setReaderConfiguration,
     getLogs,
     getUserImage,
+    setUserImage,
+    deleteUserImage,
     getIdentities,
     createIdentity,
     updateIdentity,
@@ -233,6 +293,7 @@ export default function useHidAmico() {
     getIntercomStatus,
     makeIntercomCall,
     finalizeIntercomCall,
+    ensureSipAccount,
     getSitePermissions,
     getPermissionCandidates,
     updateSitePermissions,

package/composables/useSiteSettings.ts

@@ -99,6 +99,33 @@ export default function () {
     });
   }
 
+  /**
+   * The monitoring wall for one site.
+   *
+   * A different endpoint from `getAllSiteCameras`, and the difference is the
+   * point. That one is the Settings panel's paginated CRUD list; this one is
+   * purpose-built for a wall and is what the React Native app already uses:
+   *
+   * - it is **site-scoped and authorised server-side** — the caller must be a
+   *   member of the site, of its owning organisation, or work for an
+   *   organisation engaged to serve it;
+   * - it returns `type: "ip"` cameras only, so an ANPR unit can never land on a
+   *   monitoring wall;
+   * - it returns each camera's **capability descriptor** and the server's own
+   *   `unavailableReason`, so a tile explains itself instead of showing a black
+   *   rectangle;
+   * - it never returns a credential, and it contacts no device.
+   *
+   * Unpaginated by design: a wall shows a site's cameras, and paging them was
+   * an artefact of borrowing the CRUD list.
+   */
+  async function getSiteWall(siteId: string) {
+    return await useNuxtApp().$api<Record<string, any>>(
+      `/api/site-cameras/site/${siteId}/wall`,
+      { method: "GET" }
+    );
+  }
+
   async function updateSiteInformation(
     siteId: string,
     payload: { bgImage: string; description: string; docs: { id: string; name: string }[] }
@@ -175,6 +202,7 @@ export default function () {
     updateSite,
     addCamera,
     getAllSiteCameras,
+    getSiteWall,
     setSiteGuardPosts,
     updateSiteCamera,
     deleteSiteCameraById,

package/package.json

@@ -2,7 +2,7 @@
   "name": "@7365admin1/layer-common",
   "license": "MIT",
   "type": "module",
-  "version": "3.1.4-staging.55",
+  "version": "3.1.4-staging.57",
   "author": "7365admin1",
   "main": "./nuxt.config.ts",
   "publishConfig": {

package/pages/[org]/[site]/access-mgmt/intercom/index.vue

@@ -5,7 +5,7 @@
       :org="orgId"
       message="Enable HID as a service for this site before configuring HID intercom."
     >
-      <HidIntercomManagement :site="siteId" />
+      <HidIntercomManagement :site="siteId" :org="orgId" />
     </HidEnabledGate>
   </v-container>
 </template>

package/types/site.d.ts

@@ -13,10 +13,16 @@ declare type THidPermissionAssignment = {
   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;

package/utils/camera-wall.test.ts

@@ -119,3 +119,31 @@ test("a server that says live video is unsupported is believed", () => {
   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

@@ -51,6 +51,17 @@ export type TWallCamera = {
   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;
 };
 
 /* -------------------------------------------------------------------------- */
@@ -251,6 +262,13 @@ export function tileView(
   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.");

package/middleware/member.ts

@@ -1,4 +0,0 @@
-export default defineNuxtRouteMiddleware(() => {
-  if (import.meta.server) return;
-  const adminMember = useCookie("admin-member").value ?? "";
-});