@unchainedshop/plugins 1.1.3 → 1.1.7

package/src/pricing/order-items-discount.ts

@@ -0,0 +1,116 @@
+import { IOrderPricingAdapter, OrderPricingRowCategory } from '@unchainedshop/types/orders.pricing';
+import { OrderPricingDirector, OrderPricingAdapter } from '@unchainedshop/core-orders';
+
+const resolveRatioAndTaxDivisorForPricingSheet = (pricing, total) => {
+  if (total === 0 || !pricing) {
+    return {
+      ratio: 1,
+      taxDivisor: 1,
+    };
+  }
+  const tax = pricing.taxSum();
+  const gross = pricing.gross();
+  return {
+    ratio: gross / total,
+    taxDivisor: gross / (gross - tax),
+  };
+};
+
+const resolveAmountAndTax = ({ ratio, taxDivisor }, amount) => {
+  const shareAmount = Number.isFinite(ratio) ? amount * ratio : 0;
+  const shareTaxAmount = Number.isFinite(taxDivisor) ? shareAmount - shareAmount / taxDivisor : 0;
+  return [shareAmount, shareTaxAmount];
+};
+
+const applyDiscountToMultipleShares = (shares, amount) => {
+  return shares.reduce(
+    ([currentDiscountAmount, currentTaxAmount], share) => {
+      const [shareAmount, shareTaxAmount] = resolveAmountAndTax(share, amount);
+      return [currentDiscountAmount + shareAmount, currentTaxAmount + shareTaxAmount];
+    },
+    [0, 0],
+  );
+};
+
+const calculateAmountToSplit = (configuration, amount) => {
+  const deductionAmount = configuration.rate
+    ? amount * configuration.rate
+    : Math.min(configuration.fixedRate, amount);
+
+  return Math.max(0, deductionAmount - (configuration.alreadyDeducted || 0));
+};
+
+const OrderItemsDiscount: IOrderPricingAdapter = {
+  ...OrderPricingAdapter,
+
+  key: 'shop.unchained.pricing.order-items-discount',
+  version: '1.0',
+  label: 'Apply Discounts on Total Value Of Goods',
+  orderIndex: 89,
+
+  isActivatedFor: () => {
+    return true;
+  },
+
+  actions: (params) => {
+    const pricingAdapter = OrderPricingAdapter.actions(params);
+    const { order, orderPositions, modules } = params.context;
+
+    return {
+      ...pricingAdapter,
+
+      calculate: async () => {
+        // discounts need to provide a *fixedRate*
+        // if you want to add percentual discounts,
+        // add it to the order item calculation
+
+        const totalAmountOfItems = params.calculationSheet.sum({
+          category: OrderPricingRowCategory.Items,
+        });
+
+        const itemShares = orderPositions.map((orderPosition) =>
+          resolveRatioAndTaxDivisorForPricingSheet(
+            modules.orders.positions.pricingSheet(orderPosition, order.currency, params.context),
+            totalAmountOfItems,
+          ),
+        );
+
+        let alreadyDeducted = 0;
+
+        params.discounts.forEach(({ configuration, discountId }) => {
+          // First, we deduce the discount from the items
+          const [itemsDiscountAmount, itemsTaxAmount] = applyDiscountToMultipleShares(
+            itemShares,
+            calculateAmountToSplit({ ...configuration, alreadyDeducted }, totalAmountOfItems),
+          );
+          alreadyDeducted = +itemsDiscountAmount;
+
+          const discountAmount = itemsDiscountAmount;
+          const taxAmount = itemsTaxAmount;
+          if (discountAmount) {
+            pricingAdapter.resultSheet().addDiscount({
+              amount: discountAmount * -1,
+              discountId,
+              meta: {
+                adapter: OrderItemsDiscount.key,
+              },
+            });
+            if (taxAmount !== 0) {
+              pricingAdapter.resultSheet().addTax({
+                amount: taxAmount * -1,
+                meta: {
+                  discountId,
+                  adapter: OrderItemsDiscount.key,
+                },
+              });
+            }
+          }
+        });
+
+        return pricingAdapter.calculate();
+      },
+    };
+  },
+};
+
+OrderPricingDirector.registerAdapter(OrderItemsDiscount);

package/src/pricing/order-items.ts

@@ -0,0 +1,61 @@
+import { IOrderPricingAdapter } from '@unchainedshop/types/orders.pricing';
+import { OrderPricingDirector, OrderPricingAdapter } from '@unchainedshop/core-orders';
+
+const OrderItems: IOrderPricingAdapter = {
+  ...OrderPricingAdapter,
+
+  key: 'shop.unchained.pricing.order-items',
+  version: '1.0',
+  label: 'Add Total Value Of Goods to Order',
+  orderIndex: 0,
+
+  isActivatedFor: () => {
+    return true;
+  },
+
+  actions: (params) => {
+    const pricingAdapter = OrderPricingAdapter.actions(params);
+    const { order, orderPositions, modules } = params.context;
+
+    return {
+      ...pricingAdapter,
+
+      calculate: async () => {
+        // just sum up all products items prices, taxes & fees
+        const totalAndTaxesOfAllItems = orderPositions.reduce(
+          (current, orderPosition) => {
+            const pricing = modules.orders.positions.pricingSheet(
+              orderPosition,
+              order.currency,
+              params.context,
+            );
+            const tax = pricing.taxSum();
+            const items = pricing.gross();
+            return {
+              taxes: current.taxes + tax,
+              items: current.items + items,
+            };
+          },
+          {
+            taxes: 0,
+            items: 0,
+          },
+        );
+
+        pricingAdapter.resultSheet().addItems({
+          amount: totalAndTaxesOfAllItems.items,
+        });
+
+        if (totalAndTaxesOfAllItems.taxes !== 0) {
+          pricingAdapter.resultSheet().addTax({
+            amount: totalAndTaxesOfAllItems.taxes,
+          });
+        }
+
+        return pricingAdapter.calculate();
+      },
+    };
+  },
+};
+
+OrderPricingDirector.registerAdapter(OrderItems);

package/src/pricing/order-payment.ts

@@ -0,0 +1,46 @@
+import { IOrderPricingAdapter } from '@unchainedshop/types/orders.pricing';
+import { OrderPricingDirector, OrderPricingAdapter } from '@unchainedshop/core-orders';
+
+const OrderPayment: IOrderPricingAdapter = {
+  ...OrderPricingAdapter,
+
+  key: 'shop.unchained.pricing.order-payment',
+  version: '1.0',
+  label: 'Add Payment Fees to Order',
+  orderIndex: 20,
+
+  isActivatedFor: () => {
+    return true;
+  },
+
+  actions: (params) => {
+    const pricingAdapter = OrderPricingAdapter.actions(params);
+    const { order, orderPayment, modules } = params.context;
+
+    return {
+      ...pricingAdapter,
+
+      calculate: async () => {
+        // just add tax + net price to order pricing
+        if (!orderPayment) return null;
+
+        const pricing = modules.orders.payments.pricingSheet(
+          orderPayment,
+          order.currency,
+          params.context,
+        );
+        const tax = pricing.taxSum();
+        const paymentFees = pricing.gross();
+
+        pricingAdapter.resultSheet().addPayment({ amount: paymentFees });
+        if (tax !== 0) {
+          pricingAdapter.resultSheet().addTax({ amount: tax });
+        }
+
+        return pricingAdapter.calculate();
+      },
+    };
+  },
+};
+
+OrderPricingDirector.registerAdapter(OrderPayment);

package/src/pricing/product-catalog-price.ts

@@ -0,0 +1,56 @@
+import { IProductPricingAdapter } from '@unchainedshop/types/products.pricing';
+import { ProductPricingDirector, ProductPricingAdapter } from '@unchainedshop/core-products';
+
+const ProductPrice: IProductPricingAdapter = {
+  ...ProductPricingAdapter,
+
+  key: 'shop.unchained.pricing.product-price',
+  version: '1.0',
+  label: 'Add Gross Price to Product',
+  orderIndex: 0,
+
+  isActivatedFor: () => {
+    return true;
+  },
+
+  actions: (params) => {
+    const pricingAdapter = ProductPricingAdapter.actions(params);
+
+    return {
+      ...pricingAdapter,
+
+      calculate: async () => {
+        const {
+          product,
+          country,
+          currency: forcedCurrency,
+          quantity,
+          modules,
+          services,
+        } = params.context;
+        const currency =
+          forcedCurrency ||
+          (await services.countries.resolveDefaultCurrencyCode(
+            {
+              isoCode: country,
+            },
+            params.context,
+          ));
+        const price = await modules.products.prices.price(product, { country, currency, quantity });
+        if (price) {
+          const itemTotal = price.amount * quantity;
+          pricingAdapter.resultSheet().addItem({
+            amount: itemTotal,
+            isTaxable: price.isTaxable,
+            isNetPrice: price.isNetPrice,
+            meta: { adapter: ProductPrice.key },
+          });
+        }
+
+        return pricingAdapter.calculate();
+      },
+    };
+  },
+};
+
+ProductPricingDirector.registerAdapter(ProductPrice);

package/src/pricing/product-discount.ts

@@ -0,0 +1,69 @@
+import { Discount, DiscountConfiguration } from '@unchainedshop/types/discount';
+import {
+  IProductPricingAdapter,
+  ProductPricingRowCategory,
+} from '@unchainedshop/types/products.pricing';
+import { ProductPricingDirector, ProductPricingAdapter } from '@unchainedshop/core-products';
+
+const applyRate = (configuration: DiscountConfiguration, amount) => {
+  const { rate, fixedRate } = configuration;
+  return rate ? amount * rate : Math.min(fixedRate, amount);
+};
+const ProductDiscount: IProductPricingAdapter = {
+  ...ProductPricingAdapter,
+
+  key: 'shop.unchained.pricing.product-discount',
+  version: '1.0',
+  label: 'Apply Discounts on Product Price',
+  orderIndex: 10,
+
+  isActivatedFor: () => {
+    return true;
+  },
+
+  actions: (params) => {
+    const pricingAdapter = ProductPricingAdapter.actions(params);
+
+    const addDiscount = (discount: Discount, total: number, isTaxable: boolean) => {
+      const { configuration, discountId } = discount;
+      const { isNetPrice = false, ...meta } = configuration;
+      const amount = applyRate(configuration, total);
+
+      pricingAdapter.resultSheet().addDiscount({
+        amount: amount * -1,
+        discountId,
+        isNetPrice,
+        isTaxable,
+        meta: { adapter: ProductDiscount.key, ...meta },
+      });
+    };
+
+    return {
+      ...pricingAdapter,
+
+      calculate: async () => {
+        const taxableTotal = params.calculationSheet.sum({
+          category: ProductPricingRowCategory.Item,
+          isTaxable: true,
+        });
+        const nonTaxableTotal = params.calculationSheet.sum({
+          category: ProductPricingRowCategory.Item,
+          isTaxable: false,
+        });
+
+        params.discounts.forEach((discount) => {
+          if (taxableTotal !== 0) {
+            addDiscount(discount, taxableTotal, true);
+          }
+          if (nonTaxableTotal !== 0) {
+            addDiscount(discount, nonTaxableTotal, false);
+          }
+        });
+
+        return pricingAdapter.calculate();
+      },
+    };
+  },
+};
+
+ProductPricingDirector.registerAdapter(ProductDiscount);

package/src/pricing/product-price-ECB-interbank-exchange.ts

@@ -0,0 +1,108 @@
+import { IProductPricingAdapter } from '@unchainedshop/types/products.pricing';
+import fetch from 'isomorphic-unfetch';
+import { ProductPricingDirector, ProductPricingAdapter } from '@unchainedshop/core-products';
+
+import Cache from './utils/cache';
+
+const CACHE_PERIOD = 60 * 60 * 24; // 1 day
+
+const SUPPORTED_CURRENCIES = [
+  'USD',
+  'JPY',
+  'BGN',
+  'CZK',
+  'DKK',
+  'GBP',
+  'HUF',
+  'PLN',
+  'RON',
+  'SEK',
+  'CHF',
+  'ISK',
+  'NOK',
+  'HRK',
+  'RUB',
+  'TRY',
+  'AUD',
+  'BRL',
+  'CAD',
+  'CNY',
+  'HKD',
+  'IDR',
+  'ILS',
+  'INR',
+  'KRW',
+  'MXN',
+  'MYR',
+  'NZD',
+  'PHP',
+  'SGD',
+  'THB',
+  'ZAR',
+];
+
+const cache = new Cache(CACHE_PERIOD);
+const xmlJs = require('xml-js'); // eslint-disable-line
+
+const getEURexchangeRateForCurrency = async (currency) => {
+  const response = cache.get(currency, () =>
+    fetch(`https://www.ecb.europa.eu/stats/eurofxref/eurofxref-daily.xml`, {
+      method: 'GET',
+    })
+      .then((res) => res.text())
+      .then((text) => JSON.parse(xmlJs.xml2json(text)))
+      .then(
+        (json) =>
+          json.elements?.[0]?.elements
+            .filter((e) => e.name.toLowerCase() === 'cube')[0]
+            ?.elements[0]?.elements.filter((a) => a.attributes.currency === currency)?.[0]?.attributes,
+      ),
+  );
+  return response;
+};
+
+const ProductPriceECBIntraBankExchange: IProductPricingAdapter = {
+  ...ProductPricingAdapter,
+
+  key: 'shop.unchained.pricing.price-ECB-intrabank-exchange',
+  version: '1.0',
+  label: 'Convert EUR to X with current exchange rate',
+  orderIndex: 1,
+
+  isActivatedFor: (context) => {
+    return SUPPORTED_CURRENCIES.indexOf(context.currency) !== -1;
+  },
+
+  actions: (params) => {
+    const pricingAdapter = ProductPricingAdapter.actions(params);
+
+    return {
+      ...pricingAdapter,
+
+      calculate: async () => {
+        const { product, country, quantity, currency, modules } = params.context;
+        const { calculation = [] } = params.calculationSheet;
+        const EURprice = await modules.products.prices.price(product, {
+          country,
+          currency: 'EUR',
+          quantity,
+        });
+        if (!EURprice || !EURprice?.amount || calculation?.length) return pricingAdapter.calculate();
+
+        const exchange = await getEURexchangeRateForCurrency(currency);
+        const convertedAmount = EURprice.amount * exchange.rate;
+        pricingAdapter.resultSheet().resetCalculation(params.calculationSheet);
+        pricingAdapter.resultSheet().addItem({
+          amount: convertedAmount * quantity,
+          isTaxable: EURprice.isTaxable,
+          isNetPrice: EURprice.isNetPrice,
+          meta: { adapter: ProductPriceECBIntraBankExchange.key },
+        });
+
+        return pricingAdapter.calculate();
+      },
+    };
+  },
+};
+
+ProductPricingDirector.registerAdapter(ProductPriceECBIntraBankExchange);

package/src/pricing/product-price-coinbase-exchange.ts

@@ -0,0 +1,82 @@
+import { IProductPricingAdapter } from '@unchainedshop/types/products.pricing';
+import fetch from 'isomorphic-unfetch';
+import { ProductPricingDirector, ProductPricingAdapter } from '@unchainedshop/core-products';
+
+import Cache from './utils/cache';
+
+const CACHE_PERIOD = 60 * 60 * 0.1; // 10 minutes
+const SUPPORTED_CURRENCIES = ['BTC', 'ETH', 'XRP', 'USDT', 'BCH', 'BSV', 'LTC', 'EOS', 'BNB', 'XTZ'];
+const cache = new Cache(CACHE_PERIOD);
+
+const getFiatexchangeRateForCrypto = async (base, target) => {
+  const { data } = await cache.get(`${base}-${target}`, () =>
+    fetch(`https://api.coinbase.com/v2/exchange-rates?currency=${base}`, {
+      method: 'GET',
+    }).then((res) => res.json()),
+  );
+  return data?.rates?.[target];
+};
+
+const ProductPriceCoinbaseExchange: IProductPricingAdapter = {
+  ...ProductPricingAdapter,
+
+  key: 'shop.unchained.pricing.price-coinbase-exchange',
+  version: '1.0',
+  label: 'Convert fiat/crypto to crypto with current exchange rate',
+  orderIndex: 1,
+
+  isActivatedFor: (context) => {
+    return SUPPORTED_CURRENCIES.indexOf(context.currency.toUpperCase()) !== -1;
+  },
+
+  actions: (params) => {
+    const pricingAdapter = ProductPricingAdapter.actions(params);
+    const { services, modules } = params.context;
+    return {
+      ...pricingAdapter,
+
+      calculate: async () => {
+        const { product, country, quantity, currency } = params.context;
+        const defaultCurrency = await services.countries.resolveDefaultCurrencyCode(
+          {
+            isoCode: country,
+          },
+          params.context,
+        );
+
+        const productPrice = await modules.products.prices.price(product, {
+          country,
+          currency: defaultCurrency,
+          quantity,
+        });
+
+        const { calculation = [] } = params.calculationSheet;
+
+        if (
+          !productPrice ||
+          !productPrice?.amount ||
+          calculation?.length ||
+          defaultCurrency === currency
+        )
+          return pricingAdapter.calculate();
+
+        const rate = await getFiatexchangeRateForCrypto(defaultCurrency, currency);
+
+        if (rate > 0) {
+          const convertedAmount = productPrice.amount * rate;
+          pricingAdapter.resultSheet().resetCalculation(params.calculationSheet);
+          pricingAdapter.resultSheet().addItem({
+            amount: convertedAmount * quantity,
+            isTaxable: productPrice?.isTaxable,
+            isNetPrice: productPrice?.isNetPrice,
+            meta: { adapter: ProductPriceCoinbaseExchange.key },
+          });
+        }
+
+        return pricingAdapter.calculate();
+      },
+    };
+  },
+};
+
+ProductPricingDirector.registerAdapter(ProductPriceCoinbaseExchange);

package/src/pricing/product-price-cryptopay.ts

@@ -0,0 +1,25 @@
+import { Context } from '@unchainedshop/types/api';
+import { ProductPriceRate } from '@unchainedshop/types/products.pricing';
+import bodyParser from 'body-parser';
+import { useMiddlewareWithCurrentContext } from '@unchainedshop/api';
+
+const { CRYPTOPAY_SECRET, CRYPTOPAY_PRICING_WEBHOOK_PATH = '/graphql/cryptopay-pricing' } = process.env;
+
+useMiddlewareWithCurrentContext(CRYPTOPAY_PRICING_WEBHOOK_PATH, bodyParser.json());
+
+useMiddlewareWithCurrentContext(CRYPTOPAY_PRICING_WEBHOOK_PATH, async (request, response) => {
+  const resolvedContext = request.unchainedContext as Context;
+  const { baseCurrency, token, rate, timestamp, secret } = request.body;
+  if (secret !== CRYPTOPAY_SECRET) {
+    response.end(JSON.stringify({ success: false }));
+    return;
+  }
+  const rateData: ProductPriceRate = {
+    baseCurrency,
+    quoteCurrency: token,
+    rate,
+    timestamp,
+  };
+  const success = await resolvedContext.modules.products.prices.rates.updateRate(rateData);
+  response.end(JSON.stringify({ success }));
+});

package/src/pricing/product-price-rateconversion.ts

@@ -0,0 +1,73 @@
+import { IProductPricingAdapter } from '@unchainedshop/types/products.pricing';
+import { ProductPricingDirector, ProductPricingAdapter } from '@unchainedshop/core-products';
+
+const { RATECONVERSION_MAX_AGE = '360' } = process.env;
+
+const MAX_RATE_AGE = parseInt(RATECONVERSION_MAX_AGE, 10);
+
+const ProductPriceRateConversion: IProductPricingAdapter = {
+  ...ProductPricingAdapter,
+
+  key: 'shop.unchained.pricing.rate-conversion',
+  version: '1.0',
+  label: 'Generic rate conversion plugin that converts between rates if entry in DB exists.',
+  orderIndex: 1,
+
+  isActivatedFor: () => {
+    return true;
+  },
+
+  actions: (params) => {
+    const pricingAdapter = ProductPricingAdapter.actions(params);
+    const { services, modules } = params.context;
+    return {
+      ...pricingAdapter,
+
+      calculate: async () => {
+        const { product, country, quantity, currency } = params.context;
+        const defaultCurrency = await services.countries.resolveDefaultCurrencyCode(
+          {
+            isoCode: country,
+          },
+          params.context,
+        );
+
+        const productPrice = await modules.products.prices.price(product, {
+          country,
+          currency: defaultCurrency,
+          quantity,
+        });
+
+        const { calculation = [] } = params.calculationSheet;
+        if (
+          !productPrice ||
+          !productPrice?.amount ||
+          calculation?.length ||
+          defaultCurrency === currency
+        )
+          return pricingAdapter.calculate();
+
+        const rate = await modules.products.prices.rates.getRate(
+          defaultCurrency,
+          currency,
+          MAX_RATE_AGE,
+        );
+
+        if (rate > 0) {
+          const convertedAmount = productPrice.amount * rate;
+          pricingAdapter.resultSheet().resetCalculation(params.calculationSheet);
+          pricingAdapter.resultSheet().addItem({
+            amount: convertedAmount * quantity,
+            isTaxable: productPrice?.isTaxable,
+            isNetPrice: productPrice?.isNetPrice,
+            meta: { adapter: ProductPriceRateConversion.key },
+          });
+        }
+
+        return pricingAdapter.calculate();
+      },
+    };
+  },
+};
+
+ProductPricingDirector.registerAdapter(ProductPriceRateConversion);