washday-sdk 0.0.159 → 0.0.161

package/dist/api/auth/post.js

@@ -94,6 +94,18 @@ export const regularUserLogin = function (params) {
         }
     });
 };
+export const companySignUp = function (params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const config = {};
+            return yield axiosInstance.post(`${REGULAR_USER_AUTH}/register`, params, config);
+        }
+        catch (error) {
+            console.error('Error fetching companySignUp:', error);
+            throw error;
+        }
+    });
+};
 export const regularUserTokenLogin = function (params) {
     return __awaiter(this, void 0, void 0, function* () {
         try {

package/dist/api/index.js

@@ -86,6 +86,7 @@ const WashdayClient = function WashdayClient(apiToken) {
         forgotPassword: authEndpoints.postModule.customersAppForgotPassword,
         customersAppForgotPassword: authEndpoints.postModule.customersAppForgotPassword,
         customersAppChangePassword: authEndpoints.postModule.customersAppChangePassword,
+        companySignUp: authEndpoints.postModule.companySignUp,
     });
     this.orders = bindMethods(this, {
         getList: ordersEndpoints.getModule.getList,

package/dist/utils/orders/calculateTotalTaxesIncluded.js

@@ -5,17 +5,24 @@ export const calculateTotalTaxesIncluded = (order, selectedCustomer, storeSettin
         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;
+        const qty = current.qty || 0;
+        // ExtraAmount se trata de forma separada: se conserva su valor bruto, pero se convierte a neto
+        const extraAmount = current.extraAmount; // valor bruto (con impuestos incluidos)
+        // Obtener la tasa de impuesto (por ejemplo, 16%) y convertirla a decimal:
+        const taxPercentage = getProductTaxesPercentage(current, storeSettings);
+        const taxPercentageInteger = taxPercentage / 100;
+        // Convertir extraAmount a valor neto
+        const extraAmountNet = extraAmount / (1 + taxPercentageInteger);
+        // Precio del producto (con impuestos incluidos) SIN incluir extraAmount
+        const productGrossPrice = order.express ? current.expressPrice : current.price;
+        // Extraer el precio neto del producto
+        const unitNetPrice = productGrossPrice / (1 + taxPercentageInteger);
+        // Calcular el porcentaje de descuento (aplicable solo sobre el precio neto del producto)
         if (!order.discountCode) {
             const discountsToApply = storeDiscounts.filter((discount) => discount.products.includes(current._id) && discount.isActive);
             customerDiscount = ((_a = selectedCustomer === null || selectedCustomer === void 0 ? void 0 : selectedCustomer.customer) === null || _a === void 0 ? void 0 : _a.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));
@@ -37,22 +44,24 @@ export const calculateTotalTaxesIncluded = (order, selectedCustomer, storeSettin
                 }
             }
         }
-        const taxPercentage = getProductTaxesPercentage(current, storeSettings);
-        const taxPercentageInteger = taxPercentage / 100;
-        const unitPrice = prodPrice / (1 + taxPercentageInteger);
+        // Aplicar el descuento sobre el precio neto del producto
         const discountAmountPerUnit = discPercentageInteger
-            ? unitPrice * discPercentageInteger
+            ? unitNetPrice * discPercentageInteger
             : (current.discountAmount || 0) / (1 + taxPercentageInteger);
-        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 discountedUnitNetPrice = unitNetPrice - discountAmountPerUnit;
+        // Calcular los importes netos:
+        const productNetImportWithoutDiscount = (unitNetPrice * qty) + extraAmountNet;
+        const productNetImportWithDiscount = (discountedUnitNetPrice * qty) + extraAmountNet;
+        // Para obtener los valores brutos (con impuestos), se multiplica por (1 + taxPercentageInteger)
+        const productGrossImportWithoutDiscount = productNetImportWithoutDiscount * (1 + taxPercentageInteger);
+        // La parte de impuestos es la diferencia entre el bruto y el neto
+        const totalTaxesApplied = +((productGrossImportWithoutDiscount - productNetImportWithoutDiscount)).toFixed(2);
+        const lineDiscount = +(discountAmountPerUnit * qty).toFixed(2);
         return {
             product: current,
-            qty: qty,
-            productLineImportTotal: unitPrice * qty,
-            productLineTotalWithDiscount: prodLinePriceWithDiscount,
+            qty,
+            productLineImportTotal: +productNetImportWithoutDiscount.toFixed(2), // valor neto sin descuento
+            productLineTotalWithDiscount: +productNetImportWithDiscount.toFixed(2), // valor neto con descuento
             productLineTaxesTotal: totalTaxesApplied,
             lineDiscountAmount: lineDiscount
         };

package/dist/utils/orders/calculateTotalTaxesOverPrice.js

@@ -7,24 +7,16 @@ export const calculateTotalTaxesOverPrice = (order, selectedCustomer, storeSetti
         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;
+        // Precio base sin impuestos y sin extraAmount
+        const productBasePrice = order.express ? current.expressPrice : current.price;
+        // Calcular descuentos solo sobre el producto
         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);
             customerDiscount = ((_a = selectedCustomer === null || selectedCustomer === void 0 ? void 0 : selectedCustomer.customer) === null || _a === void 0 ? void 0 : _a.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
         }
         else {
             if (discountCodeObj.type === DiscountCodeTypes.PERCENTAGE) {
@@ -35,32 +27,30 @@ export const calculateTotalTaxesOverPrice = (order, selectedCustomer, storeSetti
                         : 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);
                 }
             }
         }
-        //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 descuento solo sobre el producto
+        const productDiscount = productBasePrice * discPercentageInteger;
+        const discountedProductPrice = productBasePrice - productDiscount;
+        // Calcular subtotal: se aplica el descuento al producto, y luego se suma el extraAmount (que se cobra completo)
+        const subtotal = (discountedProductPrice * qty) + current.extraAmount;
+        // Calcular impuestos sobre el subtotal final
+        const taxPercentage = getProductTaxesPercentage(current, storeSettings) / 100;
+        const taxes = subtotal * taxPercentage;
+        // Resultados finales
+        const totalTaxesApplied = +(taxes).toFixed(2);
+        const lineDiscount = +(productDiscount * qty).toFixed(2);
+        // Se suma el extraAmount a la parte del producto descontado para obtener el valor total a cobrar de la línea
+        const prodLinePriceWithDiscount = +(((discountedProductPrice * qty) + current.extraAmount)).toFixed(2);
         return {
             product: current,
-            qty: qty,
-            productLineImportTotal: prodPrice * qty, //this is line without discount
+            qty,
+            productLineImportTotal: (productBasePrice * qty) + current.extraAmount,
             productLineTotalWithDiscount: prodLinePriceWithDiscount,
             productLineTaxesTotal: totalTaxesApplied,
             lineDiscountAmount: lineDiscount

package/dist/utils/orders/helpers.js

@@ -56,42 +56,37 @@ export const getCreditApplied = (selectedCustomer, orderTotal) => {
     return Math.min(customerCredit, orderTotal);
 };
 export const applyDiscountToProducts = (discountCode, productsArr, isExpress, storeDiscounts = [], selectedCustomer = { discount: 0 }) => {
-    var _a, _b;
     if (!discountCode) {
-        ///WE NEED TO APPLY DISCOUNT IN CASE WE HAVE AUTOMATIC DISCOUNT APPLIED
+        // Caso sin discountCode: se aplican descuentos automáticos solo sobre el precio del producto
         return {
             newOrderProds: productsArr.map((prod) => {
                 const discountsToApply = storeDiscounts.filter((discount) => discount.products.includes(prod._id) && discount.isActive);
                 const customerDiscount = (selectedCustomer === null || selectedCustomer === void 0 ? void 0 : selectedCustomer.discount) / 100 || 0;
                 const productPercentageDiscount = discountsToApply.reduce((prev, next) => {
                     if (next.type === 'percentage') {
-                        // for now we just sum percetange type discounts
                         return prev + next.value / 100;
                     }
                     return prev;
                 }, 0);
                 const prodPrice = isExpress ? prod.expressPrice : prod.price;
-                const extraAmountPerUnit = prod.extraAmount / prod.qty || 0;
-                const discountAmount = +((productPercentageDiscount + customerDiscount) *
-                    (prodPrice + extraAmountPerUnit)).toFixed(2);
+                // Se remueve el extraAmountPerUnit para que el descuento se aplique solo sobre prodPrice
+                const discountAmount = +((productPercentageDiscount + customerDiscount) * prodPrice).toFixed(2);
                 return Object.assign(Object.assign({}, prod), { discountAmount: discountAmount });
             }),
             buyAndGetProds: []
         };
     }
-    //RESTART PRODUCTS ARR DISCOUNTS
-    let newOrderProds = productsArr.map((prod) => {
-        return Object.assign(Object.assign({}, prod), { discountAmount: 0 });
-    });
-    //THIS ARRAY ALSO INCLUDES PRODUCTS OF FREE_ITEM discount code type
+    // Reiniciar los descuentos en los productos
+    let newOrderProds = productsArr.map((prod) => (Object.assign(Object.assign({}, 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) => {
                 const prodPrice = isExpress ? prod.expressPrice : prod.price;
-                const extraAmountPerUnit = prod.extraAmount / prod.qty || 0;
-                const discountAmount = +(percentageDiscount * (prodPrice + extraAmountPerUnit)).toFixed(2);
+                // Aplica descuento solo sobre prodPrice (no se incluye extraAmountPerUnit)
+                const discountAmount = +(percentageDiscount * prodPrice).toFixed(2);
                 return Object.assign(Object.assign({}, prod), { discountAmount: discountAmount });
             });
         }
@@ -101,8 +96,7 @@ export const applyDiscountToProducts = (discountCode, productsArr, isExpress, st
                 if (prodIdx !== -1) {
                     let prodObj = newOrderProds[prodIdx];
                     const prodPrice = isExpress ? prodObj.expressPrice : prodObj.price;
-                    const extraAmountPerUnit = prodObj.extraAmount / prodObj.qty || 0;
-                    const discountAmount = +(percentageDiscount * (prodPrice + extraAmountPerUnit)).toFixed(2);
+                    const discountAmount = +(percentageDiscount * prodPrice).toFixed(2);
                     prodObj.discountAmount = discountAmount;
                     newOrderProds[prodIdx] = prodObj;
                 }
@@ -113,9 +107,7 @@ export const applyDiscountToProducts = (discountCode, productsArr, isExpress, st
         const discountAmount = discountCode.value;
         if (!discountCode.applyOnceOnOrder) {
             if (discountCode.applyToAllProducts) {
-                newOrderProds = newOrderProds.map((prod) => {
-                    return Object.assign(Object.assign({}, prod), { discountAmount: discountAmount });
-                });
+                newOrderProds = newOrderProds.map((prod) => (Object.assign(Object.assign({}, prod), { discountAmount: discountAmount })));
             }
             else {
                 for (let discountProduct of discountCode.products) {
@@ -137,7 +129,7 @@ export const applyDiscountToProducts = (discountCode, productsArr, isExpress, st
         let buyConditionFulfilledCounter = 0;
         for (let prodCondition of buyConditions) {
             const orderProd = productsArr.find((ordProd) => ordProd._id === prodCondition.buyProduct._id);
-            //TODO : IN CASE WE HAVE MORE PRODUCT CONDITIONS, THIS WON'T WORK SINCE THIS LINE JUST CHECKS  1 PRODUCT CONDITION
+            // Nota: Aquí solo se verifica una condición de producto
             if (orderProd) {
                 let qty = orderProd.qty || orderProd.quantity;
                 buyConditionFulfilledCounter = Math.floor(qty / prodCondition.qty);
@@ -145,15 +137,14 @@ export const applyDiscountToProducts = (discountCode, productsArr, isExpress, st
         }
         if (buyConditionFulfilledCounter) {
             for (let prodCondition of getConditions) {
-                //HERE WE SHOULD GET PROD PRICE MAYBE VERIFY IF IS PERCENTAGE AND TAXES ARE INCLUDED IN PRICE, WE SHOULD GET PRODUCT WITHOUT TAXES;
+                // Se utiliza solo el precio del producto (sin extraAmount) para calcular el descuento
                 const prodPrice = isExpress
                     ? prodCondition.getProduct.expressPrice
                     : prodCondition.getProduct.price;
-                const extraAmountPerUnit = ((_a = prodCondition.getProduct) === null || _a === void 0 ? void 0 : _a.extraAmount) / ((_b = prodCondition.getProduct) === null || _b === void 0 ? void 0 : _b.qty) || 0 || 0;
                 const percentageDiscount = discountValue / 100;
                 const discountAmount = discountType === BuyAndGetConditionsTypes.FREE
-                    ? prodPrice + extraAmountPerUnit
-                    : +(percentageDiscount * (prodPrice + extraAmountPerUnit)).toFixed(2);
+                    ? prodPrice
+                    : +(percentageDiscount * prodPrice).toFixed(2);
                 buyAndGetProds.push(Object.assign(Object.assign({}, prodCondition.getProduct), { qty: buyConditionFulfilledCounter * prodCondition.qty, quantity: buyConditionFulfilledCounter * prodCondition.qty, discountAmount: discountAmount, isBuyAndGetProduct: true }));
             }
         }
@@ -162,10 +153,9 @@ export const applyDiscountToProducts = (discountCode, productsArr, isExpress, st
         const freeProductsSettinggs = discountCode.freeProductSetting[0];
         const freeProduct = freeProductsSettinggs.product;
         const prodPrice = isExpress ? freeProduct.expressPrice : freeProduct.price;
-        const extraAmountPerUnit = freeProduct.extraAmount / freeProduct.qty || 0 || 0;
-        const discountAmount = prodPrice + extraAmountPerUnit;
-        buyAndGetProds.push(Object.assign(Object.assign({}, freeProduct), { qty: freeProductsSettinggs.qty, quantity: freeProductsSettinggs.qty, discountAmount: discountAmount, isBuyAndGetProduct: true, isFreeItem: true //we dont' really use this attribute at the moment
-         }));
+        // Para free item, se asume que el producto es gratuito, es decir, se descuenta el precio del producto
+        const discountAmount = prodPrice;
+        buyAndGetProds.push(Object.assign(Object.assign({}, freeProduct), { qty: freeProductsSettinggs.qty, quantity: freeProductsSettinggs.qty, discountAmount: discountAmount, isBuyAndGetProduct: true, isFreeItem: true }));
     }
     return { newOrderProds, buyAndGetProds };
 };

package/package.json

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

package/src/api/auth/post.ts

@@ -111,6 +111,26 @@ export const regularUserLogin = async function (this: WashdayClientInstance, par
     }
 };
 
+export const companySignUp = async function (this: WashdayClientInstance, params: {
+    email: string,
+    password: string,
+    companyName: string,
+    name: string,
+    phoneNumber: string,
+    country: string,
+    city: string,
+    languagePreference: string,
+    isActive: boolean
+}): Promise<any> {
+    try {
+        const config = {};
+        return await axiosInstance.post(`${REGULAR_USER_AUTH}/register`, params, config);
+    } catch (error) {
+        console.error('Error fetching companySignUp:', error);
+        throw error;
+    }
+};
+
 
 export const regularUserTokenLogin = async function (this: WashdayClientInstance, params: {
     token: string

package/src/api/index.ts

@@ -93,6 +93,7 @@ const WashdayClient: WashdayClientConstructor = function WashdayClient(this: Was
         forgotPassword: authEndpoints.postModule.customersAppForgotPassword,
         customersAppForgotPassword: authEndpoints.postModule.customersAppForgotPassword,
         customersAppChangePassword: authEndpoints.postModule.customersAppChangePassword,
+        companySignUp: authEndpoints.postModule.companySignUp,
     });
     this.orders = bindMethods(this, {
         getList: ordersEndpoints.getModule.getList,

package/src/interfaces/Api.ts

@@ -68,6 +68,7 @@ export interface WashdayClientInstance {
         forgotPassword: typeof authEndpoints.postModule.forgotPassword;
         customersAppForgotPassword: typeof authEndpoints.postModule.customersAppForgotPassword;
         customersAppChangePassword: typeof authEndpoints.postModule.customersAppChangePassword;
+        companySignUp: typeof authEndpoints.postModule.companySignUp;
     }
     review: {
         getList: typeof reviewsEndpoints.getModule.getList;