@lmnto/h-mall-shared 1.0.1

package/shared/types/upgradeCart.ts

@@ -0,0 +1,226 @@
+import { Store } from "./order";
+import { Commission } from "./payments";
+
+export interface IUpgradeCart {
+  userBID: string;
+  reference: string;
+  cartProducts: any &
+    {
+      shippingItems: Array<
+        any & {
+          oneCareIncluded: boolean;
+        }
+      >;
+    }[];
+  billingAddressId: number | null;
+  shippingAddressId: number | null;
+  storeId: number | null;
+  paymentMethodId: number | null;
+  id: number;
+  cartState: string;
+  subTotal: string;
+  feesTotal: string;
+  shippingTotal?: string;
+  taxTotal: string;
+  grandTotal: string;
+  isActive: boolean;
+  createdAt: string;
+  updatedAt: string;
+  fees: Fee[];
+  taxes: Tax[];
+  cartAsset: CartAsset;
+  store?: Store;
+  cashBacks?: null | CashBack[];
+
+  commissionSubTotal: string;
+  oneCareTotal: string;
+  orderId: string;
+  pickupCostTotal: string;
+  shippingCartAssetId: string;
+  shippingMethodId: number;
+  shippingMethod: ShippingMethod;
+  shippingCostTotal: string;
+  upgradeCostTotal: string;
+  userSubscriptionType: string;
+  shippingAddress: UserAddress;
+  billingAddress: UserAddress;
+  isShippingApplicable?: boolean;
+  paymentMethod: {
+    code: string;
+    id: number;
+    name: string;
+  };
+
+  shippingCartAsset: CartAsset;
+}
+
+type ShippingMethod = {
+  code: string;
+  description: string;
+  displayName: string;
+};
+type CartAsset = {
+  id: number;
+  cartId: number;
+  assetOption: {
+    id: number;
+    name: string;
+    symbol: string;
+    isActive: boolean;
+    optionId: number;
+    provider: string;
+    createdAt: string;
+    deletedAt: string;
+    isDeleted: boolean;
+    updatedAt: string;
+    isVariable: boolean;
+    optionName: string;
+    displayOrder: number;
+    optionSymbol: string;
+    isAssetActive: boolean;
+    minPercentage: number;
+    optionIsActive: boolean;
+    paymentMethodId: number;
+    isCommissionEnabled: boolean;
+    commissionMultiplier: {
+      base: {
+        cv: number;
+        vp: number;
+      };
+      option: {
+        cv: number;
+        vp: number;
+      };
+    };
+  };
+  calculatedCommision: Commission;
+  baseAssetName: string;
+  baseAssetSymbol: string;
+  baseAssetAmount: number;
+  baseAssetPercentage: number;
+  optionAssetName: string;
+  optionAssetSymbol: string;
+  optionAssetAmount: number;
+  optionAssetPercentage: string;
+  createdAt: string;
+  updatedAt: string;
+};
+type Fee = {
+  amount: string;
+  cartId: number;
+  feeCategory: string;
+  feeName: string;
+  id: number;
+  type: string;
+  value: string;
+};
+type Tax = {
+  amount: string;
+  cartId: number;
+  id: number;
+  taxCategory: string;
+  taxName: string;
+  type: string;
+  value: string;
+};
+
+export type CashBack = {
+  id: number;
+  shippingCartId: number;
+  assetName: string;
+  assetSymbol: string;
+  cashbackAssetId: number;
+  totalAmount: string;
+};
+
+export type cartProduct = {
+  id: number;
+  sku: string;
+  name: string;
+  featureImage: string;
+  category: cartProductCategory;
+  price: number;
+  canProductBeRemoved: boolean;
+  canUserPurchaseTheProduct: boolean;
+  feedBackMessage: string;
+  maximumUserCanPurchase: number | null;
+  totalOrderExistsForProduct: number | null;
+  userPurchaseLimit: number | null;
+};
+
+export type cartProductCategory = {
+  id: number;
+  code: string;
+  name: string;
+};
+
+export type CartTableItemComponentProps = {
+  id: number;
+  product: cartProduct;
+  quantity: number;
+  cartProducts: number;
+  userPurchaseLimit: number | null;
+  maximumUserCanPurchase: number | null;
+  totalOrderExistsForProduct: number | null;
+  feedBackMessage: string;
+  canUserPurchaseTheProduct: boolean;
+  canProductBeRemoved: boolean;
+};
+
+export type BillingAddress = {
+  address: string;
+  buildingInfo: string;
+  city: string;
+  country: string;
+  countryId: number;
+  createdAt: string;
+  deletedAt: string;
+  id: number;
+  isActive: boolean;
+  isDefault: boolean;
+  isDeleted: boolean;
+  latitude: string;
+  longitude: string;
+  state: string;
+  type: string;
+  updatedAt: string;
+  userId: number;
+};
+export type UserAddress = {
+  id: number;
+  userBID: string;
+  firstName: string;
+  lastName: string;
+  phone: string;
+  email: string;
+  countryId: 3;
+  countryCode: string;
+  city: string;
+  state: string;
+  postalCode: string;
+  address: string;
+  buildingInfo: string;
+  latitude: string;
+  longitude: string;
+  type: string;
+  isDefault: boolean;
+  isActive: boolean;
+  isDeleted: boolean;
+  createdAt: string;
+  updatedAt: string;
+  deletedAt: string;
+  country: {
+    id: 3;
+    name: string;
+    code: string;
+    alphaCode: string;
+    callingCode: string;
+    zipCodeExists: boolean;
+    zipCodeRegex: string;
+    isActive: boolean;
+    isDeleted: boolean;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt: string;
+  };
+};

package/shared/types/user.ts

@@ -0,0 +1,36 @@
+import { KYC_STATUS } from "../constants/app";
+
+export interface IUserProfile {
+  id: number;
+  bid: string;
+  email: string;
+  userName: string;
+  firstName: string;
+  lastName: string;
+  phone: string;
+  activeMembership: boolean;
+  walletConsentConfirmed: boolean;
+  originType: string;
+  subscriptionType: string | null;
+  accountType: string;
+  membershipExpiryDate: string | null;
+  picture: string;
+  pgUser: {
+    clientUserId: string;
+    status: KycStatus;
+    aletaHomnifiConsent: boolean;
+    aletaHomnifiConsentDate: string;
+    aletaState: KycStatus;
+    createdAt: string;
+    updatedAt: string;
+  };
+  subscriptionActivationPending?: boolean;
+}
+
+export interface DecodedToken {
+  exp: number;
+  iat: number;
+  [key: string]: any;
+}
+
+export type KycStatus = (typeof KYC_STATUS)[keyof typeof KYC_STATUS];

package/shared/utils/app.util.ts

@@ -0,0 +1,261 @@
+import React from "react";
+
+import { CATEGORY_FOR_AI_COMPUTING } from "../constants/app";
+import { DecodedToken } from "../types/user";
+
+export const timeUntilDate = (targetDateString: string | null): string => {
+  if (!targetDateString) {
+    return "N/A";
+  }
+  const targetDate = new Date(targetDateString);
+  const currentDate = new Date();
+
+  let years = targetDate.getFullYear() - currentDate.getFullYear();
+  let months = targetDate.getMonth() - currentDate.getMonth();
+  let days = targetDate.getDate() - currentDate.getDate();
+
+  if (days < 0) {
+    months--;
+    days += new Date(
+      currentDate.getFullYear(),
+      currentDate.getMonth() + 1,
+      0,
+    ).getDate();
+  }
+
+  if (months < 0) {
+    years--;
+    months += 12;
+  }
+
+  let timeRemaining: string;
+
+  if (years > 0) {
+    timeRemaining = `${years} year${years > 1 ? "s" : ""}`;
+  } else if (months > 0) {
+    timeRemaining = `${months} month${months > 1 ? "s" : ""}`;
+  } else if (days < 30) {
+    timeRemaining = `${days} day${days > 1 ? "s" : ""}`;
+  } else {
+    timeRemaining = "";
+  }
+
+  return timeRemaining
+    ? `in ${timeRemaining} (${targetDate.toLocaleDateString()})`
+    : "Date has passed";
+};
+
+export const handleDownload = async (
+  invoiceUrl: string,
+  orderId: string,
+  prefix: string = "INV",
+) => {
+  try {
+    const response = await fetch(invoiceUrl);
+
+    const blob = await response.blob();
+
+    const url = window.URL.createObjectURL(blob);
+
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = `${prefix}_${orderId}.pdf`;
+
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+
+    window.URL.revokeObjectURL(url);
+  } catch (error) {
+    console.error("Download failed:", error);
+  }
+};
+
+export const displayExactWalletBalance = (balance: string) => {
+  const data = balance.split(".");
+  if (!data?.[1]) return data[0];
+
+  return data[0] + "." + data[1].substring(0, 5);
+};
+
+export const customGroupBy = (
+  objectArray: any[],
+  key: any,
+  arrayValue: boolean = true,
+) => {
+  return objectArray.reduce((result, item) => {
+    const groupKey = typeof key === "function" ? key(item) : item[key];
+    if (!result[groupKey]) {
+      result[groupKey] = [];
+    }
+    if (arrayValue) {
+      result[groupKey].push(item);
+    } else {
+      result[groupKey] = item;
+    }
+
+    return result;
+  }, {});
+};
+
+export const replaceForbiddenKeyword = (input: string): string => {
+  return input.replace(/minter/gi, "Computer Device");
+};
+export const replaceComputerDevice = (input: string): string => {
+  return input.replace(/computer device/gi, "minter");
+};
+
+/**
+ * Function to check if any items in the data have a category code of "minter"
+ * @param {Array} orderItems - Array of order items to check
+ * @return {Boolean} - Returns true if any item has category code "minter", otherwise false
+ */
+export const hasMinterCategory = (orderItems) => {
+  const MINTER = "minter";
+  const SMART_PAY = "smart-pay";
+
+  // Check if orderItems is valid
+  if (!Array.isArray(orderItems) || orderItems.length === 0) {
+    console.log("No items to check or invalid data format");
+    return false;
+  }
+
+  // Check each item for category code "minter"
+  for (const item of orderItems) {
+    // Case 1: Direct categoryCode property (first data structure)
+    if (item.categoryCode === MINTER || item.categoryCode === SMART_PAY) {
+      return true;
+    }
+
+    // Case 2: Nested product.category.code (second data structure)
+    if (
+      (item.product &&
+        item.product.category &&
+        item?.product?.category?.code === MINTER) ||
+      item?.product?.category?.code === SMART_PAY
+    ) {
+      return true;
+    }
+
+    // Also check in kitData if it exists (for first data structure)
+    if (Array.isArray(item.kitData) && item.kitData.length > 0) {
+      for (const kitItem of item.kitData) {
+        if (
+          kitItem.categoryCode === MINTER ||
+          kitItem.categoryCode === SMART_PAY
+        ) {
+          return true;
+        }
+      }
+    }
+  }
+
+  // No minter category found
+  return false;
+};
+
+export const hasAICategory = (orderItems) => {
+  // Check if orderItems is valid
+  if (!Array.isArray(orderItems) || orderItems.length === 0) {
+    console.log("No items to check or invalid data format");
+    return false;
+  }
+
+  // Check each item for category code "minter"
+  for (const item of orderItems) {
+    // Case 1: Direct categoryCode property (first data structure)
+    if (item.categoryCode === CATEGORY_FOR_AI_COMPUTING) {
+      return true;
+    }
+
+    // Case 2: Nested product.category.code (second data structure)
+    if (
+      item.product &&
+      item.product.category &&
+      item?.product?.category?.code === CATEGORY_FOR_AI_COMPUTING
+    ) {
+      return true;
+    }
+
+    // Also check in kitData if it exists (for first data structure)
+    if (Array.isArray(item.kitData) && item.kitData.length > 0) {
+      for (const kitItem of item.kitData) {
+        if (kitItem.categoryCode === CATEGORY_FOR_AI_COMPUTING) {
+          return true;
+        }
+      }
+    }
+  }
+
+  // No minter category found
+  return false;
+};
+
+export const truncateString = (
+  str: string,
+  startLength: number = 5,
+  endLength: number = 3,
+): string => {
+  if (str.length <= startLength + endLength) {
+    return str;
+  }
+
+  return (
+    str.substring(0, startLength) +
+    "..." +
+    str.substring(str.length - endLength)
+  );
+};
+
+export const decodeJwt = (token: string): DecodedToken | null => {
+  try {
+    const base64Url = token.split(".")[1];
+    const base64 = base64Url.replace(/-/g, "+").replace(/_/g, "/");
+    const jsonPayload = decodeURIComponent(
+      atob(base64)
+        .split("")
+        .map((c) => "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2))
+        .join(""),
+    );
+    return JSON.parse(jsonPayload);
+  } catch (error) {
+    console.error("Error decoding JWT:", error);
+    return null;
+  }
+};
+
+export function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T> {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error(`Request timed out after ${ms}ms`));
+    }, ms);
+
+    promise
+      .then((res) => {
+        clearTimeout(timeout);
+        resolve(res);
+      })
+      .catch((err) => {
+        clearTimeout(timeout);
+        reject(err);
+      });
+  });
+}
+
+/**
+ * Renders a title with red asterisk if the title contains " *"
+ * @param {string} title - The title string that may contain an asterisk
+ * @returns {React.ReactNode} - JSX element with the title and red asterisk if present
+ */
+export const renderTitleWithRedAsterisk = (title: string): React.ReactNode => {
+  if (title.includes(" *")) {
+    const parts = title.split(" *");
+    return React.createElement(
+      React.Fragment,
+      null,
+      parts[0],
+      React.createElement("span", { className: "text-red-500" }, " *"),
+    );
+  }
+  return title;
+};

package/shared/utils/notifications.util.ts

@@ -0,0 +1,39 @@
+import { toast, ToastContent, ToastOptions } from "react-toastify";
+
+import { ApiResponseDto } from "../types";
+
+const defaultOptions: ToastOptions = {
+  position: "bottom-right",
+  autoClose: 1000,
+  hideProgressBar: false,
+  closeOnClick: true,
+  pauseOnHover: true,
+};
+
+const notifySuccess = (content: ToastContent) => {
+  return toast.success(content ?? "Wow so easy!", defaultOptions);
+};
+
+const notifyError = (content: ToastContent) =>
+  toast.error(content ?? "Wow so easy!", defaultOptions);
+
+const notifyWarning = (content: ToastContent) =>
+  toast.warning(content ?? "Wow so easy!", defaultOptions);
+
+const apiNotify = <T>(data: ApiResponseDto<T | any>) => {
+  if (data?.status) {
+    const message = data?.data?.message ?? data.message;
+    notifySuccess(message);
+  } else if (data?.statusCode == 4040) {
+    notifyError("Please verify your internet connection");
+  } else {
+    notifyError(data?.msg ?? data?.message ?? "");
+  }
+};
+
+export const notification = {
+  apiNotify,
+  notifySuccess,
+  notifyError,
+  notifyWarning,
+};