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

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" | "1" | "2";
+  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; qrFormat: "0" | "1" | "2" },
+  ) {
+    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,33 @@ 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 createIdentity(readerId: string, payload: HidIdentityPayload) {
     return useNuxtApp().$api<Record<string, any>>(`${basePath}/readers/${readerId}/identities`, {
       method: "POST",
@@ -151,6 +228,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 +279,13 @@ export default function useHidAmico() {
     testReader,
     syncReader,
     runObjectOperation,
+    issueVisitorQr,
     getReaderConfiguration,
     setReaderConfiguration,
     getLogs,
     getUserImage,
+    setUserImage,
+    deleteUserImage,
     getIdentities,
     createIdentity,
     updateIdentity,
@@ -170,5 +293,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/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/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,
+  };
+}