@7365admin1/layer-common 3.2.8-staging.204 → 3.2.8-staging.206

package/components/HidReaderManagement.vue

@@ -108,6 +108,7 @@
 
     <HidReaderForm
       v-model="formDialog"
+      :site="props.site"
       :mode="selectedReader ? 'edit' : 'add'"
       :reader="selectedReader"
       :loading="saving"
@@ -125,6 +126,8 @@
             <span>Location</span><strong>{{ selectedReader?.location || "N/A" }}</strong>
             <span>HID Portal</span><strong>{{ selectedReader?.portalName || selectedReader?.portalId || "N/A" }}</strong>
             <span>Monitor Path</span><strong>{{ selectedReader?.monitorPath || "N/A" }}</strong>
+            <span>Monitor Callback</span><strong>{{ formatMonitorStatus(selectedReader?.monitorStatus) }}</strong>
+            <span>Last Callback</span><strong>{{ formatCallback(selectedReader) }}</strong>
             <span>Status</span><strong>{{ formatReaderStatus(resolveReaderStatus(selectedReader)) }}</strong>
             <span>Username</span><strong>{{ selectedReader?.username || "N/A" }}</strong>
           </div>
@@ -242,6 +245,80 @@
 </template>
 
 <script setup lang="ts">
+type HidRecord = {
+  [key: string]: unknown;
+  _id?: string;
+  data?: HidRecord;
+  items?: HidRecord[];
+  identities?: HidRecord[];
+  users?: HidRecord[];
+  user_roles?: HidRecord[];
+  result?: HidRecord;
+  metadata?: HidRecord;
+  id?: string | number;
+  name?: string;
+  registration?: string;
+  card_value?: string | number;
+  cardNo?: string | number;
+  person?: string;
+  user?: string;
+  member?: string;
+  serviceProvider?: string;
+  visitor?: string;
+  type?: string;
+  status?: string;
+  location?: string;
+  deviceId?: string;
+  portalId?: number;
+  portalName?: string;
+  monitorPath?: string;
+  monitorStatus?: string;
+  operatingMode?: "standalone" | "online";
+  lastSyncAt?: string;
+  lastSyncStatus?: "idle" | "running" | "completed" | "failed";
+  lastSyncMessage?: string;
+  lastCallbackAt?: string;
+  lastCallbackType?: string;
+  readerModel?: "VL35LF" | "VL70LF" | "unknown" | "";
+  firmwareVersion?: string;
+  cardReadingMode?: "unconfigured" | "pacs" | "csn" | "csn_for_mifare";
+  csnByteOrder?: "msb" | "lsb";
+  pacsFormat?: "raw" | "wiegand";
+};
+
+type HidReaderFormPayload = {
+  name: string;
+  baseUrl: string;
+  deviceId: string;
+  portalId: number | null;
+  portalName: string;
+  location: string;
+  username: string;
+  password: string;
+  readerModel: "VL35LF" | "VL70LF" | "unknown" | "";
+  firmwareVersion: string;
+  cardReadingMode: "unconfigured" | "pacs" | "csn" | "csn_for_mifare";
+  csnByteOrder: "msb" | "lsb";
+  pacsFormat: "raw" | "wiegand";
+  operatingMode: "standalone" | "online";
+  monitorEnabled: boolean;
+};
+
+type HidSyncUser = HidRecord & {
+  id: number;
+  name: string;
+  registration: string;
+  _identityType: string;
+};
+
+type HidSyncPayload = {
+  objects: Array<{ object: "users"; values: HidSyncUser[] }>;
+  users: HidSyncUser[];
+  unmappedCount: number;
+  stats: { newEnrolled: number; updatedInformation: number; facialData: number };
+  defaultMessage: string;
+};
+
 const props = defineProps({
   site: {
     type: String,
@@ -255,12 +332,14 @@ const {
   updateReader,
   deleteReader,
   testReader,
+  configureReaderIntegration,
+  setReaderMonitor,
+  setReaderOperatingMode,
   getIdentities,
-  createIdentity,
   runObjectOperation,
 } = useHidAmico();
 
-const readers = ref<Record<string, any>[]>([]);
+const readers = ref<HidRecord[]>([]);
 const search = ref("");
 const status = ref("");
 const loading = ref(false);
@@ -270,7 +349,7 @@ const formDialog = ref(false);
 const viewDialog = ref(false);
 const confirmDialog = ref(false);
 const resultDialog = ref(false);
-const selectedReader = ref<Record<string, any> | null>(null);
+const selectedReader = ref<HidRecord | null>(null);
 const pendingAction = ref<"test" | "sync" | "delete" | null>(null);
 const actionStage = ref<"confirm" | "review" | "loading">("confirm");
 const resultSuccess = ref(true);
@@ -278,7 +357,7 @@ const resultTitle = ref("");
 const resultMessage = ref("");
 const resultReaderName = ref("");
 const syncMessage = ref("");
-const syncPreviewPayload = ref<Record<string, any> | null>(null);
+const syncPreviewPayload = ref<HidSyncPayload | null>(null);
 const syncPreviewStats = ref({
   newEnrolled: 0,
   updatedInformation: 0,
@@ -398,31 +477,31 @@ function openAdd() {
   formDialog.value = true;
 }
 
-function openEdit(reader: Record<string, any>) {
+function openEdit(reader: HidRecord) {
   selectedReader.value = reader;
   formDialog.value = true;
 }
 
-function openView(reader: Record<string, any>) {
+function openView(reader: HidRecord) {
   selectedReader.value = reader;
   viewDialog.value = true;
 }
 
-function openTestConfirm(reader?: Record<string, any> | null) {
+function openTestConfirm(reader?: HidRecord | null) {
   if (reader) selectedReader.value = reader;
   pendingAction.value = "test";
   resetActionFlow();
   confirmDialog.value = true;
 }
 
-function openSyncConfirm(reader?: Record<string, any> | null) {
+function openSyncConfirm(reader?: HidRecord | null) {
   if (reader) selectedReader.value = reader;
   pendingAction.value = "sync";
   resetActionFlow();
   confirmDialog.value = true;
 }
 
-function openDeleteConfirm(reader: Record<string, any>) {
+function openDeleteConfirm(reader: HidRecord) {
   selectedReader.value = reader;
   pendingAction.value = "delete";
   resetActionFlow();
@@ -445,16 +524,46 @@ function closeConfirmDialog() {
   resetActionFlow();
 }
 
-async function saveReader(payload: Record<string, any>) {
+async function saveReader(payload: HidReaderFormPayload) {
   saving.value = true;
   try {
+    let readerId = String(selectedReader.value?._id || "");
+    let monitorWarning = "";
     if (selectedReader.value?._id) {
       await updateReader(selectedReader.value._id, payload);
+      if (payload.monitorEnabled) {
+        await configureReaderIntegration(selectedReader.value._id);
+        await setReaderOperatingMode(selectedReader.value._id, payload.operatingMode || "standalone");
+      } else {
+        await setReaderMonitor(selectedReader.value._id, false);
+      }
     } else {
-      await createReader({ ...payload, site: props.site });
+      const response = await createReader({ ...payload, site: props.site });
+      const createdReader = response?.data || response || {};
+      readerId = String(createdReader?._id || "");
+      monitorWarning = String(createdReader?.monitorWarning || "");
+    }
+    if (!selectedReader.value?._id && readerId && payload.monitorEnabled && !monitorWarning) {
+      await setReaderOperatingMode(readerId, payload.operatingMode || "standalone");
     }
     formDialog.value = false;
     await loadReaders();
+    if (monitorWarning) {
+      showResult(
+        false,
+        "Reader Requires Configuration",
+        monitorWarning,
+        { readerName: payload.name || "HID Reader" },
+      );
+    }
+  } catch (error: unknown) {
+    console.error("Unable to save HID reader:", error);
+    showResult(
+      false,
+      "Save HID Reader Failed",
+      getFriendlyHidError(error),
+      { readerName: payload.name || selectedReader.value?.name || "HID Reader" },
+    );
   } finally {
     saving.value = false;
   }
@@ -485,22 +594,16 @@ async function runConfirmedAction() {
 
       actionStage.value = "loading";
       const payload = syncPreviewPayload.value;
-      const hidUsersToImport = payload.hidUsersToImport || [];
-      const importedCount = hidUsersToImport.length
-        ? await importHidUsers(selectedReader.value._id, hidUsersToImport)
-        : 0;
+      const unmappedCount = Number(payload.unmappedCount || 0);
 
       if (!payload.objects.length) {
-        if (importedCount) {
-          const stats = {
-            ...syncPreviewStats.value,
-            newEnrolled: importedCount,
-          };
-          const message = syncMessage.value || `Synced ${importedCount} HID user(s) from reader.`;
+        if (unmappedCount) {
+          const message = syncMessage.value
+            || `Found ${unmappedCount} HID user(s) that must be linked from the HID Users screen.`;
           await applyReaderSyncState(selectedReader.value._id, "completed", message);
-          showResult(true, "Sync Successful", message, {
+          showResult(true, "Sync Review Required", message, {
             readerName: selectedReader.value.name || "HID Reader",
-            stats,
+            stats: syncPreviewStats.value,
           });
           confirmDialog.value = false;
           resetActionFlow();
@@ -517,8 +620,10 @@ async function runConfirmedAction() {
         return;
       }
       const result = await syncHidUsers(selectedReader.value._id, payload.users);
-      const importMessage = importedCount ? `${importedCount} HID user(s) imported from reader.` : "";
-      const message = syncMessage.value || [result.message, importMessage].filter(Boolean).join(" ");
+      const mappingMessage = unmappedCount
+        ? `${unmappedCount} HID user(s) still need to be linked from the HID Users screen.`
+        : "";
+      const message = syncMessage.value || [result.message, mappingMessage].filter(Boolean).join(" ");
       await applyReaderSyncState(selectedReader.value._id, "completed", message);
       showResult(true, "Sync Successful", message, {
         readerName: selectedReader.value.name || "HID Reader",
@@ -532,7 +637,7 @@ async function runConfirmedAction() {
     confirmDialog.value = false;
     resetActionFlow();
     await loadReaders();
-  } catch (error: any) {
+  } catch (error: unknown) {
     console.error("HID reader action failed:", error);
     const friendlyMessage = getFriendlyHidError(error);
     if ((pendingAction.value === "sync" || pendingAction.value === "test") && selectedReader.value?._id) {
@@ -552,7 +657,7 @@ async function runConfirmedAction() {
 
 async function applyReaderSyncState(readerId: string, status: "completed" | "failed", message: string) {
   const lastSyncAt = new Date().toISOString();
-  const patch: Record<string, any> = {
+  const patch: HidRecord = {
     lastSyncAt,
     lastSyncStatus: status,
     lastSyncMessage: message,
@@ -602,35 +707,40 @@ async function buildSyncPayload(readerId: string) {
     const hidUsers = normalizeHidUsers(hidResponse);
     return {
       objects: [],
-      importedCount: 0,
       users: [],
-      hidUsersToImport: hidUsers,
+      unmappedCount: hidUsers.length,
       stats: {
-        newEnrolled: hidUsers.length,
+        newEnrolled: 0,
         updatedInformation: 0,
         facialData: countFacialData(hidUsers),
       },
-      defaultMessage: hidUsers.length ? `Ready to import ${hidUsers.length} HID user(s) from reader.` : "",
+      defaultMessage: hidUsers.length
+        ? `Found ${hidUsers.length} HID user(s) that must be linked from the HID Users screen.`
+        : "",
     };
   }
 
+  const allLinkedIds = new Set(
+    identities
+      .map((identity) => Number(identity.hidUserId))
+      .filter((id: number) => Number.isInteger(id) && id > 0),
+  );
   const users = identities
+    .filter((identity) => (
+      identity.type !== "visitor"
+      && (identity.metadata as Record<string, unknown> | undefined)?.temporary !== true
+    ))
     .map(toHidUserObject)
-    .filter((user: Record<string, any>) => user.id && user.name);
+    .filter((user): user is HidSyncUser => user !== null);
   const existingHidUsers = await getExistingHidUsers(readerId);
   const existingIds = new Set(existingHidUsers.map((user) => Number(user.hidUserId)));
-  const localIds = new Set(
-    users
-      .map((user: Record<string, any>) => Number(user.id))
-      .filter((id) => Number.isInteger(id) && id > 0),
-  );
   const hidUsersToImport = existingHidUsers.filter((user) => {
     const hidUserId = Number(user.hidUserId);
-    return Number.isInteger(hidUserId) && hidUserId > 0 && !localIds.has(hidUserId);
+    return Number.isInteger(hidUserId) && hidUserId > 0 && !allLinkedIds.has(hidUserId);
   });
-  const newEnrolled = users.filter((user: Record<string, any>) => !existingIds.has(Number(user.id))).length;
-  const updatedInformation = users.filter((user: Record<string, any>) => existingIds.has(Number(user.id))).length;
-  const totalUsersToSync = users.length + hidUsersToImport.length;
+  const newEnrolled = users.filter((user) => !existingIds.has(Number(user.id))).length;
+  const updatedInformation = users.filter((user) => existingIds.has(Number(user.id))).length;
+  const totalUsersToSync = users.length;
 
   return {
     objects: users.length
@@ -642,22 +752,26 @@ async function buildSyncPayload(readerId: string) {
         ]
       : [],
     users,
-    hidUsersToImport,
-    importedCount: hidUsersToImport.length,
+    unmappedCount: hidUsersToImport.length,
     stats: {
-      newEnrolled: newEnrolled + hidUsersToImport.length,
+      newEnrolled,
       updatedInformation,
       facialData: countFacialData([...users, ...hidUsersToImport]),
     },
-    defaultMessage: totalUsersToSync ? `Ready to sync ${totalUsersToSync} HID user(s).` : "",
+    defaultMessage: [
+      totalUsersToSync ? `Ready to sync ${totalUsersToSync} linked HID user(s).` : "",
+      hidUsersToImport.length
+        ? `${hidUsersToImport.length} HID user(s) must be linked from the HID Users screen.`
+        : "",
+    ].filter(Boolean).join(" "),
   };
 }
 
-async function syncHidUsers(readerId: string, users: Record<string, any>[]) {
+async function syncHidUsers(readerId: string, users: HidSyncUser[]) {
   const existingIds = await getExistingHidUserIds(readerId);
   const usersToCreate = users.filter((user) => !existingIds.has(Number(user.id)));
   const usersToModify = users.filter((user) => existingIds.has(Number(user.id)));
-  const results: Record<string, any>[] = [];
+  const results: HidRecord[] = [];
 
   if (usersToModify.length) {
     const modifyResults = [];
@@ -711,7 +825,7 @@ async function getExistingHidUsers(readerId: string) {
   return normalizeHidUsers(hidResponse);
 }
 
-function normalizeHidUsers(response: Record<string, any>) {
+function normalizeHidUsers(response: HidRecord) {
   const users =
     response?.data?.users ||
     response?.data?.data?.users ||
@@ -731,49 +845,29 @@ function normalizeHidUsers(response: Record<string, any>) {
     : [];
 }
 
-async function importHidUsers(readerId: string, hidUsers: Record<string, any>[]) {
-  let importedCount = 0;
-  for (const user of hidUsers) {
-    if (!user.hidUserId) continue;
-    try {
-      await createIdentity(readerId, {
-        site: props.site,
-        hidUserId: user.hidUserId,
-        registration: user.registration || "",
-        cardNo: user.cardNo || "",
-        type: "resident",
-        status: "active",
-        metadata: {
-          name: user.metadata?.name || user.name || `HID User ${user.hidUserId}`,
-          hidImported: true,
-          importedAt: new Date().toISOString(),
-        },
-      });
-      importedCount += 1;
-    } catch {
-      // Existing users may already be mapped; keep syncing the remaining HID users.
-    }
-  }
-  return importedCount;
-}
+function toHidUserObject(identity: HidRecord): HidSyncUser | null {
+  const id = toHidNumericId(identity.hidUserId);
+  const name = String(
+    identity.metadata?.name ?? identity.name ?? `User ${identity.hidUserId ?? ""}`,
+  ).trim();
+  if (!id || !name) return null;
 
-function toHidUserObject(identity: Record<string, any>) {
   return {
-    id: toHidNumericId(identity.hidUserId),
-    name: identity.metadata?.name || identity.name || `User ${identity.hidUserId || ""}`.trim(),
+    id,
+    name,
     registration: identity.registration || "",
     _identityType: identity.type || "resident",
   };
 }
 
-function toHidUserCreateValues(user: Record<string, any>) {
+function toHidUserCreateValues(user: HidSyncUser) {
   return {
     id: user.id,
     ...toHidUserValues(user),
   };
 }
 
-function toHidUserValues(user: Record<string, any>) {
+function toHidUserValues(user: HidSyncUser) {
   return {
     name: user.name,
     registration: user.registration || "",
@@ -873,11 +967,11 @@ function showResult(
   resultDialog.value = true;
 }
 
-function countFacialData(users: Record<string, any>[]) {
+function countFacialData(users: HidRecord[]) {
   return users.filter((user) => user.face || user.photo || user.image || user.imageUrl || user.faceImage).length;
 }
 
-function getFriendlyHidError(error: any) {
+function getFriendlyHidError(error: unknown) {
   const message = getHidErrorMessage(error);
   const lowerMessage = message.toLowerCase();
 
@@ -939,22 +1033,30 @@ function getFriendlyHidError(error: any) {
   return message || "The HID device rejected the request. Please check the reader connection and try again.";
 }
 
-function getHidErrorMessage(error: any) {
-  const data =
-    error?.data ||
-    error?.response?._data ||
-    error?.response?.data ||
-    error?.cause?.data ||
-    error?.cause?.response?._data ||
-    {};
+function asHidRecord(value: unknown): HidRecord {
+  return typeof value === "object" && value !== null ? value as HidRecord : {};
+}
+
+function getHidErrorMessage(error: unknown) {
+  const record = asHidRecord(error);
+  const response = asHidRecord(record.response);
+  const cause = asHidRecord(record.cause);
+  const causeResponse = asHidRecord(cause.response);
+  const data = asHidRecord(
+    record.data
+    ?? response._data
+    ?? response.data
+    ?? cause.data
+    ?? causeResponse._data,
+  );
 
   return String(
-    data?.message ||
-      data?.error ||
-      data?.statusMessage ||
-      error?.statusMessage ||
-      error?.message ||
-      "Request failed.",
+    data.message
+      ?? data.error
+      ?? data.statusMessage
+      ?? record.statusMessage
+      ?? record.message
+      ?? "Request failed.",
   );
 }
 
@@ -964,13 +1066,13 @@ function formatDate(value?: string) {
   return Number.isNaN(date.getTime()) ? "N/A" : date.toLocaleString();
 }
 
-function resolveReaderStatus(reader?: Record<string, any> | null) {
+function resolveReaderStatus(reader?: HidRecord | null) {
   if (!reader) return "";
   if (reader.lastSyncStatus === "failed" && reader.status === "active") return "offline";
   return reader.status || "offline";
 }
 
-function normalizeReaderStatus(reader: Record<string, any>) {
+function normalizeReaderStatus(reader: HidRecord) {
   return {
     ...reader,
     status: resolveReaderStatus(reader),
@@ -982,6 +1084,19 @@ function formatReaderStatus(value?: string) {
   if (value === "offline") return "Offline";
   return value.charAt(0).toUpperCase() + value.slice(1);
 }
+
+function formatMonitorStatus(value?: string) {
+  if (value === "configured") return "Enabled";
+  if (value === "disabled") return "Disabled";
+  if (value === "failed") return "Failed";
+  return "Not configured";
+}
+
+function formatCallback(reader?: HidRecord | null) {
+  if (!reader?.lastCallbackAt) return "No callback received";
+  const type = typeof reader.lastCallbackType === "string" ? reader.lastCallbackType : "event";
+  return `${type} - ${formatDate(String(reader.lastCallbackAt))}`;
+}
 </script>
 
 

package/components/HidServiceSettingsPanel.vue

@@ -60,10 +60,18 @@
 </template>
 
 <script setup lang="ts">
+type HidServiceMetadata = Record<string, unknown> & {
+  services?: unknown[];
+};
+
+type HidServiceSite = Record<string, unknown> & {
+  metadata?: HidServiceMetadata;
+};
+
 const props = defineProps<{
   site: string;
   org: string;
-  siteData?: Record<string, any> | null;
+  siteData?: HidServiceSite | null;
 }>();
 
 const emit = defineEmits<{
@@ -112,13 +120,14 @@ function buildHidServices(enabled: boolean) {
     status: enabled ? "active" : "inactive",
   };
 
-  const index = currentServices.findIndex((item: any) =>
-    hidServiceKeys.includes(normalizeServiceKey(item?.key ?? item?.code ?? item?.name)),
-  );
+  const index = currentServices.findIndex((item) => {
+    const record = toServiceRecord(item);
+    return hidServiceKeys.includes(normalizeServiceKey(record.key ?? record.code ?? record.name));
+  });
 
   if (index >= 0) {
     currentServices[index] = {
-      ...currentServices[index],
+      ...toServiceRecord(currentServices[index]),
       ...service,
     };
   } else {
@@ -146,7 +155,7 @@ async function saveHidService(value: boolean) {
     emit("refresh");
     await refreshNuxtData(`layout-selected-site-details-${useRuntimeConfig().public.APP}`);
     showMessage(`HID Face Reader ${value ? "enabled" : "disabled"} successfully`, "success");
-  } catch (error: any) {
+  } catch (error: unknown) {
     hidEnabled.value = previousValue;
     showMessage(errorConverter(error), "error");
   } finally {
@@ -154,6 +163,12 @@ async function saveHidService(value: boolean) {
   }
 }
 
+function toServiceRecord(value: unknown): Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : {};
+}
+
 function goToHidReaders() {
   navigateTo({
     name: "org-site-access-mgmt-hid-readers",