@goweekdays/layer-common 0.0.1

package/composables/useLocal.ts

@@ -0,0 +1,53 @@
+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_BOOK_KEEPING } = appConfig;
+
+  const apps = computed(() => {
+    return [
+      {
+        title: "Inventory Management",
+        icon: "mdi-warehouse",
+        link: APP_INVENTORY as string,
+        landingPage: "home",
+      },
+      {
+        title: "Asset Management",
+        icon: "mdi-package-variant-closed",
+        link: APP_ASSET as string,
+        landingPage: "home",
+      },
+      {
+        title: "Bookkeeping Management",
+        icon: "mdi-file-document-multiple",
+        link: APP_BOOK_KEEPING as string,
+        landingPage: "home",
+      },
+    ];
+  });
+
+  function redirect(link: string, page?: string) {
+    const href = page ? `${link}/${page}` : link;
+
+    window.location.href = href;
+  }
+
+  const headerSearch = useState("headerSearch", () => "");
+
+  return {
+    cookieConfig,
+    getUserFromCookie,
+    drawer,
+    apps,
+    redirect,
+    headerSearch,
+  };
+}

package/composables/useLocalAuth.ts

@@ -0,0 +1,117 @@
+export default function useLocalAuth() {
+  const { cookieConfig } = useRuntimeConfig().public;
+
+  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);
+      }
+    }
+  }
+
+  const currentUser = useState((): TUser | null => null);
+
+  async function getCurrentUser() {
+    const user = useCookie("user", cookieConfig).value;
+    if (!user) return null;
+    const _user = await useNuxtApp().$api<TUser>(`/api/users/id/${user}`, {
+      method: "GET",
+    });
+    currentUser.value = _user;
+    return _user;
+  }
+
+  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 {
+    login,
+    logout,
+    clearCookies,
+    getCurrentUser,
+    setToken,
+    forgotPassword,
+    resetPassword,
+    currentUser,
+    verify,
+    signUp,
+  };
+}

package/composables/useOrg.ts

@@ -0,0 +1,73 @@
+export default function useOrg() {
+  function getOrgs({ page = 1, search = "", user = "" } = {}) {
+    return useNuxtApp().$api<Array<TOrg>>("/api/organizations", {
+      method: "GET",
+      query: {
+        page,
+        search,
+        user,
+      },
+    });
+  }
+
+  const org = useState("org", (): TOrg => {
+    return {
+      _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", () => 0);
+  const total = computed(() => seats.value * perSeatPrice);
+
+  function getByName(name = "") {
+    return useNuxtApp().$api<TOrg>(`/api/organizations/name/${name}`, {
+      method: "GET",
+    });
+  }
+
+  return {
+    org,
+    getOrgs,
+    reset,
+    set,
+    perSeatPrice,
+    seats,
+    total,
+    getByName,
+  };
+}

package/composables/usePaymentMethod.ts

@@ -0,0 +1,69 @@
+export default function usePaymentMethod() {
+  function linkEWallet({
+    mobile_number = "",
+    type = "GCASH",
+    success_return_url = "",
+    failure_return_url = "",
+    cancel_return_url = "",
+    subscriptionData = {},
+  } = {}) {
+    return useNuxtApp().$api<Record<string, any>>(
+      "/api/payment-methods/e-wallet",
+      {
+        method: "POST",
+        body: {
+          mobile_number,
+          type,
+          success_return_url,
+          failure_return_url,
+          cancel_return_url,
+          subscriptionData,
+        },
+      }
+    );
+  }
+
+  function linkCard({
+    cardType = "",
+    cardNumber = "",
+    expiryMonth = "",
+    expiryYear = "",
+    cvv = "",
+    cardholderName = "",
+    currency = "",
+    success_return_url = "",
+    failure_return_url = "",
+    subscriptionData = {},
+  } = {}) {
+    return useNuxtApp().$api<Record<string, any>>("/api/payment-methods/card", {
+      method: "POST",
+      body: {
+        cardType,
+        cardNumber,
+        expiryMonth,
+        expiryYear,
+        cvv,
+        cardholderName,
+        currency,
+        success_return_url,
+        failure_return_url,
+        subscriptionData,
+      },
+    });
+  }
+
+  function getByUser() {
+    return useNuxtApp().$api<Array<Record<string, any>>>(
+      "/api/payment-methods",
+      {
+        method: "GET",
+      }
+    );
+  }
+
+  return {
+    linkEWallet,
+    linkCard,
+    getByUser,
+  };
+}

package/composables/usePermission.ts

@@ -0,0 +1,54 @@
+export default function usePermission() {
+  // Permission-Based Access Control with Dynamic Role Creation
+
+  // Utility to list all resources and their actions
+  function listPermissions(permissions: TPermissions): {
+    resource: string;
+    actions: { title: string; description: string }[];
+  }[] {
+    return Object.entries(permissions).map(([resource, actions]) => ({
+      resource,
+      actions: Object.entries(actions).map(([action, { description }]) => ({
+        title: action,
+        description,
+      })),
+    }));
+  }
+
+  // Utility to check if a user has permission
+  function hasPermission(
+    user: TRole,
+    permissions: TPermissions,
+    resource: string,
+    action: string,
+    data?: any
+  ): boolean {
+    const permissionKey = `${resource}:${action}`;
+
+    // Check if the permission exists in the user's permission array
+    if (!user.permissions?.includes(permissionKey)) {
+      return false;
+    }
+
+    const resourcePermissions = permissions[resource];
+    if (!resourcePermissions || !resourcePermissions[action]) {
+      return false;
+    }
+
+    const permissionCheck = resourcePermissions[action].check;
+
+    // Evaluate the permission check
+    if (typeof permissionCheck === "boolean") {
+      return permissionCheck;
+    } else if (typeof permissionCheck === "function") {
+      return permissionCheck(user, data);
+    }
+
+    return false;
+  }
+
+  return {
+    listPermissions,
+    hasPermission,
+  };
+}

package/composables/useRecapPermission.ts

@@ -0,0 +1,26 @@
+export default function useRecapPermission() {
+  const permissions: TPermissions = {
+    request: {
+      "create-request": {
+        check: true,
+        description: "Create a new request.",
+      },
+      "review-request": {
+        check: true,
+        description: "Review a request.",
+      },
+      "approve-request": {
+        check: true,
+        description: "Approve a request.",
+      },
+      "delete-request": {
+        check: true,
+        description: "Delete authored request.",
+      },
+    },
+  };
+
+  return {
+    permissions,
+  };
+}

package/composables/useRole.ts

@@ -0,0 +1,73 @@
+export default function useRole() {
+  function createRole(
+    { name, permissions, type } = {} as {
+      name: string;
+      permissions: Array<string>;
+      type: string;
+    }
+  ) {
+    return useNuxtApp().$api("/api/roles", {
+      method: "POST",
+      body: { name, permissions, type },
+    });
+  }
+
+  function getRoles({ search = "", page = 1, limit = 20, type = "" } = {}) {
+    return useNuxtApp().$api<TKeyValuePair>("/api/roles", {
+      method: "GET",
+      query: { search, page, limit, type },
+    });
+  }
+
+  function getRoleById(id: string) {
+    return useNuxtApp().$api<TKeyValuePair>(`/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 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(`/api/roles/${_id}`, {
+      method: "DELETE",
+    });
+  }
+
+  const role = useState<TRole>("userRole", () => {
+    return {
+      _id: "",
+      name: "",
+      permissions: [],
+      description: "",
+      createdAt: "",
+      updatedAt: "",
+      deletedAt: "",
+    };
+  });
+
+  return {
+    role,
+    createRole,
+    getRoles,
+    getRoleById,
+    updateRoleById,
+    updateRoleFieldById,
+    deleteRole,
+  };
+}

package/composables/useSubscription.ts

@@ -0,0 +1,94 @@
+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<TSubscription>(`/api/subscriptions/id/${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 checkSubscription() {
+    const { currentUser } = useLocalAuth();
+
+    if (currentUser.value && currentUser.value._id) {
+      try {
+        const result = await getSubscriptionStatusById(currentUser.value._id);
+        affiliateSubscription.value = result.status;
+      } catch (error) {
+        console.error("failed to get the subscription", error);
+      }
+    }
+  }
+
+  function initAffiliateSubscription(
+    customer_id: string,
+    amount: number,
+    payment_method_id: string,
+    currency?: string
+  ) {
+    return useNuxtApp().$api("/api/subscriptions/affiliate", {
+      method: "POST",
+      body: {
+        customer_id,
+        amount,
+        payment_method_id,
+        currency,
+      },
+    });
+  }
+
+  type TOrgSubscription = {
+    customer_id: string;
+    amount: number;
+    payment_method_id: string;
+    currency?: string;
+    organization: TOrg;
+    billingAddress: TAddress;
+  };
+
+  function initOrgSubscription(value: TOrgSubscription) {
+    return useNuxtApp().$api("/api/subscriptions/organization", {
+      method: "POST",
+      body: value,
+    });
+  }
+
+  return {
+    add,
+    getById,
+    getSubscriptions,
+    affiliateSubscription,
+    checkSubscription,
+    getSubscriptionStatusById,
+    cancelSubscription,
+    initAffiliateSubscription,
+    initOrgSubscription,
+  };
+}

package/composables/useUser.ts

@@ -0,0 +1,95 @@
+export default function useUser() {
+  function inviteUser({ email = "", app = "", role = "", name = "" } = {}) {
+    return useNuxtApp().$api<TKeyValuePair>("/api/auth/invite", {
+      method: "POST",
+      body: { email, app, role, name },
+    });
+  }
+
+  function updateName({ firstName = "", lastName = "" } = {}) {
+    return useNuxtApp().$api<TKeyValuePair>("/api/users/name", {
+      method: "PUT",
+      body: { firstName, lastName },
+    });
+  }
+
+  function updateBirthday({ month = "", day = 0, year = 0 } = {}) {
+    return useNuxtApp().$api<TKeyValuePair>("/api/users/birthday", {
+      method: "PUT",
+      body: { month, day, year },
+    });
+  }
+
+  function updateGender(gender = "") {
+    return useNuxtApp().$api<TKeyValuePair>("/api/users/gender", {
+      method: "PUT",
+      body: { gender },
+    });
+  }
+
+  function updateEmail(email = "") {
+    return useNuxtApp().$api<TKeyValuePair>("/api/users/email", {
+      method: "PUT",
+      body: { email },
+    });
+  }
+
+  function updateContact(contact = "") {
+    return useNuxtApp().$api<TKeyValuePair>("/api/users/contact", {
+      method: "PUT",
+      body: { contact },
+    });
+  }
+
+  function updateUserFieldById(id = "", field = "", value = "") {
+    return useNuxtApp().$api<TKeyValuePair>(`/api/users/field/${id}`, {
+      method: "PATCH",
+      body: { field, value },
+    });
+  }
+
+  function getUsers({
+    status = "active",
+    type = "",
+    search = "",
+    page = 1,
+  } = {}) {
+    return useNuxtApp().$api<TKeyValuePair>("/api/users", {
+      method: "GET",
+      query: { status, search, page, type },
+    });
+  }
+
+  function getById(id = "") {
+    return useNuxtApp().$api<TKeyValuePair>(`/api/users/id/${id}`, {
+      method: "GET",
+    });
+  }
+
+  function createUserByVerification({
+    firstName = "",
+    lastName = "",
+    password = "",
+    id = "",
+    referralCode = "",
+    type = "",
+  } = {}) {
+    return useNuxtApp().$api<TKeyValuePair>(`/api/users/invite/${id}`, {
+      method: "POST",
+      body: { firstName, lastName, password, referralCode, type },
+    });
+  }
+
+  return {
+    inviteUser,
+    updateName,
+    updateBirthday,
+    updateGender,
+    updateEmail,
+    updateContact,
+    updateUserFieldById,
+    getUsers,
+    createUserByVerification,
+    getById,
+  };
+}