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

package/composables/useHidAmico.ts

@@ -28,6 +28,46 @@ type HidIdentityPayload = {
   metadata?: Record<string, any>;
 };
 
+type HidVisitorQrData = {
+  visitorId: string;
+  readerId: string;
+  hidUserId: number;
+  qrValue: string;
+  qrFormat: "0";
+  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 HidSipAccountData = {
+  orgId: string;
+  site: string;
+  userId: string;
+  extension: string;
+  username: string;
+  password: string;
+  sipAddress: string;
+  websocketUrl: string;
+  status: "active";
+  provisionedAt: string;
+};
+
 export default function useHidAmico() {
   const basePath = "/api/access-management/hid";
 
@@ -78,6 +118,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 +162,54 @@ 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 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,6 +249,49 @@ 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,
     createReader,
@@ -159,10 +300,16 @@ export default function useHidAmico() {
     testReader,
     syncReader,
     runObjectOperation,
+    issueVisitorQr,
     getReaderConfiguration,
     setReaderConfiguration,
     getLogs,
     getUserImage,
+    setUserImage,
+    deleteUserImage,
+    getUserPinStatus,
+    setUserPin,
+    deleteUserPin,
     getIdentities,
     createIdentity,
     updateIdentity,
@@ -170,5 +317,9 @@ export default function useHidAmico() {
     getIntercomStatus,
     makeIntercomCall,
     finalizeIntercomCall,
+    ensureSipAccount,
+    getSitePermissions,
+    getPermissionCandidates,
+    updateSitePermissions,
   };
 }

package/composables/useHidNavigation.ts

@@ -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/useLocalAuth.ts

@@ -1,36 +1,7 @@
 export default function useLocalAuth() {
   const { cookieConfig } = useRuntimeConfig().public;
 
-  const _address = {
-    country: "",
-    address1: "",
-    address2: "",
-    city: "",
-    province: "",
-    postalCode: "",
-  };
-
-  const user = {
-    _id: "",
-    givenName: "",
-    middleName: "",
-    surname: "",
-    address: _address,
-    email: "",
-    password: "",
-    type: "",
-    createdAt: "",
-    organization: "",
-    role: "",
-    primaryPhone: "",
-    mobilePhone: "",
-    serviceProviders: [],
-  };
-
-  const currentUser = useState(
-    "currentUser",
-    (): TUser | null => JSON.parse(JSON.stringify(user))
-  );
+  const currentUser = useState<TUser | null>("currentUser", () => null);
 
   async function authenticate() {
     const user = useCookie("user", cookieConfig).value;
@@ -41,9 +12,7 @@ export default function useLocalAuth() {
       );
 
     watchEffect(() => {
-      if (getCurrentUserReq.value) {
-        currentUser.value = getCurrentUserReq.value as TUser;
-      }
+      currentUser.value = (getCurrentUserReq.value as TUser | null) ?? null;
     });
 
     watchEffect(() => {
@@ -70,6 +39,7 @@ export default function useLocalAuth() {
     useCookie("sid", cookieConfig).value = null;
     useCookie("user", cookieConfig).value = null;
     useCookie("organization", cookieConfig).value = null;
+    currentUser.value = null;
   }
 
   async function logout() {
@@ -79,17 +49,20 @@ export default function useLocalAuth() {
         await useNuxtApp().$api(`/api/auth/${sid}`, {
           method: "DELETE",
         });
-
-        clearCookies();
       } catch (error) {
         console.error("Logout failed:", error);
       }
+
+      clearCookies();
     }
   }
 
   async function getCurrentUser() {
     const user = useCookie("user", cookieConfig).value;
-    if (!user) return null;
+    if (!user) {
+      currentUser.value = null;
+      return null;
+    }
     const _user = await useNuxtApp().$api<TUser>(`/api/users/id/${user}`, {
       method: "GET",
     });

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 }

package/composables/useOrg.ts

@@ -170,7 +170,7 @@ export default function useOrg() {
 
   function updateOrg(
     id: string,
-    value: Partial<Pick<TOrg, "name" | "type" | "email" | "nature" | "contact">>
+    value: Partial<Pick<TOrg, "name" | "type" | "email" | "nature" | "contact" | "terms" | "policies">>
   ) {
     return useNuxtApp()
       .$api<Record<string, any>>(`/api/organizations/${id}`, {

package/composables/useRole.ts

@@ -68,6 +68,26 @@ export default function useRole() {
     });
   }
 
+  function getDeletionPreview(_id: string) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/roles/${_id}/deletion-preview`,
+      { method: "GET" }
+    );
+  }
+
+  function deleteWithReassignments(
+    _id: string,
+    reassignments: Array<{ memberId: string; roleId: string }>
+  ) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/roles/${_id}/delete-with-reassignments`,
+      {
+        method: "PUT",
+        body: { reassignments },
+      }
+    );
+  }
+
   const role = useState<TRole>("userRole", () => {
     return {
       _id: "",
@@ -103,6 +123,8 @@ export default function useRole() {
     updateRoleById,
     updateRoleFieldById,
     deleteRole,
+    getDeletionPreview,
+    deleteWithReassignments,
     updatePermissionById,
     getRoleByUserId,
   };

package/composables/useServiceProviderInvitation.ts

@@ -0,0 +1,145 @@
+/**
+ * Service-provider invitations — the list a property manager sees and the
+ * things they can do to a row.
+ *
+ * Separate from `useVerification` because these rows are not generic
+ * verifications any more: they have their own states (waiting for Seven365,
+ * waiting for the provider, not approved, declined) and their own actions,
+ * and the server scopes them to the caller's own organisation.
+ */
+export type TServiceProviderInvitation = {
+  _id: string;
+  email: string;
+  type: string;
+  status: string;
+  statusLabel: string;
+  rejectionReason?: string | null;
+  createdAt?: string;
+  expireAt?: string;
+  deletedAt?: string | null;
+  metadata?: Record<string, any>;
+  history?: Array<{
+    action: string;
+    at: string;
+    byName?: string;
+    reason?: string;
+  }>;
+};
+
+/** The words on screen. Kept beside the server's own list on purpose — a
+ *  status the server invents must never render as a raw stored value. */
+export const SERVICE_PROVIDER_INVITE_LABELS: Record<string, string> = {
+  "awaiting-approval": "Waiting for Seven365",
+  pending: "Waiting for the provider",
+  rejected: "Not approved",
+  complete: "Accepted",
+  declined: "Declined",
+  cancelled: "Cancelled",
+  expired: "Expired",
+};
+
+export function serviceProviderInviteLabel(status?: string) {
+  return SERVICE_PROVIDER_INVITE_LABELS[String(status ?? "")] ?? "Unknown";
+}
+
+export default function useServiceProviderInvitation() {
+  const base = "/api/service-provider-invitations";
+
+  function getInvitations({
+    org = "",
+    status = "",
+    page = 1,
+    limit = 20,
+  } = {}): Promise<{
+    items: TServiceProviderInvitation[];
+    pages: number;
+    pageRange: string;
+  }> {
+    return useNuxtApp().$api(base, {
+      method: "GET",
+      query: { org, status, page, limit },
+    });
+  }
+
+  function cancelInvitation(id: string) {
+    return useNuxtApp().$api<{ message: string }>(`${base}/${id}/cancel`, {
+      method: "PUT",
+    });
+  }
+
+  /** Sends the same invitation again. Never creates a second row. */
+  function resendInvitation(id: string) {
+    return useNuxtApp().$api<{ message: string }>(`${base}/${id}/resend`, {
+      method: "PUT",
+    });
+  }
+
+  /** Soft delete — the row leaves this list, Seven365 keeps the record. */
+  function deleteInvitation(id: string) {
+    return useNuxtApp().$api<{ message: string }>(`${base}/${id}`, {
+      method: "DELETE",
+    });
+  }
+
+  // ---- Seven365 super admin ------------------------------------------------
+
+  function getApprovals({
+    status = "awaiting-approval",
+    page = 1,
+    limit = 20,
+    includeDeleted = false,
+  } = {}): Promise<{
+    items: TServiceProviderInvitation[];
+    pages: number;
+    pageRange: string;
+    awaitingApprovalCount: number;
+  }> {
+    return useNuxtApp().$api(`${base}/approvals`, {
+      method: "GET",
+      query: { status, page, limit, includeDeleted },
+    });
+  }
+
+  function getApprovalCount(): Promise<{ count: number }> {
+    return useNuxtApp().$api(`${base}/approvals/count`, { method: "GET" });
+  }
+
+  function approveInvitation(id: string) {
+    return useNuxtApp().$api<{ message: string }>(`${base}/${id}/approve`, {
+      method: "PUT",
+    });
+  }
+
+  /** The reason is required — it is what the property manager is shown. */
+  function rejectInvitation(id: string, reason: string) {
+    return useNuxtApp().$api<{ message: string }>(`${base}/${id}/reject`, {
+      method: "PUT",
+      body: { reason },
+    });
+  }
+
+  // ---- the invited service provider ----------------------------------------
+
+  function getInvitation(id: string): Promise<TServiceProviderInvitation> {
+    return useNuxtApp().$api(`${base}/${id}`, { method: "GET" });
+  }
+
+  function declineInvitation(id: string) {
+    return useNuxtApp().$api<{ message: string }>(`${base}/${id}/decline`, {
+      method: "PUT",
+    });
+  }
+
+  return {
+    getInvitations,
+    cancelInvitation,
+    resendInvitation,
+    deleteInvitation,
+    getApprovals,
+    getApprovalCount,
+    approveInvitation,
+    rejectInvitation,
+    getInvitation,
+    declineInvitation,
+  };
+}