@iservice365/layer-common 0.1.0 → 0.2.1

package/composables/useServiceProvider.ts

@@ -0,0 +1,218 @@
+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 = "",
+  } = {}) {
+    return useNuxtApp().$api<Record<string, any>>("/api/service-providers", {
+      method: "POST",
+      body: {
+        name,
+        type,
+        description,
+        email,
+        orgId,
+        siteId,
+        siteName,
+        serviceProviderOrgId,
+      },
+    });
+  }
+
+  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,108 @@
+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: "",
+      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<TCustomer>(`/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/useSubscription.ts

@@ -0,0 +1,149 @@
+export default function useSubscription() {
+  function add(subscriptionId: string, user: string) {
+    return useNuxtApp().$api("/api/subscriptions", {
+      method: "POST",
+      body: {
+        subscriptionId,
+        user,
+      },
+    });
+  }
+
+  function getById(id: string) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/subscriptions/id/${id}`
+    );
+  }
+
+  function getByAffiliateId(id: string) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/subscriptions/affiliate/${id}`
+    );
+  }
+
+  function getByOrgId(id: string) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/subscriptions/org/${id}`
+    );
+  }
+
+  function getSubscriptions() {
+    return useNuxtApp().$api("/api/subscriptions");
+  }
+
+  function getSubscriptionStatusById(id: string) {
+    return useNuxtApp().$api<Record<string, string>>(
+      `/api/subscriptions/status/${id}`
+    );
+  }
+
+  function cancelSubscription(id: string) {
+    return useNuxtApp().$api(`/api/subscriptions/cancel/${id}`, {
+      method: "DELETE",
+    });
+  }
+
+  const affiliateSubscription = useState(
+    "affiliateSubscription",
+    () => "inactive"
+  );
+
+  async function affSubscriptionStatus() {
+    const { currentUser } = useLocalAuth();
+
+    if (currentUser.value && currentUser.value._id) {
+      try {
+        const result = await getByAffiliateId(currentUser.value._id);
+        affiliateSubscription.value = result.status as string;
+      } catch (error) {
+        console.error("failed to get the subscription", error);
+      }
+    }
+  }
+
+  const orgSubscription = useState("orgSubscription", () => "inactive");
+
+  async function orgSubscriptionStatus() {
+    const { currentOrg } = useOrg();
+
+    if (currentOrg.value) {
+      try {
+        const result = await getByOrgId(currentOrg.value);
+        orgSubscription.value = result.status as string;
+      } catch (error) {
+        console.error("failed to get the subscription", error);
+      }
+    }
+  }
+
+  type TSub = {
+    amount: number;
+    payment_method_type: string;
+    payment_method_card_number?: string;
+    payment_method_expiry_month?: string;
+    payment_method_expiry_year?: string;
+    payment_method_cvv?: string;
+    payment_method_cardholder_name?: string;
+    currency?: string;
+    seats?: number;
+    organization?: TOrg;
+    billingAddress: TAddress;
+    promoCode?: string;
+  };
+
+  function initOrgSubscription(value: TSub) {
+    return useNuxtApp().$api<Record<string, any>>(
+      "/api/subscriptions/organization",
+      {
+        method: "POST",
+        body: value,
+      }
+    );
+  }
+
+  function initAffiliateSubscription(value: TSub) {
+    return useNuxtApp().$api<Record<string, any>>(
+      "/api/subscriptions/affiliate",
+      {
+        method: "POST",
+        body: value,
+      }
+    );
+  }
+
+  function updateSeatsById({
+    subscriptionId = "",
+    seats = 0,
+    amount = 0,
+    promoCode = "",
+  } = {}) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/subscriptions/seats/${subscriptionId}`,
+      {
+        method: "PUT",
+        body: {
+          seats,
+          amount,
+          promoCode,
+        },
+      }
+    );
+  }
+
+  return {
+    add,
+    getById,
+    getByOrgId,
+    getSubscriptions,
+    affSubscriptionStatus,
+    affiliateSubscription,
+    orgSubscriptionStatus,
+    orgSubscription,
+    getSubscriptionStatusById,
+    cancelSubscription,
+    initAffiliateSubscription,
+    initOrgSubscription,
+    getByAffiliateId,
+    updateSeatsById,
+  };
+}

package/composables/useUser.ts

@@ -1,48 +1,58 @@
 export default function useUser() {
   function inviteUser({ email = "", app = "", role = "", name = "" } = {}) {
-    return useNuxtApp().$api<TKeyValuePair>("/api/auth/invite", {
+    return useNuxtApp().$api<Record<string, any>>("/api/auth/invite", {
       method: "POST",
       body: { email, app, role, name },
     });
   }
 
-  function updateName({ firstName = "", lastName = "" } = {}) {
-    return useNuxtApp().$api<TKeyValuePair>("/api/users/name", {
+  function updateName(name = "") {
+    return useNuxtApp().$api<Record<string, any>>("/api/users/name", {
       method: "PUT",
-      body: { firstName, lastName },
+      body: { name },
     });
   }
 
-  function updateBirthday({ month = "", day = 0, year = 0 } = {}) {
-    return useNuxtApp().$api<TKeyValuePair>("/api/users/birthday", {
-      method: "PUT",
+  function updateBirthday(id: string, { month = "", day = 0, year = 0 } = {}) {
+    return useNuxtApp().$api<Record<string, any>>(`/api/users/birthday/${id}`, {
+      method: "PATCH",
       body: { month, day, year },
     });
   }
 
   function updateGender(gender = "") {
-    return useNuxtApp().$api<TKeyValuePair>("/api/users/gender", {
+    return useNuxtApp().$api<Record<string, any>>("/api/users/gender", {
       method: "PUT",
       body: { gender },
     });
   }
 
   function updateEmail(email = "") {
-    return useNuxtApp().$api<TKeyValuePair>("/api/users/email", {
+    return useNuxtApp().$api<Record<string, any>>("/api/users/email", {
       method: "PUT",
       body: { email },
     });
   }
 
   function updateContact(contact = "") {
-    return useNuxtApp().$api<TKeyValuePair>("/api/users/contact", {
+    return useNuxtApp().$api<Record<string, any>>("/api/users/contact", {
       method: "PUT",
       body: { contact },
     });
   }
 
+  function updatePassword(
+    id: string,
+    { currentPassword = "", newPassword = "", passwordConfirmation = "" }
+  ) {
+    return useNuxtApp().$api<Record<string, any>>(`/api/users/password/${id}`, {
+      method: "PATCH",
+      body: { currentPassword, newPassword, passwordConfirmation },
+    });
+  }
+
   function updateUserFieldById(id = "", field = "", value = "") {
-    return useNuxtApp().$api<TKeyValuePair>(`/api/users/field/${id}`, {
+    return useNuxtApp().$api<Record<string, any>>(`/api/users/field/${id}`, {
       method: "PATCH",
       body: { field, value },
     });
@@ -54,14 +64,14 @@ export default function useUser() {
     search = "",
     page = 1,
   } = {}) {
-    return useNuxtApp().$api<TKeyValuePair>("/api/users", {
+    return useNuxtApp().$api<Record<string, any>>("/api/users", {
       method: "GET",
       query: { status, search, page, type },
     });
   }
 
   function getById(id = "") {
-    return useNuxtApp().$api<TKeyValuePair>(`/api/users/id/${id}`, {
+    return useNuxtApp().$api<Record<string, any>>(`/api/users/id/${id}`, {
       method: "GET",
     });
   }
@@ -72,12 +82,24 @@ export default function useUser() {
     password = "",
     id = "",
   } = {}) {
-    return useNuxtApp().$api<TKeyValuePair>(`/api/users/invite/${id}`, {
+    return useNuxtApp().$api<Record<string, any>>(`/api/users/invite/${id}`, {
       method: "POST",
       body: { firstName, lastName, password },
     });
   }
 
+  function createUserByVerification({
+    name = "",
+    password = "",
+    id = "",
+    type = "",
+  } = {}) {
+    return useNuxtApp().$api<Record<string, any>>(`/api/users/invite/${id}`, {
+      method: "POST",
+      body: { name, password, type },
+    });
+  }
+
   return {
     inviteUser,
     updateName,
@@ -85,9 +107,11 @@ export default function useUser() {
     updateGender,
     updateEmail,
     updateContact,
+    updatePassword,
     updateUserFieldById,
     getUsers,
     createUserByInvite,
     getById,
+    createUserByVerification,
   };
 }