washday-sdk 1.0.1 → 1.1.0

package/src/utils/orders/calculateOrderTotal.ts

@@ -11,36 +11,79 @@ export const calculateOrderTotal = (
   storeSettings: IStore,
   hasShippingCost: boolean,
   storeDiscounts: any[] = [],
-  discountCodeObj: any
+  discountCodeObj: any,
+  redeemPointsDiscount: number = 0 // 💡 NUEVO parámetro
 ): any => {
   try {
     const appliedOrderDiscounts: any = {};
-    const productTableCalculator = storeSettings?.taxesType === 'over_price' ? calculateTotalTaxesOverPrice : calculateTotalTaxesIncluded;
-    const productTableImports = productTableCalculator(order, selectedCustomer, storeSettings, storeDiscounts, appliedOrderDiscounts, discountCodeObj);
 
-    // PRODUCT LINE TOTALS
+    const productTableCalculator =
+      storeSettings?.taxesType === 'over_price'
+        ? calculateTotalTaxesOverPrice
+        : calculateTotalTaxesIncluded;
+
+    const productTableImports = productTableCalculator(
+      order,
+      selectedCustomer,
+      storeSettings,
+      storeDiscounts,
+      appliedOrderDiscounts,
+      discountCodeObj
+    );
+
+    // === PRODUCT LINE TOTALS ===
     const {
       totalQuantity,
       totalImportWithDiscount,
       totalImportWithoutDiscount,
       totalImporTaxes,
-      totalDiscountAmount
+      totalDiscountAmount,
+      totalSubtotalAmount
     } = getProductLineTotals(productTableImports);
 
-    // DISCOUNT TOTAL AND SHIPPING SERVICE COST
+    // === DISCOUNT CODE (monetario tipo NUMBER que se aplica una sola vez) ===
     let discountCodeAmount = 0;
-    let shippingCost = getShippingCost(discountCodeObj, hasShippingCost, storeSettings);
+    if (
+      discountCodeObj &&
+      discountCodeObj.type === DiscountCodeTypes.NUMBER &&
+      discountCodeObj.applyOnceOnOrder
+    ) {
+      const includesProducts =
+        discountCodeObj.applyToAllProducts ||
+        order.products.some((curr: any) =>
+          discountCodeObj.products.includes(curr._id)
+        );
 
-    if (discountCodeObj && discountCodeObj.type === DiscountCodeTypes.NUMBER && discountCodeObj.applyOnceOnOrder) {
-      const includesProducts = discountCodeObj.applyToAllProducts || order.products.some((curr: any) => discountCodeObj.products.includes(curr._id));
       discountCodeAmount = includesProducts ? discountCodeObj.value : 0;
     }
 
-    // ORDER TOTAL CALCULATION AND CREDIT APPLIED
-    let orderTotalWithOutCredit = +(totalImportWithDiscount + totalImporTaxes + shippingCost - discountCodeAmount).toFixed(2);
-    let creditApplied = getCreditApplied(selectedCustomer, orderTotalWithOutCredit);
-    let orderTotal = +(orderTotalWithOutCredit - creditApplied).toFixed(2);
+    // === SHIPPING COST ===
+    const shippingCost = getShippingCost(
+      discountCodeObj,
+      hasShippingCost,
+      storeSettings
+    );
+
+    // === TOTAL ANTES DE CRÉDITOS/PUNTOS ===
+    const orderTotalWithOutCredit = +(
+      totalImportWithDiscount +
+      shippingCost -
+      discountCodeAmount
+    ).toFixed(2);
+
+    // === APLICAR CRÉDITO Y PUNTOS REDIMIDOS ===
+    const creditApplied = getCreditApplied(
+      selectedCustomer,
+      orderTotalWithOutCredit
+    );
+
+    const orderTotal = +(
+      orderTotalWithOutCredit -
+      creditApplied -
+      redeemPointsDiscount
+    ).toFixed(2);
 
+    // === RETURN FINAL OBJECT ===
     return {
       ...order,
       totalQuantity,
@@ -49,12 +92,14 @@ export const calculateOrderTotal = (
       taxesTotal: totalImporTaxes,
       total: orderTotal,
       creditApplied,
+      redeemPointsApplied: redeemPointsDiscount, // ✅ NUEVO CAMPO
       productTotalWithoutDiscount: totalImportWithoutDiscount,
       totalDiscountAmount: totalDiscountAmount + discountCodeAmount,
       shippingServiceTotal: shippingCost,
-      appliedOrderDiscounts
+      appliedOrderDiscounts,
+      subtotal: totalSubtotalAmount
     };
   } catch (error) {
     throw error;
   }
-};
+};

package/src/utils/orders/calculateTotalTaxesIncluded.ts

@@ -1,3 +1,4 @@
+import { DiscountCodeTypes } from "../../enum";
 import { IOrderProduct } from "../../interfaces/Product";
 import { getProductTaxesPercentage } from "./helpers";
 
@@ -8,25 +9,39 @@ export const calculateTotalTaxesIncluded = (
   storeDiscounts: any[],
   appliedOrderDiscounts: any,
   discountCodeObj: any | null
-) => {
+): any => {
   const productTableImports = [...order.products, ...order.buyAndGetProducts].map((current: IOrderProduct) => {
+    const qty = current.qty || 0;
+    const taxPercentage = getProductTaxesPercentage(current, storeSettings);
+    const taxFactor = 1 + taxPercentage / 100;
+
+    // Convertir extraAmount de bruto a neto
+    const extraAmountGross = current.extraAmount || 0;
+    const extraAmountNet = extraAmountGross / taxFactor;
+
+    // Precio bruto del producto (sin extraAmount)
+    const productGrossPrice = order.express ? current.expressPrice : current.price;
+    // Convertir precio bruto a neto
+    const unitNetPrice = productGrossPrice / taxFactor;
+
+    // Determinar el porcentaje de descuento (si aplica)
     let discPercentageInteger = 0;
     let productPercentageDiscount = 0;
     let customerDiscount = 0;
-    let qty = current.qty || 0;
-    const extraAmountPerUnit = current.extraAmount / qty;
-    const prodPrice = (order.express ? current.expressPrice : current.price) + extraAmountPerUnit;
-
     if (!order.discountCode) {
       const discountsToApply = storeDiscounts.filter(
-        (discount) => discount.products.includes(current._id) && discount.isActive
+        (discount: any) => discount.isActive && discount.products.some((p: any) => {
+          if (typeof p === 'string') {
+            return p === current._id
+          } else if (typeof p === 'object') {
+            return p._id === current._id
+          }
+          return false
+        })
       );
       customerDiscount = selectedCustomer?.customer?.discount || 0;
       productPercentageDiscount = discountsToApply.reduce((prev, next) => {
-        if (next.type === 'percentage') {
-          return prev + next.value;
-        }
-        return prev;
+        return next.type === 'percentage' ? prev + next.value : prev;
       }, 0);
       discPercentageInteger = +((productPercentageDiscount + customerDiscount) / 100).toFixed(2);
       discountsToApply.forEach((discount) => (appliedOrderDiscounts[discount._id] = discount));
@@ -45,30 +60,47 @@ export const calculateTotalTaxesIncluded = (
         if (discountType === 'percentage' && current.isBuyAndGetProduct) {
           discPercentageInteger = +(discountValue / 100).toFixed(2);
         }
+        if (discountType === 'free' && current.isBuyAndGetProduct) {
+          discPercentageInteger = 1;
+        }
+      } else if (discountCodeObj.type === DiscountCodeTypes.FREE_ITEM && ((current as any).isFreeItem)) {
+        discPercentageInteger = 1;
       }
     }
 
-    const taxPercentage = getProductTaxesPercentage(current, storeSettings);
-    const taxPercentageInteger = taxPercentage / 100;
+    // === NUEVO: Aplicar descuento sobre el precio total ajustado (producto base + extra prorrateado) ===
+    // Si hay cantidad, repartir el extra neto entre cada unidad
+    const unitExtraNet = qty > 0 ? extraAmountNet / qty : 0;
+    // Precio neto ajustado: precio base + extra (por unidad)
+    const adjustedUnitNetPrice = unitNetPrice + unitExtraNet;
+    // Calcular el descuento sobre el precio ajustado
+    const discountAmountPerUnit = discPercentageInteger ? adjustedUnitNetPrice * discPercentageInteger : 0;
+    // Precio neto con descuento aplicado por unidad
+    const discountedUnitNetPrice = adjustedUnitNetPrice - discountAmountPerUnit;
+
+    // === Totales de la línea ===
+    // Total neto sin descuento: precio base total + extra (ya prorrateado en el total)
+    const productNetTotalWithoutDiscount = (unitNetPrice * qty) + extraAmountNet;
+    // Total neto con descuento: se aplica el descuento sobre el precio ajustado por unidad
+    const productNetTotalWithDiscount = discountedUnitNetPrice * qty;
+
+    // Reaplicar IVA a ambos totales
+    const productLineImportTotal = +(productNetTotalWithoutDiscount * taxFactor).toFixed(2);
+    const productLineTotalWithDiscount = +(productNetTotalWithDiscount * taxFactor).toFixed(2);
 
-    const unitPrice = prodPrice / (1 + taxPercentageInteger);
-    const discountAmountPerUnit = discPercentageInteger
-      ? unitPrice * discPercentageInteger
-      : (current.discountAmount || 0) / (1 + taxPercentageInteger);
+    // Calcular el total de impuestos como la diferencia entre bruto y neto con descuento
+    const totalTaxesApplied = +(productLineTotalWithDiscount - productNetTotalWithDiscount).toFixed(2);
 
-    const prodPriceWithDiscountPerUnit = unitPrice - discountAmountPerUnit;
-    const taxesAmountPerUnit = prodPriceWithDiscountPerUnit * taxPercentageInteger;
-    const totalTaxesApplied = +(taxesAmountPerUnit * qty).toFixed(2);
-    const lineDiscount = qty * discountAmountPerUnit;
-    const prodLinePriceWithDiscount = +(qty * prodPriceWithDiscountPerUnit).toFixed(2);
+    const lineDiscount = +(discountAmountPerUnit * qty).toFixed(2);
 
     return {
       product: current,
-      qty: qty,
-      productLineImportTotal: unitPrice * qty,
-      productLineTotalWithDiscount: prodLinePriceWithDiscount,
+      qty,
+      productLineImportTotal,           // Total bruto sin descuento (incluye extra y IVA)
+      productLineTotalWithDiscount,     // Total bruto con descuento aplicado sobre el precio ajustado
       productLineTaxesTotal: totalTaxesApplied,
-      lineDiscountAmount: lineDiscount
+      lineDiscountAmount: lineDiscount,
+      productLineSubtotal: productNetTotalWithoutDiscount // Subtotal neto (sin IVA)
     };
   });
   return productTableImports;

package/src/utils/orders/calculateTotalTaxesOverPrice.ts

@@ -8,35 +8,41 @@ export const calculateTotalTaxesOverPrice = (
   storeDiscounts: any[],
   appliedOrderDiscounts: any,
   discountCodeObj: any | null
-
-
 ) => {
   const productTableImports = [...order.products, ...order.buyAndGetProducts].map((current) => {
     let discPercentageInteger = 0;
     let productPercentageDiscount = 0;
     let customerDiscount = 0;
-    let qty = current.qty;
-    // extraAmount es en general sin importar el qty, entonces aqui lo repartimos por igual
-    const extraAmountPerUnit = current.extraAmount / qty;
-    const prodPrice = (order.express ? current.expressPrice : current.price) + extraAmountPerUnit;
+    const qty = current.qty || current.quantity; // cantidad
+
+    // Precio base sin impuestos (en modo over_price el precio es neto)
+    const productBasePrice = order.express ? current.expressPrice : current.price;
 
+    // === NUEVO: Considerar extraAmount en el precio a descontar ===
+    // extraAmount es el ajuste total para la línea; se reparte por unidad
+    const extraAmount = current.extraAmount || 0;
+    const unitExtra = qty > 0 ? extraAmount / qty : 0;
+    // Precio ajustado: suma del precio base y el extra por unidad
+    const adjustedPrice = productBasePrice + unitExtra;
+
+    // Cálculo de descuento sobre el precio ajustado
     if (!order.discountCode) {
-      //IF ORDER HAS A DISCOUNT CODE WE DON'T APPLY ANY OTHER DISCOUNT (AUTOMATICALLY OR CUSTOMER DISCOUNT)
-      //THIS WILL GET THE DISCOUNTS OF THE CURRENT PRODUCT
-      // get store discounts if product applies and customer discount
       const discountsToApply = storeDiscounts.filter(
-        (discount) => discount.products.includes(current._id) && discount.isActive
+        (discount: any) => discount.isActive && discount.products.some((p: any) => {
+          if (typeof p === 'string') {
+            return p === current._id
+          } else if (typeof p === 'object') {
+            return p._id === current._id
+          }
+          return false
+        })
       );
       customerDiscount = selectedCustomer?.customer?.discount || 0;
-      productPercentageDiscount = discountsToApply.reduce((prev, next) => {
-        if (next.type === 'percentage') {
-          // for now we just sum percetange type discounts
-          return prev + next.value;
-        }
-        return prev;
+      productPercentageDiscount = discountsToApply.reduce((acc, discount) => {
+        return discount.type === 'percentage' ? acc + discount.value : acc;
       }, 0);
       discPercentageInteger = +((productPercentageDiscount + customerDiscount) / 100).toFixed(2);
-      discountsToApply.forEach((discount) => (appliedOrderDiscounts[discount._id] = discount)); // it will do this for every product, if two products has the same discount it will just overwrite
+      discountsToApply.forEach((discount) => (appliedOrderDiscounts[discount._id] = discount));
     } else {
       if (discountCodeObj.type === DiscountCodeTypes.PERCENTAGE) {
         discPercentageInteger = +(discountCodeObj.value / 100).toFixed(2);
@@ -45,39 +51,49 @@ export const calculateTotalTaxesOverPrice = (
             ? +(discountCodeObj.value / 100).toFixed(2)
             : 0;
         }
-      }
-      if (discountCodeObj.type === DiscountCodeTypes.BUY_X_GET_Y) {
-        const discountType = discountCodeObj.buyAndGetConditions[0].getDiscountType;
-        const discountValue = discountCodeObj.buyAndGetConditions[0].discountValue;
-        if (discountType === BuyAndGetConditionsTypes.PERCENTAGE && current.isBuyAndGetProduct) {
-          discPercentageInteger = +(discountValue / 100).toFixed(2);
+      } else if (discountCodeObj.type === DiscountCodeTypes.BUY_X_GET_Y) {
+        const condition = discountCodeObj.buyAndGetConditions[0];
+        if (condition.getDiscountType === BuyAndGetConditionsTypes.PERCENTAGE && current.isBuyAndGetProduct) {
+          discPercentageInteger = +(condition.discountValue / 100).toFixed(2);
         }
+        if (condition.getDiscountType === BuyAndGetConditionsTypes.FREE && current.isBuyAndGetProduct) {
+          discPercentageInteger = 1;
+        }
+      } else if (discountCodeObj.type === DiscountCodeTypes.FREE_ITEM && current.isFreeItem) {
+        discPercentageInteger = 1;
       }
     }
 
-    //GET DISCOUNT AMOUNT (IN CASE discPercentageInteger is 0 it could be a discount of a integer number)
-    const discountAmountPerUnit = discPercentageInteger
-      ? prodPrice * discPercentageInteger
-      : (current.discountAmount || 0);
-    //GET PRODUCT PRICE WITH DISCOUNT
-    const prodPriceWithDiscountPerUnit = prodPrice - discountAmountPerUnit;
-    //GET PRODUCT TAXES APPLIED TO FINAL PRICE PER UNIT
-    const taxPercentage = getProductTaxesPercentage(current, storeSettings);
-    const taxPercentageInteger = taxPercentage / 100;
-    const prodPriceWithoutTaxesPerUnit = prodPriceWithDiscountPerUnit;
-    const taxesAmountPerUnit = prodPriceWithoutTaxesPerUnit * taxPercentageInteger;
-    const totalTaxesApplied = +(taxesAmountPerUnit * qty).toFixed(2);
-    let lineDiscount = qty * discountAmountPerUnit;
-    let prodLinePriceWithDiscount = +(qty * prodPriceWithDiscountPerUnit).toFixed(2);
+    // Calcular el descuento por unidad sobre el precio ajustado
+    const productDiscount = adjustedPrice * discPercentageInteger;
+    const discountedAdjustedPrice = adjustedPrice - productDiscount;
+
+    // Subtotal para la línea (precio descontado por unidad * cantidad) SIN impuestos
+    const subtotal = discountedAdjustedPrice * qty;
+
+    // Calcular impuestos sobre el subtotal
+    const taxPercentage = getProductTaxesPercentage(current, storeSettings) / 100;
+    const taxes = subtotal * taxPercentage;
+
+    // Resultados finales:
+    const totalTaxesApplied = +taxes.toFixed(2);
+    const lineDiscount = +(productDiscount * qty).toFixed(2);
+
+    // Precio total con descuento, reaplicando impuestos
+    const prodLinePriceWithDiscount = +((subtotal * (1 + taxPercentage))).toFixed(2);
 
     return {
       product: current,
-      qty: qty,
-      productLineImportTotal: prodPrice * qty, //this is line without discount
+      qty,
+      // Total bruto original sin descuento: (precio base * cantidad) + extraAmount
+      productLineImportTotal: (productBasePrice * qty) + extraAmount,
+      // Total final con descuento, con impuestos incluidos
       productLineTotalWithDiscount: prodLinePriceWithDiscount,
       productLineTaxesTotal: totalTaxesApplied,
-      lineDiscountAmount: lineDiscount
+      lineDiscountAmount: lineDiscount,
+      // Subtotal neto (sin impuestos) con descuento aplicado
+      productLineSubtotal: subtotal
     };
   });
   return productTableImports;
-};
+};

package/src/utils/orders/helpers.ts

@@ -1,73 +1,221 @@
-import { DiscountCodeTypes } from "../../enum";
+import { BuyAndGetConditionsTypes, DiscountCodeTypes } from "../../enum";
 import { ICustomer } from "../../interfaces/Customer";
 import { IOrderProduct, ProductLineTotals } from "../../interfaces/Product";
 import { IStore, ITaxConfig } from "../../interfaces/Store";
 
 export const getProductTaxesPercentage = (productObj: IOrderProduct, store: IStore): number => {
-    const getTaxValue = (tax: ITaxConfig | null | undefined, isTaxExempt: boolean): number => {
-        if (!tax) {
-            // If no store tax configured, always return 0
-            return 0;
-        }
+  const getTaxValue = (tax: ITaxConfig | null | undefined, isTaxExempt: boolean): number => {
+    if (!tax) {
+      // If no store tax configured, always return 0
+      return 0;
+    }
 
-        if (isTaxExempt) {
-            // If store tax is configured and taxExempt is true, return 0
-            return 0;
-        }
+    if (isTaxExempt) {
+      // If store tax is configured and taxExempt is true, return 0
+      return 0;
+    }
 
-        // If store tax configured and taxExempt is false, return store tax
-        return tax.value;
-    };
+    // If store tax configured and taxExempt is false, return store tax
+    return tax.value;
+  };
 
-    const tax1 = getTaxValue(store.taxOne, !productObj.taxExemptOne);
-    const tax2 = getTaxValue(store.taxTwo, !productObj.taxExemptTwo);
-    const tax3 = getTaxValue(store.taxThree, !productObj.taxExemptThree);
+  const tax1 = getTaxValue(store.taxOne, productObj.taxExemptOne);
+  const tax2 = getTaxValue(store.taxTwo, productObj.taxExemptTwo);
+  const tax3 = getTaxValue(store.taxThree, productObj.taxExemptThree);
 
-    return tax1 + tax2 + tax3;
+  return tax1 + tax2 + tax3;
 };
 
 export const getProductLineTotals = (productLinesTotals: ProductLineTotals[]) => {
-    const totalQuantity = +productLinesTotals.reduce((acum, line) => acum + line.qty, 0).toFixed(2);
-    const totalImportWithDiscount = +productLinesTotals
-        .reduce((acum, line) => acum + line.productLineTotalWithDiscount, 0)
-        .toFixed(2);
-    const totalImportWithoutDiscount = +productLinesTotals
-        .reduce((acum, line) => acum + line.productLineImportTotal, 0)
-        .toFixed(2);
-    const totalImporTaxes = +productLinesTotals
-        .reduce((acum, line) => acum + line.productLineTaxesTotal, 0)
-        .toFixed(2);
-    const totalDiscountAmount = +productLinesTotals
-        .reduce((acum, line) => acum + line.lineDiscountAmount, 0)
-        .toFixed(2);
+  const totalQuantity = +productLinesTotals.reduce((acum, line) => acum + line.qty, 0).toFixed(2);
+  const totalImportWithDiscount = +productLinesTotals
+    .reduce((acum, line) => acum + line.productLineTotalWithDiscount, 0)
+    .toFixed(2);
+  const totalImportWithoutDiscount = +productLinesTotals
+    .reduce((acum, line) => acum + line.productLineImportTotal, 0)
+    .toFixed(2);
+  const totalImporTaxes = +productLinesTotals
+    .reduce((acum, line) => acum + line.productLineTaxesTotal, 0)
+    .toFixed(2);
+  const totalDiscountAmount = +productLinesTotals
+    .reduce((acum, line) => acum + line.lineDiscountAmount, 0)
+    .toFixed(2);
+  const totalSubtotalAmount = +productLinesTotals
+    .reduce((acum, line) => acum + line.productLineSubtotal, 0)
+    .toFixed(2);
 
-    return {
-        totalQuantity,
-        totalImportWithDiscount,
-        totalImportWithoutDiscount,
-        totalImporTaxes,
-        totalDiscountAmount
-    };
+  return {
+    totalQuantity,
+    totalImportWithDiscount,
+    totalImportWithoutDiscount,
+    totalImporTaxes,
+    totalDiscountAmount,
+    totalSubtotalAmount
+  };
 };
 
 export const getShippingCost = (discountObject: any, requireShippingService: boolean, store: IStore): number => {
-    const shippingCost = requireShippingService ? store?.orderPageConfig?.shippingServiceCost ?? 0 : 0;
+  const shippingCost = requireShippingService ? store?.orderPageConfig?.shippingServiceCost ?? 0 : 0;
 
-    if (discountObject?.type === DiscountCodeTypes.FREE_DELIVERY) {
-        return 0;
-    }
+  if (discountObject?.type === DiscountCodeTypes.FREE_DELIVERY) {
+    return 0;
+  }
 
-    return shippingCost;
+  return shippingCost;
 };
 
 export const getCreditApplied = (selectedCustomer: { customer: ICustomer } | undefined, orderTotal: number): number => {
-    const customerCredit = selectedCustomer?.customer?.credit ?? 0;
+  const customerCredit = selectedCustomer?.customer?.credit ?? 0;
 
-    if (customerCredit === 0 || !selectedCustomer) {
-        return 0;
-    }
+  if (customerCredit === 0 || !selectedCustomer) {
+    return 0;
+  }
 
-    return Math.min(customerCredit, orderTotal);
+  return Math.min(customerCredit, orderTotal);
 };
 
+export const applyDiscountToProducts = (
+  discountCode: {
+    freeProductSetting: any;
+    products: any;
+    value: number;
+    type: string;
+    applyToAllProducts: boolean;
+    applyOnceOnOrder: boolean;
+    buyAndGetConditions: any,
+  },
+  productsArr: any,
+  isExpress: boolean,
+  storeDiscounts: any = [],
+  selectedCustomer = { discount: 0 }
+) => {
+  if (!discountCode) {
+    // Caso sin discountCode: se aplican descuentos automáticos solo sobre el precio del producto
+    return {
+      newOrderProds: productsArr.map((prod: any) => {
+        const discountsToApply = storeDiscounts.filter(
+          (discount: any) => discount.isActive && discount.products.some((p: any) =>{
+            if(typeof p === 'string') {
+              return p === prod._id
+            } else if(typeof p === 'object') {
+              return p._id === prod._id
+            }
+            return false
+          })
+        );
+        const customerDiscount = selectedCustomer?.discount / 100 || 0;
+        const productPercentageDiscount = discountsToApply.reduce((prev: number, next: any) => {
+          if (next.type === 'percentage') {
+            return prev + next.value / 100;
+          }
+          return prev;
+        }, 0);
+        const prodPrice = isExpress ? prod.expressPrice : prod.price;
+        // Se remueve el extraAmountPerUnit para que el descuento se aplique solo sobre prodPrice
+        const discountAmount = +((productPercentageDiscount + customerDiscount) * prodPrice).toFixed(2);
+        return { ...prod, discountAmount: discountAmount };
+      }),
+      buyAndGetProds: []
+    };
+  }
+
+  // Reiniciar los descuentos en los productos
+  let newOrderProds = productsArr.map((prod: any) => ({ ...prod, discountAmount: 0 }));
 
+  // Array para productos de descuento BUY_X_GET_Y o FREE_ITEM
+  const buyAndGetProds = [];
+
+  if (discountCode && discountCode.type === DiscountCodeTypes.PERCENTAGE) {
+    const percentageDiscount = discountCode.value / 100;
+    if (discountCode.applyToAllProducts) {
+      newOrderProds = newOrderProds.map((prod: any) => {
+        const prodPrice = isExpress ? prod.expressPrice : prod.price;
+        // Aplica descuento solo sobre prodPrice (no se incluye extraAmountPerUnit)
+        const discountAmount = +(percentageDiscount * prodPrice).toFixed(2);
+        return { ...prod, discountAmount: discountAmount };
+      });
+    } else {
+      for (let discountProduct of discountCode.products) {
+        const prodIdx = newOrderProds.findIndex((prod: any) => prod._id === discountProduct);
+        if (prodIdx !== -1) {
+          let prodObj = newOrderProds[prodIdx];
+          const prodPrice = isExpress ? prodObj.expressPrice : prodObj.price;
+          const discountAmount = +(percentageDiscount * prodPrice).toFixed(2);
+          prodObj.discountAmount = discountAmount;
+          newOrderProds[prodIdx] = prodObj;
+        }
+      }
+    }
+  }
+
+  if (discountCode && discountCode.type === DiscountCodeTypes.NUMBER) {
+    const discountAmount = discountCode.value;
+    if (!discountCode.applyOnceOnOrder) {
+      if (discountCode.applyToAllProducts) {
+        newOrderProds = newOrderProds.map((prod: any) => ({ ...prod, discountAmount: discountAmount }));
+      } else {
+        for (let discountProduct of discountCode.products) {
+          const prodIdx = newOrderProds.findIndex((prod: any) => prod._id === discountProduct);
+          if (prodIdx !== -1) {
+            let prodObj = newOrderProds[prodIdx];
+            prodObj.discountAmount = discountAmount;
+            newOrderProds[prodIdx] = prodObj;
+          }
+        }
+      }
+    }
+  }
+
+  if (discountCode.buyAndGetConditions && discountCode.type === DiscountCodeTypes.BUY_X_GET_Y) {
+    const buyConditions = discountCode.buyAndGetConditions[0].buyConditions;
+    const getConditions = discountCode.buyAndGetConditions[0].getConditions;
+    const discountType = discountCode.buyAndGetConditions[0].getDiscountType;
+    const discountValue = discountCode.buyAndGetConditions[0].discountValue;
+    let buyConditionFulfilledCounter = 0;
+
+    for (let prodCondition of buyConditions) {
+      const orderProd = productsArr.find((ordProd: any) => ordProd._id === prodCondition.buyProduct._id);
+      // Nota: Aquí solo se verifica una condición de producto
+      if (orderProd) {
+        let qty = orderProd.qty || orderProd.quantity;
+        buyConditionFulfilledCounter = Math.floor(qty / prodCondition.qty);
+      }
+    }
+
+    if (buyConditionFulfilledCounter) {
+      for (let prodCondition of getConditions) {
+        // Se utiliza solo el precio del producto (sin extraAmount) para calcular el descuento
+        const prodPrice = isExpress
+          ? prodCondition.getProduct.expressPrice
+          : prodCondition.getProduct.price;
+        const percentageDiscount = discountValue / 100;
+        const discountAmount =
+          discountType === BuyAndGetConditionsTypes.FREE
+            ? prodPrice
+            : +(percentageDiscount * prodPrice).toFixed(2);
+        buyAndGetProds.push({
+          ...prodCondition.getProduct,
+          qty: buyConditionFulfilledCounter * prodCondition.qty,
+          quantity: buyConditionFulfilledCounter * prodCondition.qty,
+          discountAmount: discountAmount,
+          isBuyAndGetProduct: true
+        });
+      }
+    }
+  } else if (discountCode.type === DiscountCodeTypes.FREE_ITEM) {
+    const freeProductsSettinggs = discountCode.freeProductSetting[0];
+    const freeProduct = freeProductsSettinggs.product;
+    const prodPrice = isExpress ? freeProduct.expressPrice : freeProduct.price;
+    // Para free item, se asume que el producto es gratuito, es decir, se descuenta el precio del producto
+    const discountAmount = prodPrice;
+    buyAndGetProds.push({
+      ...freeProduct,
+      qty: freeProductsSettinggs.qty,
+      quantity: freeProductsSettinggs.qty,
+      discountAmount: discountAmount,
+      isBuyAndGetProduct: true,
+      isFreeItem: true
+    });
+  }
+  return { newOrderProds, buyAndGetProds };
+};

package/src/utils/orders/index.ts

@@ -1,5 +1,7 @@
 import { calculateOrderTotal } from './calculateOrderTotal';
+import { applyDiscountToProducts } from './helpers';
 
 export {
-    calculateOrderTotal
+    calculateOrderTotal,
+    applyDiscountToProducts
 }