@7365admin1/layer-common 4.97.0 → 4.97.1-staging.500

package/components/HidReaderManagement.vue

@@ -87,6 +87,8 @@
 
           <v-list density="compact" min-width="180">
             <v-list-item title="View" @click="openView(item)" />
+            <v-list-item title="Access Permissions" @click="openPermissions(item)" />
+            <v-list-item title="Identification Methods" @click="openIdentification(item)" />
             <v-list-item title="Sync HID Reader" @click="openSyncConfirm(item)" />
             <v-list-item title="Test Connection" @click="openTestConfirm(item)" />
             <v-list-item title="Edit" @click="openEdit(item)" />
@@ -144,6 +146,125 @@
       </v-card>
     </v-dialog>
 
+    <!--
+      IDENTIFICATION METHODS - what this reader accepts at the door.
+
+      Per reader, not per site: the device's own `identifier` module is the
+      authority, and a site-wide copy could only ever describe one of them.
+
+      There is deliberately no Bluetooth control. The HID API has no Bluetooth
+      identification field; the old site-level toggle of that name referred to
+      the phone-as-a-card feature in the mobile app, which is a different thing.
+    -->
+    <v-dialog v-model="identificationDialog" max-width="430" persistent>
+      <v-card rounded="lg">
+        <v-card-title class="screen-card-title">Identification Methods</v-card-title>
+
+        <v-card-text v-if="identificationStage === 'edit'">
+          <p class="identification-lead">
+            Credentials {{ selectedReader?.name || "this HID Reader" }} will accept at the door.
+          </p>
+
+          <div class="identification-grid">
+            <div
+              v-for="method in identificationMethodRows"
+              :key="method.key"
+              class="identification-row"
+            >
+              <div class="identification-copy">
+                <span>{{ method.label }}</span>
+                <small v-if="!method.supported">Not supported by this reader</small>
+              </div>
+              <v-switch
+                v-model="identificationForm[method.key]"
+                class="app-switch"
+                hide-details
+                density="compact"
+                :disabled="!method.supported || identificationSaving"
+              />
+            </div>
+          </div>
+
+          <!--
+            One reader setting with two modes, not two switches:
+            `pin_identification_enabled` is 1 for PIN and 0 for ID-and-password.
+            A reader without the PIN capability can be given neither.
+          -->
+          <div class="identification-credential">
+            <div class="identification-copy">
+              <span>Credential entry</span>
+              <small v-if="!credentialModeSupported">Not supported by this reader</small>
+            </div>
+            <v-radio-group
+              v-model="identificationForm.credentialMode"
+              hide-details
+              density="compact"
+              :disabled="!credentialModeSupported || identificationSaving"
+            >
+              <v-radio label="PIN" value="pin" />
+              <v-radio label="ID and password" value="idPassword" />
+            </v-radio-group>
+          </div>
+
+          <p class="identification-applied">
+            Confirmed on the reader:
+            <strong>{{ formatDate(selectedReader?.identificationMethodsAppliedAt) }}</strong>
+          </p>
+
+          <!--
+            Its own action, not a save. A reader's settings can change without
+            us — a firmware update, its own touchscreen, a restore, a reset —
+            and saving only writes what is on screen. This reads the device
+            first and reports what had moved.
+          -->
+          <div class="dialog-actions-inline">
+            <AppButton
+              variant="ghost"
+              icon="mdi-sync"
+              :disabled="identificationReconciling || identificationSaving || !selectedReader?.identificationMethods"
+              @click="reapplyIdentificationMethods"
+            >
+              {{ identificationReconciling ? "Checking reader..." : "Re-apply settings" }}
+            </AppButton>
+          </div>
+        </v-card-text>
+
+        <v-card-text v-else class="reader-action-content">
+          <v-icon icon="mdi-shield-key-outline" class="dialog-mark" size="48" />
+          <h3>Change what opens this door?</h3>
+          <p>
+            You are about to change the credentials {{ selectedReader?.name || "this HID Reader" }}
+            accepts.
+          </p>
+          <p v-if="identificationBeingDisabled.length" class="identification-warning">
+            Turning off: <strong>{{ identificationBeingDisabled.join(", ") }}</strong>.
+            Anyone relying on that credential will stop getting in at this reader.
+          </p>
+        </v-card-text>
+
+        <v-card-actions>
+          <v-spacer />
+          <AppButton
+            variant="ghost"
+            :disabled="identificationSaving || identificationReconciling"
+            @click="identificationStage === 'confirm' ? (identificationStage = 'edit') : (identificationDialog = false)"
+          >
+            {{ identificationStage === "confirm" ? "Back" : "Cancel" }}
+          </AppButton>
+          <AppButton
+            v-if="identificationStage === 'edit'"
+            :disabled="!identificationChanged || identificationReconciling"
+            @click="identificationStage = 'confirm'"
+          >
+            Save
+          </AppButton>
+          <AppButton v-else :disabled="identificationSaving" @click="saveIdentificationMethods">
+            {{ identificationSaving ? "Applying..." : "Apply to reader" }}
+          </AppButton>
+        </v-card-actions>
+      </v-card>
+    </v-dialog>
+
     <v-dialog v-model="confirmDialog" max-width="390" persistent>
       <v-card rounded="lg" class="reader-action-dialog">
         <v-card-title class="screen-card-title">{{ confirmTitle }}</v-card-title>
@@ -241,6 +362,18 @@
         </v-card-actions>
       </v-card>
     </v-dialog>
+
+    <!-- Who may actually pass this reader. Enrolment makes a person
+         RECOGNISABLE; this is what puts them in the group the access rule is
+         attached to, and without it a recognised person is refused at the
+         door. Reloads the list on save so the reader's own counts stay true. -->
+    <HidAccessPermissions
+      v-model="permissionsDialog"
+      :site="props.site"
+      :org="props.org"
+      :reader="selectedReader"
+      @saved="loadReaders"
+    />
   </section>
 </template>
 
@@ -284,6 +417,21 @@ type HidRecord = {
   cardReadingMode?: "unconfigured" | "pacs" | "csn" | "csn_for_mifare";
   csnByteOrder?: "msb" | "lsb";
   pacsFormat?: "raw" | "wiegand";
+  capabilities?: {
+    card?: boolean;
+    facial?: boolean;
+    qr?: boolean;
+    pin?: boolean;
+    intercom?: boolean;
+  };
+  identificationMethods?: {
+    facial?: boolean;
+    card?: boolean;
+    qrCode?: boolean;
+    credentialMode?: "pin" | "idPassword";
+  };
+  /** When the READER confirmed the methods, not when they were saved here. */
+  identificationMethodsAppliedAt?: string;
 };
 
 type HidReaderFormPayload = {
@@ -322,6 +470,13 @@ const props = defineProps({
     type: String,
     required: true,
   },
+  // The permission endpoints are org-scoped (`assertOrganizationSiteAccess`),
+  // and this component previously had no reason to know the org. Passed from
+  // the page, as `HidQrCodeConfiguration` already does.
+  org: {
+    type: String,
+    required: true,
+  },
 });
 
 const {
@@ -333,6 +488,8 @@ const {
   configureReaderIntegration,
   setReaderMonitor,
   setReaderOperatingMode,
+  setReaderIdentificationMethods,
+  reconcileReaderIdentificationMethods,
   getReaderUsers,
 } = useHidAmico();
 
@@ -347,6 +504,20 @@ const viewDialog = ref(false);
 const confirmDialog = ref(false);
 const resultDialog = ref(false);
 const selectedReader = ref<HidRecord | null>(null);
+const permissionsDialog = ref(false);
+const identificationDialog = ref(false);
+/* Two stages in one dialog, like the sync flow: the controls, then the
+   confirmation. Switching a credential off decides what stops opening a door,
+   so it is never one click away. */
+const identificationStage = ref<"edit" | "confirm">("edit");
+const identificationSaving = ref(false);
+const identificationReconciling = ref(false);
+const identificationForm = ref<{
+  facial: boolean;
+  card: boolean;
+  qrCode: boolean;
+  credentialMode: "pin" | "idPassword";
+}>({ facial: false, card: false, qrCode: false, credentialMode: "idPassword" });
 const pendingAction = ref<"test" | "sync" | "delete" | null>(null);
 const actionStage = ref<"confirm" | "review" | "loading">("confirm");
 const resultSuccess = ref(true);
@@ -484,6 +655,182 @@ function openView(reader: HidRecord) {
   viewDialog.value = true;
 }
 
+function openPermissions(reader: HidRecord) {
+  selectedReader.value = reader;
+  permissionsDialog.value = true;
+}
+
+/*
+ * The reader record is the source of truth, including for what is already on.
+ * A missing `identificationMethods` means nothing has been applied through this
+ * screen yet; the switches start off rather than guessing at the device.
+ */
+function openIdentification(reader: HidRecord) {
+  selectedReader.value = reader;
+  const current = reader.identificationMethods || {};
+  identificationForm.value = {
+    facial: current.facial === true,
+    card: current.card === true,
+    qrCode: current.qrCode === true,
+    credentialMode: current.credentialMode === "pin" ? "pin" : "idPassword",
+  };
+  identificationStage.value = "edit";
+  identificationDialog.value = true;
+}
+
+/*
+ * A reader saved before capabilities were recorded has none. Those are treated
+ * as capable rather than having every control disabled on an older record —
+ * the backend gate makes the same allowance, and it is the one that decides.
+ */
+function readerSupports(key: "facial" | "card" | "qr" | "pin") {
+  const capabilities = selectedReader.value?.capabilities;
+  if (!capabilities) return true;
+  return capabilities[key] === true;
+}
+
+const identificationMethodRows = computed(() => [
+  { key: "facial" as const, label: "Facial", supported: readerSupports("facial") },
+  { key: "card" as const, label: "Card", supported: readerSupports("card") },
+  { key: "qrCode" as const, label: "QR code", supported: readerSupports("qr") },
+]);
+
+/* Both modes ride the reader's single PIN switch, so the pair stands or falls
+   together on that one capability. */
+const credentialModeSupported = computed(() => readerSupports("pin"));
+
+const identificationChanged = computed(() => {
+  const current = selectedReader.value?.identificationMethods || {};
+  const form = identificationForm.value;
+  return (
+    form.facial !== (current.facial === true)
+    || form.card !== (current.card === true)
+    || form.qrCode !== (current.qrCode === true)
+    || form.credentialMode !== (current.credentialMode === "pin" ? "pin" : "idPassword")
+  );
+});
+
+/* Named in the confirmation, because switching a credential OFF is the change
+   that locks somebody out. */
+const identificationBeingDisabled = computed(() => {
+  const current = selectedReader.value?.identificationMethods || {};
+  const form = identificationForm.value;
+  const disabled: string[] = [];
+  if (current.facial === true && !form.facial) disabled.push("Facial");
+  if (current.card === true && !form.card) disabled.push("Card");
+  if (current.qrCode === true && !form.qrCode) disabled.push("QR code");
+  if (current.credentialMode === "pin" && form.credentialMode !== "pin") disabled.push("PIN");
+  return disabled;
+});
+
+/*
+ * Reload after BOTH outcomes.
+ *
+ * The confirmed time and the stored methods must come from the server, which
+ * only writes them once the reader has echoed the values back. Assuming them
+ * here would let the screen claim a door accepts something it refused. On
+ * failure the reload matters just as much: the API names the credential the
+ * reader would not take, and the controls must go back to what the device
+ * actually holds rather than keeping the rejected choice on screen.
+ */
+/*
+ * What the device is actually holding, put back to what we hold for it.
+ *
+ * Worth a button of its own because drift has causes nobody here controls — a
+ * firmware update, somebody using the reader's own touchscreen, a restore, a
+ * reset. Saving the dialog only writes what is on screen; this reads the
+ * device first and reports what had moved.
+ */
+async function reapplyIdentificationMethods() {
+  const readerId = String(selectedReader.value?._id || "");
+  if (!readerId) return;
+
+  const readerName = String(selectedReader.value?.name || "HID Reader");
+  identificationReconciling.value = true;
+  try {
+    const response = await reconcileReaderIdentificationMethods(readerId);
+    const result = (response?.data || response || {}) as HidRecord;
+    identificationDialog.value = false;
+    await loadReaders();
+    selectedReader.value = readers.value.find((reader) => String(reader._id) === readerId) || null;
+
+    const status = String(result.status || "");
+    const drifted = Array.isArray(result.drifted) ? result.drifted.map(String) : [];
+    if (status === "drift_corrected") {
+      showResult(
+        true,
+        "Settings Re-applied",
+        `${readerName} had drifted and has been put back. Corrected: ${drifted.map(identificationFieldLabel).join(", ")}.`,
+        { readerName },
+      );
+    } else if (status === "in_sync") {
+      showResult(true, "Settings Already Correct", `${readerName} matches what iService365 holds for it.`, { readerName });
+    } else if (status === "skipped" && result.reason === "duplicate_reader") {
+      // Not a failure to retry: the device is registered twice, and until a
+      // person removes one record both would fight over its configuration.
+      showResult(
+        false,
+        "Duplicate HID Reader",
+        `${readerName} shares a device with another registered reader. Remove or deactivate one of them before re-applying settings.`,
+        { readerName },
+      );
+    } else if (status === "skipped") {
+      showResult(
+        false,
+        "Nothing to Re-apply",
+        `No identification methods have been set for ${readerName} yet.`,
+        { readerName },
+      );
+    } else {
+      showResult(false, "Could Not Re-apply Settings", String(result.message || "The HID reader could not be reached."), { readerName });
+    }
+  } catch (error: unknown) {
+    console.error("Unable to reconcile HID identification methods:", error);
+    identificationDialog.value = false;
+    await loadReaders();
+    showResult(false, "Could Not Re-apply Settings", getFriendlyHidError(error), { readerName });
+  } finally {
+    identificationReconciling.value = false;
+  }
+}
+
+/** The reader's own field names, as the person in front of the door knows them. */
+function identificationFieldLabel(field: string) {
+  const labels: Record<string, string> = {
+    face_identification_enabled: "Facial",
+    card_identification_enabled: "Card",
+    qrcode_identification_enabled: "QR code",
+    pin_identification_enabled: "Credential entry",
+    multi_factor_authentication: "Multi-factor",
+  };
+  return labels[field] || field;
+}
+
+async function saveIdentificationMethods() {
+  const readerId = String(selectedReader.value?._id || "");
+  if (!readerId) return;
+
+  const readerName = String(selectedReader.value?.name || "HID Reader");
+  identificationSaving.value = true;
+  try {
+    await setReaderIdentificationMethods(readerId, { ...identificationForm.value });
+    identificationDialog.value = false;
+    await loadReaders();
+    selectedReader.value = readers.value.find((reader) => String(reader._id) === readerId) || null;
+    showResult(true, "Identification Methods Updated", `${readerName} now accepts the credentials you selected.`, {
+      readerName,
+    });
+  } catch (error: unknown) {
+    console.error("Unable to set HID identification methods:", error);
+    identificationDialog.value = false;
+    await loadReaders();
+    showResult(false, "Identification Methods Not Applied", getFriendlyHidError(error), { readerName });
+  } finally {
+    identificationSaving.value = false;
+    identificationStage.value = "edit";
+  }
+}
+
 function openTestConfirm(reader?: HidRecord | null) {
   if (reader) selectedReader.value = reader;
   pendingAction.value = "test";
@@ -919,6 +1266,57 @@ function formatCallback(reader?: HidRecord | null) {
   margin-top: 20px;
 }
 
+.identification-lead {
+  margin: 0 0 14px;
+  color: var(--muted);
+  font-size: 13px;
+}
+
+.identification-grid {
+  display: grid;
+  gap: 4px;
+}
+
+.identification-row,
+.identification-credential {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 16px;
+}
+
+.identification-credential {
+  align-items: flex-start;
+  margin-top: 12px;
+  padding-top: 12px;
+  border-top: 1px solid var(--border);
+}
+
+.identification-copy {
+  display: grid;
+  gap: 2px;
+  font-size: 13px;
+  color: var(--text);
+}
+
+/* The reason a control is dead, next to the control rather than in a tooltip
+   nobody opens. */
+.identification-copy small {
+  color: var(--muted);
+  font-size: 11px;
+}
+
+.identification-applied {
+  margin: 16px 0 0;
+  color: var(--muted);
+  font-size: 12px;
+}
+
+.identification-warning {
+  color: var(--text);
+  font-size: 13px;
+}
+
 .reader-action-dialog {
   overflow: hidden;
 }

package/components/HidReaderUserRoster.vue

@@ -27,7 +27,7 @@
             v-model="search"
             search
             placeholder="Search Amico user, UID or registration"
-            @keyup.enter="reloadFromFirstPage"
+            @keyup.enter="onSearchSubmit"
           />
           <AppSelect
             v-model="userType"
@@ -208,6 +208,7 @@ const {
 } = useHidAmico();
 const readers = ref<HidReader[]>([]);
 const users = ref<HidReaderUser[]>([]);
+const { selectHidReader, resolveForSite } = useHidReaderSelection();
 const selectedReaderId = ref("");
 const search = ref("");
 const userType = ref<"all" | "user" | "visitor">("all");
@@ -270,7 +271,11 @@ async function loadReaders() {
     readers.value = (Array.isArray(items) ? items : [])
       .map(toReader)
       .filter((reader): reader is HidReader => reader !== null);
-    if (!selectedReaderId.value && readers.value.length) selectedReaderId.value = readers.value[0]._id;
+    /* Shared with every other HID screen — see `useHidReaderSelection`. The
+       resolver refuses a remembered reader that is not this site's, so a site
+       switch or a deleted reader falls back to the first rather than querying
+       an id the site does not own. */
+    selectedReaderId.value = resolveForSite(props.site, readers.value);
   } catch (error: unknown) {
     readers.value = [];
     showToast(getErrorMessage(error), "error");
@@ -284,6 +289,8 @@ async function loadUsers() {
     return;
   }
 
+  const sequence = loadUsersSequence.value + 1;
+  loadUsersSequence.value = sequence;
   loading.value = true;
   try {
     let clientFiltersUserType = false;
@@ -319,6 +326,7 @@ async function loadUsers() {
     const pageItems = clientFiltersUserType
       ? matchingItems.slice(pageStart, pageStart + 10)
       : matchingItems;
+    if (sequence !== loadUsersSequence.value) return;
     users.value = pageItems.map(toReaderUser);
     total.value = clientFiltersUserType
       ? matchingItems.length
@@ -330,13 +338,15 @@ async function loadUsers() {
       ? ""
       : toText(response.pageRange ?? data.pageRange);
   } catch (error: unknown) {
+    if (sequence !== loadUsersSequence.value) return;
     users.value = [];
     total.value = 0;
     pages.value = 1;
     serverPageRange.value = "";
     showToast(getErrorMessage(error), "error");
   } finally {
-    loading.value = false;
+    // Only the newest load owns the spinner.
+    if (sequence === loadUsersSequence.value) loading.value = false;
   }
 }
 
@@ -350,6 +360,31 @@ function reloadFromFirstPage() {
   loadUsers();
 }
 
+/**
+ * Typing is the search. It used to reload on `@keyup.enter` and on nothing
+ * else, so unless you guessed Enter was required the screen sent no request at
+ * all. Debounced, because each reload is a login/load/logout round trip to a
+ * reader over a VPN; Enter still works and skips the wait.
+ */
+const SEARCH_DEBOUNCE_MS = 400;
+let searchDebounce: ReturnType<typeof setTimeout> | undefined;
+
+function onSearchInput() {
+  clearTimeout(searchDebounce);
+  searchDebounce = setTimeout(reloadFromFirstPage, SEARCH_DEBOUNCE_MS);
+}
+
+function onSearchSubmit() {
+  clearTimeout(searchDebounce);
+  reloadFromFirstPage();
+}
+
+watch(search, onSearchInput);
+onBeforeUnmount(() => clearTimeout(searchDebounce));
+
+/** Discards a load whose answer arrives after a newer one started. */
+const loadUsersSequence = ref(0);
+
 function hasFacialData(user: HidReaderUser) {
   return user.metadata?.facialEnrolled === true || Boolean(toText(user.metadata?.facialData));
 }
@@ -511,6 +546,12 @@ function toNumber(value: unknown, fallback: number) {
   const number = Number(value);
   return Number.isFinite(number) ? number : fallback;
 }
+
+/* Publish every change, including the seed above: a screen that had to fall
+   back to the first reader should leave the others agreeing with it. */
+watch(selectedReaderId, (value) => {
+  if (value) selectHidReader(props.site, value);
+});
 </script>
 
 <style scoped>