@unchainedshop/plugins 1.1.3 → 1.1.4

package/src/payment/worldline-saferpay/worldline-saferpay-client/models/PaymentPageInitialize.ts

@@ -0,0 +1,55 @@
+import { PaymentMethods } from './PaymentMethods';
+import { Request } from './Request';
+import { Response } from './Response';
+import { TransactionAmount } from './Transaction';
+
+export interface PaymentPageInitializeInput extends Request {
+  ConfigSet?: string;
+  TerminalId: string;
+  Payment: {
+    Amount: TransactionAmount;
+    OrderId?: string;
+    PayerNote?: string;
+    Description: string;
+    MandateId?: string;
+    Options?: {
+      PreAuth?: boolean;
+      AllowPartialAuthorization?: boolean;
+    };
+  };
+  Recurring?: {
+    initial: boolean;
+  };
+  Installment?: {
+    initial: boolean;
+  };
+  PaymentMethods?: PaymentMethods[];
+  PaymentMethodsOptions?: Map<string, Map<string, string>>;
+  Authentication?: {
+    Exemption?: string;
+    ThreeDsChallenge?: string;
+  };
+  Wallets?: string[];
+  Payer?: {
+    IpAddress?: string;
+    LanguageCode?: string;
+  };
+  BillingAddress?: Map<string, string>;
+  DeliveryAddress?: Map<string, string>;
+  RegisterAlias?: {
+    IdGenerator: 'MANUAL' | 'RANDOM' | 'RANDOM_UNIQUE';
+    Id?: string;
+    Lifetime?: number;
+  };
+  ReturnUrls: {
+    Success: string;
+    Fail: string;
+    Abort?: string;
+  };
+}
+
+export interface PaymentPageInitializeResponse extends Response {
+  Token: string;
+  Expiration: string; // ISO8601 UTC
+  RedirectUrl: string;
+}

package/src/payment/worldline-saferpay/worldline-saferpay-client/models/Request.ts

@@ -0,0 +1,14 @@
+export interface RequestHeader {
+  SpecVersion: string;
+  CustomerId: string;
+  RequestId: string;
+  RetryIndicator: number;
+  ClientInfo?: {
+    ShopInfo?: string;
+    OsInfo?: string;
+  };
+}
+
+export interface Request {
+  RequestHeader: RequestHeader;
+}

package/src/payment/worldline-saferpay/worldline-saferpay-client/models/Response.ts

@@ -0,0 +1,9 @@
+export interface Response {
+  ResponseHeader: {
+    RequestId: string;
+    SpecVersion: string;
+  };
+  ErrorName?: string;
+  ErrorMessage?: string;
+  Behavior?: 'ABORT' | 'OTHER_MEANS' | 'RETRY' | 'RETRY_LATER';
+}

package/src/payment/worldline-saferpay/worldline-saferpay-client/models/Transaction.ts

@@ -0,0 +1,6 @@
+export type TransactionStatus = 'AUTHORIZED' | 'CANCELED' | 'CAPTURED' | 'PENDING';
+
+export type TransactionAmount = {
+  Value: string;
+  CurrencyCode: string;
+};

package/src/payment/worldline-saferpay/worldline-saferpay-client/models/TransactionCancel.ts

@@ -0,0 +1,15 @@
+import { Response } from './Response';
+import { Request } from './Request';
+
+export interface TransactionCancelInput extends Request {
+  TransactionReference: {
+    TransactionId: string;
+    OrderId?: string;
+  };
+}
+
+export interface TransactionCancelResponse extends Response {
+  TransactionId: string;
+  OrderId?: string;
+  Date: string;
+}

package/src/pricing/delivery-swiss-tax.ts

@@ -0,0 +1,115 @@
+import moment from 'moment';
+import { DeliveryPricingAdapter, DeliveryPricingDirector } from '@unchainedshop/core-delivery';
+import {
+  DeliveryPricingAdapterContext,
+  IDeliveryPricingAdapter,
+} from '@unchainedshop/types/delivery.pricing';
+
+// https://www.ch.ch/de/mehrwertsteuersatz-schweiz/
+export const SwissTaxCategories = {
+  DEFAULT: {
+    rate: (date) => {
+      const referenceDate = moment(date);
+      if (referenceDate.isBefore('2018-01-01')) {
+        return 0.08;
+      }
+      return 0.077;
+    },
+  },
+  REDUCED: {
+    value: 'reduced',
+    rate: () => {
+      return 0.025;
+    },
+  },
+  SPECIAL: {
+    value: 'special',
+    rate: () => {
+      return 0.037;
+    },
+  },
+};
+
+const getTaxRate = (context: DeliveryPricingAdapterContext) => {
+  const date = context.order && context.order.ordered ? new Date(context.order.ordered) : new Date();
+
+  const taxCategoryFromProvider = context.deliveryProvider?.configuration?.find(({ key }) => {
+    if (key === 'swiss-tax-category') return true;
+    return null;
+  })?.value;
+
+  if (taxCategoryFromProvider === SwissTaxCategories.REDUCED.value) {
+    return SwissTaxCategories.REDUCED.rate();
+  }
+  if (taxCategoryFromProvider === SwissTaxCategories.SPECIAL.value) {
+    return SwissTaxCategories.SPECIAL.rate();
+  }
+  return SwissTaxCategories.DEFAULT.rate(date);
+};
+
+const isDeliveryAddressInSwitzerland = ({ orderDelivery, order, country = null }) => {
+  let countryCode = country?.toUpperCase().trim() || order.countryCode;
+
+  const address = orderDelivery?.context?.address || order?.billingAddress;
+
+  if (address?.countryCode > '') {
+    countryCode = address.countryCode?.toUpperCase().trim();
+  }
+
+  return countryCode === 'CH' || countryCode === 'LI';
+};
+
+export const DeliverySwissTax: IDeliveryPricingAdapter = {
+  ...DeliveryPricingAdapter,
+
+  key: 'shop.unchained.pricing.delivery-swiss-tax',
+  version: '1.0',
+  label: 'Apply Swiss Tax on Delivery Fees',
+  orderIndex: 20,
+
+  isActivatedFor: (context) => {
+    return isDeliveryAddressInSwitzerland(context);
+  },
+
+  actions: (params) => {
+    const pricingAdapter = DeliveryPricingAdapter.actions(params);
+    const { context } = params;
+
+    return {
+      ...pricingAdapter,
+
+      calculate: async () => {
+        const taxRate = getTaxRate(context);
+        DeliveryPricingAdapter.log(`DeliverySwissTax -> Tax Multiplicator: ${taxRate}`);
+        params.calculationSheet.filterBy({ isTaxable: true }).forEach(({ isNetPrice, ...row }) => {
+          if (!isNetPrice) {
+            const taxAmount = row.amount - row.amount / (1 + taxRate);
+            pricingAdapter.resultSheet().calculation.push({
+              ...row,
+              amount: -taxAmount,
+              isTaxable: false,
+              isNetPrice: false,
+              meta: { adapter: DeliverySwissTax.key },
+            });
+            pricingAdapter.resultSheet().addTax({
+              amount: taxAmount,
+              rate: taxRate,
+              meta: { adapter: DeliverySwissTax.key },
+            });
+          } else {
+            const taxAmount = row.amount * taxRate;
+            pricingAdapter.resultSheet().addTax({
+              amount: taxAmount,
+              rate: taxRate,
+              meta: { adapter: DeliverySwissTax.key },
+            });
+          }
+        });
+
+        return pricingAdapter.calculate();
+      },
+    };
+  },
+};
+
+DeliveryPricingDirector.registerAdapter(DeliverySwissTax);

package/src/pricing/discount-100-off.ts

@@ -0,0 +1,44 @@
+import { IDiscountAdapter } from '@unchainedshop/types/discount';
+import { OrderDiscountDirector, OrderDiscountAdapter } from '@unchainedshop/core-orders';
+
+const HundredOff: IDiscountAdapter = {
+  ...OrderDiscountAdapter,
+
+  key: 'shop.unchained.discount.100-off',
+  label: '100 Off',
+  version: '1.0',
+  orderIndex: 1,
+
+  // return true if a discount is allowed to get added manually by a user
+  isManualAdditionAllowed: async () => {
+    return true;
+  },
+
+  // return true if a discount is allowed to get removed manually by a user
+  isManualRemovalAllowed: async () => {
+    return true;
+  },
+
+  actions: async ({ context }) => ({
+    ...(await OrderDiscountAdapter.actions({ context })),
+
+    isValidForSystemTriggering: async () => {
+      return false;
+    },
+
+    isValidForCodeTriggering: async ({ code }) => {
+      return code.toUpperCase() === '100OFF';
+    },
+
+    // returns the appropriate discount context for a calculation adapter
+    discountForPricingAdapterKey: ({ pricingAdapterKey }) => {
+      if (pricingAdapterKey === 'shop.unchained.pricing.order-discount') {
+        return { fixedRate: 10000 };
+      }
+
+      return null;
+    },
+  }),
+};
+
+OrderDiscountDirector.registerAdapter(HundredOff);

package/src/pricing/discount-half-price-manual.ts

@@ -0,0 +1,43 @@
+import { IDiscountAdapter } from '@unchainedshop/types/discount';
+import { OrderDiscountDirector, OrderDiscountAdapter } from '@unchainedshop/core-orders';
+
+const HalfPriceManual: IDiscountAdapter = {
+  ...OrderDiscountAdapter,
+
+  key: 'shop.unchained.discount.half-price-manual',
+  label: 'Half Price',
+  version: '1.0',
+  orderIndex: 2,
+
+  // return true if a discount is allowed to get added manually by a user
+  isManualAdditionAllowed: async () => {
+    return true;
+  },
+
+  // return true if a discount is allowed to get removed manually by a user
+  isManualRemovalAllowed: async () => {
+    return true;
+  },
+
+  actions: async ({ context }) => ({
+    ...(await OrderDiscountAdapter.actions({ context })),
+
+    isValidForSystemTriggering: async () => {
+      return false;
+    },
+
+    isValidForCodeTriggering: async ({ code }) => {
+      return code === 'HALFPRICE';
+    },
+
+    // returns the appropriate discount context for a calculation adapter
+    discountForPricingAdapterKey({ pricingAdapterKey }) {
+      if (pricingAdapterKey === 'shop.unchained.pricing.product-discount') {
+        return { rate: 0.5 };
+      }
+      return null;
+    },
+  }),
+};
+
+OrderDiscountDirector.registerAdapter(HalfPriceManual);

package/src/pricing/discount-half-price.ts

@@ -0,0 +1,46 @@
+import { IDiscountAdapter } from '@unchainedshop/types/discount';
+import { OrderDiscountDirector, OrderDiscountAdapter } from '@unchainedshop/core-orders';
+
+const HalfPrice: IDiscountAdapter = {
+  ...OrderDiscountAdapter,
+
+  key: 'shop.unchained.discount.half-price',
+  label: 'Half Price',
+  version: '1.0',
+  orderIndex: 3,
+
+  // return true if a discount is allowed to get added manually by a user
+  isManualAdditionAllowed: async () => {
+    return false;
+  },
+
+  // return true if a discount is allowed to get removed manually by a user
+  isManualRemovalAllowed: async () => {
+    return false;
+  },
+
+  actions: async ({ context }) => ({
+    ...(await OrderDiscountAdapter.actions({ context })),
+
+    isValidForSystemTriggering: async () => {
+      const { order } = context;
+      const user = await context.modules.users.findUserById(order.userId);
+      const isUserEligibleForHalfPrice = user?.tags && user.tags.indexOf('half-price') !== -1;
+      return !!isUserEligibleForHalfPrice;
+    },
+
+    isValidForCodeTriggering: async () => {
+      return false;
+    },
+
+    // returns the appropriate discount context for a calculation adapter
+    discountForPricingAdapterKey({ pricingAdapterKey }) {
+      if (pricingAdapterKey === 'shop.unchained.pricing.product-discount') {
+        return { rate: 0.5 };
+      }
+      return null;
+    },
+  }),
+};
+
+OrderDiscountDirector.registerAdapter(HalfPrice);

package/src/pricing/free-delivery.ts

@@ -0,0 +1,31 @@
+import { DeliveryPricingAdapter, DeliveryPricingDirector } from '@unchainedshop/core-delivery';
+import { IDeliveryPricingAdapter } from '@unchainedshop/types/delivery.pricing';
+
+export const DeliveryFreePrice: IDeliveryPricingAdapter = {
+  ...DeliveryPricingAdapter,
+
+  key: 'shop.unchained.pricing.delivery-free',
+  version: '1.0',
+  label: 'Free Delivery',
+  orderIndex: 0,
+
+  isActivatedFor: () => {
+    return true;
+  },
+
+  actions: (params) => {
+    const pricingAdapter = DeliveryPricingAdapter.actions(params);
+    return {
+      ...pricingAdapter,
+      calculate: async () => {
+        pricingAdapter.resultSheet().addFee({
+          amount: 0,
+          meta: { adapter: DeliveryFreePrice.key },
+        });
+        return pricingAdapter.calculate();
+      },
+    };
+  },
+};
+
+DeliveryPricingDirector.registerAdapter(DeliveryFreePrice);

package/src/pricing/free-payment.ts

@@ -0,0 +1,32 @@
+import { PaymentPricingAdapter, PaymentPricingDirector } from '@unchainedshop/core-payment';
+import { IPaymentPricingAdapter } from '@unchainedshop/types/payments.pricing';
+
+export const PaymentFreePrice: IPaymentPricingAdapter = {
+  ...PaymentPricingAdapter,
+
+  key: 'shop.unchained.pricing.payment-free',
+  version: '1.0',
+  label: 'Free Payment',
+  orderIndex: 0,
+
+  isActivatedFor: () => {
+    return true;
+  },
+
+  actions: (params) => {
+    const pricingAdapter = PaymentPricingAdapter.actions(params);
+
+    return {
+      ...pricingAdapter,
+      calculate: async () => {
+        pricingAdapter.resultSheet().addFee({
+          amount: 0,
+          meta: { adapter: PaymentFreePrice.key },
+        });
+        return pricingAdapter.calculate();
+      },
+    };
+  },
+};
+
+PaymentPricingDirector.registerAdapter(PaymentFreePrice);

package/src/pricing/order-delivery.ts

@@ -0,0 +1,45 @@
+import { IOrderPricingAdapter } from '@unchainedshop/types/orders.pricing';
+import { OrderPricingDirector, OrderPricingAdapter } from '@unchainedshop/core-orders';
+
+const OrderDelivery: IOrderPricingAdapter = {
+  ...OrderPricingAdapter,
+
+  key: 'shop.unchained.pricing.order-delivery',
+  version: '1.0',
+  label: 'Add Delivery Fees to Order',
+  orderIndex: 10,
+
+  isActivatedFor: () => {
+    return true;
+  },
+
+  actions: (params) => {
+    const pricingAdapter = OrderPricingAdapter.actions(params);
+    const { order, orderDelivery, modules } = params.context;
+
+    return {
+      ...pricingAdapter,
+
+      calculate: async () => {
+        // just add tax + net price to order pricing
+        if (!orderDelivery) return null;
+        const pricing = modules.orders.deliveries.pricingSheet(
+          orderDelivery,
+          order.currency,
+          params.context,
+        );
+        const tax = pricing.taxSum();
+        const shipping = pricing.gross();
+
+        pricingAdapter.resultSheet().addDelivery({ amount: shipping });
+        if (tax !== 0) {
+          pricingAdapter.resultSheet().addTax({ amount: tax });
+        }
+
+        return pricingAdapter.calculate();
+      },
+    };
+  },
+};
+
+OrderPricingDirector.registerAdapter(OrderDelivery);

package/src/pricing/order-discount.ts

@@ -0,0 +1,158 @@
+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();
+  if (gross - tax === 0) {
+    return {
+      ratio: 0,
+      taxDivisor: 0,
+    };
+  }
+  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) && taxDivisor !== 0 ? 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 : configuration.fixedRate;
+
+  const leftInDiscount = Math.max(0, deductionAmount - (configuration.alreadyDeductedForDiscount || 0));
+  const leftToDeduct = Math.min(configuration.amountLeft, leftInDiscount);
+  return Math.max(0, leftToDeduct);
+};
+
+const OrderDiscount: IOrderPricingAdapter = {
+  ...OrderPricingAdapter,
+
+  key: 'shop.unchained.pricing.order-discount',
+  version: '1.0',
+  label: 'Apply Discounts on Total Order Value',
+  orderIndex: 90,
+
+  isActivatedFor: () => {
+    return true;
+  },
+
+  actions: (params) => {
+    const pricingAdapter = OrderPricingAdapter.actions(params);
+    const { order, orderDelivery, orderPositions, orderPayment, 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 totalAmountOfPaymentAndDelivery =
+          params.calculationSheet.sum({
+            category: OrderPricingRowCategory.Payment,
+          }) +
+          params.calculationSheet.sum({
+            category: OrderPricingRowCategory.Delivery,
+          });
+
+        const itemShares = orderPositions.map((orderPosition) =>
+          resolveRatioAndTaxDivisorForPricingSheet(
+            modules.orders.positions.pricingSheet(orderPosition, order.currency, params.context),
+            totalAmountOfItems,
+          ),
+        );
+
+        const deliveryShare = resolveRatioAndTaxDivisorForPricingSheet(
+          orderDelivery &&
+            modules.orders.deliveries.pricingSheet(orderDelivery, order.currency, params.context),
+          totalAmountOfPaymentAndDelivery,
+        );
+        const paymentShare = resolveRatioAndTaxDivisorForPricingSheet(
+          orderPayment &&
+            modules.orders.payments.pricingSheet(orderPayment, order.currency, params.context),
+          totalAmountOfPaymentAndDelivery,
+        );
+
+        let amountLeft = totalAmountOfPaymentAndDelivery + totalAmountOfItems;
+
+        params.discounts.forEach(({ configuration, discountId }) => {
+          // First, we deduce the discount from the items
+          let alreadyDeductedForDiscount = 0;
+          const [itemsDiscountAmount, itemsTaxAmount] = applyDiscountToMultipleShares(
+            itemShares,
+            calculateAmountToSplit(
+              { ...configuration, amountLeft, alreadyDeductedForDiscount },
+              totalAmountOfItems,
+            ),
+          );
+          amountLeft -= itemsDiscountAmount;
+          alreadyDeductedForDiscount += itemsDiscountAmount;
+
+          // After the items, we deduct the remaining discount from payment & delivery fees
+          const [deliveryAndPaymentDiscountAmount, deliveryAndPaymentTaxAmount] =
+            applyDiscountToMultipleShares(
+              [deliveryShare, paymentShare],
+              calculateAmountToSplit(
+                { ...configuration, amountLeft, alreadyDeductedForDiscount },
+                totalAmountOfPaymentAndDelivery,
+              ),
+            );
+          amountLeft -= deliveryAndPaymentDiscountAmount;
+          alreadyDeductedForDiscount += itemsDiscountAmount;
+
+          const discountAmount = itemsDiscountAmount + deliveryAndPaymentDiscountAmount;
+          const taxAmount = itemsTaxAmount + deliveryAndPaymentTaxAmount;
+
+          if (discountAmount) {
+            pricingAdapter.resultSheet().addDiscount({
+              amount: discountAmount * -1,
+              discountId,
+              meta: {
+                adapter: OrderDiscount.key,
+              },
+            });
+            if (taxAmount !== 0) {
+              pricingAdapter.resultSheet().addTax({
+                amount: taxAmount * -1,
+                meta: {
+                  discountId,
+                  adapter: OrderDiscount.key,
+                },
+              });
+            }
+          }
+        });
+
+        return pricingAdapter.calculate();
+      },
+    };
+  },
+};
+
+OrderPricingDirector.registerAdapter(OrderDiscount);