@7365admin1/layer-common 3.2.7 → 3.2.8-staging.201

package/composables/useHidAmico.ts

@@ -6,6 +6,8 @@ type HidReaderPayload = {
   username?: string;
   password?: string;
   deviceId?: string;
+  portalId?: number;
+  portalName?: string;
   monitorPath?: string;
   enabled?: boolean;
   status?: string;
@@ -28,6 +30,83 @@ type HidIdentityPayload = {
   metadata?: Record<string, any>;
 };
 
+type HidVisitorQrData = {
+  visitorId: string;
+  readerId: string;
+  hidUserId: number;
+  qrValue: string;
+  qrFormat: "0";
+  portalId: number;
+  portalName: string;
+  readerName: string;
+  issuedAt: string;
+  expiresAt: string;
+};
+
+type HidVisitorQrResponse = HidVisitorQrData | { data: HidVisitorQrData };
+
+type HidPermissionListResponse = {
+  items: THidPermissionCandidate[];
+  page: number;
+  pages: number;
+  pageRange: string;
+  limit: number;
+};
+
+type HidFacialEnrollmentResult = {
+  user_id?: number;
+  success?: boolean;
+  scores?: Record<string, unknown>;
+  errors?: Array<{ code?: number; message?: string }>;
+};
+
+export type HidPhysicalCardType = "pacs" | "csn";
+
+export type HidPhysicalCard = {
+  id: string;
+  value: string;
+  userId: number;
+  cardType: HidPhysicalCardType | "unknown";
+  facilityCode?: number;
+  cardNumber?: number;
+  source?: "manual" | "reader" | "device";
+  enrolledAt?: string;
+};
+
+type HidPhysicalCardInput =
+  | { cardType: "pacs"; facilityCode: number; cardNumber: number }
+  | { cardType: "csn"; cardValue: string };
+
+export type HidSipAccountData = {
+  orgId: string;
+  site: string;
+  userId: string;
+  extension: string;
+  username: string;
+  password: string;
+  sipAddress: string;
+  websocketUrl: string;
+  status: "active";
+  provisionedAt: string;
+};
+
+/**
+ * True only for the specific validation error an API that predates core #1878
+ * returns when the discover body carries `site`. Deliberately narrow: after
+ * #1878 `site` is required, so this message can no longer be produced and the
+ * fallback below can never hide a real authorization refusal.
+ */
+export function isUnknownSiteFieldError(error: unknown): boolean {
+  const record = typeof error === "object" && error !== null
+    ? error as Record<string, unknown>
+    : {};
+  const data = typeof record.data === "object" && record.data !== null
+    ? record.data as Record<string, unknown>
+    : {};
+  const message = String(data.message || record.message || "");
+  return message.includes("\"site\"") && message.includes("not allowed");
+}
+
 export default function useHidAmico() {
   const basePath = "/api/access-management/hid";
 
@@ -78,6 +157,16 @@ export default function useHidAmico() {
     });
   }
 
+  function issueVisitorQr(
+    readerId: string,
+    payload: { visitorId: string; validityMinutes: number },
+  ) {
+    return useNuxtApp().$api<HidVisitorQrResponse>(`${basePath}/readers/${readerId}/visitor-qr`, {
+      method: "POST",
+      body: payload,
+    });
+  }
+
   function getReaderConfiguration(readerId: string, payload: Record<string, string[]> = {}) {
     return useNuxtApp().$api<Record<string, any>>(`${basePath}/readers/${readerId}/configuration`, {
       method: "POST",
@@ -112,6 +201,127 @@ 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 getUserCards(readerId: string, hidUserId: string | number) {
+    return useNuxtApp().$api<{
+      data: { readerId: string; hidUserId: number; cards: HidPhysicalCard[] };
+    }>(`${basePath}/readers/${readerId}/users/${hidUserId}/cards`, {
+      method: "GET",
+    });
+  }
+
+  function assignUserCard(
+    readerId: string,
+    hidUserId: string | number,
+    payload: HidPhysicalCardInput,
+  ) {
+    return useNuxtApp().$api<{ data: { card: HidPhysicalCard; verified: boolean } }>(
+      `${basePath}/readers/${readerId}/users/${hidUserId}/cards`,
+      { method: "POST", body: payload },
+    );
+  }
+
+  function enrollUserCard(
+    readerId: string,
+    hidUserId: string | number,
+    cardType: HidPhysicalCardType,
+    timeoutSeconds = 30,
+  ) {
+    return useNuxtApp().$api<{ data: { card: HidPhysicalCard; verified: boolean } }>(
+      `${basePath}/readers/${readerId}/users/${hidUserId}/cards/enroll`,
+      { method: "POST", body: { cardType, timeoutSeconds } },
+    );
+  }
+
+  function cancelUserCardEnrollment(readerId: string) {
+    return useNuxtApp().$api<{ data: { cancelled: boolean } }>(
+      `${basePath}/readers/${readerId}/cards/enrollment/cancel`,
+      { method: "POST" },
+    );
+  }
+
+  function deleteUserCard(
+    readerId: string,
+    hidUserId: string | number,
+    cardId: string | number,
+  ) {
+    return useNuxtApp().$api<{ data: { deleted: boolean } }>(
+      `${basePath}/readers/${readerId}/users/${hidUserId}/cards/${cardId}`,
+      { method: "DELETE" },
+    );
+  }
+
+  async function discoverReader(
+    payload: Pick<HidReaderPayload, "baseUrl" | "username" | "password" | "site">,
+  ) {
+    const post = (body: Record<string, unknown>) =>
+      useNuxtApp().$api<Record<string, unknown>>(`${basePath}/readers/discover`, {
+        method: "POST",
+        body,
+      });
+
+    try {
+      return await post(payload as Record<string, unknown>);
+    } catch (error: unknown) {
+      // The discover endpoint only started accepting (and requiring) `site` in
+      // core #1878. An API that predates it validates the body with Joi's
+      // default allowUnknown:false and answers `"site" is not allowed`, so the
+      // web layer would break the moment it shipped ahead of the API. Retry once
+      // without `site` so both API versions work.
+      // ponytail: remove this fallback once core #1878 is deployed everywhere.
+      if (!isUnknownSiteFieldError(error)) throw error;
+      const { site: _site, ...legacy } = payload;
+      return await post(legacy as Record<string, unknown>);
+    }
+  }
+
+  function getUserPinStatus(readerId: string, hidUserId: string | number) {
+    return useNuxtApp().$api<{ data: { pinEnrolled: boolean } }>(
+      `${basePath}/readers/${readerId}/users/${hidUserId}/pin`,
+      { method: "GET" },
+    );
+  }
+
+  function setUserPin(readerId: string, hidUserId: string | number, pin: string) {
+    return useNuxtApp().$api<{ data: { pinEnrolled: boolean } }>(
+      `${basePath}/readers/${readerId}/users/${hidUserId}/pin`,
+      { method: "PUT", body: { pin } },
+    );
+  }
+
+  function deleteUserPin(readerId: string, hidUserId: string | number) {
+    return useNuxtApp().$api<{ data: { pinEnrolled: boolean } }>(
+      `${basePath}/readers/${readerId}/users/${hidUserId}/pin`,
+      { method: "DELETE" },
+    );
+  }
+
   function createIdentity(readerId: string, payload: HidIdentityPayload) {
     return useNuxtApp().$api<Record<string, any>>(`${basePath}/readers/${readerId}/identities`, {
       method: "POST",
@@ -151,18 +361,73 @@ export default function useHidAmico() {
     });
   }
 
+  function getSitePermissions(siteId: string, orgId: string, readerId: string) {
+    return useNuxtApp().$api<{ data: THidSitePermissions }>(
+      `${basePath}/sites/${siteId}/permissions`,
+      { 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;
+      limit?: number;
+    },
+  ) {
+    return useNuxtApp().$api<HidPermissionListResponse>(
+      `${basePath}/sites/${siteId}/permission-candidates`,
+      { method: "GET", query },
+    );
+  }
+
+  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: { orgId, readerId, assignments } },
+    );
+  }
+
   return {
     getReaders,
+    discoverReader,
     createReader,
     updateReader,
     deleteReader,
     testReader,
     syncReader,
     runObjectOperation,
+    issueVisitorQr,
     getReaderConfiguration,
     setReaderConfiguration,
     getLogs,
     getUserImage,
+    setUserImage,
+    deleteUserImage,
+    getUserCards,
+    assignUserCard,
+    enrollUserCard,
+    cancelUserCardEnrollment,
+    deleteUserCard,
+    getUserPinStatus,
+    setUserPin,
+    deleteUserPin,
     getIdentities,
     createIdentity,
     updateIdentity,
@@ -170,5 +435,9 @@ export default function useHidAmico() {
     getIntercomStatus,
     makeIntercomCall,
     finalizeIntercomCall,
+    ensureSipAccount,
+    getSitePermissions,
+    getPermissionCandidates,
+    updateSitePermissions,
   };
 }

package/composables/useHidNavigation.ts

@@ -28,9 +28,9 @@ export default function useHidNavigation() {
           },
         },
         {
-          title: "Administrator",
+          title: "HID Cards",
           route: {
-            name: "org-site-access-mgmt-administrator",
+            name: "org-site-access-mgmt-hid-cards",
             params: { org, site },
           },
         },
@@ -41,13 +41,6 @@ export default function useHidNavigation() {
             params: { org, site },
           },
         },
-        {
-          title: "Identity Mapping",
-          route: {
-            name: "org-site-access-mgmt-identity-mapping",
-            params: { org, site },
-          },
-        },
         {
           title: "Access Logs",
           route: {

package/composables/useMember.ts

@@ -1,8 +1,8 @@
 export default function useMember() {
   const members = useState<Array<TMember>>("members", () => []);
-  const page = useState("page", () => 1);
-  const pages = useState("pages", () => 0);
-  const pageRange = useState("pageRange", () => "-- - -- of --");
+  const page = useState("memberPage", () => 1);
+  const pages = useState("memberPages", () => 0);
+  const pageRange = useState("memberPageRange", () => "-- - -- of --");
 
   const member = useState<TMember>("member", () => ({
     _id: "",

package/composables/useNFCPatrolDailyReport.ts

@@ -52,16 +52,24 @@ export function useNFCPatrolDailyReport(
   const report = ref<NFCPatrolSummaryReport | null>(null);
   const loading = ref(false);
   const notFound = ref(false);
+  /**
+   * A request that FAILED is not a route with no patrols. Without this the
+   * screen answered a 500 with "No patrol log found for this route", which is
+   * a statement about the data the server never made.
+   */
+  const failed = ref(false);
 
   async function fetchReport() {
     if (!site || !filters.date || !filters.route) {
       report.value = null;
       notFound.value = false;
+      failed.value = false;
       return;
     }
 
     loading.value = true;
     notFound.value = false;
+    failed.value = false;
 
     try {
       const [logsRes, siteInfo] = await Promise.all([
@@ -92,6 +100,10 @@ export function useNFCPatrolDailyReport(
         report.value = null;
         notFound.value = true;
       }
+    } catch {
+      report.value = null;
+      notFound.value = false;
+      failed.value = true;
     } finally {
       loading.value = false;
     }
@@ -101,6 +113,7 @@ export function useNFCPatrolDailyReport(
     report,
     loading,
     notFound,
+    failed,
     fetchReport,
   };
 }

package/composables/useNFCPatrolMonthlyReport.ts

@@ -2,11 +2,11 @@ import type {
   NFCPatrolReportFilters,
   NFCPatrolSummaryReport,
   NFCPatrolReportSummaryRow,
-  NFCPatrolMonthlyReportRow,
   NFCPatrolMonthlyReport,
 } from "../types/nfc-patrol-report";
 import useNFCPatrolLog from "./useNFCPatrolLog";
 import useSite from "./useSite";
+import { collectAllPages, mapLogsToMonthlyRows } from "../utils/nfc-patrol-report";
 
 interface NFCPatrolLogListResponse {
   items?: Record<string, any>[];
@@ -14,55 +14,6 @@ interface NFCPatrolLogListResponse {
   pageRange?: string;
 }
 
-const MONTHS = [
-  "January",
-  "February",
-  "March",
-  "April",
-  "May",
-  "June",
-  "July",
-  "August",
-  "September",
-  "October",
-  "November",
-  "December",
-];
-function mapLogsToMonthlyRows(
-  logs: Record<string, any>[],
-): NFCPatrolMonthlyReportRow[] {
-  const rows = MONTHS.map((month) => ({
-    month,
-    checked: 0,
-    checkedPercentage: 0,
-    missed: 0,
-    missedPercentage: 0,
-  }));
-
-  logs.forEach((log) => {
-    const monthIndex = new Date(log.date).getMonth();
-
-    for (const checkpoint of log.checkPoints ?? []) {
-      if (checkpoint.status === "Completed") {
-        rows[monthIndex].checked++;
-      } else if (checkpoint.status === "Skipped") {
-        rows[monthIndex].missed++;
-      }
-    }
-  });
-
-  rows.forEach((row) => {
-    const total = row.checked + row.missed;
-
-    if (total > 0) {
-      row.checkedPercentage = Math.round((row.checked / total) * 100);
-      row.missedPercentage = Math.round((row.missed / total) * 100);
-    }
-  });
-
-  return rows;
-}
-
 function buildAddress(address?: Record<string, string>) {
   if (!address) return undefined;
 
@@ -90,32 +41,42 @@ export function useNFCPatrolMonthlyReport(
   const report = ref<NFCPatrolMonthlyReport | null>(null);
   const loading = ref(false);
   const notFound = ref(false);
+  /**
+   * A request that FAILED is not a route with no patrols. Without this the
+   * screen answered a 500 with "No patrol log found for this route", which is
+   * a statement about the data the server never made.
+   */
+  const failed = ref(false);
 
   async function fetchReport() {
     if (!site || !filters.route) {
       report.value = null;
       notFound.value = false;
+      failed.value = false;
       return;
     }
 
     loading.value = true;
     notFound.value = false;
+    failed.value = false;
     const currentYear = new Date().getFullYear().toString();
     try {
-      const [logsRes, siteInfo] = await Promise.all([
-        getPatrolLogs({
-            page: 1,
+      // The whole year, not page one of it. `collectAllPages` reads the page
+      // count out of the first reply and walks the rest.
+      const [logs, siteInfo] = await Promise.all([
+        collectAllPages((page) =>
+          getPatrolLogs({
+            page,
             limit: 100,
             site,
             routeId: filters.route,
             date: currentYear,
             type: "month",
-        }),
+          }),
+        ),
         getSiteById(site),
       ]);
 
-      const logs = logsRes.items ?? [];
-
       if (logs.length) {
         const routeName = logs[0]?.route?.name ?? "-";
 
@@ -131,6 +92,10 @@ export function useNFCPatrolMonthlyReport(
         report.value = null;
         notFound.value = true;
       }
+    } catch {
+      report.value = null;
+      notFound.value = false;
+      failed.value = true;
     } finally {
       loading.value = false;
     }
@@ -140,6 +105,7 @@ export function useNFCPatrolMonthlyReport(
     report,
     loading,
     notFound,
+    failed,
     fetchReport,
   };
 }

package/composables/useNFCPatrolReport.ts

@@ -91,6 +91,12 @@ export function useNFCPatrolReport(
   const report = ref<NFCPatrolReport | null>(null);
   const loading = ref(false);
   const notFound = ref(false);
+  /**
+   * A request that FAILED is not a route with no patrols. Without this the
+   * screen answered a 500 with "No patrol log found for this route", which is
+   * a statement about the data the server never made.
+   */
+  const failed = ref(false);
   const selectedActivityRemarks = ref("");
   const dialogRemarks = ref(false);
 
@@ -98,11 +104,13 @@ export function useNFCPatrolReport(
     if (!site || !filters.date || !filters.route || !filters.timeRange) {
       report.value = null;
       notFound.value = false;
+      failed.value = false;
       return;
     }
 
     loading.value = true;
     notFound.value = false;
+    failed.value = false;
 
     try {
       const [logsRes, siteInfo] = await Promise.all([
@@ -128,6 +136,10 @@ export function useNFCPatrolReport(
         report.value = null;
         notFound.value = true;
       }
+    } catch {
+      report.value = null;
+      notFound.value = false;
+      failed.value = true;
     } finally {
       loading.value = false;
     }
@@ -165,6 +177,7 @@ export function useNFCPatrolReport(
     report,
     loading,
     notFound,
+    failed,
     selectedActivityRemarks,
     dialogRemarks,
     fetchReport,

package/composables/useNotificationPreference.ts

@@ -0,0 +1,87 @@
+/**
+ * A person's own notification settings.
+ *
+ * The server decides everything that matters here: which categories this person
+ * is offered, which channels each one can actually reach them on, and what the
+ * words are. Nothing on this side maintains a second list — a screen that made
+ * up its own module names is how the previous version came to show three
+ * switches that governed nothing.
+ *
+ * There is no user id in either call. Whose settings these are comes from the
+ * session, so a person can only ever see and change their own.
+ */
+
+export type TNotificationChannelSetting = {
+  key: string;
+  label: string;
+  /** false = this category cannot reach them this way; drawn, dimmed, explained */
+  supported: boolean;
+  /** the plain-English reason, present only when unsupported */
+  note?: string;
+  enabled: boolean;
+};
+
+export type TNotificationCategorySetting = {
+  key: string;
+  label: string;
+  description: string;
+  safety: boolean;
+  channels: TNotificationChannelSetting[];
+};
+
+export type TNotificationPreferences = {
+  channels: Array<{ key: string; label: string }>;
+  categories: TNotificationCategorySetting[];
+};
+
+const EMPTY: TNotificationPreferences = { channels: [], categories: [] };
+
+export default function useNotificationPreference() {
+  function getPreferences() {
+    return useNuxtApp().$api<{ data: TNotificationPreferences }>(
+      "/api/notification-preferences",
+      { method: "GET" },
+    );
+  }
+
+  /**
+   * Save the whole screen at once.
+   *
+   * What is sent is the list of switches that are OFF, which is also how the
+   * server stores it: somebody who has changed nothing has no stored row at
+   * all, and behaves exactly as they did before this screen existed.
+   */
+  function savePreferences(preferences: TNotificationPreferences) {
+    const off = preferences.categories.flatMap((category) =>
+      category.channels
+        .filter((channel) => channel.supported && !channel.enabled)
+        .map((channel) => ({ category: category.key, channel: channel.key })),
+    );
+
+    return useNuxtApp().$api<{ data: TNotificationPreferences }>(
+      "/api/notification-preferences",
+      { method: "PUT", body: { off } },
+    );
+  }
+
+  return { getPreferences, savePreferences, EMPTY_PREFERENCES: EMPTY };
+}
+
+/**
+ * The sentence shown when somebody switches a safety or security alert off.
+ *
+ * It says what will stop arriving and how to undo it, and it does not argue —
+ * the owner's decision is that these can be switched off, so the job here is to
+ * make sure nobody does it by accident, not to talk them out of it.
+ */
+export function safetyOffConfirmation(categoryLabel: string, channelLabel: string) {
+  return {
+    title: `Turn off ${categoryLabel}?`,
+    body:
+      `You will stop getting ${categoryLabel.toLowerCase()} alerts under "${channelLabel}". ` +
+      `These are safety and security alerts, so they are on for everyone by default. ` +
+      `You can turn them back on here at any time.`,
+    confirm: "Turn it off",
+    cancel: "Keep it on",
+  };
+}

package/composables/useOnlineFormPages.ts

@@ -20,6 +20,8 @@ export type FormBlock =
   | { type: "checkbox-group"; title?: string; single?: boolean; items: CheckboxItemDef[] }
   | { type: "paragraph"; text: string }
   | { type: "section-header"; text: string }
+  | { type: "ordered-list"; title?: string; items: string[] }
+  | { type: "unordered-list"; title?: string; items: string[] }
   | { type: "divider" }
   | { type: "signature-row"; label: string; key: string }
   | { type: "acknowledgement"; text: string }