@7365admin1/layer-common 4.0.0 → 4.0.2

package/components/HidUserMapping.vue

@@ -0,0 +1,583 @@
+<template>
+  <section class="hid-user-mapping">
+    <v-alert type="info" variant="tonal" density="compact" class="mb-4">
+      This screen links an existing Amico user to an iService record. It does not create,
+      rename, or delete the user on the HID reader. Visitor QR passes are linked from the
+      visitor transaction automatically.
+    </v-alert>
+
+    <TableMain
+      title="HID User Mapping"
+      :headers="headers"
+      :items="users"
+      :loading="loading"
+      :items-per-page="-1"
+      :page="page"
+      :pages="pages"
+      :page-range="pageRange"
+      item-value="_rowKey"
+      show-header
+      @refresh="loadUsers"
+      @update:page="goToPage"
+    >
+      <template #extension>
+        <div class="app-filter-row hid-user-mapping__filters">
+          <AppSelect
+            v-if="readers.length"
+            v-model="selectedReaderId"
+            class="reader-select"
+            :items="readerOptions"
+            @update:model-value="reloadFromFirstPage"
+          />
+          <AppField
+            v-model="search"
+            search
+            placeholder="Search Amico user, UID or registration"
+            @keyup.enter="reloadFromFirstPage"
+          />
+          <AppSelect
+            v-model="mappingFilter"
+            :items="mappingFilterOptions"
+            placeholder="Mapping status"
+            @update:model-value="reloadFromFirstPage"
+          />
+        </div>
+      </template>
+
+      <template #[`item.name`]="{ item }">
+        <span class="app-cell--strong">{{ getRawName(item) }}</span>
+      </template>
+
+      <template #[`item.hidUserId`]="{ item }">
+        <span class="app-cell--num">{{ formatUid(item.hidUserId) }}</span>
+      </template>
+
+      <template #[`item.registration`]="{ item }">
+        <span class="app-cell--num">{{ item.registration || "N/A" }}</span>
+      </template>
+
+      <template #[`item.linkedRecord`]="{ item }">
+        <span :class="isMapped(item) ? 'app-cell--strong' : 'app-cell--muted'">
+          {{ getMappingLabel(item) }}
+        </span>
+      </template>
+
+      <template #[`item.mappingStatus`]="{ item }">
+        <StatusChip :status="isMapped(item) ? 'Mapped' : 'Unmapped'" />
+      </template>
+
+      <template #[`item.action-table`]="{ item }">
+        <v-menu v-if="isMapped(item)">
+          <template #activator="{ props: menuProps }">
+            <AppButton v-bind="menuProps" variant="row" icon="mdi-dots-vertical" />
+          </template>
+          <v-list density="compact" min-width="150">
+            <v-list-item title="Change mapping" @click="openMapping(item)" />
+            <v-list-item title="Remove mapping" class="text-error" @click="openUnmap(item)" />
+          </v-list>
+        </v-menu>
+        <AppButton v-else variant="secondary" icon="mdi-link-variant" @click="openMapping(item)">
+          Map
+        </AppButton>
+      </template>
+
+      <template #no-data>
+        <div class="table-card__empty">
+          <v-icon icon="mdi-account-off-outline" size="32" />
+          <span>No HID users found for this mapping filter.</span>
+        </div>
+      </template>
+    </TableMain>
+
+    <v-dialog v-model="mappingDialog" max-width="520" persistent>
+      <v-card rounded="lg">
+        <v-card-title class="small-title">
+          {{ isMapped(selectedUser) ? "Change HID User Mapping" : "Map HID User" }}
+        </v-card-title>
+        <v-card-text>
+          <div class="hid-user-summary">
+            <strong>{{ getRawName(selectedUser) }}</strong>
+            <span>{{ formatUid(selectedUser?.hidUserId) }} · {{ selectedUser?.registration || "No registration" }}</span>
+          </div>
+
+          <div class="field-label">Link To <span>*</span></div>
+          <AppSelect
+            v-model="mappingForm.category"
+            :items="categoryOptions"
+            placeholder="Select record type"
+            class="mb-3"
+            @update:model-value="onCategoryChanged"
+          />
+
+          <div class="field-label">iService Record <span>*</span></div>
+          <AppSelect
+            v-model="mappingForm.subjectId"
+            :items="candidateOptions"
+            :loading="loadingCandidates"
+            placeholder="Select an existing site record"
+          />
+          <p class="field-hint">
+            {{ categoryHint }}
+          </p>
+        </v-card-text>
+        <v-card-actions class="pa-0">
+          <v-btn class="text-none action-cancel" variant="flat" height="44" @click="mappingDialog = false">
+            Cancel
+          </v-btn>
+          <v-btn
+            class="text-none action-submit"
+            variant="flat"
+            height="44"
+            :loading="saving"
+            @click="saveMapping"
+          >
+            Save Mapping
+          </v-btn>
+        </v-card-actions>
+      </v-card>
+    </v-dialog>
+
+    <v-dialog v-model="unmapDialog" max-width="420" persistent>
+      <v-card rounded="lg">
+        <v-card-title class="small-title">Remove HID User Mapping</v-card-title>
+        <v-card-text>
+          Remove the iService link for <strong>{{ getRawName(selectedUser) }}</strong>?
+          The user and their credentials remain on the HID reader.
+        </v-card-text>
+        <v-card-actions>
+          <v-spacer />
+          <AppButton variant="ghost" :disabled="saving" @click="unmapDialog = false">Cancel</AppButton>
+          <AppButton :loading="saving" @click="removeMapping">Remove Mapping</AppButton>
+        </v-card-actions>
+      </v-card>
+    </v-dialog>
+
+    <v-snackbar v-model="snackbar.show" :color="snackbar.color" timeout="3500">
+      {{ snackbar.message }}
+    </v-snackbar>
+  </section>
+</template>
+
+<script setup lang="ts">
+const props = defineProps({
+  site: {
+    type: String,
+    required: true,
+  },
+});
+
+type HidMetadata = Record<string, unknown> & {
+  name?: string;
+  mappingLabel?: string;
+  mappingCategory?: THidPermissionCategory;
+};
+type HidReader = Record<string, unknown> & {
+  _id: string;
+  name?: string;
+  deviceId?: string;
+  portalName?: string;
+};
+type HidReaderUser = Record<string, unknown> & {
+  _id?: string;
+  _rowKey?: string;
+  hidUserId?: string;
+  registration?: string;
+  name?: string;
+  metadata?: HidMetadata;
+  person?: string;
+  member?: string;
+  serviceProvider?: string;
+  visitor?: string;
+};
+
+const { getReaders, getReaderUsers, getPermissionCandidates, createIdentity, updateIdentity, deleteIdentity } = useHidAmico();
+const route = useRoute();
+const orgId = computed(() => String(route.params.org || ""));
+const readers = ref<HidReader[]>([]);
+const users = ref<HidReaderUser[]>([]);
+const selectedReaderId = ref("");
+const search = ref("");
+const mappingFilter = ref<"" | "mapped" | "unmapped">("");
+const page = ref(1);
+const pages = ref(1);
+const total = ref(0);
+const serverPageRange = ref("");
+const loading = ref(false);
+const saving = ref(false);
+const mappingDialog = ref(false);
+const unmapDialog = ref(false);
+const selectedUser = ref<HidReaderUser | null>(null);
+const permissionCandidates = ref<THidPermissionCandidate[]>([]);
+const loadingCandidates = ref(false);
+const snackbar = reactive({ show: false, color: "success", message: "" });
+const mappingForm = reactive({
+  category: "resident" as THidPermissionCategory,
+  subjectId: "",
+});
+
+const headers = [
+  { title: "Amico Name", value: "name", sortable: false },
+  { title: "UID", value: "hidUserId", sortable: false },
+  { title: "Registration No.", value: "registration", sortable: false },
+  { title: "iService Record", value: "linkedRecord", sortable: false },
+  { title: "Status", value: "mappingStatus", sortable: false },
+  { title: "", value: "action-table", sortable: false },
+];
+const mappingFilterOptions = [
+  { title: "All users", value: "" },
+  { title: "Unmapped", value: "unmapped" },
+  { title: "Mapped", value: "mapped" },
+];
+const categoryOptions = [
+  { title: "Resident", value: "resident" },
+  { title: "Property management", value: "property_management" },
+  { title: "Service provider", value: "service_provider" },
+];
+const readerOptions = computed(() => readers.value.map((reader) => ({
+  title: `${reader.name || reader.deviceId || reader._id} - ${reader.portalName || "Portal not configured"}`,
+  value: reader._id,
+})));
+const candidateOptions = computed(() => permissionCandidates.value.map((candidate) => ({
+  title: candidate.subtitle ? `${candidate.name} · ${candidate.subtitle}` : candidate.name,
+  value: candidate.subjectId,
+})));
+const categoryHint = computed(() => {
+  if (mappingForm.category === "service_provider") {
+    return "Service provider candidates are provider records assigned to this site.";
+  }
+  return "The HID identity is linked to one active record at this site.";
+});
+const pageRange = computed(() => {
+  if (serverPageRange.value) return serverPageRange.value;
+  if (!total.value) return "0-0 of 0";
+  const start = (page.value - 1) * 10 + 1;
+  return `${start}-${Math.min(page.value * 10, total.value)} of ${total.value}`;
+});
+
+watch(() => props.site, init, { immediate: true });
+
+async function init() {
+  await loadReaders();
+  await loadUsers();
+}
+
+async function loadReaders() {
+  if (!props.site) return;
+  try {
+    const response = toRecord(await getReaders({ site: props.site, page: 1, limit: 100 }));
+    const data = toRecord(response.data);
+    const items = response.items ?? data.items ?? data.readers ?? [];
+    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;
+  } catch (error: unknown) {
+    readers.value = [];
+    showToast(getErrorMessage(error), "error");
+  }
+}
+
+async function loadUsers() {
+  if (!selectedReaderId.value) {
+    users.value = [];
+    total.value = 0;
+    return;
+  }
+
+  loading.value = true;
+  try {
+    const response = toRecord(await getReaderUsers(selectedReaderId.value, {
+      page: page.value,
+      limit: 10,
+      search: search.value.trim(),
+      status: mappingFilter.value,
+    }));
+    const data = toRecord(response.data);
+    const items = response.items ?? data.items ?? [];
+    users.value = (Array.isArray(items) ? items : []).map(toReaderUser);
+    total.value = toNumber(response.total ?? data.total, users.value.length);
+    pages.value = Math.max(1, toNumber(response.pages ?? data.pages, 1));
+    serverPageRange.value = toText(response.pageRange ?? data.pageRange);
+  } catch (error: unknown) {
+    users.value = [];
+    total.value = 0;
+    pages.value = 1;
+    serverPageRange.value = "";
+    showToast(getErrorMessage(error), "error");
+  } finally {
+    loading.value = false;
+  }
+}
+
+function goToPage(nextPage: number) {
+  page.value = nextPage;
+  loadUsers();
+}
+
+function reloadFromFirstPage() {
+  page.value = 1;
+  loadUsers();
+}
+
+async function openMapping(user: HidReaderUser) {
+  selectedUser.value = user;
+  mappingForm.category = getMappingCategory(user);
+  mappingForm.subjectId = getMappedSubjectId(user);
+  await loadCandidates();
+  mappingDialog.value = true;
+}
+
+async function onCategoryChanged() {
+  mappingForm.subjectId = "";
+  await loadCandidates();
+}
+
+async function loadCandidates() {
+  if (!selectedReaderId.value || !orgId.value) {
+    permissionCandidates.value = [];
+    return;
+  }
+  loadingCandidates.value = true;
+  try {
+    const response = await getPermissionCandidates(props.site, {
+      orgId: orgId.value,
+      readerId: selectedReaderId.value,
+      category: mappingForm.category,
+      page: 1,
+      limit: 500,
+    });
+    permissionCandidates.value = response.items ?? response.data?.items ?? [];
+  } catch (error: unknown) {
+    permissionCandidates.value = [];
+    showToast(getErrorMessage(error), "error");
+  } finally {
+    loadingCandidates.value = false;
+  }
+}
+
+async function saveMapping() {
+  const user = selectedUser.value;
+  const hidUserId = toText(user?.hidUserId);
+  const candidate = permissionCandidates.value.find((item) => item.subjectId === mappingForm.subjectId);
+  if (!user || !selectedReaderId.value || !hidUserId || !candidate) {
+    showToast("Select an iService record to create the HID user mapping.", "error");
+    return;
+  }
+
+  saving.value = true;
+  try {
+    const payload = {
+      site: props.site,
+      hidUserId,
+      registration: toText(user.registration),
+      person: mappingForm.category === "resident" ? candidate.subjectId : "",
+      member: mappingForm.category === "property_management" ? candidate.subjectId : "",
+      serviceProvider: mappingForm.category === "service_provider" ? candidate.subjectId : "",
+      type: getIdentityType(mappingForm.category),
+      status: "active" as const,
+      metadata: {
+        ...toRecord(user.metadata),
+        name: getRawName(user),
+        mappingLabel: candidate.subtitle ? `${candidate.name} · ${candidate.subtitle}` : candidate.name,
+        mappingCategory: mappingForm.category,
+      },
+    };
+    const identityId = getIdentityId(user);
+    if (identityId) {
+      await updateIdentity(identityId, payload);
+    } else {
+      await createIdentity(selectedReaderId.value, payload);
+    }
+    mappingDialog.value = false;
+    await loadUsers();
+    showToast("HID user mapping saved.");
+  } catch (error: unknown) {
+    showToast(getErrorMessage(error), "error");
+  } finally {
+    saving.value = false;
+  }
+}
+
+function openUnmap(user: HidReaderUser) {
+  selectedUser.value = user;
+  unmapDialog.value = true;
+}
+
+async function removeMapping() {
+  const identityId = selectedUser.value ? getIdentityId(selectedUser.value) : "";
+  if (!identityId) {
+    showToast("This HID user does not have a removable iService mapping.", "error");
+    return;
+  }
+  saving.value = true;
+  try {
+    await deleteIdentity(identityId);
+    unmapDialog.value = false;
+    await loadUsers();
+    showToast("HID user mapping removed. The reader user is unchanged.");
+  } catch (error: unknown) {
+    showToast(getErrorMessage(error), "error");
+  } finally {
+    saving.value = false;
+  }
+}
+
+function isMapped(user?: HidReaderUser | null) {
+  return Boolean(user?.person || user?.member || user?.serviceProvider || user?.visitor);
+}
+
+function getIdentityId(user: HidReaderUser) {
+  return isMapped(user) ? toText(user._id) : "";
+}
+
+function getMappingCategory(user: HidReaderUser): THidPermissionCategory {
+  if (user.serviceProvider) return "service_provider";
+  if (user.member) return "property_management";
+  return "resident";
+}
+
+function getMappedSubjectId(user: HidReaderUser) {
+  return toText(user.person) || toText(user.member) || toText(user.serviceProvider);
+}
+
+function getMappingLabel(user: HidReaderUser) {
+  if (!isMapped(user)) return "Unmapped";
+  return toText(user.metadata?.mappingLabel) || `${getCategoryTitle(getMappingCategory(user))} record`;
+}
+
+function getCategoryTitle(category: THidPermissionCategory) {
+  return category === "property_management"
+    ? "Property management"
+    : category === "service_provider" ? "Service provider" : "Resident";
+}
+
+function getIdentityType(category: THidPermissionCategory) {
+  return category === "resident"
+    ? "resident" as const
+    : category === "service_provider" ? "contractor" as const : "staff" as const;
+}
+
+function getRawName(user?: HidReaderUser | null) {
+  return toText(user?.metadata?.name) || toText(user?.name) || "Unknown";
+}
+
+function formatUid(value: unknown) {
+  const text = toText(value);
+  if (!text) return "N/A";
+  const numeric = Number(text);
+  return Number.isSafeInteger(numeric) && numeric > 0 ? `UID${String(numeric).padStart(6, "0")}` : text;
+}
+
+function showToast(message: string, color = "success") {
+  snackbar.message = message;
+  snackbar.color = color;
+  snackbar.show = true;
+}
+
+function getErrorMessage(error: unknown) {
+  const record = toRecord(error);
+  const data = toRecord(record.data);
+  return toText(data.message) || toText(record.message) || "Unable to update HID user mapping.";
+}
+
+function toReader(value: unknown): HidReader | null {
+  const reader = toRecord(value);
+  const id = toText(reader._id);
+  return id ? { ...reader, _id: id, name: toText(reader.name) || undefined } : null;
+}
+
+function toReaderUser(value: unknown): HidReaderUser {
+  const user = toRecord(value);
+  return {
+    ...user,
+    _id: toText(user._id) || undefined,
+    _rowKey: toText(user._rowKey) || toText(user.id) || toText(user.hidUserId),
+    hidUserId: toText(user.hidUserId) || toText(user.id) || undefined,
+    registration: toText(user.registration) || undefined,
+    name: toText(user.name) || undefined,
+    metadata: toMetadata(user.metadata),
+    person: toText(user.person) || undefined,
+    member: toText(user.member) || undefined,
+    serviceProvider: toText(user.serviceProvider) || undefined,
+    visitor: toText(user.visitor) || undefined,
+  };
+}
+
+function toMetadata(value: unknown): HidMetadata {
+  return toRecord(value) as HidMetadata;
+}
+
+function toRecord(value: unknown): Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : {};
+}
+
+function toText(value: unknown) {
+  if (typeof value === "string") return value.trim();
+  if (typeof value === "number") return String(value);
+  return "";
+}
+
+function toNumber(value: unknown, fallback: number) {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : fallback;
+}
+</script>
+
+<style scoped>
+.hid-user-mapping {
+  padding: 24px 0;
+  min-width: 0;
+}
+
+.hid-user-mapping__filters {
+  margin: 0;
+  padding: 10px 14px;
+}
+
+.hid-user-mapping__filters :deep(.app-field) {
+  max-width: 320px;
+}
+
+.small-title,
+.field-label,
+.hid-user-summary strong {
+  color: var(--text);
+}
+
+.small-title {
+  font-size: 14px;
+  font-weight: 700;
+}
+
+.field-label {
+  font-size: 12px;
+  font-weight: 600;
+  margin-bottom: 6px;
+}
+
+.field-label span {
+  color: var(--err);
+}
+
+.field-hint {
+  margin: 6px 0 0;
+  color: var(--muted);
+  font-size: 12px;
+  font-weight: 600;
+  line-height: 1.45;
+}
+
+.hid-user-summary {
+  display: grid;
+  gap: 4px;
+  margin-bottom: 18px;
+}
+
+.hid-user-summary span {
+  color: var(--muted);
+  font-size: 12px;
+  font-weight: 600;
+}
+</style>

package/components/MemberMain.vue

@@ -491,7 +491,13 @@ async function updateMemberRole() {
     await setMember({ mode: "assign-role" });
     await getAll();
   } catch (error: any) {
-    message.value = error?.response?._data?.message || "Failed to update role";
+    // `message.value` alone sets the snackbar's TEXT and never opens it, so a
+    // refused role change said nothing at all - the dialog just closed and the
+    // row kept its old role. `showMessage` is the one that shows it.
+    showMessage(
+      error?.response?._data?.message || "Failed to update role.",
+      "error",
+    );
   }
 }
 
@@ -543,7 +549,11 @@ async function handleUpdateMemberStatus() {
     showMessage(res.message, "success");
     getAll();
   } catch (error: any) {
-    const errorMessage = error?.response?._data?.message;
+    // An error with no `message` on it drew an EMPTY red snackbar - a failure
+    // reported as a blank bar.
+    const errorMessage =
+      error?.response?._data?.message ||
+      `Could not ${updateActionText.value.toLowerCase()} this member.`;
     showMessage(errorMessage, "error");
   } finally {
     updateLoading.value = false;

package/components/RolePermissionMain.vue

@@ -348,7 +348,8 @@ const { getRoleById: _getRoleById, deleteRole } = useRole();
 
 const { data: role, refresh: getRoleById } = useLazyAsyncData(
   "role-permissions-get-by-id",
-  () => _getRoleById(roleId.value)
+  () => _getRoleById(roleId.value),
+  { immediate: false }
 );
 
 watchEffect(() => {

package/composables/useConsoleTier.ts

@@ -0,0 +1,73 @@
+import { computed } from "vue";
+import { useCookie, useRuntimeConfig, useState } from "#app";
+
+import useMember from "./useMember";
+import useRole from "./useRole";
+import { consoleTier, type TConsoleTier } from "../utils/console-tier";
+
+/**
+ * WHICH SEVEN365 TIER THE SIGNED-IN PERSON IS - fetched once, shared, and
+ * used ONLY to decide what to draw.
+ *
+ * The rule lives in `utils/console-tier.ts` and mirrors the server's
+ * `isPlatformOwner`. Read that file for why `role.default` is the marker, and
+ * for the honest limit: the server re-decides this on every write from the
+ * session, so a browser that flips this boolean gets a visible button and a
+ * 401. Nothing here is a permission check.
+ *
+ * Both requests hit endpoints the console already uses, so no new API surface
+ * and no proxy rule was needed:
+ *
+ *   GET /api/members/user/:user/app/admin   the Seven365 staff membership
+ *   GET /api/roles/id/:role                 that membership's role document
+ *
+ * `admin` is the membership type deliberately, not the org app's own `APP`.
+ * A Seven365 person can also hold an ordinary organisation membership - and on
+ * staging that one carries a role merely NAMED "Super Admin" - so asking for
+ * the org membership would read the wrong row and answer the wrong tier.
+ */
+export default function useConsoleTier() {
+  const { cookieConfig } = useRuntimeConfig().public;
+
+  const tier = useState<TConsoleTier>("consoleTier", () => "none");
+  // Separate from `tier` because "not looked yet" and "looked, not staff" are
+  // both `none` on the glass but only one of them should be re-tried.
+  const resolved = useState<boolean>("consoleTierResolved", () => false);
+
+  const { getByUserIdType } = useMember();
+  const { getRoleById } = useRole();
+
+  async function load(force = false): Promise<TConsoleTier> {
+    if (resolved.value && !force) return tier.value;
+
+    const user = useCookie("user", cookieConfig).value as string | null;
+
+    try {
+      if (!user) {
+        tier.value = "none";
+        return tier.value;
+      }
+
+      const member = await getByUserIdType(user, "admin");
+      const role = member?.role ? await getRoleById(member.role as string) : null;
+
+      tier.value = consoleTier(member, role);
+    } catch {
+      // Fails closed. A 404 here is the ordinary answer for somebody who is
+      // not Seven365 staff at all, so it is not worth a console error.
+      tier.value = "none";
+    } finally {
+      resolved.value = true;
+    }
+
+    return tier.value;
+  }
+
+  return {
+    tier,
+    resolved,
+    isOwner: computed(() => tier.value === "owner"),
+    isStaff: computed(() => tier.value === "owner" || tier.value === "staff"),
+    load,
+  };
+}