washday-sdk 1.6.69 → 1.6.71

package/dist/api/discounts/get.js

@@ -75,13 +75,27 @@ export const getAutomaticDiscountById = function (storeId, discountId) {
         }
     });
 };
-export const verifyDiscountCode = function (storeId, code) {
+const buildVerifyQueryString = (params) => {
+    if (!params)
+        return '';
+    const entries = [];
+    if (params.currentDate)
+        entries.push(`currentDate=${encodeURIComponent(params.currentDate)}`);
+    if (params.orderSubtotal !== undefined &&
+        params.orderSubtotal !== null &&
+        Number.isFinite(Number(params.orderSubtotal))) {
+        entries.push(`orderSubtotal=${encodeURIComponent(String(params.orderSubtotal))}`);
+    }
+    return entries.length ? `?${entries.join('&')}` : '';
+};
+export const verifyDiscountCode = function (storeId, code, params) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
             const config = {
                 headers: { Authorization: `Bearer ${this.apiToken}` }
             };
-            return yield this.axiosInstance.get(`${GET_SET_DISCOUNT_CODES}/${storeId}/${code}/verify`, config);
+            const qs = buildVerifyQueryString(params);
+            return yield this.axiosInstance.get(`${GET_SET_DISCOUNT_CODES}/${storeId}/${code}/verify${qs}`, config);
         }
         catch (error) {
             console.error('Error fetching verifyDiscountCode:', error);
@@ -89,13 +103,14 @@ export const verifyDiscountCode = function (storeId, code) {
         }
     });
 };
-export const verifyDiscountCodeCustomersApp = function (storeId, code) {
+export const verifyDiscountCodeCustomersApp = function (storeId, code, params) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
             const config = {
                 headers: { Authorization: `Bearer ${this.apiToken}` }
             };
-            return yield this.axiosInstance.get(`${GET_DISCOUNT_CODES_CUSTOMER_APP}/${storeId}/${code}/verify`, config);
+            const qs = buildVerifyQueryString(params);
+            return yield this.axiosInstance.get(`${GET_DISCOUNT_CODES_CUSTOMER_APP}/${storeId}/${code}/verify${qs}`, config);
         }
         catch (error) {
             console.error('Error fetching verifyDiscountCodeCustomersApp:', error);

package/dist/utils/orders/calculateOrderTotal.js

@@ -1,7 +1,7 @@
 import { DiscountCodeTypes } from "../../enum";
 import { calculateTotalTaxesIncluded } from "./calculateTotalTaxesIncluded";
 import { calculateTotalTaxesOverPrice } from "./calculateTotalTaxesOverPrice";
-import { getCreditApplied, getProductLineTotals, getShippingCost } from "./helpers";
+import { applyDiscountToProducts, getCreditApplied, getProductLineTotals, getShippingCost, } from "./helpers";
 const getNormalizedId = (value) => {
     if (value === null || value === undefined) {
         return "";
@@ -38,37 +38,46 @@ const hasMatchingDiscountTarget = (targets = [], product) => {
 };
 export const calculateOrderTotal = (order, selectedCustomer, storeSettings, hasShippingCost, storeDiscounts = [], discountCodeObj, redeemPointsDiscount = 0 // 💡 NUEVO parámetro
 ) => {
-    var _a;
+    var _a, _b, _c;
     try {
         const appliedOrderDiscounts = {};
+        // For NUMBER coupons (fixed-amount) we must bake `discountAmount` per
+        // line so the tax calculators can reduce the taxable base BEFORE
+        // computing tax. `applyDiscountToProducts` handles both per-unit
+        // (`applyOnceOnOrder=false`) and proportional allocation
+        // (`applyOnceOnOrder=true`). For other coupon types, the tax calc derives
+        // the discount via `discPercentageInteger` so we can skip the pre-pass.
+        let processedOrder = order;
+        if (discountCodeObj && discountCodeObj.type === DiscountCodeTypes.NUMBER) {
+            const { newOrderProds, buyAndGetProds } = applyDiscountToProducts(discountCodeObj, (_a = order.products) !== null && _a !== void 0 ? _a : [], Boolean(order.express), storeDiscounts, selectedCustomer === null || selectedCustomer === void 0 ? void 0 : selectedCustomer.customer);
+            processedOrder = Object.assign(Object.assign({}, order), { products: newOrderProds, buyAndGetProducts: buyAndGetProds && buyAndGetProds.length > 0
+                    ? buyAndGetProds
+                    : (_b = order.buyAndGetProducts) !== null && _b !== void 0 ? _b : [] });
+        }
         const productTableCalculator = (storeSettings === null || storeSettings === void 0 ? void 0 : storeSettings.taxesType) === 'over_price'
             ? calculateTotalTaxesOverPrice
             : calculateTotalTaxesIncluded;
-        const productTableImports = productTableCalculator(order, selectedCustomer, storeSettings, storeDiscounts, appliedOrderDiscounts, discountCodeObj);
+        const productTableImports = productTableCalculator(processedOrder, selectedCustomer, storeSettings, storeDiscounts, appliedOrderDiscounts, discountCodeObj);
         // === PRODUCT LINE TOTALS ===
         const { totalQuantity, totalImportWithDiscount, totalImportWithoutDiscount, totalImporTaxes, totalDiscountAmount, totalSubtotalAmount, taxBreakdown } = getProductLineTotals(productTableImports);
-        // === DISCOUNT CODE (monetario tipo NUMBER que se aplica una sola vez) ===
-        let discountCodeAmount = 0;
-        if (discountCodeObj &&
-            discountCodeObj.type === DiscountCodeTypes.NUMBER &&
-            discountCodeObj.applyOnceOnOrder) {
-            const includesProducts = discountCodeObj.applyToAllProducts ||
-                order.products.some((curr) => hasMatchingDiscountTarget(discountCodeObj.products, curr));
-            discountCodeAmount = includesProducts ? discountCodeObj.value : 0;
-        }
+        // NOTE: the old post-tax "discountCodeAmount" subtraction was removed.
+        // NUMBER coupons (both `applyOnceOnOrder=true` and `=false`) are now
+        // applied pre-tax via per-line `discountAmount` baked above, so
+        // `totalImportWithDiscount` already reflects the coupon AND its tax
+        // reduction effect. `totalDiscountAmount` from the line totals is the
+        // nominal coupon value (user-facing "Descuento").
         // === SHIPPING COST ===
         const shippingCost = getShippingCost(discountCodeObj, hasShippingCost, storeSettings);
         // === TOTAL ANTES DE CRÉDITOS/PUNTOS ===
         const orderTotalWithOutCredit = +(totalImportWithDiscount +
-            shippingCost -
-            discountCodeAmount).toFixed(2);
+            shippingCost).toFixed(2);
         // === APLICAR CRÉDITO Y PUNTOS REDIMIDOS ===
         const creditApplied = getCreditApplied(selectedCustomer, orderTotalWithOutCredit);
         const orderTotal = +(orderTotalWithOutCredit -
             creditApplied -
             redeemPointsDiscount).toFixed(2);
         // === RETURN FINAL OBJECT ===
-        return Object.assign(Object.assign({}, order), { totalQuantity, customerDiscount: order.discountCode ? 0 : (_a = selectedCustomer === null || selectedCustomer === void 0 ? void 0 : selectedCustomer.customer) === null || _a === void 0 ? void 0 : _a.discount, productTotal: totalImportWithDiscount, taxesTotal: totalImporTaxes, taxBreakdown, total: orderTotal, creditApplied, redeemPointsApplied: redeemPointsDiscount, productTotalWithoutDiscount: totalImportWithoutDiscount, totalDiscountAmount: totalDiscountAmount + discountCodeAmount, shippingServiceTotal: shippingCost, appliedOrderDiscounts, subtotal: totalSubtotalAmount });
+        return Object.assign(Object.assign({}, order), { totalQuantity, customerDiscount: order.discountCode ? 0 : (_c = selectedCustomer === null || selectedCustomer === void 0 ? void 0 : selectedCustomer.customer) === null || _c === void 0 ? void 0 : _c.discount, productTotal: totalImportWithDiscount, taxesTotal: totalImporTaxes, taxBreakdown, total: orderTotal, creditApplied, redeemPointsApplied: redeemPointsDiscount, productTotalWithoutDiscount: totalImportWithoutDiscount, totalDiscountAmount: totalDiscountAmount, shippingServiceTotal: shippingCost, appliedOrderDiscounts, subtotal: totalSubtotalAmount });
     }
     catch (error) {
         throw error;

package/dist/utils/orders/calculateTotalTaxesIncluded.js

@@ -92,10 +92,23 @@ export const calculateTotalTaxesIncluded = (order, selectedCustomer, storeSettin
         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;
+        // Calcular el descuento por unidad.
+        // - PERCENTAGE/BUY_X_GET_Y/FREE_ITEM: derive from `discPercentageInteger`
+        //   (already applied as percentage on adjusted net unit price).
+        // - NUMBER (fixed): `current.discountAmount` is the per-line GROSS
+        //   discount in pesos, baked by `applyDiscountToProducts`. Convert to
+        //   per-unit net so the existing pipeline computes tax post-discount.
+        let discountAmountPerUnit = discPercentageInteger ? adjustedUnitNetPrice * discPercentageInteger : 0;
+        const isFixedNumberCoupon = !!discountCodeObj &&
+            discountCodeObj.type === DiscountCodeTypes.NUMBER &&
+            Number(current.discountAmount) > 0;
+        if (isFixedNumberCoupon && qty > 0) {
+            const perUnitGrossDiscount = Number(current.discountAmount) / qty;
+            const perUnitNetDiscount = perUnitGrossDiscount / taxFactor;
+            discountAmountPerUnit = Math.min(adjustedUnitNetPrice, perUnitNetDiscount);
+        }
         // Precio neto con descuento aplicado por unidad
-        const discountedUnitNetPrice = adjustedUnitNetPrice - discountAmountPerUnit;
+        const discountedUnitNetPrice = Math.max(0, 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;
@@ -111,7 +124,12 @@ export const calculateTotalTaxesIncluded = (order, selectedCustomer, storeSettin
             store: storeSettings,
             lineTaxAmount: totalTaxesApplied,
         });
-        const lineDiscount = +(discountAmountPerUnit * qty).toFixed(2);
+        // For NUMBER coupons the user-facing "Descuento" is the gross slice
+        // (which is what was baked into `current.discountAmount`). For other
+        // discount types, line discount = per-unit net × qty (existing).
+        const lineDiscount = isFixedNumberCoupon
+            ? Number(current.discountAmount)
+            : +(discountAmountPerUnit * qty).toFixed(2);
         return {
             product: current,
             qty,

package/dist/utils/orders/calculateTotalTaxesOverPrice.js

@@ -68,6 +68,12 @@ export const calculateTotalTaxesOverPrice = (order, selectedCustomer, storeSetti
                         : 0;
                 }
             }
+            else if (discountCodeObj.type === DiscountCodeTypes.NUMBER) {
+                // Fixed-amount discount baked by `applyDiscountToProducts` as
+                // `current.discountAmount` (line-total, NET pesos in over_price).
+                // Per-unit treatment: derive `productDiscount = discountAmount / qty`
+                // so the existing pipeline below subtracts pre-tax.
+            }
             else if (discountCodeObj.type === DiscountCodeTypes.BUY_X_GET_Y) {
                 const condition = discountCodeObj.buyAndGetConditions[0];
                 if (condition.getDiscountType === BuyAndGetConditionsTypes.PERCENTAGE && current.isBuyAndGetProduct) {
@@ -81,9 +87,19 @@ export const calculateTotalTaxesOverPrice = (order, selectedCustomer, storeSetti
                 discPercentageInteger = 1;
             }
         }
-        // Calcular el descuento por unidad sobre el precio ajustado
-        const productDiscount = adjustedPrice * discPercentageInteger;
-        const discountedAdjustedPrice = adjustedPrice - productDiscount;
+        // Calcular el descuento por unidad sobre el precio ajustado.
+        // - PERCENTAGE/BUY_X_GET_Y/FREE_ITEM: derive from `discPercentageInteger`.
+        // - NUMBER (fixed): `current.discountAmount` is the per-line NET discount
+        //   in pesos, baked by `applyDiscountToProducts`. Convert to per-unit.
+        let productDiscount = adjustedPrice * discPercentageInteger;
+        const isFixedNumberCoupon = !!discountCodeObj &&
+            discountCodeObj.type === DiscountCodeTypes.NUMBER &&
+            Number(current.discountAmount) > 0;
+        if (isFixedNumberCoupon && qty > 0) {
+            const perUnitDiscount = Number(current.discountAmount) / qty;
+            productDiscount = Math.min(adjustedPrice, perUnitDiscount);
+        }
+        const discountedAdjustedPrice = Math.max(0, adjustedPrice - productDiscount);
         // Subtotal para la línea (precio descontado por unidad * cantidad) SIN impuestos
         const subtotal = discountedAdjustedPrice * qty;
         // Calcular impuestos sobre el subtotal

package/dist/utils/orders/helpers.js

@@ -110,7 +110,7 @@ const getApplicableTaxesForProduct = (productObj, store) => {
         return acc;
     }, []);
 };
-const allocateByWeights = (total, weights) => {
+export const allocateByWeights = (total, weights) => {
     if (weights.length === 0)
         return [];
     if (total <= 0)
@@ -132,6 +132,43 @@ const allocateByWeights = (total, weights) => {
     }
     return out;
 };
+// Allocate a fixed order-level discount across eligible line bases (in cents).
+// Each entry is capped at its corresponding base. Overflow caused by the cap
+// is rerouted to the next-largest base. The result sums to
+// min(totalCents, sum(baseCents)).
+export const allocateFixedDiscountAcrossLines = (totalCents, baseCents) => {
+    const len = baseCents.length;
+    if (len === 0)
+        return [];
+    const safeBases = baseCents.map((b) => Math.max(0, Math.trunc(b)));
+    const sumBases = safeBases.reduce((a, b) => a + b, 0);
+    if (sumBases <= 0 || totalCents <= 0) {
+        return new Array(len).fill(0);
+    }
+    const cappedTotal = Math.min(Math.trunc(totalCents), sumBases);
+    const slices = allocateByWeights(cappedTotal, safeBases);
+    let overflow = 0;
+    for (let i = 0; i < len; i += 1) {
+        if (slices[i] > safeBases[i]) {
+            overflow += slices[i] - safeBases[i];
+            slices[i] = safeBases[i];
+        }
+    }
+    if (overflow === 0)
+        return slices;
+    const headroomOrder = safeBases
+        .map((b, i) => ({ i, headroom: b - slices[i] }))
+        .filter((entry) => entry.headroom > 0)
+        .sort((a, b) => b.headroom - a.headroom);
+    for (const entry of headroomOrder) {
+        if (overflow <= 0)
+            break;
+        const take = Math.min(entry.headroom, overflow);
+        slices[entry.i] += take;
+        overflow -= take;
+    }
+    return slices;
+};
 export const aggregateTaxBreakdown = (items) => {
     const byKey = new Map();
     items.forEach((item) => {
@@ -225,7 +262,28 @@ export const getCreditApplied = (selectedCustomer, orderTotal) => {
     }
     return Math.min(customerCredit, orderTotal);
 };
+const productsMeetMinimumSubtotal = (productsArr, isExpress, minimumOrderSubtotal) => {
+    if (!Number.isFinite(minimumOrderSubtotal) || minimumOrderSubtotal <= 0)
+        return true;
+    const subtotal = (productsArr || []).reduce((sum, prod) => {
+        var _a, _b, _c, _d, _e;
+        if (!prod || prod.isBuyAndGetProduct || prod.isFreeItem)
+            return sum;
+        const price = Number((_b = (_a = (isExpress ? prod.expressPrice : prod.price)) !== null && _a !== void 0 ? _a : prod.price) !== null && _b !== void 0 ? _b : 0);
+        const qty = Number((_d = (_c = prod.quantity) !== null && _c !== void 0 ? _c : prod.qty) !== null && _d !== void 0 ? _d : 0);
+        const extra = Number((_e = prod.extraAmount) !== null && _e !== void 0 ? _e : 0);
+        if (!Number.isFinite(price) || !Number.isFinite(qty))
+            return sum;
+        return sum + price * qty + (Number.isFinite(extra) ? extra : 0);
+    }, 0);
+    return subtotal >= minimumOrderSubtotal;
+};
 export const applyDiscountToProducts = (discountCode, productsArr, isExpress, storeDiscounts = [], selectedCustomer = { discount: 0 }) => {
+    var _a;
+    if (discountCode &&
+        !productsMeetMinimumSubtotal(productsArr, isExpress, Number((_a = discountCode.minimumOrderSubtotal) !== null && _a !== void 0 ? _a : 0))) {
+        discountCode = null;
+    }
     if (!discountCode) {
         // Caso sin discountCode: se aplican descuentos automáticos solo sobre el precio del producto
         return {
@@ -275,21 +333,54 @@ export const applyDiscountToProducts = (discountCode, productsArr, isExpress, st
         }
     }
     if (discountCode && discountCode.type === DiscountCodeTypes.NUMBER) {
-        const discountAmount = discountCode.value;
-        if (!discountCode.applyOnceOnOrder) {
-            if (discountCode.applyToAllProducts) {
-                newOrderProds = newOrderProds.map((prod) => (Object.assign(Object.assign({}, prod), { discountAmount: discountAmount })));
-            }
-            else {
-                const discountProductIds = getTargetProductIdSet(discountCode.products);
-                newOrderProds = newOrderProds.map((prod) => {
-                    if (!discountProductIds.has(getProductIdentity(prod))) {
-                        return prod;
-                    }
-                    return Object.assign(Object.assign({}, prod), { discountAmount });
+        const couponValue = Number(discountCode.value) || 0;
+        const eligibilityIds = discountCode.applyToAllProducts
+            ? null
+            : getTargetProductIdSet(discountCode.products);
+        const isEligibleProd = (prod) => eligibilityIds === null || eligibilityIds.has(getProductIdentity(prod));
+        if (discountCode.applyOnceOnOrder) {
+            // applyOnceOnOrder=true: allocate the fixed amount proportionally
+            // across eligible lines so each line carries its share as a pre-tax
+            // discountAmount. The downstream tax calc reads this and reduces the
+            // taxable base before computing tax.
+            const eligibleEntries = [];
+            newOrderProds.forEach((prod, idx) => {
+                var _a, _b;
+                if (!isEligibleProd(prod))
+                    return;
+                const prodPrice = isExpress
+                    ? (_a = prod.expressPrice) !== null && _a !== void 0 ? _a : prod.price
+                    : prod.price;
+                const qty = Number((_b = prod.qty) !== null && _b !== void 0 ? _b : prod.quantity) || 0;
+                const extra = Number(prod.extraAmount) || 0;
+                const baseCents = Math.round(((Number(prodPrice) || 0) * qty + extra) * 100);
+                if (baseCents > 0) {
+                    eligibleEntries.push({ idx, baseCents });
+                }
+            });
+            if (eligibleEntries.length > 0) {
+                const couponCents = Math.max(0, Math.round(couponValue * 100));
+                const sliceCents = allocateFixedDiscountAcrossLines(couponCents, eligibleEntries.map((e) => e.baseCents));
+                const newProdsCopy = newOrderProds.slice();
+                eligibleEntries.forEach((e, i) => {
+                    const slicePesos = +(sliceCents[i] / 100).toFixed(2);
+                    newProdsCopy[e.idx] = Object.assign(Object.assign({}, newProdsCopy[e.idx]), { discountAmount: slicePesos });
                 });
+                newOrderProds = newProdsCopy;
             }
         }
+        else {
+            // applyOnceOnOrder=false: per-unit fixed discount. Total per eligible
+            // line is value * qty (was a flat `value` previously — silent bug).
+            newOrderProds = newOrderProds.map((prod) => {
+                var _a;
+                if (!isEligibleProd(prod))
+                    return prod;
+                const qty = Number((_a = prod.qty) !== null && _a !== void 0 ? _a : prod.quantity) || 0;
+                const lineDiscount = +(couponValue * qty).toFixed(2);
+                return Object.assign(Object.assign({}, prod), { discountAmount: lineDiscount });
+            });
+        }
     }
     if (discountCode.buyAndGetConditions && discountCode.type === DiscountCodeTypes.BUY_X_GET_Y) {
         const buyConditions = discountCode.buyAndGetConditions[0].buyConditions;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "washday-sdk",
-  "version": "1.6.69",
+  "version": "1.6.71",
   "description": "Washday utilities functions and API",
   "main": "dist/index.js",
   "type": "module",

package/src/api/discounts/get.ts

@@ -63,24 +63,50 @@ export const getAutomaticDiscountById = async function (this: WashdayClientInsta
   }
 };
 
-export const verifyDiscountCode = async function (this: WashdayClientInstance, storeId: string, code: string,): Promise<any> {
+const buildVerifyQueryString = (params?: { orderSubtotal?: number; currentDate?: string }): string => {
+  if (!params) return '';
+  const entries: string[] = [];
+  if (params.currentDate) entries.push(`currentDate=${encodeURIComponent(params.currentDate)}`);
+  if (
+    params.orderSubtotal !== undefined &&
+    params.orderSubtotal !== null &&
+    Number.isFinite(Number(params.orderSubtotal))
+  ) {
+    entries.push(`orderSubtotal=${encodeURIComponent(String(params.orderSubtotal))}`);
+  }
+  return entries.length ? `?${entries.join('&')}` : '';
+};
+
+export const verifyDiscountCode = async function (
+  this: WashdayClientInstance,
+  storeId: string,
+  code: string,
+  params?: { orderSubtotal?: number; currentDate?: string },
+): Promise<any> {
   try {
     const config = {
       headers: { Authorization: `Bearer ${this.apiToken}` }
     };
-    return await this.axiosInstance.get(`${GET_SET_DISCOUNT_CODES}/${storeId}/${code}/verify`, config);
+    const qs = buildVerifyQueryString(params);
+    return await this.axiosInstance.get(`${GET_SET_DISCOUNT_CODES}/${storeId}/${code}/verify${qs}`, config);
   } catch (error) {
     console.error('Error fetching verifyDiscountCode:', error);
     throw error;
   }
 };
 
-export const verifyDiscountCodeCustomersApp = async function (this: WashdayClientInstance, storeId: string, code: string,): Promise<any> {
+export const verifyDiscountCodeCustomersApp = async function (
+  this: WashdayClientInstance,
+  storeId: string,
+  code: string,
+  params?: { orderSubtotal?: number; currentDate?: string },
+): Promise<any> {
   try {
     const config = {
       headers: { Authorization: `Bearer ${this.apiToken}` }
     };
-    return await this.axiosInstance.get(`${GET_DISCOUNT_CODES_CUSTOMER_APP}/${storeId}/${code}/verify`, config);
+    const qs = buildVerifyQueryString(params);
+    return await this.axiosInstance.get(`${GET_DISCOUNT_CODES_CUSTOMER_APP}/${storeId}/${code}/verify${qs}`, config);
   } catch (error) {
     console.error('Error fetching verifyDiscountCodeCustomersApp:', error);
     throw error;

package/src/api/discounts/put.ts

@@ -52,6 +52,9 @@ export const updateDiscountCodeById = async function (this: WashdayClientInstanc
     code?: string;
     fromDate?: string;
     toDate?: string;
+    applyOnceOnOrder?: boolean;
+    applyToAllProducts?: boolean;
+    minimumOrderSubtotal?: number;
 }): Promise<any> {
     try {
         const config = {

package/src/api/order/put.ts

@@ -1,12 +1,18 @@
 import { AxiosResponse } from "axios";
 import { WashdayClientInstance } from "../../interfaces/Api";
 import { IUpdateOrderByIdDto } from "../../interfaces/Order";
+import { PaymentMethodsEnum } from "../../enum";
 import axiosInstance from "../axiosInstance";
 import { generateQueryParamsStr } from "../../utils/apiUtils";
 const GET_SET_ORDER = 'api/v2/order';
 const GET_SET_ORDER_OLD = 'api/order';
 const GET_SET_ORDER_PAYMENTLINES = (orderId: string) => `/api/v2/order/${orderId}/paymentLines`;
 
+type EditablePaymentMethod =
+    | PaymentMethodsEnum.Cash
+    | PaymentMethodsEnum.Card
+    | PaymentMethodsEnum.Transfer;
+
 export const updateById = async function (this: WashdayClientInstance, id: string, data: IUpdateOrderByIdDto): Promise<any> {
     try {
         const config = {
@@ -21,6 +27,7 @@ export const updateById = async function (this: WashdayClientInstance, id: strin
 
 export const updatePaymentLineById = async function (this: WashdayClientInstance, orderId: string, id: string, data: {
     amountPaid: number
+    paymentMethod?: EditablePaymentMethod
     updatedDate: Date
     pinUserId?: string
 }): Promise<any> {

package/src/interfaces/Store.ts

@@ -422,6 +422,7 @@ export interface IDiscountCode {
     createdBy: IUser | string,
     isActive: boolean,
     applyOnceOnOrder: boolean,
+    minimumOrderSubtotal?: number,
     applyToAllProducts: boolean,
     hasUseLimit: boolean,
     useLimitQty: number,

package/src/utils/orders/calculateOrderTotal.ts

@@ -3,7 +3,12 @@ import { ICustomer } from "../../interfaces/Customer";
 import { IStore } from "../../interfaces/Store";
 import { calculateTotalTaxesIncluded } from "./calculateTotalTaxesIncluded";
 import { calculateTotalTaxesOverPrice } from "./calculateTotalTaxesOverPrice";
-import { getCreditApplied, getProductLineTotals, getShippingCost } from "./helpers";
+import {
+  applyDiscountToProducts,
+  getCreditApplied,
+  getProductLineTotals,
+  getShippingCost,
+} from "./helpers";
 
 const getNormalizedId = (value: any): string => {
   if (value === null || value === undefined) {
@@ -54,13 +59,38 @@ export const calculateOrderTotal = (
   try {
     const appliedOrderDiscounts: any = {};
 
+    // For NUMBER coupons (fixed-amount) we must bake `discountAmount` per
+    // line so the tax calculators can reduce the taxable base BEFORE
+    // computing tax. `applyDiscountToProducts` handles both per-unit
+    // (`applyOnceOnOrder=false`) and proportional allocation
+    // (`applyOnceOnOrder=true`). For other coupon types, the tax calc derives
+    // the discount via `discPercentageInteger` so we can skip the pre-pass.
+    let processedOrder = order;
+    if (discountCodeObj && discountCodeObj.type === DiscountCodeTypes.NUMBER) {
+      const { newOrderProds, buyAndGetProds } = applyDiscountToProducts(
+        discountCodeObj,
+        order.products ?? [],
+        Boolean(order.express),
+        storeDiscounts,
+        selectedCustomer?.customer
+      );
+      processedOrder = {
+        ...order,
+        products: newOrderProds,
+        buyAndGetProducts:
+          buyAndGetProds && buyAndGetProds.length > 0
+            ? buyAndGetProds
+            : order.buyAndGetProducts ?? [],
+      };
+    }
+
     const productTableCalculator =
       storeSettings?.taxesType === 'over_price'
         ? calculateTotalTaxesOverPrice
         : calculateTotalTaxesIncluded;
 
     const productTableImports = productTableCalculator(
-      order,
+      processedOrder,
       selectedCustomer,
       storeSettings,
       storeDiscounts,
@@ -79,21 +109,12 @@ export const calculateOrderTotal = (
       taxBreakdown
     } = getProductLineTotals(productTableImports);
 
-    // === DISCOUNT CODE (monetario tipo NUMBER que se aplica una sola vez) ===
-    let discountCodeAmount = 0;
-    if (
-      discountCodeObj &&
-      discountCodeObj.type === DiscountCodeTypes.NUMBER &&
-      discountCodeObj.applyOnceOnOrder
-    ) {
-      const includesProducts =
-        discountCodeObj.applyToAllProducts ||
-        order.products.some((curr: any) =>
-          hasMatchingDiscountTarget(discountCodeObj.products, curr)
-        );
-
-      discountCodeAmount = includesProducts ? discountCodeObj.value : 0;
-    }
+    // NOTE: the old post-tax "discountCodeAmount" subtraction was removed.
+    // NUMBER coupons (both `applyOnceOnOrder=true` and `=false`) are now
+    // applied pre-tax via per-line `discountAmount` baked above, so
+    // `totalImportWithDiscount` already reflects the coupon AND its tax
+    // reduction effect. `totalDiscountAmount` from the line totals is the
+    // nominal coupon value (user-facing "Descuento").
 
     // === SHIPPING COST ===
     const shippingCost = getShippingCost(
@@ -105,8 +126,7 @@ export const calculateOrderTotal = (
     // === TOTAL ANTES DE CRÉDITOS/PUNTOS ===
     const orderTotalWithOutCredit = +(
       totalImportWithDiscount +
-      shippingCost -
-      discountCodeAmount
+      shippingCost
     ).toFixed(2);
 
     // === APLICAR CRÉDITO Y PUNTOS REDIMIDOS ===
@@ -133,7 +153,7 @@ export const calculateOrderTotal = (
       creditApplied,
       redeemPointsApplied: redeemPointsDiscount, // ✅ NUEVO CAMPO
       productTotalWithoutDiscount: totalImportWithoutDiscount,
-      totalDiscountAmount: totalDiscountAmount + discountCodeAmount,
+      totalDiscountAmount: totalDiscountAmount,
       shippingServiceTotal: shippingCost,
       appliedOrderDiscounts,
       subtotal: totalSubtotalAmount

package/src/utils/orders/calculateTotalTaxesIncluded.ts

@@ -107,10 +107,26 @@ export const calculateTotalTaxesIncluded = (
     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;
+
+    // Calcular el descuento por unidad.
+    // - PERCENTAGE/BUY_X_GET_Y/FREE_ITEM: derive from `discPercentageInteger`
+    //   (already applied as percentage on adjusted net unit price).
+    // - NUMBER (fixed): `current.discountAmount` is the per-line GROSS
+    //   discount in pesos, baked by `applyDiscountToProducts`. Convert to
+    //   per-unit net so the existing pipeline computes tax post-discount.
+    let discountAmountPerUnit = discPercentageInteger ? adjustedUnitNetPrice * discPercentageInteger : 0;
+    const isFixedNumberCoupon =
+      !!discountCodeObj &&
+      discountCodeObj.type === DiscountCodeTypes.NUMBER &&
+      Number(current.discountAmount) > 0;
+    if (isFixedNumberCoupon && qty > 0) {
+      const perUnitGrossDiscount = Number(current.discountAmount) / qty;
+      const perUnitNetDiscount = perUnitGrossDiscount / taxFactor;
+      discountAmountPerUnit = Math.min(adjustedUnitNetPrice, perUnitNetDiscount);
+    }
+
     // Precio neto con descuento aplicado por unidad
-    const discountedUnitNetPrice = adjustedUnitNetPrice - discountAmountPerUnit;
+    const discountedUnitNetPrice = Math.max(0, adjustedUnitNetPrice - discountAmountPerUnit);
 
     // === Totales de la línea ===
     // Total neto sin descuento: precio base total + extra (ya prorrateado en el total)
@@ -130,7 +146,12 @@ export const calculateTotalTaxesIncluded = (
       lineTaxAmount: totalTaxesApplied,
     });
 
-    const lineDiscount = +(discountAmountPerUnit * qty).toFixed(2);
+    // For NUMBER coupons the user-facing "Descuento" is the gross slice
+    // (which is what was baked into `current.discountAmount`). For other
+    // discount types, line discount = per-unit net × qty (existing).
+    const lineDiscount = isFixedNumberCoupon
+      ? Number(current.discountAmount)
+      : +(discountAmountPerUnit * qty).toFixed(2);
 
     return {
       product: current,

package/src/utils/orders/calculateTotalTaxesOverPrice.ts

@@ -81,6 +81,11 @@ export const calculateTotalTaxesOverPrice = (
             ? +(discountCodeObj.value / 100).toFixed(2)
             : 0;
         }
+      } else if (discountCodeObj.type === DiscountCodeTypes.NUMBER) {
+        // Fixed-amount discount baked by `applyDiscountToProducts` as
+        // `current.discountAmount` (line-total, NET pesos in over_price).
+        // Per-unit treatment: derive `productDiscount = discountAmount / qty`
+        // so the existing pipeline below subtracts pre-tax.
       } else if (discountCodeObj.type === DiscountCodeTypes.BUY_X_GET_Y) {
         const condition = discountCodeObj.buyAndGetConditions[0];
         if (condition.getDiscountType === BuyAndGetConditionsTypes.PERCENTAGE && current.isBuyAndGetProduct) {
@@ -94,9 +99,20 @@ export const calculateTotalTaxesOverPrice = (
       }
     }
 
-    // Calcular el descuento por unidad sobre el precio ajustado
-    const productDiscount = adjustedPrice * discPercentageInteger;
-    const discountedAdjustedPrice = adjustedPrice - productDiscount;
+    // Calcular el descuento por unidad sobre el precio ajustado.
+    // - PERCENTAGE/BUY_X_GET_Y/FREE_ITEM: derive from `discPercentageInteger`.
+    // - NUMBER (fixed): `current.discountAmount` is the per-line NET discount
+    //   in pesos, baked by `applyDiscountToProducts`. Convert to per-unit.
+    let productDiscount = adjustedPrice * discPercentageInteger;
+    const isFixedNumberCoupon =
+      !!discountCodeObj &&
+      discountCodeObj.type === DiscountCodeTypes.NUMBER &&
+      Number(current.discountAmount) > 0;
+    if (isFixedNumberCoupon && qty > 0) {
+      const perUnitDiscount = Number(current.discountAmount) / qty;
+      productDiscount = Math.min(adjustedPrice, perUnitDiscount);
+    }
+    const discountedAdjustedPrice = Math.max(0, adjustedPrice - productDiscount);
 
     // Subtotal para la línea (precio descontado por unidad * cantidad) SIN impuestos
     const subtotal = discountedAdjustedPrice * qty;