@eeplatform/nuxt-layer-common 1.0.0

package/composables/usePaymentMethod.ts

@@ -0,0 +1,347 @@
+import { z } from "zod";
+
+export default function usePaymentMethod() {
+  function linkEWallet({
+    type = "GCASH",
+    customer_id = "",
+    success_return_url = "",
+    failure_return_url = "",
+    cancel_return_url = "",
+    category = "individual",
+  } = {}) {
+    return useNuxtApp().$api<Record<string, any>>(
+      "/api/payment-methods/e-wallet",
+      {
+        method: "POST",
+        body: {
+          customer_id,
+          type,
+          success_return_url,
+          failure_return_url,
+          cancel_return_url,
+          category,
+        },
+      }
+    );
+  }
+
+  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(user = "") {
+    return useNuxtApp().$api<Array<Record<string, any>>>(
+      `/api/payment-methods/user/${user}`,
+      {
+        method: "GET",
+      }
+    );
+  }
+
+  function getByOrg(org = "") {
+    return useNuxtApp().$api<Array<Record<string, any>>>(
+      `/api/payment-methods/org/${org}`,
+      {
+        method: "GET",
+      }
+    );
+  }
+
+  function getById(id = "") {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/payment-methods/id/${id}`
+    );
+  }
+
+  function getByCustomerId(id = "") {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/payment-methods/customer/${id}`
+    );
+  }
+
+  const eWalletNumber = useState("eWalletNumber", () => "");
+  const cardNumber = useState("cardNumber", () => "");
+  const cardExpiration = useState("cardExpiration", () => "");
+  const cardSecurityCode = useState("cardSecurityCode", () => "");
+  const cardholderName = useState("cardholderName", () => "");
+  const cardholderMobileNumber = useState("cardholderMobileNumber", () => "");
+  const cardholderEmail = useState("cardholderEmail", () => "");
+  const selectedPaymentMethod = useState("selectedPaymentMethod", () => "");
+
+  function linkOnly(value: Record<string, any>) {
+    return useNuxtApp().$api<Record<string, any>>(
+      "/api/payment-methods/link-only",
+      {
+        method: "POST",
+        body: value,
+      }
+    );
+  }
+
+  const supportedEwallets = [
+    {
+      channel: "GCASH",
+      logo: "/gcash-logo.svg",
+      type: "EWALLET",
+      text: "GCash",
+    },
+    {
+      channel: "PAYMAYA",
+      logo: "/paymaya-logo.svg",
+      type: "EWALLET",
+      text: "PayMaya",
+    },
+    {
+      channel: "GRABPAY",
+      logo: "/grabpay-logo.svg",
+      type: "EWALLET",
+      text: "GrabPay",
+    },
+    {
+      channel: "SHOPEEPAY",
+      logo: "/shopeepay-logo.svg",
+      type: "EWALLET",
+      text: "ShopeePay",
+    },
+  ];
+
+  const supportedDirectDebit = [
+    {
+      channel: "UBP",
+      logo: "/ubp-logo.svg",
+      type: "DIRECT_DEBIT",
+      text: "BA_UBP",
+    },
+    {
+      channel: "BDO",
+      logo: "/bdo-logo.svg",
+      type: "DIRECT_DEBIT",
+      text: "BDO",
+    },
+    {
+      channel: "BPI",
+      logo: "/bpi-logo.svg",
+      type: "DIRECT_DEBIT",
+      text: "BA_BPI",
+    },
+    {
+      channel: "RCBC",
+      logo: "/rcbc-logo.svg",
+      type: "DIRECT_DEBIT",
+      text: "RCBC",
+    },
+    {
+      channel: "Chinabank",
+      logo: "/chinabank-logo.svg",
+      type: "DIRECT_DEBIT",
+      text: "Chinabank",
+    },
+  ];
+
+  const supportedPaymentMethods = [
+    ...supportedEwallets,
+    ...supportedDirectDebit,
+  ];
+
+  const { updatePaymentMethodById } = useSubscription();
+
+  const linkingOverlay = useState("linkingOverlay", () => false);
+  const updatingPaymentMethod = useState("updatingPaymentMethod", () => false);
+  const linkingMessage = useState("linkingMessage", () => "");
+  const paymentMethod = useState(
+    "paymentMethod",
+    (): Record<string, any> | null => null
+  );
+
+  function reset() {
+    eWalletNumber.value = "";
+    cardNumber.value = "";
+    cardExpiration.value = "";
+    cardSecurityCode.value = "";
+    cardholderName.value = "";
+    paymentMethod.value = null;
+  }
+
+  async function initLink(value: TLinkParams, callback?: Function) {
+    const validation = z.object({
+      subscriptionId: z.string().min(1).optional(),
+      paymentMethodType: z.enum(["EWALLET", "DIRECT_DEBIT", "CREDIT_CARD"]),
+      paymentMethodChannel: z.string().min(1),
+      customerId: z.string().min(1),
+      card_number: z.string().optional(),
+      expiry_month: z.string().optional(),
+      expiry_year: z.string().optional(),
+      card_security_code: z.string().optional(),
+      cardholder_name: z.string().optional(),
+    });
+
+    const parsed = validation.safeParse(value);
+
+    if (!parsed.success) {
+      throw new Error(
+        `Validation failed: ${parsed.error.issues
+          .map((issue) => `${issue.path.join(".")}: ${issue.message}`)
+          .join(", ")}`
+      );
+    }
+
+    linkingOverlay.value = true;
+    const success_return_url = `${window.origin}/payment-method-linked`;
+    const failure_return_url = `${window.origin}/payment-method-failed-link`;
+    const cancel_return_url = `${window.origin}/payment-method-cancel-link`;
+
+    const payload: Record<string, any> = {
+      type: value.paymentMethodType,
+      reusability: "MULTIPLE_USE",
+    };
+
+    if (payload.type === "EWALLET") {
+      payload.country = "PH";
+      payload.ewallet = {
+        channel_code: value.paymentMethodChannel,
+        channel_properties: {
+          success_return_url,
+          failure_return_url,
+          cancel_return_url,
+        },
+      };
+
+      payload.customer_id = value.customerId;
+    } else if (payload.type === "DIRECT_DEBIT") {
+      payload.direct_debit = {
+        channel_code: value.paymentMethodChannel,
+        channel_properties: {
+          success_return_url,
+          failure_return_url,
+        },
+      };
+      payload.customer_id = value.customerId;
+    } else if (payload.type === "CARD") {
+      payload.card = {
+        currency: "PHP",
+        channel_properties: {
+          success_return_url,
+          failure_return_url,
+          skip_three_d_secure: true,
+        },
+        card_information: {
+          card_number: value.card_number,
+          expiry_month: value.expiry_month,
+          expiry_year: value.expiry_year,
+          cvv: value.card_security_code,
+          cardholder_name: value.cardholder_name,
+        },
+      };
+    }
+
+    try {
+      const _paymentMethod = await linkOnly(payload);
+
+      // Open a small popup window
+      const popupWidth = 500;
+      const popupHeight = 600;
+      const left = (screen.width - popupWidth) / 2;
+      const top = (screen.height - popupHeight) / 2;
+
+      const popup = window.open(
+        _paymentMethod.actions[0].url,
+        "eWalletPopup",
+        `width=${popupWidth},height=${popupHeight},top=${top},left=${left},resizable=yes,scrollbars=yes`
+      );
+
+      // Check every 500ms if the popup is closed
+      const checkPopupClosed = setInterval(async () => {
+        if (!popup || popup.closed) {
+          clearInterval(checkPopupClosed);
+          console.log(
+            "Popup closed. Proceeding with subscription automation..."
+          );
+          // Call your function to handle subscription
+
+          const temp = await getById(_paymentMethod.id);
+
+          if (temp.status === "ACTIVE" && value.subscriptionId) {
+            await updatePaymentMethodById(
+              value.subscriptionId,
+              _paymentMethod.id as string
+            );
+
+            paymentMethod.value = await getById(_paymentMethod.id);
+          }
+
+          if (callback) {
+            callback();
+          }
+
+          updatingPaymentMethod.value = false;
+          linkingOverlay.value = false;
+        }
+      }, 500);
+    } catch (error: any) {
+      linkingMessage.value = error.response._data.message;
+    }
+  }
+
+  function updateStatusById(id: string, status: string) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/payment-methods/status/${id}`,
+      {
+        method: "PATCH",
+        body: { status },
+      }
+    );
+  }
+
+  return {
+    linkEWallet,
+    linkCard,
+    getByUser,
+    getByOrg,
+    eWalletNumber,
+    cardNumber,
+    cardExpiration,
+    cardSecurityCode,
+    cardholderName,
+    cardholderMobileNumber,
+    cardholderEmail,
+    selectedPaymentMethod,
+    reset,
+    linkOnly,
+    getById,
+    supportedPaymentMethods,
+    supportedDirectDebit,
+    supportedEwallets,
+    initLink,
+    linkingOverlay,
+    updatingPaymentMethod,
+    linkingMessage,
+    paymentMethod,
+    getByCustomerId,
+    updateStatusById,
+  };
+}

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/usePrice.ts

@@ -0,0 +1,15 @@
+export default function usePrice() {
+  function getByNameType(name: string, type: string) {
+    return useNuxtApp().$api<Record<string, any>>("/api/prices/price", {
+      method: "GET",
+      params: {
+        name,
+        type,
+      },
+    });
+  }
+
+  return {
+    getByNameType,
+  };
+}

package/composables/usePromoCode.ts

@@ -0,0 +1,43 @@
+export default function usePromoCode() {
+  function add(value: TPromoCode) {
+    return useNuxtApp().$api<Record<string, any>>("/api/promo-codes", {
+      method: "POST",
+      body: value,
+    });
+  }
+
+  function getPromoCodes({ search = "", page = 1, status = "active" } = {}) {
+    return useNuxtApp().$api<Record<string, any>>("/api/promo-codes", {
+      method: "GET",
+      query: {
+        search,
+        page,
+        status,
+      },
+    });
+  }
+
+  function getByCode(code: string, type?: string, assigned?: boolean) {
+    return useNuxtApp().$api<TPromoCode>("/api/promo-codes/code", {
+      method: "GET",
+      params: {
+        code,
+        type,
+        assigned,
+      },
+    });
+  }
+
+  function getById(id: string) {
+    return useNuxtApp().$api<TPromoCode>(`/api/promo-codes/id/${id}`, {
+      method: "GET",
+    });
+  }
+
+  return {
+    add,
+    getPromoCodes,
+    getByCode,
+    getById,
+  };
+}

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,89 @@
+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<Record<string, any>>(`/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("userRole", (): TRole => {
+    return {
+      _id: "",
+      name: "",
+      org: "",
+      permissions: [],
+      createdAt: "",
+      updatedAt: "",
+      deletedAt: "",
+      default: false,
+    };
+  });
+
+  return {
+    role,
+    createRole,
+    getRoles,
+    getRoleById,
+    updateRoleById,
+    updateRoleFieldById,
+    deleteRole,
+    updatePermissionById,
+  };
+}

package/composables/useSchoolPermission.ts

@@ -0,0 +1,13 @@
+export function useSchoolPermission() {
+  const { memberPermissions, rolePermissions, invitationPermission } =
+    useCommonPermissions();
+  const permissions: TPermissions = {
+    members: memberPermissions,
+    invitations: invitationPermission,
+    roles: rolePermissions,
+  };
+
+  return {
+    permissions,
+  };
+}