@7365admin1/layer-common 1.8.0

package/composables/useRole.ts

@@ -0,0 +1,104 @@
+export default function useRole() {
+  function createRole(
+    { name, permissions, type, org } = {} as {
+      name: string;
+      permissions: Array<string>;
+      type: string;
+      org?: string;
+    }
+  ) {
+    return useNuxtApp().$api("/api/roles", {
+      method: "POST",
+      body: { name, permissions, type, org },
+    });
+  }
+
+  function getRoles({
+    search = "",
+    page = 1,
+    limit = 20,
+    type = "",
+    org = "",
+  } = {}) {
+    return useNuxtApp().$api<Record<string, any>>("/api/roles", {
+      method: "GET",
+      query: { search, page, limit, type, org },
+    });
+  }
+
+  function getRoleById(id: string) {
+    return useNuxtApp().$api<TRole>(`/api/roles/id/${id}`, {
+      method: "GET",
+    });
+  }
+
+  function updateRoleById(
+    _id: string,
+    name?: string,
+    permissions?: Array<string>
+  ) {
+    return useNuxtApp().$api(`/api/roles/id/${_id}`, {
+      method: "PATCH",
+      body: { name, permissions },
+    });
+  }
+
+  function updatePermissionById(_id: string, permissions?: Array<string>) {
+    return useNuxtApp().$api(`/api/roles/permissions/id/${_id}`, {
+      method: "PATCH",
+      body: { permissions },
+    });
+  }
+
+  function updateRoleFieldById(_id: string, field: string, value: string) {
+    return useNuxtApp().$api(`/api/roles/${_id}`, {
+      method: "PATCH",
+      body: { field, value },
+    });
+  }
+
+  function deleteRole(_id: string) {
+    return useNuxtApp().$api<Record<string, any>>(`/api/roles/${_id}`, {
+      method: "DELETE",
+    });
+  }
+
+  const role = useState<TRole>("userRole", () => {
+    return {
+      _id: "",
+      name: "",
+      permissions: [],
+      description: "",
+      createdAt: "",
+      updatedAt: "",
+      deletedAt: "",
+    };
+  });
+
+  const { getByUserId } = useMember();
+
+  async function getRoleByUserId(user: string) {
+    const member = ref<TMember | null>(null);
+
+    try {
+      const res = await getByUserId(user);
+      member.value = res;
+      const _role = await getRoleById(res.role);
+      Object.assign(role.value, _role);
+    } catch (error) {
+      console.log(error);
+    }
+  }
+
+  return {
+    role,
+    createRole,
+    getRoles,
+    getRoleById,
+    updateRoleById,
+    updateRoleFieldById,
+    deleteRole,
+    updatePermissionById,
+    getRoleByUserId,
+  };
+}

package/composables/useSecurityUtils.ts

@@ -0,0 +1,18 @@
+export default function(){
+
+    const formatLocation = ({block, level, unit}: {block: number, level: string, unit: string | TBuildingUnit}) => {
+    const parts = [];
+
+    if (block) parts.push(`Block ${block}`);
+    if (level) parts.push(level);
+    if (unit) parts.push(unit);
+
+    return parts.join(" / ");
+    };
+
+
+    return {
+        formatLocation
+
+    }
+}

package/composables/useServiceProvider.ts

@@ -0,0 +1,224 @@
+export default function useServiceProvider() {
+  const serviceProviders = useState<Array<TServiceProvider>>(
+    "serviceProviders",
+    () => []
+  );
+  const serviceProviderCategories = useState<string[]>(
+    "serviceProviderCategories",
+    () => []
+  );
+
+  const page = useState("page", () => 1);
+  const pages = useState("pages", () => 0);
+  const pageRange = useState("pageRange", () => "-- - -- of --");
+
+  const serviceProvider = useState(
+    "serviceProvider",
+    (): TServiceProvider => ({
+      _id: "",
+      name: "",
+      orgId: "",
+      customerOrgId: "",
+      siteId: "",
+      serviceProviderOrgId: "",
+      type: "",
+      nature: "",
+    })
+  );
+
+  async function getServiceProviders({
+    page = 1,
+    search = "",
+    limit = 10,
+    serviceProviderId = "",
+    orgId = "",
+    siteId = "",
+  } = {}) {
+    try {
+      const response = await useNuxtApp().$api<Record<string, any>>(
+        "/api/service-providers",
+        {
+          method: "GET",
+          query: { page, search, limit, serviceProviderId, orgId, siteId },
+        }
+      );
+      serviceProviders.value = response.items;
+      pages.value = response.pages;
+      pageRange.value = response.pageRange;
+    } catch (err) {
+      console.error(err);
+    }
+  }
+
+  async function getAll({
+    page = 1,
+    search = "",
+    limit = 10,
+    serviceProviderOrgId = "",
+    orgId = "",
+    siteId = "",
+  } = {}) {
+    return useNuxtApp().$api<Record<string, any>>("/api/service-providers", {
+      method: "GET",
+      query: { page, search, limit, serviceProviderOrgId, orgId, siteId },
+    });
+  }
+
+  async function getByProviderOrg({
+    page = 1,
+    search = "",
+    limit = 10,
+    provider = "",
+    org = "",
+  } = {}) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/service-providers/provider/${provider}/org/${org}`,
+      {
+        method: "GET",
+        query: { page, search, limit },
+      }
+    );
+  }
+
+  async function getByServiceProviderOrgIdType({ id = "", type = "" } = {}) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/service-providers/org/${id}/type/${type}`,
+      {
+        method: "GET",
+      }
+    );
+  }
+
+  async function getServiceProviderNames({
+    page = 1,
+    search = "",
+    limit = 10,
+  } = {}): Promise<TServiceProviderPaginatedResponse | undefined> {
+    try {
+      const response =
+        await useNuxtApp().$api<TServiceProviderPaginatedResponse>(
+          "/api/service-providers/name",
+          {
+            method: "GET",
+            query: { page, search, limit },
+          }
+        );
+      return response;
+    } catch (err) {
+      console.error(err);
+    }
+  }
+
+  async function getServiceProviderCategories() {
+    try {
+      const response = await useNuxtApp().$api<{
+        items: string[];
+        page: number;
+        pages: number;
+        pageRange: string;
+        limit: number;
+      }>("/api/service-providers/category?page=1&limit=100", {
+        method: "GET",
+      });
+      serviceProviderCategories.value = response.items;
+    } catch (err) {
+      console.error("Error fetching service provider categories:", err);
+    }
+  }
+
+  async function createServiceProviderInvite({
+    email,
+    siteId,
+    serviceProviderOrgId,
+  }: {
+    email: string;
+    siteId: string;
+    serviceProviderOrgId: string;
+  }) {
+    try {
+      await useNuxtApp().$api<Record<string, any>>(
+        "/api/auth/invite/service-provider",
+        {
+          method: "POST",
+          body: { email, siteId, serviceProviderOrgId },
+        }
+      );
+    } catch (err) {
+      console.error("Error creating service provider invite:", err);
+    }
+  }
+
+  async function invite({
+    email = "",
+    orgId = "",
+    siteId = "",
+    siteName = "",
+  } = {}) {
+    return useNuxtApp().$api<Record<string, any>>(
+      "/api/service-providers/invite",
+      {
+        method: "POST",
+        body: { email, orgId, siteId, siteName },
+      }
+    );
+  }
+
+  async function add({
+    name = "",
+    type = "",
+    description = "",
+    email = "",
+    orgId = "",
+    siteId = "",
+    siteName = "",
+    // serviceProviderOrgId = "",
+    // org = "",
+    orgName = "",
+    category = "",
+  } = {}) {
+    return useNuxtApp().$api<Record<string, any>>("/api/service-providers", {
+      method: "POST",
+      body: {
+        name,
+        type,
+        description,
+        email,
+        orgId,
+        siteId,
+        siteName,
+        // serviceProviderOrgId,
+        // org,
+        orgName,
+        category,
+      },
+    });
+  }
+
+  async function addViaInvite(id = "") {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/service-providers/id/${id}`,
+      {
+        method: "POST",
+      }
+    );
+  }
+
+  return {
+    serviceProviders,
+    serviceProvider,
+    serviceProviderCategories,
+    page,
+    pages,
+    pageRange,
+    getByProviderOrg,
+    getServiceProviders,
+    getServiceProviderNames,
+    getServiceProviderCategories,
+    getAll,
+    createServiceProviderInvite,
+    getByServiceProviderOrgIdType,
+    invite,
+    add,
+    addViaInvite,
+  };
+}

package/composables/useSite.ts

@@ -0,0 +1,109 @@
+export default function useSite() {
+  const sites = ref<Array<TSite>>([]);
+  const page = ref(1);
+  const pages = ref(0);
+  const pageRange = ref("-- - -- of --");
+  const search = ref("");
+
+  const site = useState(
+    "site",
+    (): TSite => ({
+      _id: "",
+      name: "",
+      description: "",
+      orgId: "",
+      blocks: 0,
+      customerOrgId: "",
+      customerSiteId: "",
+      createdAt: "",
+      updatedAt: "",
+      deletedAt: "",
+    })
+  );
+
+  const { currentUser } = useLocalAuth();
+
+  async function getSites({
+    orgId,
+    page: requestPage = 1,
+    search: searchQuery = "",
+    limit = 10,
+    sort = "createdAt",
+    order = "asc",
+  }: {
+    orgId?: string;
+    page?: number;
+    search?: string;
+    limit?: number;
+    sort?: string;
+    order?: string;
+  } = {}) {
+    try {
+      const organizationId = orgId || currentUser.value?.defaultOrg;
+
+      const response = await useNuxtApp().$api<Record<string, any>>(
+        `/api/sites/organization/${organizationId}`,
+        {
+          method: "GET",
+          query: { page: requestPage, search: searchQuery, limit, sort, order },
+        }
+      );
+
+      sites.value = response.items;
+      page.value = requestPage;
+      pages.value = response.pages;
+      pageRange.value = response.pageRange;
+
+      return response;
+    } catch (err) {
+      console.error(err);
+    }
+  }
+
+  function createSite(payload: TSiteCreate) {
+    return useNuxtApp().$api<Record<string, any>>(`/api/sites`, {
+      method: "POST",
+      body: payload,
+    });
+  }
+
+  function deleteSite(id: string) {
+    return useNuxtApp().$api<Record<string, any>>(`/api/sites/${id}`, {
+      method: "DELETE",
+    });
+  }
+
+  async function getSiteById(id: string) {
+    return useNuxtApp().$api<TSite>(`/api/sites/${id}`, {
+      method: "GET",
+    });
+  }
+
+  function getAll({
+    org = "",
+    page = 1,
+    search = "",
+    limit = 10,
+    sort = "createdAt",
+    order = "asc",
+  } = {}) {
+    return useNuxtApp().$api<Record<string, any>>("/api/sites", {
+      method: "GET",
+      query: { page, search, limit, sort, order, org },
+    });
+  }
+
+  return {
+    sites,
+    site,
+    page,
+    pages,
+    pageRange,
+    search,
+    getSites,
+    createSite,
+    deleteSite,
+    getSiteById,
+    getAll,
+  };
+}

package/composables/useSiteEntryPassSettings.ts

@@ -0,0 +1,46 @@
+export default function useSiteEntryPassSettings() {
+  function getBySiteId(siteId: string) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/site-entrypass-settings/site/${siteId}`,
+      {
+        method: "GET",
+      }
+    );
+  }
+
+  function getById(id: string) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/site-entrypass-settings/${id}`,
+      {
+        method: "GET",
+      }
+    );
+  }
+
+  function add(value: any) {
+    return useNuxtApp().$api<Record<string, any>>(
+      "/api/site-entrypass-settings",
+      {
+        method: "POST",
+        body: value,
+      }
+    );
+  }
+
+  function updateBySiteId(value: any, siteId: string) {
+    return useNuxtApp().$api<Record<string, any>>(
+      "/api/site-entrypass-settings/site/" + siteId,
+      {
+        method: "PUT",
+        body: value,
+      }
+    );
+  }
+
+  return {
+    getBySiteId,
+    getById,
+    add,
+    updateBySiteId,
+  };
+}

package/composables/useSiteSettings.ts

@@ -0,0 +1,123 @@
+export default function () {
+  async function getSiteById(siteId: string) {
+    return await useNuxtApp().$api<Record<string, any>>(
+      `/api/sites/${siteId}`,
+      {
+        method: "GET",
+      }
+    );
+  }
+
+  async function getSiteLevels(siteId: string, query: { block: number }) {
+    return await useNuxtApp().$api<Record<string, any>>(
+      `/api/buildings/site/${siteId}`,
+      {
+        method: "GET",
+        query: query,
+      }
+    );
+  }
+
+  async function getSiteUnits(siteId: string, block: number, level: string) {
+    return await useNuxtApp().$api<Record<string, any>>(
+      `/api/building-units/site/${siteId}/block/${block}/level/${level}`,
+      {
+        method: "GET",
+      }
+    );
+  }
+
+  async function updateSite(siteId: string, payload: { block: number }) {
+    return await useNuxtApp().$api<Record<string, any>>(
+      `/api/sites/${siteId}/block`,
+      {
+        method: "PUT",
+        body: payload,
+      }
+    );
+  }
+  async function updateSitebyId(
+    siteId: string,
+    payload: { field: string; value: number }
+  ) {
+    return await useNuxtApp().$api<Record<string, any>>(
+      `/api/sites/id/${siteId}`,
+      {
+        method: "PATCH",
+        body: payload,
+      }
+    );
+  }
+  async function addCamera(camera: TSiteCamera) {
+    return await useNuxtApp().$api<Record<string, any>>(`/api/site-cameras`, {
+      method: "POST",
+      body: camera,
+    });
+  }
+
+  async function updateSiteCamera(
+    id: string,
+    value: Partial<
+      Pick<
+        TSiteCamera,
+        | "host"
+        | "category"
+        | "guardPost"
+        | "password"
+        | "username"
+        | "direction"
+      >
+    >
+  ) {
+    return await useNuxtApp().$api<Record<string, any>>(
+      `/api/site-cameras/id/${id}`,
+      {
+        method: "PATCH",
+        body: value,
+      }
+    );
+  }
+
+  async function deleteSiteCameraById(id: string) {
+    return await useNuxtApp().$api<Record<string, any>>(
+      `/api/site-cameras/id/${id}`,
+      {
+        method: "DELETE",
+      }
+    );
+  }
+
+  async function getAllSiteCameras(payload: {
+    site: string;
+    type?: string;
+    page?: number;
+  }) {
+    return await useNuxtApp().$api<Record<string, any>>(`/api/site-cameras`, {
+      method: "GET",
+      query: payload,
+    });
+  }
+
+  async function setSiteGuardPosts(siteId: string, value: number) {
+    return await useNuxtApp().$api<Record<string, any>>(
+      `/api/sites/guard-post/id/${siteId}`,
+      {
+        method: "PATCH",
+        body: { guardPost: value },
+      }
+    );
+  }
+
+  return {
+    getSiteById,
+    getSiteLevels,
+    getSiteUnits,
+    updateSite,
+    addCamera,
+    getAllSiteCameras,
+    setSiteGuardPosts,
+    updateSiteCamera,
+    deleteSiteCameraById,
+    updateSitebyId,
+  };
+}