@7365admin1/layer-common 3.0.7 → 3.0.9

package/composables/useCommonPermission.ts

@@ -221,6 +221,64 @@ export function useCommonPermissions() {
       },
     }
 
+    const siteSettingsPermissions: Record<string, TPermission> = {
+      "manage-site-information": {
+        check: true,
+        description:
+          "Allows the user to manage site information.",
+      },
+      "manage-anpr-camera": {
+        check: true,
+        description:
+          "Allows the user to manage ANPR camera settings.",
+      },
+      "manage-cctv-camera": {
+        check: true,
+        description:
+          "Allows the user to manage CCTV camera settings.",
+      },
+      "manage-delivery-companies": {
+        check: true,
+        description:
+          "Allows the user to manage delivery companies.",
+      },
+      "manage-resident-visitors": {
+        check: true,
+        description:
+          "Allows the user to manage resident visitors.",
+      },
+      "manage-work-order-settings": {
+        check: true,
+        description: "Allows the user to manage work order settings.",
+      },
+      "manage-billing-and-soa-configuration": {
+        check: true,
+        description:
+          "Allows the user to manage billing and SOA configuration.",
+      },
+      "manage-nfc-management": {
+        check: true,
+        description:
+          "Allows the user to manage NFC management.",
+      },
+      "manage-nfc-patrol-settings": {
+        check: true,
+        description:
+          "Allows the user to manage NFC patrol settings.",
+      },
+      "manage-entry-pass": {
+        check: true,
+        description:
+          "Allows the user to manage entry passes.",
+      },
+      "manage-red-dot-settings": {
+        check: true,
+        description:
+          "Allows the user to manage red dot settings.",
+      },
+
+    }
+  
   return {
     invitationPermissions,
     memberPermissions,
@@ -231,5 +289,6 @@ export function useCommonPermissions() {
     buildingManagementPermissions,
     buildingUnitManagementPermissions,
     bulletinBoardPermissions,
+    siteSettingsPermissions
   };
 }

package/composables/useDashboard.ts

@@ -1,4 +1,22 @@
 export default function () {
+  function getDashboard(
+    site = "",
+    serviceType: TServiceType,
+    period: TDashboardValues = "today",
+    query: Record<string, any> = {}
+  ) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/dashboard/serviceType/${serviceType}/site/${site}`,
+      {
+        method: "GET",
+        query: {
+          period,
+          ...query,
+        },
+      }
+    );
+  }
+
   function getDashboardHygiene(
     site = "",
     period: TDashboardValues = "today",
@@ -34,6 +52,7 @@ export default function () {
   function getDashboardHygieneTaskSchedule(
     site = "",
     serviceType: TServiceType,
+    period: TDashboardValues = "today",
     page = 1,
     limit = 4
   ) {
@@ -42,6 +61,7 @@ export default function () {
     >(`/api/dashboard/serviceType/${serviceType}/site/${site}/task-schedule`, {
       method: "GET",
       query: {
+        period,
         page,
         limit,
       },
@@ -51,6 +71,7 @@ export default function () {
   function getDashboardHygieneAttendance(
     site = "",
     serviceType: TServiceType,
+    period: TDashboardValues = "today",
     page = 1,
     limit = 4
   ) {
@@ -59,6 +80,7 @@ export default function () {
       {
         method: "GET",
         query: {
+          period,
           page,
           limit,
         },
@@ -69,6 +91,7 @@ export default function () {
   function getDashboardHygieneFeedbacks(
     site = "",
     serviceType: TServiceType,
+    period: TDashboardValues = "today",
     page = 1,
     limit = 4
   ) {
@@ -77,6 +100,7 @@ export default function () {
       {
         method: "GET",
         query: {
+          period,
           page,
           limit,
         },
@@ -86,12 +110,13 @@ export default function () {
 
   function getDashboardPropertyManagement(
     site = "",
+    serviceType: TServiceType = "property_management_agency",
     period: TDashboardValues = "today",
     type = "",
     facility = ""
   ) {
     return useNuxtApp().$api<Record<string, any>>(
-      `/api/dashboard/serviceType/property_management_agency/site/${site}`,
+      `/api/dashboard/serviceType/${serviceType}/site/${site}`,
       {
         method: "GET",
         query: {
@@ -103,12 +128,32 @@ export default function () {
     );
   }
 
+  function getDashboardSecurity(
+    site = "",
+    serviceType: TServiceType = "security_agency",
+    period: TDashboardValues = "today",
+    type = ""
+  ) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/dashboard/serviceType/${serviceType}/site/${site}`,
+      {
+        method: "GET",
+        query: {
+          period,
+          ...(type ? { type } : {}),
+        },
+      }
+    );
+  }
+
   return {
+    getDashboard,
     getDashboardHygiene,
     getDashboardHygieneWeeklyActivity,
     getDashboardHygieneTaskSchedule,
     getDashboardHygieneAttendance,
     getDashboardHygieneFeedbacks,
     getDashboardPropertyManagement,
+    getDashboardSecurity,
   };
 }

package/composables/useHidAmico.ts

@@ -0,0 +1,152 @@
+type HidReaderPayload = {
+  site?: string;
+  name?: string;
+  location?: string;
+  baseUrl?: string;
+  username?: string;
+  password?: string;
+  deviceId?: string;
+  monitorPath?: string;
+  enabled?: boolean;
+  status?: string;
+  lastSyncAt?: string;
+  lastSyncStatus?: "idle" | "running" | "completed" | "failed";
+  lastSyncMessage?: string;
+};
+
+type HidIdentityPayload = {
+  site?: string;
+  hidUserId?: string | number;
+  registration?: string;
+  cardNo?: string;
+  person?: string;
+  user?: string;
+  member?: string;
+  visitor?: string;
+  type?: "resident" | "staff" | "contractor" | "visitor" | "unknown";
+  status?: "active" | "inactive" | "deleted";
+  metadata?: Record<string, any>;
+};
+
+export default function useHidAmico() {
+  const basePath = "/api/access-management/hid";
+
+  function getReaders(query: Record<string, any> = {}) {
+    return useNuxtApp().$api<Record<string, any>>(`${basePath}/readers`, {
+      method: "GET",
+      query,
+    });
+  }
+
+  function createReader(payload: HidReaderPayload) {
+    return useNuxtApp().$api<Record<string, any>>(`${basePath}/readers`, {
+      method: "POST",
+      body: payload,
+    });
+  }
+
+  function updateReader(readerId: string, payload: HidReaderPayload) {
+    return useNuxtApp().$api<Record<string, any>>(`${basePath}/readers/${readerId}`, {
+      method: "PATCH",
+      body: payload,
+    });
+  }
+
+  function deleteReader(readerId: string) {
+    return useNuxtApp().$api<Record<string, any>>(`${basePath}/readers/${readerId}`, {
+      method: "DELETE",
+    });
+  }
+
+  function testReader(readerId: string) {
+    return useNuxtApp().$api<Record<string, any>>(`${basePath}/readers/${readerId}/test`, {
+      method: "POST",
+    });
+  }
+
+  function syncReader(readerId: string, payload: Record<string, any> = {}) {
+    return useNuxtApp().$api<Record<string, any>>(`${basePath}/readers/${readerId}/sync`, {
+      method: "POST",
+      body: payload,
+    });
+  }
+
+  function runObjectOperation(readerId: string, payload: Record<string, any>) {
+    return useNuxtApp().$api<Record<string, any>>(`${basePath}/readers/${readerId}/objects`, {
+      method: "POST",
+      body: payload,
+    });
+  }
+
+  function getReaderConfiguration(readerId: string, payload: Record<string, string[]> = {}) {
+    return useNuxtApp().$api<Record<string, any>>(`${basePath}/readers/${readerId}/configuration`, {
+      method: "POST",
+      body: payload,
+    });
+  }
+
+  function setReaderConfiguration(readerId: string, payload: Record<string, any>) {
+    return useNuxtApp().$api<Record<string, any>>(`${basePath}/readers/${readerId}/configuration`, {
+      method: "PUT",
+      body: payload,
+    });
+  }
+
+  function getIdentities(readerId: string, query: Record<string, any> = {}) {
+    return useNuxtApp().$api<Record<string, any>>(`${basePath}/readers/${readerId}/identities`, {
+      method: "GET",
+      query,
+    });
+  }
+
+  function getLogs(readerId: string, query: Record<string, any> = {}) {
+    return useNuxtApp().$api<Record<string, any>>(`${basePath}/readers/${readerId}/logs`, {
+      method: "GET",
+      query,
+    });
+  }
+
+  function getUserImage(readerId: string, hidUserId: string | number) {
+    return useNuxtApp().$api<Record<string, any>>(`${basePath}/readers/${readerId}/users/${hidUserId}/image`, {
+      method: "GET",
+    });
+  }
+
+  function createIdentity(readerId: string, payload: HidIdentityPayload) {
+    return useNuxtApp().$api<Record<string, any>>(`${basePath}/readers/${readerId}/identities`, {
+      method: "POST",
+      body: payload,
+    });
+  }
+
+  function updateIdentity(identityId: string, payload: HidIdentityPayload) {
+    return useNuxtApp().$api<Record<string, any>>(`${basePath}/identities/${identityId}`, {
+      method: "PATCH",
+      body: payload,
+    });
+  }
+
+  function deleteIdentity(identityId: string) {
+    return useNuxtApp().$api<Record<string, any>>(`${basePath}/identities/${identityId}`, {
+      method: "DELETE",
+    });
+  }
+
+  return {
+    getReaders,
+    createReader,
+    updateReader,
+    deleteReader,
+    testReader,
+    syncReader,
+    runObjectOperation,
+    getReaderConfiguration,
+    setReaderConfiguration,
+    getLogs,
+    getUserImage,
+    getIdentities,
+    createIdentity,
+    updateIdentity,
+    deleteIdentity,
+  };
+}

package/composables/useHidNavigation.ts

@@ -0,0 +1,106 @@
+import type { ComputedRef, Ref } from "vue";
+
+type HidNavigationParams = {
+  org: string;
+  site: string;
+};
+
+export default function useHidNavigation() {
+  const { getSiteById } = useSiteSettings();
+  const { getHidServiceEnabled } = useOptionalServices();
+
+  function getHidFaceReaderMenu({ org, site }: HidNavigationParams) {
+    return {
+      title: "HID Face Reader",
+      children: [
+        {
+          title: "Face Reader",
+          route: {
+            name: "org-site-access-mgmt-hid-readers",
+            params: { org, site },
+          },
+        },
+        {
+          title: "HID Users",
+          route: {
+            name: "org-site-access-mgmt-hid-users",
+            params: { org, site },
+          },
+        },
+        {
+          title: "Administrator",
+          route: {
+            name: "org-site-access-mgmt-administrator",
+            params: { org, site },
+          },
+        },
+        {
+          title: "Identity Mapping",
+          route: {
+            name: "org-site-access-mgmt-identity-mapping",
+            params: { org, site },
+          },
+        },
+        {
+          title: "Access Logs",
+          route: {
+            name: "org-site-access-mgmt-access-logs",
+            params: { org, site },
+          },
+        },
+      ],
+      icon: "mdi-face-recognition",
+    };
+  }
+
+  function useHidFaceReaderMenu({
+    org,
+    site,
+    fallbackSite,
+    cacheKey = "hid-face-reader-menu-site",
+  }: {
+    org: Ref<string> | ComputedRef<string>;
+    site: Ref<string> | ComputedRef<string>;
+    fallbackSite?: Ref<Record<string, any> | undefined> | ComputedRef<Record<string, any> | undefined>;
+    cacheKey?: string;
+  }) {
+    const siteDetails = ref<Record<string, any> | null>(null);
+
+    watch(
+      site,
+      async (siteId) => {
+        if (!siteId || siteId === "site") {
+          siteDetails.value = null;
+          return;
+        }
+
+        try {
+          siteDetails.value = await getSiteById(siteId);
+        } catch (error) {
+          console.error("Failed to load HID navigation site details:", error);
+          siteDetails.value = null;
+        }
+      },
+      { immediate: true },
+    );
+
+    const enabled = computed(() =>
+      getHidServiceEnabled(site.value, siteDetails.value || fallbackSite?.value),
+    );
+
+    const menuItem = computed(() =>
+      enabled.value ? getHidFaceReaderMenu({ org: org.value, site: site.value }) : null,
+    );
+
+    return {
+      enabled,
+      menuItem,
+      siteDetails,
+    };
+  }
+
+  return {
+    getHidFaceReaderMenu,
+    useHidFaceReaderMenu,
+  };
+}

package/composables/useMember.ts

@@ -53,9 +53,15 @@ export default function useMember() {
     status = "active",
     siteId = "",
   } = {}) {
+    const query: Record<string, any> = { page, limit, type, status };
+
+    if (search) query.search = search;
+    if (user) query.user = user;
+    if (org) query.org = org;
+
     return useNuxtApp().$api<Record<string, any>>("/api/members", {
       method: "GET",
-      query: { page, limit, search, user, org, type, status, siteId },
+      query,
     });
   }
   function createUserByVerification(

package/composables/useOptionalServices.ts

@@ -0,0 +1,118 @@
+const optionalServiceFields = [
+  "services",
+  "enabledServices",
+  "serviceTypes",
+  "modules",
+  "enabledModules",
+  "features",
+  "enabledFeatures",
+  "entitlements",
+  "subscriptions",
+  "products",
+];
+
+const hidServiceKeys = [
+  "hid",
+  "hid_amico",
+  "hid_access_control",
+  "hid_access_management",
+  "hid_reader",
+  "hid_readers",
+  "face_reader",
+  "face_readers",
+  "facial_recognition",
+  "biometric_reader",
+  "biometric_readers",
+];
+
+function normalizeServiceKey(value: unknown) {
+  return String(value ?? "")
+    .trim()
+    .toLowerCase()
+    .replace(/[\s-]+/g, "_");
+}
+
+function itemHasService(item: any) {
+  if (!item) return false;
+
+  if (typeof item === "string") {
+    return hidServiceKeys.includes(normalizeServiceKey(item));
+  }
+
+  if (Array.isArray(item)) {
+    return item.some(itemHasService);
+  }
+
+  if (typeof item === "object") {
+    const key = normalizeServiceKey(
+      item.key ??
+        item.code ??
+        item.name ??
+        item.type ??
+        item.service ??
+        item.module ??
+        item.feature,
+    );
+
+    const isEnabled =
+      item.enabled ??
+      item.active ??
+      item.isEnabled ??
+      (item.status ? item.status === "active" : true);
+
+    if (hidServiceKeys.includes(key)) return isEnabled !== false;
+
+    return Object.values(item).some(itemHasService);
+  }
+
+  return false;
+}
+
+export default function useOptionalServices() {
+  const hidServiceOverrides = useState<Record<string, boolean>>(
+    "hid-service-overrides",
+    () => ({}),
+  );
+
+  function hasHidService(source: Record<string, any> | null | undefined) {
+    if (!source) return false;
+
+    if (itemHasService(source.metadata?.services)) return true;
+
+    const presentGateFields = optionalServiceFields.filter((field) =>
+      Object.prototype.hasOwnProperty.call(source, field),
+    );
+
+    if (!presentGateFields.length) return false;
+
+    return presentGateFields.some((field) => itemHasService(source[field]));
+  }
+
+  function getHidServiceEnabled(
+    siteId: string,
+    source: Record<string, any> | null | undefined,
+  ) {
+    if (siteId && Object.prototype.hasOwnProperty.call(hidServiceOverrides.value, siteId)) {
+      return hidServiceOverrides.value[siteId];
+    }
+
+    return hasHidService(source);
+  }
+
+  function setHidServiceOverride(siteId: string, enabled: boolean) {
+    if (!siteId) return;
+
+    hidServiceOverrides.value = {
+      ...hidServiceOverrides.value,
+      [siteId]: enabled,
+    };
+  }
+
+  return {
+    hasHidService,
+    getHidServiceEnabled,
+    setHidServiceOverride,
+    hidServiceKeys,
+    optionalServiceFields,
+  };
+}