@7365admin1/layer-common 3.2.1 → 3.2.2-staging.76

package/components/FeedbackMain.vue

@@ -721,9 +721,9 @@ const {
     _getFeedbacks({
       page: page.value,
       site: route.params.site as string,
-      provider: currentUser.value.serviceProvider,
-      ...(currentUser.value.type != "site" && {
-        userId: currentUser.value._id,
+      provider: currentUser.value?.serviceProvider,
+      ...(currentUser.value?.type != "site" && {
+        userId: currentUser.value?._id,
       }),
       service: "Security",
       dateFrom: moment(startDate.value, "DD/MM/YYYY").startOf("day"),
@@ -998,9 +998,9 @@ async function handleAccept() {
         _id: feedbackData.value._id,
         statusUpdate: {
           status: "In-Progress",
-          updatedById: currentUser.value._id,
-          updatedByName: `${currentUser.value.givenName} ${currentUser.value.surname}`,
-          assignee: currentUser.value._id,
+          updatedById: currentUser.value?._id,
+          updatedByName: `${currentUser.value?.givenName} ${currentUser.value?.surname}`,
+          assignee: currentUser.value?._id,
           provider: currentUser.value?.serviceProvider,
         },
       };
@@ -1158,7 +1158,7 @@ async function submit() {
     isSubmitting.value = true;
 
     const result = await createFeedback({
-      createdBy: currentUser.value._id,
+      createdBy: currentUser.value?._id,
       description: _feedback.value.description,
       attachments: _feedback.value.attachments,
       site: route.params.site as string,

package/components/HidAccessLogDashboard.vue

@@ -327,6 +327,8 @@ type AccessTab = "resident" | "visitor" | "administrator";
 type AccessRow = {
   key: string;
   identityKey: string;
+  identityType?: string;
+  visitorId?: string;
   name: string;
   facialData: string;
   faceImage?: string;
@@ -351,6 +353,7 @@ const { getVisitors } = useVisitor();
 
 const readers = ref<Record<string, any>[]>([]);
 const identities = ref<Record<string, any>[]>([]);
+const allIdentities = ref<Record<string, any>[]>([]);
 const visitorRecords = ref<Record<string, any>>({});
 const logs = ref<Record<string, any>[]>([]);
 const liveAccessLogs = ref<Record<string, any>[]>([]);
@@ -418,8 +421,17 @@ const selectedHistoryRows = computed<AccessRow[]>(() => {
   if (!selectedHistoryRow.value) return [];
 
   const selectedKey = selectedHistoryRow.value.identityKey;
-  const matchedLogs = logs.value.filter((log) => getLogIdentityKey(log) === selectedKey);
-  const matchedLiveLogs = liveAccessLogs.value.filter((log) => getAccessLogIdentityKey(log) === selectedKey);
+  const selectedIdentity = findIdentityByKey(selectedKey);
+  const matchedLogs = logs.value.filter((log) =>
+    selectedIdentity
+      ? accessLogMatchesIdentity(log, selectedIdentity)
+      : getLogIdentityKey(log) === selectedKey,
+  );
+  const matchedLiveLogs = liveAccessLogs.value.filter((log) =>
+    selectedIdentity
+      ? accessLogMatchesIdentity(log, selectedIdentity)
+      : getAccessLogIdentityKey(log) === selectedKey,
+  );
 
   if (!matchedLogs.length && !matchedLiveLogs.length) {
     return rows.value.filter((row) => row.identityKey === selectedKey);
@@ -549,28 +561,41 @@ async function loadDashboard() {
     const isAdministratorTab = activeTab.value === "administrator";
     const isVisitorTab = activeTab.value === "visitor";
     const [identityResponse, logResponse, hidAccessLogs, configurationResponse, roleResponse, visitorResponse, readerUserResponse] = await Promise.all([
-      getIdentities(selectedReaderId.value, {
-        page: 1,
-        limit: 500,
-        ...(!isAdministratorTab ? { type: getIdentityType(activeTab.value) } : {}),
-      }),
-      getLogs(selectedReaderId.value, {
-        page: 1,
-        limit: 500,
-      }),
-      loadLiveAccessLogs(selectedReaderId.value),
-      loadReaderConfiguration(selectedReaderId.value),
-      isAdministratorTab ? loadAdministratorRoles(selectedReaderId.value) : Promise.resolve(null),
+      loadDashboardSource(
+        getIdentities(selectedReaderId.value, {
+          page: 1,
+          limit: 500,
+        }),
+        null,
+        "identities",
+      ),
+      loadDashboardSource(
+        getLogs(selectedReaderId.value, {
+          page: 1,
+          limit: 500,
+        }),
+        null,
+        "persisted access logs",
+      ),
+      loadDashboardSource(loadLiveAccessLogs(selectedReaderId.value), [], "live access logs"),
+      loadDashboardSource(loadReaderConfiguration(selectedReaderId.value), {}, "reader configuration"),
+      isAdministratorTab
+        ? loadDashboardSource(loadAdministratorRoles(selectedReaderId.value), null, "administrator roles")
+        : Promise.resolve(null),
       isVisitorTab && props.org
-        ? getVisitors({
-            org: props.org,
-            site: props.site,
-            page: 1,
-            limit: 500,
-            order: "desc",
-          })
+        ? loadDashboardSource(
+            getVisitors({
+              org: props.org,
+              site: props.site,
+              page: 1,
+              limit: 500,
+              order: "desc",
+            }),
+            null,
+            "visitor records",
+          )
         : Promise.resolve(null),
-      loadReaderUsers(selectedReaderId.value),
+      loadDashboardSource(loadReaderUsers(selectedReaderId.value), [], "reader users"),
     ]);
 
     if (sequence !== loadSequence.value) return;
@@ -578,18 +603,19 @@ async function loadDashboard() {
     const loadedIdentities = identityResponse?.items ?? identityResponse?.data?.items ?? identityResponse?.data?.identities ?? [];
     const mergedIdentities = mergeReaderUsersWithIdentities(readerUserResponse, loadedIdentities);
     const loadedVisitors = visitorResponse?.items ?? visitorResponse?.data?.items ?? visitorResponse?.data?.visitors ?? [];
-    visitorRecords.value = isVisitorTab
-      ? Object.fromEntries(loadedVisitors.map((visitor: Record<string, any>) => [String(visitor._id), visitor]))
-      : {};
+    visitorRecords.value = Object.fromEntries(
+      loadedVisitors.map((visitor: Record<string, any>) => [String(visitor._id), visitor]),
+    );
     administratorUserIds.value = getAdministratorRoleUserIds(roleResponse);
+    allIdentities.value = mergedIdentities;
     identities.value = isAdministratorTab
       ? mergedIdentities.filter((identity: Record<string, any>) => {
           const hidUserId = toHidNumericId(identity.hidUserId);
           return Boolean(hidUserId && administratorUserIds.value.has(hidUserId));
         })
-      : isVisitorTab
-        ? mergedIdentities.filter((identity: Record<string, any>) => Boolean(getVisitorRecord(identity)))
-      : mergedIdentities;
+      : activeTab.value === "visitor"
+        ? mergedIdentities.filter(isVisitorIdentity)
+        : mergedIdentities.filter((identity: Record<string, any>) => !isVisitorIdentity(identity));
     logs.value = logResponse?.items ?? logResponse?.data?.items ?? logResponse?.data?.logs ?? [];
     liveAccessLogs.value = hidAccessLogs;
     readerConfiguration.value = normalizeReaderConfiguration(configurationResponse);
@@ -601,6 +627,15 @@ async function loadDashboard() {
   }
 }
 
+async function loadDashboardSource<T>(request: Promise<T>, fallback: T, label: string): Promise<T> {
+  try {
+    return await request;
+  } catch (error) {
+    console.warn(`Unable to load HID ${label}`, error);
+    return fallback;
+  }
+}
+
 async function loadUserImages(items: Record<string, any>[]) {
   if (!selectedReaderId.value) return;
 
@@ -766,6 +801,7 @@ function mergeReaderUsersWithIdentities(readerUsers: Record<string, any>[], iden
 function resetDashboardData() {
   selectedHistoryRow.value = undefined;
   identities.value = [];
+  allIdentities.value = [];
   visitorRecords.value = {};
   logs.value = [];
   liveAccessLogs.value = [];
@@ -773,15 +809,11 @@ function resetDashboardData() {
   administratorUserIds.value = new Set();
 }
 
-function getIdentityType(tab: AccessTab) {
-  if (tab === "administrator") return "admin";
-  return tab;
-}
-
 function isVisibleForActiveTab(row: AccessRow) {
   const identity = findIdentityByKey(row.identityKey);
+  const isVisitor = row.identityType === "visitor" || Boolean(row.visitorId) || isVisitorIdentity(identity);
   if (activeTab.value === "visitor") {
-    return Boolean(identity && getVisitorRecord(identity));
+    return isVisitor;
   }
 
   if (activeTab.value === "administrator") {
@@ -789,7 +821,11 @@ function isVisibleForActiveTab(row: AccessRow) {
     return Boolean(hidUserId && administratorUserIds.value.has(hidUserId));
   }
 
-  return !identity || !getVisitorRecord(identity);
+  return !isVisitor;
+}
+
+function isVisitorIdentity(identity: Record<string, unknown> | undefined) {
+  return Boolean(identity && (identity.type === "visitor" || identity.visitor));
 }
 
 function loadAdministratorRoles(readerId: string) {
@@ -835,13 +871,13 @@ function getIdentityKey(identity: Record<string, any>) {
   return [
     identity.hidUserId,
     identity.registration,
-    identity.cardNo,
+    identity.cardNo || identity.metadata?.qrCodeValue,
   ].filter(Boolean).join("|");
 }
 
 function findIdentityByKey(identityKey: string) {
   if (!identityKey) return undefined;
-  return identities.value.find((identity) => getIdentityKey(identity) === identityKey);
+  return allIdentities.value.find((identity) => getIdentityKey(identity) === identityKey);
 }
 
 function getLogIdentityKey(log: Record<string, any>) {
@@ -851,7 +887,7 @@ function getLogIdentityKey(log: Record<string, any>) {
   return [
     identity.hidUserId || lookup.hidUserId || rawLog.user_id || rawLog.userId || rawLog.hidUserId,
     identity.registration || lookup.registration,
-    identity.cardNo || lookup.cardNo || rawLog.card_value || rawLog.cardNo,
+    identity.cardNo || lookup.cardNo || rawLog.card_value || rawLog.cardNo || rawLog.qrcode_value,
   ].filter(Boolean).join("|");
 }
 
@@ -1145,12 +1181,15 @@ function getRawAccessLogs(event: Record<string, any>) {
 
 function mapAccessLogToRow(rawLog: Record<string, any>, event: Record<string, any>, index: string): AccessRow {
   const identity = findIdentityForAccessLog(rawLog, event);
+  const eventIdentity = event.payload?.identity || event.payload?.identityLookup || {};
   const rawAccessTime = getAccessLogTime(rawLog, event);
   const identityKey = identity ? getIdentityKey(identity) : getLogIdentityKey({ ...event, payload: { ...event.payload, rawAccessLog: rawLog } });
 
   return {
     key: `${event._id || event.id || "log"}-${rawLog.id || rawLog.time || index}`,
     identityKey,
+    identityType: String(identity?.type || eventIdentity.type || "").toLowerCase() || undefined,
+    visitorId: String(identity?.visitor || eventIdentity.visitor || "") || undefined,
     name: identity ? getName(identity) : getRawLogName(rawLog, event),
     facialData: identity ? getFacialData(identity) : "N/A",
     faceImage: identity ? getUserImageSrc(identity) : "",
@@ -1166,32 +1205,33 @@ function mapAccessLogToRow(rawLog: Record<string, any>, event: Record<string, an
 function findIdentityForAccessLog(rawLog: Record<string, any>, event: Record<string, any>) {
   const eventIdentityId = event.payload?.identity?._id;
   if (eventIdentityId) {
-    const byId = identities.value.find((identity) => String(identity._id) === String(eventIdentityId));
+    const byId = allIdentities.value.find((identity) => String(identity._id) === String(eventIdentityId));
     if (byId) return byId;
   }
 
   const hidUserId = rawLog.user_id ?? rawLog.userId ?? rawLog.hidUserId ?? event.payload?.identity?.hidUserId ?? event.payload?.identityLookup?.hidUserId;
   const registration = rawLog.registration ?? event.payload?.identity?.registration ?? event.payload?.identityLookup?.registration;
   const cardNo = rawLog.card_value || rawLog.cardNo || event.payload?.identity?.cardNo || event.payload?.identityLookup?.cardNo;
+  const qrCodeValue = rawLog.qrcode_value || rawLog.qrCode || rawLog.qrcode;
 
-  return identities.value.find((identity) => {
+  return allIdentities.value.find((identity) => {
     return (
       (hidUserId !== undefined && hidUserId !== null && String(identity.hidUserId) === String(hidUserId)) ||
       (registration && identity.registration === registration) ||
-      (cardNo && String(identity.cardNo) === String(cardNo))
+      (cardNo && String(identity.cardNo) === String(cardNo)) ||
+      (qrCodeValue && String(identity.metadata?.qrCodeValue || "") === String(qrCodeValue))
     );
   });
 }
 
 function getLatestAccessLogForIdentity(identity: Record<string, any>) {
-  const identityKey = getIdentityKey(identity);
   const accessLogs = [
     ...liveAccessLogs.value,
     ...logs.value.flatMap((event) => getRawAccessLogs(event)),
   ];
 
   return accessLogs
-    .filter((log) => getAccessLogIdentityKey(log) === identityKey)
+    .filter((log) => accessLogMatchesIdentity(log, identity))
     .sort((a, b) => {
       const aTime = parseDate(getAccessLogTime(a, {}))?.getTime() || 0;
       const bTime = parseDate(getAccessLogTime(b, {}))?.getTime() || 0;
@@ -1199,11 +1239,46 @@ function getLatestAccessLogForIdentity(identity: Record<string, any>) {
     })[0];
 }
 
+function toUnknownRecord(value: unknown): Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : {};
+}
+
+function accessLogMatchesIdentity(log: unknown, identity: unknown) {
+  const logRecord = toUnknownRecord(log);
+  const identityRecord = toUnknownRecord(identity);
+  const payload = toUnknownRecord(logRecord.payload);
+  const rawLog = Object.keys(toUnknownRecord(payload.rawAccessLog)).length
+    ? toUnknownRecord(payload.rawAccessLog)
+    : logRecord;
+  const eventIdentity = Object.keys(toUnknownRecord(payload.identity)).length
+    ? toUnknownRecord(payload.identity)
+    : toUnknownRecord(payload.identityLookup);
+  const metadata = toUnknownRecord(identityRecord.metadata);
+  const hidUserId = rawLog.user_id ?? rawLog.userId ?? rawLog.hidUserId ?? eventIdentity.hidUserId;
+  const registration = rawLog.registration || eventIdentity.registration;
+  const credential =
+    rawLog.card_value ||
+    rawLog.cardNo ||
+    rawLog.qrcode_value ||
+    rawLog.qrCode ||
+    rawLog.qrcode ||
+    eventIdentity.cardNo;
+  const identityCredential = identityRecord.cardNo || metadata.qrCodeValue;
+
+  return Boolean(
+    (hidUserId !== undefined && hidUserId !== null && String(identityRecord.hidUserId) === String(hidUserId)) ||
+    (registration && identityRecord.registration === registration) ||
+    (credential && identityCredential && String(identityCredential) === String(credential)),
+  );
+}
+
 function getAccessLogIdentityKey(rawLog: Record<string, any>) {
   return [
     rawLog.user_id ?? rawLog.userId ?? rawLog.hidUserId,
     rawLog.registration,
-    rawLog.card_value || rawLog.cardNo,
+    rawLog.card_value || rawLog.cardNo || rawLog.qrcode_value,
   ].filter(Boolean).join("|");
 }
 

package/components/HidCameraCaptureDialog.vue

@@ -0,0 +1,199 @@
+<template>
+  <v-dialog
+    :model-value="modelValue"
+    max-width="520"
+    persistent
+    @update:model-value="emit('update:modelValue', $event)"
+  >
+    <v-card class="camera-dialog" rounded="lg">
+      <v-card-title class="d-flex align-center justify-space-between pa-4">
+        <span class="text-subtitle-1 font-weight-bold">Take Facial Photo</span>
+        <v-btn
+          icon="mdi-close"
+          variant="text"
+          size="small"
+          aria-label="Close camera"
+          @click="close"
+        />
+      </v-card-title>
+
+      <v-divider />
+
+      <v-card-text class="pa-4">
+        <div class="camera-viewport">
+          <video
+            ref="videoElement"
+            class="camera-preview"
+            autoplay
+            muted
+            playsinline
+          />
+
+          <div v-if="starting" class="camera-state">
+            <v-progress-circular indeterminate color="primary" />
+            <span class="mt-3">Starting camera...</span>
+          </div>
+
+          <div v-else-if="cameraError" class="camera-state px-6 text-center">
+            <v-icon icon="mdi-camera-off-outline" size="42" color="error" />
+            <span class="mt-3 text-error">{{ cameraError }}</span>
+          </div>
+        </div>
+
+        <canvas ref="canvasElement" class="d-none" />
+
+        <div class="text-caption text-medium-emphasis mt-3 text-center">
+          Keep your face centered and make sure the area is well lit.
+        </div>
+      </v-card-text>
+
+      <v-divider />
+
+      <v-card-actions class="pa-4">
+        <v-btn variant="text" @click="close">Cancel</v-btn>
+        <v-spacer />
+        <v-btn
+          color="primary"
+          variant="flat"
+          prepend-icon="mdi-camera"
+          :disabled="starting || !!cameraError || !stream"
+          @click="capture"
+        >
+          Take Photo
+        </v-btn>
+      </v-card-actions>
+    </v-card>
+  </v-dialog>
+</template>
+
+<script setup lang="ts">
+const props = defineProps<{ modelValue: boolean }>();
+const emit = defineEmits<{
+  "update:modelValue": [value: boolean];
+  capture: [dataUrl: string];
+}>();
+
+const videoElement = ref<HTMLVideoElement | null>(null);
+const canvasElement = ref<HTMLCanvasElement | null>(null);
+const stream = shallowRef<MediaStream | null>(null);
+const starting = ref(false);
+const cameraError = ref("");
+
+function stopCamera() {
+  stream.value?.getTracks().forEach((track) => track.stop());
+  stream.value = null;
+  if (videoElement.value) videoElement.value.srcObject = null;
+}
+
+function getCameraErrorMessage(caught: unknown) {
+  if (caught instanceof DOMException) {
+    if (caught.name === "NotAllowedError") {
+      return "Camera permission was denied. Allow camera access and try again.";
+    }
+    if (caught.name === "NotFoundError") {
+      return "No camera was found on this device.";
+    }
+    if (caught.name === "NotReadableError") {
+      return "The camera is currently being used by another application.";
+    }
+  }
+  return "Unable to open the camera. Use HTTPS or check the browser camera permission.";
+}
+
+async function startCamera() {
+  stopCamera();
+  cameraError.value = "";
+  starting.value = true;
+
+  try {
+    if (!navigator.mediaDevices?.getUserMedia) {
+      throw new Error("Camera API is unavailable");
+    }
+
+    stream.value = await navigator.mediaDevices.getUserMedia({
+      audio: false,
+      video: {
+        facingMode: "user",
+        width: { ideal: 1280 },
+        height: { ideal: 960 },
+      },
+    });
+
+    await nextTick();
+    if (!videoElement.value) throw new Error("Camera preview is unavailable");
+    videoElement.value.srcObject = stream.value;
+    await videoElement.value.play();
+  } catch (caught: unknown) {
+    stopCamera();
+    cameraError.value = getCameraErrorMessage(caught);
+  } finally {
+    starting.value = false;
+  }
+}
+
+function capture() {
+  const video = videoElement.value;
+  const canvas = canvasElement.value;
+  if (!video || !canvas || !video.videoWidth || !video.videoHeight) return;
+
+  canvas.width = video.videoWidth;
+  canvas.height = video.videoHeight;
+  const context = canvas.getContext("2d");
+  if (!context) return;
+
+  context.translate(canvas.width, 0);
+  context.scale(-1, 1);
+  context.drawImage(video, 0, 0, canvas.width, canvas.height);
+
+  emit("capture", canvas.toDataURL("image/jpeg", 0.9));
+  close();
+}
+
+function close() {
+  stopCamera();
+  emit("update:modelValue", false);
+}
+
+watch(
+  () => props.modelValue,
+  (isOpen) => {
+    if (isOpen) void startCamera();
+    else stopCamera();
+  }
+);
+
+onBeforeUnmount(stopCamera);
+</script>
+
+<style scoped>
+.camera-dialog {
+  overflow: hidden;
+}
+
+.camera-viewport {
+  position: relative;
+  width: 100%;
+  overflow: hidden;
+  aspect-ratio: 3 / 4;
+  border-radius: 8px;
+  background: #111722;
+}
+
+.camera-preview {
+  width: 100%;
+  height: 100%;
+  object-fit: cover;
+  transform: scaleX(-1);
+}
+
+.camera-state {
+  position: absolute;
+  inset: 0;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  background: #111722;
+  color: #ffffff;
+}
+</style>