@eeplatform/nuxt-layer-common 1.0.0

package/composables/useSubscription.ts

@@ -0,0 +1,264 @@
+export default function useSubscription() {
+  function createSubscriptionPlan(
+    seats: number,
+    trialDays: number,
+    productId: string
+  ) {
+    return useNuxtApp().$api("/api/subscriptions/plan", {
+      method: "POST",
+      body: {
+        seats,
+        trialDays,
+        productId,
+      },
+    });
+  }
+
+  function add(subscriptionId: string, user: string) {
+    return useNuxtApp().$api("/api/subscriptions", {
+      method: "POST",
+      body: {
+        subscriptionId,
+        user,
+      },
+    });
+  }
+
+  function addBillingContactById(id: string, email: string) {
+    return useNuxtApp().$api(`/api/subscriptions/billing-contact/${id}`, {
+      method: "PUT",
+      body: {
+        email,
+      },
+    });
+  }
+
+  function updateBillingContactByAddedAt(
+    id: string,
+    addedAt: string,
+    email: string
+  ) {
+    return useNuxtApp().$api(
+      `/api/subscriptions/billing-contact/${id}/added-at/${addedAt}`,
+      {
+        method: "PUT",
+        body: {
+          email,
+        },
+      }
+    );
+  }
+
+  function deleteBillingContactByAddedAt(id: string, addedAt: string) {
+    return useNuxtApp().$api(
+      `/api/subscriptions/billing-contact/${id}/added-at/${addedAt}`,
+      {
+        method: "DELETE",
+      }
+    );
+  }
+
+  function getById(id: string) {
+    return useNuxtApp().$api<TSubscription>(`/api/subscriptions/id/${id}`);
+  }
+
+  function getByAffiliateId(id: string) {
+    return useNuxtApp().$api<TSubscription>(
+      `/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"
+  );
+
+  function updatePromoCodeById(id: string, promoCode: string) {
+    return useNuxtApp().$api(`/api/subscriptions/promo-code/${id}`, {
+      method: "PUT",
+      body: {
+        promoCode,
+      },
+    });
+  }
+
+  function updateStatusById(id: string, status: string) {
+    return useNuxtApp().$api(`/api/subscriptions/status/${id}`, {
+      method: "PUT",
+      body: {
+        status,
+      },
+    });
+  }
+
+  function updatePaymentMethodById(id: string, paymentMethodId: string) {
+    return useNuxtApp().$api(`/api/subscriptions/payment-method/${id}`, {
+      method: "PUT",
+      body: {
+        paymentMethodId,
+      },
+    });
+  }
+
+  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 data = await getByOrgId(currentOrg.value);
+        orgSubscription.value = data?.status as string;
+      } catch (error) {
+        console.error("failed to get the subscription", error);
+      }
+    }
+  }
+
+  type TSub = {
+    customer_id: string;
+    amount: number;
+    payment_method_id: string;
+    payment_method_type: string;
+    payment_method_channel: 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({
+    transactionId = "",
+    subscriptionId = "",
+    seats = 0,
+    amount = 0,
+  } = {}) {
+    return useNuxtApp().$api<Record<string, any>>(
+      `/api/subscriptions/seats/${subscriptionId}`,
+      {
+        method: "PUT",
+        body: {
+          seats,
+          amount,
+          transactionId,
+        },
+      }
+    );
+  }
+
+  function processSubscriptionPayment(id: string, invoice: string) {
+    return useNuxtApp().$api(`/api/subscriptions/payment/id/${id}`, {
+      method: "PUT",
+      body: {
+        invoice,
+      },
+    });
+  }
+
+  function addOrgSubscription(value: {
+    user: string;
+    transactionId?: string;
+    promoCode?: string;
+    seats: number;
+    perSeatPrice: number;
+    currency: string;
+    org: {
+      name: string;
+      email: string;
+      contact: string;
+      busInst: string;
+      type: string;
+    };
+  }) {
+    return useNuxtApp().$api("/api/subscriptions/subscribe", {
+      method: "POST",
+      body: value,
+    });
+  }
+
+  return {
+    add,
+    getById,
+    getByOrgId,
+    getSubscriptions,
+    affSubscriptionStatus,
+    affiliateSubscription,
+    orgSubscriptionStatus,
+    orgSubscription,
+    getSubscriptionStatusById,
+    cancelSubscription,
+    initAffiliateSubscription,
+    initOrgSubscription,
+    getByAffiliateId,
+    updateSeatsById,
+    updatePromoCodeById,
+    updateStatusById,
+    updatePaymentMethodById,
+    addBillingContactById,
+    updateBillingContactByAddedAt,
+    deleteBillingContactByAddedAt,
+    processSubscriptionPayment,
+    createSubscriptionPlan,
+    addOrgSubscription,
+  };
+}

package/composables/useUser.ts

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

package/composables/useUtils.ts

@@ -0,0 +1,294 @@
+export default function useUtils() {
+  const requiredRule = (v: string) => !!v || "Required";
+
+  const emailRule = (v: string): true | string => {
+    const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return regex.test(v) || "Please enter a valid email address";
+  };
+
+  const validateDate = (value: string): boolean | string => {
+    const dateRegex = /^(0[1-9]|1[0-2])\/(0[1-9]|[12][0-9]|3[01])\/\d{4}$/;
+
+    if (!dateRegex.test(value)) return "Invalid date format (MM/DD/YYYY)";
+
+    return true;
+  };
+
+  function requireListRule(value: string[]) {
+    return value.length ? "" : "Required";
+  }
+
+  const minOneMonthAdvance = (value: string): boolean | string => {
+    if (!/^(0[1-9]|1[0-2])\/(0[1-9]|[12][0-9]|3[01])\/\d{4}$/.test(value)) {
+      return "Invalid date format (MM/DD/YYYY)";
+    }
+
+    const [month, day, year] = value.split("/").map(Number);
+    const selectedDate = new Date(year, month - 1, day);
+
+    const currentDate = new Date();
+    const minDate = new Date();
+    minDate.setMonth(currentDate.getMonth() + 1); // 1 month in advance
+
+    return (
+      selectedDate >= minDate || "Date must be at least 1 month in advance"
+    );
+  };
+
+  const passwordRule = (v: string) =>
+    v.length >= 8 || "Password must be at least 8 characters long";
+
+  const confirmPasswordRule =
+    (newPassword: Ref<string>, confirmPassword: Ref<string>) => () =>
+      confirmPassword.value === newPassword.value || "Passwords must match";
+
+  const validateEmail = (email: Ref<string>, emailErrors: Ref<string[]>) => {
+    emailErrors.value = [];
+
+    if (!email.value) {
+      emailErrors.value.push("Please input your email");
+    } else {
+      const result = emailRule(email.value);
+      if (result !== true) {
+        emailErrors.value.push(result);
+      }
+    }
+  };
+
+  const validateWord = (value: string): boolean | string => {
+    if (value.trim().length < 3) return "Must be at least 3 characters";
+    return true;
+  };
+
+  const validatePassword = (
+    password: Ref<string>,
+    passwordErrors: Ref<string[]>
+  ) => {
+    passwordErrors.value = [];
+
+    if (!password.value) {
+      passwordErrors.value.push("Please input your password");
+    } else if (!passwordRule(password.value)) {
+      passwordErrors.value.push("Password must be at least 8 characters long");
+    }
+  };
+
+  function back() {
+    useRouter().back();
+  }
+
+  function debounce<T extends (...args: any[]) => void>(
+    func: T,
+    wait: number
+  ): (...args: Parameters<T>) => void {
+    let timeoutId: ReturnType<typeof setTimeout>;
+
+    return function (...args: Parameters<T>) {
+      clearTimeout(timeoutId);
+      timeoutId = setTimeout(() => func(...args), wait);
+    };
+  }
+
+  function insertBetween(arr: any, elementToInsert: any) {
+    return arr.flatMap((item: any, index: number, array: any) =>
+      index < array.length - 1 ? [item, elementToInsert] : [item]
+    );
+  }
+
+  function getNameInitials(name: string) {
+    if (typeof name !== "string" || name.trim() === "") {
+      return ""; // Default fallback for invalid input
+    }
+
+    const words = name.trim().split(/\s+/); // Split by spaces
+
+    if (words.length === 1) {
+      return words[0].slice(0, 2).toUpperCase(); // Take first two letters of the single word
+    }
+
+    return words
+      .map((word) => word[0]?.toUpperCase()) // Take the first letter of each word and capitalize
+      .join("")
+      .slice(0, 2); // Limit to 2 characters
+  }
+
+  function getDimensions(
+    file: File
+  ): Promise<{ width: number; height: number }> {
+    const img = new Image();
+    img.src = URL.createObjectURL(file);
+    return new Promise((resolve, reject) => {
+      img.onload = () => {
+        const width = img.width;
+        const height = img.height;
+        resolve({ width, height });
+      };
+
+      img.onerror = () => {
+        reject(new Error("Failed to read image dimensions"));
+      };
+    });
+  }
+
+  async function getCountries() {
+    try {
+      const countries = await useNuxtApp().$api<Array<Record<string, any>>>(
+        "https://restcountries.com/v3.1/all?fields=name,currencies,idd",
+        { method: "GET" }
+      );
+
+      const uniqueCountries: Map<
+        string,
+        { index: string; name: string; code: string }
+      > = new Map();
+
+      countries.forEach((country) => {
+        let suffixes = country.idd?.suffixes?.[0] || "";
+        let code = `${country.idd?.root || ""}${suffixes}`;
+        let name = country.name?.common || "";
+
+        if (name && code && !uniqueCountries.has(code)) {
+          uniqueCountries.set(code, { index: `${name}-${code}`, name, code });
+        }
+      });
+
+      return Array.from(uniqueCountries.values()).sort((a, b) =>
+        a.name.localeCompare(b.name)
+      );
+    } catch (error) {
+      console.error(error);
+      throw new Error("Failed to fetch countries.");
+    }
+  }
+
+  const formatter = new Intl.NumberFormat("en-US", {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
+  });
+
+  function formatNumber(
+    amount: number,
+    options: {
+      currency?: string;
+      locale?: string;
+      useSymbol?: boolean;
+      decimalPlaces?: number;
+    } = {}
+  ): string {
+    const {
+      currency,
+      locale = "en-US",
+      useSymbol = false,
+      decimalPlaces = 2,
+    } = options;
+
+    return new Intl.NumberFormat(locale, {
+      style: useSymbol && currency ? "currency" : "decimal",
+      currency: currency || "USD", // Default currency (ignored if `useSymbol` is false)
+      minimumFractionDigits: decimalPlaces,
+      maximumFractionDigits: decimalPlaces,
+    }).format(amount);
+  }
+
+  // 🔹 Examples:
+  // console.log(formatNumber(1234.56)); // "1,234.56" (comma separator, 2 decimals)
+  // console.log(formatNumber(1234.56, { decimalPlaces: 0 })); // "1,234" (no decimals)
+  // console.log(formatNumber(1234.56, { useSymbol: true, currency: "USD" })); // "$1,234.56"
+  // console.log(formatNumber(1234.56, { useSymbol: true, currency: "PHP", decimalPlaces: 0 })); // "₱1,234"
+  // console.log(formatNumber(1234.56, { useSymbol: false, decimalPlaces: 0 })); // "1,234"
+  // console.log(formatNumber(1234.56, { useSymbol: true, currency: "EUR", locale: "de-DE" })); // "1.234,56 €"
+  // console.log(formatNumber(1234.56, { useSymbol: true, currency: "EUR", locale: "de-DE", decimalPlaces: 0 })); // "1.234 €"
+
+  function computeTieredCost(
+    seats: number,
+    tiers: { min: number; max: number; price: number }[],
+    remainingDays?: number,
+    totalDaysInMonth?: number
+  ) {
+    let totalCost = 0;
+
+    for (let i = 1; i <= seats; i++) {
+      for (const { min, max, price } of tiers) {
+        const effectiveMax = max === 0 ? Infinity : max;
+
+        if (i >= min && i <= effectiveMax) {
+          // Prorate the cost for this seat based on its tier price
+          if (remainingDays && totalDaysInMonth) {
+            totalCost += price * (remainingDays / totalDaysInMonth);
+            break;
+          }
+
+          totalCost += price;
+          break; // Stop checking once we apply the correct tier pricing
+        }
+      }
+    }
+
+    return totalCost; // This now returns the total prorated cost
+  }
+
+  function convertPermissionsToArray(permissions: TPermissions) {
+    return Object.entries(permissions).flatMap(([resource, actions]) =>
+      Object.keys(actions).map((action) => `${resource}:${action}`)
+    );
+  }
+
+  function extractMonthYear(expiry: string) {
+    const [month, year] = expiry.split("/");
+    return {
+      month: month.padStart(2, "0"),
+      year: 2000 + parseInt(year, 10),
+    };
+  }
+
+  function getRouteParam(field = "") {
+    if (!field) return "";
+
+    return (useRoute().params[field] as string) ?? "";
+  }
+
+  function replaceMatch(str: string, match: string, replace: string) {
+    return str.replace(new RegExp(match, "g"), replace);
+  }
+
+  function setRouteParams(...args: Array<Record<string, string>>) {
+    const params: Record<string, string> = {};
+
+    args.forEach((arg) => {
+      Object.entries(arg).forEach(([key, value]) => {
+        if (value !== undefined && value !== null && value !== "") {
+          params[key] = value;
+        }
+      });
+    });
+
+    return params;
+  }
+
+  return {
+    requiredRule,
+    emailRule,
+    passwordRule,
+    confirmPasswordRule,
+    validateEmail,
+    validatePassword,
+    back,
+    debounce,
+    insertBetween,
+    getNameInitials,
+    getDimensions,
+    validateWord,
+    getCountries,
+    formatter,
+    formatNumber,
+    validateDate,
+    minOneMonthAdvance,
+    computeTieredCost,
+    requireListRule,
+    convertPermissionsToArray,
+    extractMonthYear,
+    getRouteParam,
+    replaceMatch,
+    setRouteParams,
+  };
+}

package/composables/useVerification.ts

@@ -0,0 +1,19 @@
+export default function useUser() {
+  function getVerifications({
+    status = "pending",
+    type = "user-invite",
+    search = "",
+    page = 1,
+    email = "",
+    app = "",
+  } = {}) {
+    return useNuxtApp().$api<Record<string, any>>("/api/verifications", {
+      method: "GET",
+      query: { status, search, page, type, email, app },
+    });
+  }
+
+  return {
+    getVerifications,
+  };
+}