softseti-sale-calculator-library 4.0.1 → 4.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "softseti-sale-calculator-library",
-  "version": "4.0.1",
+  "version": "4.1.0",
   "description": "Sales calculation engine by Softseti",
   "main": "src/index.js",
   "types": "src/index.d.ts",

package/src/core/CalculationEngine.js

@@ -0,0 +1,218 @@
+/**
+ * Calculation Engine
+ * Handles core sale calculations including subtotal, total, and wholesale pricing
+ */
+const RoundingUtils = require('../utils/RoundingUtils');
+const ValidationUtils = require('../utils/ValidationUtils');
+
+class CalculationEngine {
+  /**
+   * @param {SalesCalculator} calculator - Parent calculator instance
+   */
+  constructor(calculator) {
+    this.calculator = calculator;
+
+    // Initialize ALL use cases
+    this.calculateSubtotal = new (require('../usecases/CalculateSubtotal'))(calculator);
+    this.calculateTotal = new (require('../usecases/CalculateTotal'))(calculator);
+    this.calculateProductPrice = new (require('../usecases/CalculateProductPrice'))(calculator);
+    this.calculateProductDiscount = new (require('../usecases/CalculateProductDiscount'))(calculator);
+    this.calculateProductSum = new (require('../usecases/CalculateProductSum'))(calculator);
+    this.calculateWholesale = new (require('../usecases/CalculateWholesale'))(calculator);
+  }
+
+  /**
+   * Preprocess sale data
+   * @param {Object} sale - Sale object
+   * @returns {Promise<Object>} Preprocessed sale
+   */
+  async preprocessSale(sale) {
+    ValidationUtils.validateSaleStructure(sale, this.calculator.data.products);
+
+    const saleCurrency = this.calculator.data.currencies[sale.currency_id];
+
+    // Add currency ISO if not provided
+    if (!sale.currency_iso && saleCurrency?.iso) {
+      sale.currency_iso = saleCurrency.iso;
+    }
+
+    // Set default currency if none specified
+    if (!sale.currency_id && !sale.currency_iso) {
+      sale.currency_id = 88; // Default currency ID
+      sale.currency_iso = 'MXN'; // Default currency
+    }
+
+    // Process deals
+    if (sale.dwSaleDeals) {
+      sale.dwSaleDeals = sale.dwSaleDeals.map(deal => ({
+        ...deal,
+        sum: deal.amount ? deal.amount * -1 : 0
+      }));
+    }
+
+    // Process payments
+    if (sale.payments) {
+      const processedPayments = [];
+      for (const payment of sale.payments) {
+        const originalCurrency = this.calculator.data.currencies[payment.currency_id];
+
+        if (payment.amount && payment.original_amount) {
+          processedPayments.push({
+            ...payment,
+            original_currency_id: payment.currency_id,
+            original_currency_iso: originalCurrency?.iso,
+            currency_id: sale.currency_id,
+            currency_iso: sale.currency_iso,
+            change_amount: 0
+          });
+        } else {
+          const details = await this.calculator.paymentEngine.calculatePaymentDetails({
+            ...payment,
+            original_gived_amount: payment.gived_amount || payment.amount,
+            original_currency_iso: originalCurrency?.iso
+          }, sale);
+
+          processedPayments.push({
+            ...payment,
+            original_currency_id: payment.currency_id,
+            original_currency_iso: originalCurrency?.iso,
+            currency_id: sale.currency_id,
+            currency_iso: sale.currency_iso,
+            original_gived_amount: payment.gived_amount || payment.amount,
+            ...details
+          });
+        }
+      }
+      sale.payments = processedPayments;
+    }
+
+    // Process products
+    if (sale.dwSaleProducts) {
+      sale.dwSaleProducts = sale.dwSaleProducts.map(product => {
+        const productData = this.calculator.data.products[product.product_id];
+        const productCurrency = this.calculator.data.currencies[productData?.currency_id];
+
+        // Calculate actual price (including wholesale)
+        const actualPrice = this.calcDwSaleProductPrice(product, sale);
+
+        return {
+          ...product,
+          price: actualPrice,
+          public_price: actualPrice,
+          currency_iso: productCurrency?.iso || sale.currency_iso,
+          currency_id: productData?.currency_id || sale.currency_id
+        };
+      });
+    }
+
+    // Process wholesale levels
+    if (this.calculator.data.wholesaleLevels) {
+      Object.keys(this.calculator.data.wholesaleLevels).forEach(productId => {
+        this.calculator.data.wholesaleLevels[productId] =
+          this.calculator.data.wholesaleLevels[productId].map(level => ({
+            ...level,
+            price: RoundingUtils.roundCurrency(level.price, this.calculator.config)
+          }));
+      });
+    }
+
+    // Store preprocessed sale
+    this.calculator.preprocessedSale = sale;
+
+    return sale;
+  }
+
+  /**
+   * Calculate total sale amount
+   * @param {Object} sale - Sale object
+   * @returns {Promise<number>} Total amount
+   */
+  async calcTotal(sale) {
+    return this.calculateTotal.calculate(sale);
+  }
+
+  /**
+   * Calculate subtotal
+   * @param {Object} sale - Sale object
+   * @returns {number} Subtotal amount
+   */
+  calcSubtotal(sale) {
+    return this.calculateSubtotal.calculate(sale);
+  }
+
+  /**
+   * Calculate product discount
+   * @param {Object} product - Product object
+   * @param {Object} sale - Sale object
+   * @returns {number} Discount amount
+   */
+  calcDwSaleProductDiscount(product, sale) {
+    return this.calculateProductDiscount.calculate(product, sale);
+  }
+
+  /**
+   * Calculate product sum
+   * @param {Object} saleProduct - Sale product object
+   * @param {Object} sale - Sale object
+   * @returns {number} Product sum
+   */
+  calcDwSaleProductSum(saleProduct, sale) {
+    return this.calculateProductSum.calculate(saleProduct, sale);
+  }
+
+  /**
+   * Calculate product price
+   * @param {Object} saleProduct - Sale product object
+   * @param {Object} sale - Sale object
+   * @returns {number} Product price
+   */
+  calcDwSaleProductPrice(saleProduct, sale) {
+    return this.calculateProductPrice.calculate(saleProduct, sale);
+  }
+
+  /**
+   * Get applied wholesale levels
+   * @param {Object} sale - Sale object
+   * @returns {Array} Applied wholesale levels
+   */
+  appliedWholesaleLevels(sale) {
+    return this.calculateWholesale.getAppliedLevels(sale);
+  }
+
+  /**
+   * Calculate sale totals
+   * @param {Object} sale - Sale object
+   * @returns {Promise<Object>} Sale totals object
+   */
+  async calculateSaleTotals(sale) {
+    const subtotal = this.calcSubtotal(sale);
+    const total = await this.calcTotal(sale);
+    const change = await this.calculator.paymentEngine.calcChange(sale);
+    const debt = await this.calculator.paymentEngine.calcDebt(sale);
+
+    const result = {
+      subtotal,
+      total,
+      change,
+      debt
+    };
+
+    // Add original currency totals if different
+    if (sale.original_currency_iso && sale.original_currency_iso !== sale.currency_iso) {
+      result.original_subtotal = this.calculator.currencyEngine.exchange(
+        subtotal,
+        sale.currency_iso,
+        sale.original_currency_iso
+      );
+      result.original_total = this.calculator.currencyEngine.exchange(
+        total,
+        sale.currency_iso,
+        sale.original_currency_iso
+      );
+    }
+
+    return result;
+  }
+}
+
+module.exports = CalculationEngine;

package/src/core/CurrencyEngine.js

@@ -0,0 +1,104 @@
+/**
+ * Currency Engine
+ * Handles currency exchange and conversion
+ */
+const RoundingUtils = require('../utils/RoundingUtils');
+
+class CurrencyEngine {
+  /**
+   * @param {SalesCalculator} calculator - Parent calculator instance
+   */
+  constructor(calculator) {
+    this.calculator = calculator;
+  }
+
+  /**
+   * Convert amount between currencies
+   * @param {number} amount - Amount to convert
+   * @param {string} fromCurrency - ISO code (e.g. 'MXN')
+   * @param {string} toCurrency - ISO code (e.g. 'USD')
+   * @returns {number} Converted amount
+   */
+  exchange(amount, fromCurrency, toCurrency) {
+    if (fromCurrency === toCurrency) {
+      return RoundingUtils.roundCurrency(amount, this.calculator.config);
+    }
+    
+    // Try exchange rate first
+    const exchangeRateModel = this.findExchangeRate(fromCurrency, toCurrency);
+    if (exchangeRateModel) {
+      return RoundingUtils.roundCurrency(
+        this.applyExchangeStrategy(amount, exchangeRateModel),
+        this.calculator.config
+      );
+    }
+    
+    // Fallback to currency converter rate
+    const currencyConverterRateModel = this.findCurrencyConverterRate(fromCurrency, toCurrency);
+    if (!currencyConverterRateModel) {
+      throw new Error(`No exchange rate found for ${fromCurrency}->${toCurrency}`);
+    }
+    
+    return RoundingUtils.roundCurrency(
+      amount * currencyConverterRateModel.rate,
+      this.calculator.config
+    );
+  }
+
+  /**
+   * Find exchange rate
+   * @param {string} from - From currency ISO
+   * @param {string} to - To currency ISO
+   * @returns {Object|null} Exchange rate model or null
+   */
+  findExchangeRate(from, to) {
+    return Object.values(this.calculator.data.exchangeRates).find(rate =>
+      rate.from_currency_iso === from &&
+      rate.to_currency_iso === to
+    );
+  }
+
+  /**
+   * Find currency converter rate
+   * @param {string} from - From currency ISO
+   * @param {string} to - To currency ISO
+   * @returns {Object|null} Currency converter rate or null
+   */
+  findCurrencyConverterRate(from, to) {
+    return Object.values(this.calculator.data.currencyConverterRates).find(rate =>
+      rate.from_currency_iso === from &&
+      rate.to_currency_iso === to
+    );
+  }
+
+  /**
+   * Apply exchange strategy
+   * @param {number} amount - Amount to convert
+   * @param {Object} exchangeRate - Exchange rate model
+   * @returns {number} Converted amount
+   */
+  applyExchangeStrategy(amount, exchangeRate) {
+    return (amount * exchangeRate.to_currency_value) / exchangeRate.from_currency_value;
+  }
+
+  /**
+   * Get currency by ID
+   * @param {number} currencyId - Currency ID
+   * @returns {Object|null} Currency object or null
+   */
+  getCurrencyById(currencyId) {
+    return this.calculator.data.currencies[currencyId] || null;
+  }
+
+  /**
+   * Get currency ISO by ID
+   * @param {number} currencyId - Currency ID
+   * @returns {string|null} Currency ISO or null
+   */
+  getCurrencyIso(currencyId) {
+    const currency = this.getCurrencyById(currencyId);
+    return currency ? currency.iso : null;
+  }
+}
+
+module.exports = CurrencyEngine;

package/src/core/PaymentEngine.js

@@ -0,0 +1,174 @@
+/**
+ * Payment Engine
+ * Handles payment calculations, currency conversions, and debt management
+ */
+const RoundingUtils = require('../utils/RoundingUtils');
+
+class PaymentEngine {
+  /**
+   * @param {SalesCalculator} calculator - Parent calculator instance
+   */
+  constructor(calculator) {
+    this.calculator = calculator;
+  }
+
+  /**
+   * Calculate change amount
+   * @param {Object} sale - Sale object
+   * @returns {Promise<number>} Change amount
+   */
+  async calcChange(sale) {
+    const total = await this.calculator.calculationEngine.calcTotal(sale);
+    const paymentSum = this.sumGivedAmountPayments(sale);
+    const change = paymentSum - total;
+    return RoundingUtils.roundCurrency(change > 0 ? change : 0, this.calculator.config);
+  }
+
+  /**
+   * Calculate remaining debt
+   * @param {Object} sale - Sale object
+   * @returns {Promise<number>} Debt amount
+   */
+  async calcDebt(sale) {
+    const total = await this.calculator.calculationEngine.calcTotal(sale);
+    const paymentSum = await this.sumAmountPayments(sale);
+    const debt = total - paymentSum;
+    return RoundingUtils.roundCurrency(debt > 0 ? debt : 0, this.calculator.config);
+  }
+
+  /**
+   * Sum effective payment amounts
+   * @param {Object} sale - Sale object
+   * @returns {Promise<number>} Total effective payment amount
+   */
+  async sumAmountPayments(sale) {
+    const payments = sale.payments || [];
+    let sum = 0;
+    
+    for (const payment of payments) {
+      sum += await this.calcPaymentAmount(payment, sale);
+    }
+    
+    return RoundingUtils.roundCurrency(sum, this.calculator.config);
+  }
+
+  /**
+   * Sum raw payment amounts
+   * @param {Object} sale - Sale object
+   * @returns {number} Total given payment amount
+   */
+  sumGivedAmountPayments(sale) {
+    return RoundingUtils.roundCurrency((sale.payments || []).reduce((sum, payment) => {
+      return sum + this.calcGivedPaymentAmount(payment, sale);
+    }, 0), this.calculator.config);
+  }
+
+  /**
+   * Calculate effective payment amount
+   * @param {Object} payment - Payment object
+   * @param {Object} sale - Sale object
+   * @returns {Promise<number>} Effective amount in sale currency
+   */
+  async calcPaymentAmount(payment, sale) {
+    const total = await this.calculator.calculationEngine.calcTotal(sale);
+    const payments = sale.payments || [];
+
+    const index = payments.findIndex(p =>
+      p.original_gived_amount === payment.original_gived_amount &&
+      p.currency_id === payment.currency_id &&
+      p.payment_type_id === payment.payment_type_id
+    );
+
+    if (index === -1) return 0;
+
+    let accumulated = 0;
+
+    for (let i = 0; i < index; i++) {
+      const prevPayment = payments[i];
+      const amount = this.calculator.currencyEngine.exchange(
+        prevPayment.original_gived_amount,
+        prevPayment.original_currency_iso,
+        sale.currency_iso
+      );
+      const remaining = total - accumulated;
+      accumulated += Math.min(amount, remaining);
+    }
+
+    const currentAmount = this.calculator.currencyEngine.exchange(
+      payment.original_gived_amount,
+      payment.original_currency_iso,
+      sale.currency_iso
+    );
+
+    const remaining = total - accumulated;
+    const appliedAmount = Math.min(currentAmount, Math.max(remaining, 0));
+
+    return RoundingUtils.roundCurrency(appliedAmount, this.calculator.config);
+  }
+
+  /**
+   * Calculate original payment amount
+   * @param {Object} payment - Payment object
+   * @param {Object} sale - Sale object
+   * @returns {Promise<number>} Amount in payment's original currency
+   */
+  async calcOriginalPaymentAmount(payment, sale) {
+    const effectiveAmount = await this.calcPaymentAmount(payment, sale);
+    
+    return this.calculator.currencyEngine.exchange(
+      effectiveAmount,
+      sale.currency_iso,
+      payment.original_currency_iso
+    );
+  }
+
+  /**
+   * Calculate given payment amount
+   * @param {Object} payment - Payment object
+   * @param {Object} sale - Sale object
+   * @returns {number} Converted amount without debt adjustment
+   */
+  calcGivedPaymentAmount(payment, sale) {
+    return RoundingUtils.roundCurrency(this.calculator.currencyEngine.exchange(
+      payment.original_gived_amount,
+      payment.original_currency_iso,
+      sale.currency_iso
+    ), this.calculator.config);
+  }
+
+  /**
+   * Calculate complete payment details
+   * @param {Object} payment - Payment object
+   * @param {Object} sale - Sale object
+   * @returns {Promise<Object>} Payment details
+   */
+  async calculatePaymentDetails(payment, sale) {
+    const amount = await this.calcPaymentAmount(payment, sale);
+    
+    const gived_amount = this.calculator.currencyEngine.exchange(
+      payment.original_gived_amount,
+      payment.original_currency_iso,
+      sale.currency_iso
+    );
+
+    const original_amount = this.calculator.currencyEngine.exchange(
+      amount,
+      sale.currency_iso,
+      payment.original_currency_iso
+    );
+
+    const exchange_rate = gived_amount / payment.original_gived_amount;
+
+    return {
+      ...payment,
+      amount: RoundingUtils.roundCurrency(amount, this.calculator.config),
+      gived_amount: RoundingUtils.roundCurrency(gived_amount, this.calculator.config),
+      original_amount: RoundingUtils.roundCurrency(original_amount, this.calculator.config),
+      original_gived_amount: payment.original_gived_amount,
+      exchange_rate: RoundingUtils.roundCurrency(exchange_rate, this.calculator.config),
+      change_amount: RoundingUtils.roundCurrency(gived_amount - amount, this.calculator.config)
+    };
+  }
+}
+
+module.exports = PaymentEngine;

package/src/core/RuleEngineWrapper.js

@@ -0,0 +1,110 @@
+/**
+ * Rule Engine Wrapper
+ * Provides abstraction for rule engine with fallback support
+ */
+class RuleEngineWrapper {
+  constructor() {
+    this.engine = null;
+    this.ruleCache = new Map();
+    this.initializeEngine();
+  }
+
+  /**
+   * Initialize engine with graceful fallback
+   */
+  initializeEngine() {
+    try {
+      // Try to load ZenEngine if available
+      const { ZenEngine } = require('@gorules/zen-engine');
+      this.engine = new ZenEngine();
+      console.log('ZenEngine loaded successfully');
+    } catch (error) {
+      console.warn('ZenEngine not available, using fallback mode:', error.message);
+      this.engine = null;
+    }
+  }
+
+  /**
+   * Check if rule engine is available
+   * @returns {boolean} True if engine is available
+   */
+  isAvailable() {
+    return this.engine !== null;
+  }
+
+  /**
+   * Evaluate a business rule
+   * @param {Object} ruleContent - Rule content
+   * @param {Object} context - Execution context
+   * @returns {Promise<Object>} Evaluation result
+   */
+  async evaluateRule(ruleContent, context) {
+    if (!this.isAvailable()) {
+      return this.fallbackEvaluation(ruleContent, context);
+    }
+    
+    try {
+      const decision = this.engine.createDecision(ruleContent);
+      return await decision.safeEvaluate(context);
+    } catch (error) {
+      console.error('Rule evaluation error, using fallback:', error);
+      return this.fallbackEvaluation(ruleContent, context);
+    }
+  }
+
+  /**
+   * Execute multiple rules
+   * @param {Array} rules - Rules to execute
+   * @param {Object} context - Execution context
+   * @returns {Promise<Array>} Execution results
+   */
+  async executeRules(rules, context) {
+    const results = [];
+    
+    for (const rule of rules) {
+      try {
+        const result = await this.evaluateRule(rule.rule_content, context);
+        results.push(result);
+      } catch (error) {
+        results.push({
+          ruleId: rule.id,
+          success: false,
+          error: error.message
+        });
+      }
+    }
+    
+    return results;
+  }
+
+  /**
+   * Fallback evaluation when engine is not available
+   * @param {Object} ruleContent - Rule content
+   * @param {Object} context - Execution context
+   * @returns {Object} Default result
+   */
+  fallbackEvaluation(ruleContent, context) {
+    // Return default result when engine is not available
+    return {
+      success: true,
+      data: {},
+      message: 'Rule engine not available, using fallback'
+    };
+  }
+
+  /**
+   * Validate rule structure
+   * @param {Object} ruleContent - Rule content
+   * @returns {boolean} True if rule is valid
+   */
+  validateRule(ruleContent) {
+    if (!ruleContent || typeof ruleContent !== 'object') {
+      return false;
+    }
+    
+    const requiredProperties = ['nodes', 'edges', 'contentType'];
+    return requiredProperties.every(prop => ruleContent.hasOwnProperty(prop));
+  }
+}
+
+module.exports = RuleEngineWrapper;