@eeplatform/nuxt-layer-common 1.0.0

package/composables/useLocal.ts

@@ -0,0 +1,63 @@
+export default function useLocal() {
+  const appConfig = useRuntimeConfig().public;
+
+  const { cookieConfig } = appConfig;
+
+  function getUserFromCookie() {
+    return useCookie("user", cookieConfig).value;
+  }
+
+  const drawer = useState("drawer", () => true);
+
+  const { APP_INVENTORY, APP_ASSET, APP_FINANCE } = appConfig;
+  const { currentOrg } = useOrg();
+
+  const apps = computed(() => {
+    return [
+      {
+        title: "Finance",
+        icon: "mdi-file-document-multiple",
+        link: APP_FINANCE as string,
+        landingPage: `org/${currentOrg.value ?? ""}`,
+      },
+      {
+        title: "Inventory",
+        icon: "mdi-warehouse",
+        link: APP_INVENTORY as string,
+        landingPage: `org/${currentOrg.value ?? ""}`,
+      },
+      {
+        title: "Asset",
+        icon: "mdi-package-variant-closed",
+        link: APP_ASSET as string,
+        landingPage: `org/${currentOrg.value ?? ""}`,
+      },
+    ];
+  });
+
+  function redirect(link: string, page?: string) {
+    const href = page ? `${link}/${page}` : link;
+
+    window.location.href = href;
+  }
+
+  const headerSearch = useState("headerSearch", () => "");
+
+  const items = ref<Array<Record<string, any>>>([]);
+  const page = ref(1);
+  const pages = ref(0);
+  const pageRange = ref("");
+
+  return {
+    cookieConfig,
+    getUserFromCookie,
+    drawer,
+    apps,
+    redirect,
+    headerSearch,
+    items,
+    page,
+    pages,
+    pageRange,
+  };
+}

package/composables/useLocalAuth.ts

@@ -0,0 +1,157 @@
+export default function useLocalAuth() {
+  const { cookieConfig } = useRuntimeConfig().public;
+
+  const currentUser = useState<TUser | null>("currentUser", () => null);
+
+  function authenticate() {
+    if (currentUser.value) {
+      return;
+    }
+
+    // Get access token from cookies
+    const accessToken = useCookie("accessToken", cookieConfig).value;
+
+    if (!accessToken) {
+      // Redirect to login page if no access token
+      navigateTo({ name: "index" });
+    }
+
+    const user = useCookie("user", cookieConfig).value;
+
+    const { data: getCurrentUserReq, error: getCurrentUserErr } =
+      useLazyAsyncData("get-current-user", () =>
+        useNuxtApp().$api<TUser>(`/api/users/id/${user}`)
+      );
+
+    watchEffect(() => {
+      if (getCurrentUserReq.value) {
+        currentUser.value = getCurrentUserReq.value;
+      }
+    });
+
+    watchEffect(() => {
+      if (getCurrentUserErr.value) {
+        // Redirect to login page if user authentication fails
+        navigateTo({ name: "index" });
+      }
+    });
+  }
+
+  async function login({ email = "", password = "", role = "" }) {
+    return useNuxtApp().$api<TKeyValuePair>("/api/auth/login", {
+      method: "POST",
+      body: JSON.stringify({ email, password, role }),
+    });
+  }
+
+  function setToken({
+    refreshToken = "",
+    accessToken = "",
+    user = "",
+    org = "",
+  }) {
+    useCookie("accessToken", cookieConfig).value = accessToken;
+    useCookie("refreshToken", cookieConfig).value = refreshToken;
+    useCookie("user", cookieConfig).value = user;
+    useCookie("org", cookieConfig).value = org;
+  }
+
+  function clearCookies() {
+    useCookie("accessToken", cookieConfig).value = null;
+    useCookie("refreshToken", cookieConfig).value = null;
+    useCookie("user", cookieConfig).value = null;
+    useCookie("organization", cookieConfig).value = null;
+  }
+
+  async function logout() {
+    const refreshToken = useCookie("refreshToken", cookieConfig).value;
+    if (refreshToken) {
+      try {
+        await useNuxtApp().$api(`/api/auth/logout/${refreshToken}`, {
+          method: "DELETE",
+        });
+
+        clearCookies();
+      } catch (error) {
+        console.error("Logout failed:", error);
+      }
+    }
+  }
+
+  async function getCurrentUser() {
+    const user = useCookie("user", cookieConfig).value;
+    if (!user) return null;
+    try {
+      const _user = await useNuxtApp().$api<TUser>(`/api/users/id/${user}`, {
+        method: "GET",
+      });
+
+      currentUser.value = _user;
+      return _user;
+    } catch (error) {
+      console.log("Error fetching current user:", error);
+    }
+  }
+
+  async function forgotPassword(email: string) {
+    if (!email) {
+      throw new Error("Email is required for password reset request.");
+    }
+
+    try {
+      const response = await useNuxtApp().$api("/api/auth/forget-password", {
+        method: "POST",
+        body: JSON.stringify({ email }),
+        headers: { "Content-Type": "application/json" },
+      });
+      return response;
+    } catch (error) {
+      console.error("Error in password reset request:", error);
+      throw error;
+    }
+  }
+
+  async function resetPassword(
+    otp: string,
+    newPassword: string,
+    passwordConfirmation: string
+  ) {
+    try {
+      return await useNuxtApp().$api("/api/auth/reset-password", {
+        method: "POST",
+        body: JSON.stringify({ otp, newPassword, passwordConfirmation }),
+        headers: { "Content-Type": "application/json" },
+      });
+    } catch (error) {
+      console.error("Error resetting password:", error);
+      throw error;
+    }
+  }
+
+  function verify(id: string) {
+    return useNuxtApp().$api<TKeyValuePair>(`/api/auth/verify/${id}`, {
+      method: "GET",
+    });
+  }
+
+  function signUp(email: string, referral: string) {
+    return useNuxtApp().$api<TKeyValuePair>("/api/auth/sign-up", {
+      method: "POST",
+      body: { email, referral },
+    });
+  }
+
+  return {
+    authenticate,
+    login,
+    logout,
+    clearCookies,
+    getCurrentUser,
+    setToken,
+    forgotPassword,
+    resetPassword,
+    currentUser,
+    verify,
+    signUp,
+  };
+}

package/composables/useLocalSetup.ts

@@ -0,0 +1,46 @@
+export function useLocalSetup(type: string, org?: string) {
+  const { currentUser } = useLocalAuth();
+
+  const userId = computed(() => currentUser.value?._id ?? "");
+
+  const { getByUserType } = useMember();
+
+  const { data: userMemberData, error: userMemberError } = useLazyAsyncData(
+    "get-member-by-id",
+    () => getByUserType(userId.value, type, org),
+    { watch: [userId], immediate: false }
+  );
+
+  watchEffect(() => {
+    if (userMemberError.value) {
+      navigateTo({
+        name: "index",
+      });
+    }
+  });
+
+  const { getRoleById } = useRole();
+
+  const roleId = computed(() => userMemberData.value?.role ?? "");
+
+  const userAppRole = useState<Record<string, any> | null>(
+    "userAppRole",
+    () => null
+  );
+
+  const { data: getRoleByIdReq } = useLazyAsyncData(
+    "get-role-by-id",
+    () => getRoleById(roleId.value),
+    { watch: [roleId], immediate: false }
+  );
+
+  watchEffect(() => {
+    if (getRoleByIdReq.value) {
+      userAppRole.value = getRoleByIdReq.value;
+    }
+  });
+
+  return {
+    userAppRole,
+  };
+}

package/composables/useMember.ts

@@ -0,0 +1,107 @@
+export default function useMember() {
+  const members = useState<Array<TMember>>("members", () => []);
+  const page = useState("page", () => 1);
+  const pages = useState("pages", () => 0);
+  const pageRange = useState("pageRange", () => "-- - -- of --");
+
+  const member = useState<TMember>("member", () => ({
+    _id: "",
+    org: "",
+    orgName: "",
+    roleName: "",
+    name: "",
+    user: "",
+    role: "",
+    type: "",
+    customerOrgId: "",
+    customerSiteId: "",
+    status: "",
+    createdAt: "",
+    updatedAt: "",
+    deletedAt: "",
+  }));
+
+  function getByUserId(user: string) {
+    return useNuxtApp().$api<TMember>(`/api/members/user/${user}`);
+  }
+
+  function getByUserType(user: string, type: string, org?: string) {
+    return useNuxtApp().$api<TMember>(`/api/members/user/${user}/app/${type}`, {
+      method: "GET",
+      query: { org },
+    });
+  }
+
+  async function getAll({
+    page = 1,
+    search = "",
+    limit = 10,
+    user = "",
+    org = "",
+    type = "",
+    status = "active",
+  } = {}) {
+    return useNuxtApp().$api<Record<string, any>>("/api/members", {
+      method: "GET",
+      query: { page, limit, search, user, org, type, status },
+    });
+  }
+  function createUserByVerification(
+    verificationId: string,
+    payload: Record<string, any>
+  ) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/users/invite/${verificationId}`,
+      {
+        method: "POST",
+        body: payload,
+      }
+    );
+  }
+
+  function createMemberInvite(verificatonId: string) {
+    return useNuxtApp().$api<TMember>(
+      `/api/members/verification/${verificatonId}`,
+      {
+        method: "POST",
+      }
+    );
+  }
+  function updateMemberStatus(id: string, status: string) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/members/status/${status}/id/${id}`,
+      {
+        method: "PUT",
+      }
+    );
+  }
+
+  function updateMemberRole(
+    id: string,
+    role: string,
+    type: string,
+    org: string
+  ) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/members/id/${id}/role/${role}/type/${type}/org/${org}`,
+      {
+        method: "PUT",
+      }
+    );
+  }
+  return {
+    members,
+    member,
+    page,
+    pages,
+    pageRange,
+
+    getAll,
+    getByUserId,
+    createUserByVerification,
+    createMemberInvite,
+    getByUserType,
+    updateMemberStatus,
+    updateMemberRole,
+  };
+}

package/composables/useOrder.ts

@@ -0,0 +1,22 @@
+export default function useOrder() {
+  function getOrders({
+    search = "",
+    id = "",
+    page = 1,
+    status = "succeeded",
+  } = {}) {
+    return useNuxtApp().$api<Record<string, any>>("/api/orders", {
+      method: "GET",
+      query: {
+        search,
+        id,
+        page,
+        status,
+      },
+    });
+  }
+
+  return {
+    getOrders,
+  };
+}

package/composables/useOrg.ts

@@ -0,0 +1,106 @@
+export default function useOrg() {
+  function getAll({ page = 1, search = "", limit = 20, status = "" } = {}) {
+    return useNuxtApp().$api<Record<string, any>>("/api/organizations", {
+      method: "GET",
+      query: {
+        page,
+        search,
+        limit,
+        status,
+      },
+    });
+  }
+
+  function getById(id = "") {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/organizations/id/${id}`,
+      {
+        method: "GET",
+      }
+    );
+  }
+
+  function getByUserId({ page = 1, search = "", user = "", limit = 20 } = {}) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/organizations/user/${user}`,
+      {
+        method: "GET",
+        query: {
+          page,
+          search,
+          limit,
+        },
+      }
+    );
+  }
+
+  const org = ref({
+    _id: "",
+    name: "",
+    email: "",
+    contact: "",
+    busInst: "",
+    type: "",
+    status: "",
+  });
+
+  function reset() {
+    org.value._id = "";
+    org.value.name = "";
+    org.value.email = "";
+    org.value.contact = "";
+    org.value.busInst = "";
+    org.value.type = "";
+    org.value.status = "";
+  }
+
+  function set({
+    _id = "",
+    name = "",
+    email = "",
+    contact = "",
+    busInst = "",
+    type = "",
+    status = "",
+  } = {}) {
+    org.value._id = _id;
+    org.value.name = name;
+    org.value.email = email;
+    org.value.contact = contact;
+    org.value.busInst = busInst;
+    org.value.type = type;
+    org.value.status = status;
+  }
+
+  const perSeatPrice = 300;
+  const seats = useState("seats", () => 1);
+  const total = computed(() => seats.value * perSeatPrice);
+
+  function getByName(name = "") {
+    return useNuxtApp().$api<TOrg>(`/api/organizations/name/${name}`, {
+      method: "GET",
+    });
+  }
+
+  const { currentUser } = useLocalAuth();
+
+  const currentOrg = computed(
+    () =>
+      (useRoute().params.organization as string) ||
+      currentUser.value?.defaultOrg
+  );
+
+  return {
+    org,
+    getAll,
+    getByUserId,
+    reset,
+    set,
+    perSeatPrice,
+    seats,
+    total,
+    getByName,
+    currentOrg,
+    getById,
+  };
+}

package/composables/useOrgPermission.ts

@@ -0,0 +1,27 @@
+export function useOrgPermission() {
+  const { memberPermissions, rolePermissions, invitationPermission } =
+    useCommonPermissions();
+  const permissions: TPermissions = {
+    organizations: {
+      "create-organization": {
+        check: true,
+        description: "Create Organization",
+      },
+      "view-organization": {
+        check: true,
+        description: "View Organization",
+      },
+      "view-organization-details": {
+        check: true,
+        description: "View Organization Details",
+      },
+    },
+    members: memberPermissions,
+    invitations: invitationPermission,
+    roles: rolePermissions,
+  };
+
+  return {
+    permissions,
+  };
+}

package/composables/usePayment.ts

@@ -0,0 +1,22 @@
+export default function usePayment() {
+  function getPayments({
+    search = "",
+    id = "",
+    page = 1,
+    status = "completed",
+  } = {}) {
+    return useNuxtApp().$api<Record<string, any>>("/api/payments", {
+      method: "GET",
+      query: {
+        search,
+        id,
+        page,
+        status,
+      },
+    });
+  }
+
+  return {
+    getPayments,
+  };
+}