@unchainedshop/plugins 2.6.0 → 2.7.0

package/src/payment/payrexx/payrexx.ts

@@ -0,0 +1,25 @@
+export const mapOrderDataToGatewayObject = ({ order, orderPayment, pricing }, options = {}) => {
+  const {
+    EMAIL_WEBSITE_NAME = 'Unchained',
+    EMAIL_WEBSITE_URL,
+    DATATRANS_SUCCESS_PATH = '/payrexx/success',
+    DATATRANS_ERROR_PATH = '/payrexx/error',
+    DATATRANS_CANCEL_PATH = '/payrexx/cancel',
+  } = process.env;
+
+  const { currency, amount } = pricing.total({ useNetPrice: false });
+  const gatewayObject = {
+    amount: Math.round(amount),
+    currency: currency.toUpperCase(),
+    purpose: encodeURIComponent(`${EMAIL_WEBSITE_NAME} #${order._id}`),
+    reservation: true,
+    skipResultPage: true,
+    successRedirectUrl: `${EMAIL_WEBSITE_URL}${DATATRANS_SUCCESS_PATH}`,
+    failedRedirectUrl: `${EMAIL_WEBSITE_URL}${DATATRANS_ERROR_PATH}`,
+    cancelRedirectUrl: `${EMAIL_WEBSITE_URL}${DATATRANS_CANCEL_PATH}`,
+    referenceId: orderPayment._id,
+    'fields[email]': order.contact?.emailAddress,
+    ...options,
+  };
+  return gatewayObject;
+};

package/src/payment/payrexx/readme.md

@@ -0,0 +1,4 @@
+## Test Webhooks:
+
+```
+```

package/src/payment/stripe/middleware.ts

@@ -4,18 +4,10 @@ import stripe from './stripe.js';
 
 const logger = createLogger('unchained:core-payment:stripe:webhook');
 
-const { STRIPE_ENDPOINT_SECRET, STRIPE_WEBHOOK_ENVIRONMENT } = process.env;
-
-function checkEnvironment(metadata: any) {
-  const environmentInMetadata = metadata?.environment;
-  const environmentInEnv = STRIPE_WEBHOOK_ENVIRONMENT;
-
-  if (!environmentInMetadata && !environmentInEnv) {
-    return true;
-  }
-
-  return environmentInEnv === environmentInMetadata;
-}
+export const WebhookEventTypes = {
+  PAYMENT_INTENT_SUCCEEDED: 'payment_intent.succeeded',
+  SETUP_INTENT_SUCCEEDED: 'setup_intent.succeeded',
+};
 
 export const stripeHandler = async (request, response) => {
   const resolvedContext = request.unchainedContext as Context;
@@ -25,30 +17,50 @@ export const stripeHandler = async (request, response) => {
 
   try {
     const sig = request.headers['stripe-signature'];
-    event = stripe.webhooks.constructEvent(request.body, sig, STRIPE_ENDPOINT_SECRET);
-    logger.verbose(`received event`, {
-      type: event.type,
-    });
+    event = stripe.webhooks.constructEvent(request.body, sig, process.env.STRIPE_ENDPOINT_SECRET);
   } catch (err) {
-    logger.error(`failed event validation with: ${err.message}`);
+    logger.error(`Error constructing event: ${err.message}`);
     response.writeHead(400);
     response.end(err.message);
     return;
   }
 
+  if (!Object.values(WebhookEventTypes).find(event.type)) {
+    logger.verbose(`unhandled event type`, {
+      type: event.type,
+    });
+    response.writeHead(200);
+    response.end({
+      ignored: true,
+      message: `Unhandled event type: ${event.type}. Supported types: ${Object.values(WebhookEventTypes).join(', ')}`,
+    });
+  }
+
+  const environmentInMetadata = event.data?.object?.metadata?.environment || '';
+  const environmentInEnv = process.env.STRIPE_WEBHOOK_ENVIRONMENT || '';
+  if (environmentInMetadata !== environmentInEnv) {
+    logger.verbose(`unhandled event environment`, {
+      type: event.type,
+      environment: environmentInMetadata,
+    });
+    response.writeHead(200);
+    response.end(
+      JSON.stringify({
+        ignored: true,
+        message: `Unhandled event environment: ${environmentInMetadata}. Supported environment: ${environmentInEnv}`,
+      }),
+    );
+    return;
+  }
+
+  logger.verbose(`Processing event`, {
+    type: event.type,
+  });
   try {
-    if (event.type === 'payment_intent.succeeded') {
+    if (event.type === WebhookEventTypes.PAYMENT_INTENT_SUCCEEDED) {
       const paymentIntent = event.data.object;
       const { orderPaymentId } = paymentIntent.metadata || {};
 
-      if (!checkEnvironment(paymentIntent.metadata)) {
-        logger.verbose(`event ignored because of environment difference`, {
-          type: event.type,
-        });
-        response.end(JSON.stringify({ received: true, ignored: true }));
-        return;
-      }
-
       logger.verbose(`checkout with orderPaymentId: ${orderPaymentId}`, {
         type: event.type,
       });
@@ -75,25 +87,26 @@ export const stripeHandler = async (request, response) => {
         resolvedContext,
       );
 
-      logger.info(`confirmed checkout for order: ${order._id}`, {
+      logger.info(`checkout successful`, {
+        orderPaymentId,
         orderId: order._id,
         type: event.type,
       });
-    } else if (event.type === 'setup_intent.succeeded') {
+      response.writeHead(200);
+      response.end({
+        message: 'checkout successful',
+        orderId: order._id,
+      });
+    } else if (event.type === WebhookEventTypes.SETUP_INTENT_SUCCEEDED) {
       const setupIntent = event.data.object;
       const { paymentProviderId, userId } = setupIntent.metadata || {};
 
-      if (!checkEnvironment(setupIntent.metadata)) {
-        response.end(JSON.stringify({ received: true, ignored: true }));
-        return;
-      }
-
       logger.verbose(`registered payment credential with paymentProviderId: ${paymentProviderId}`, {
         type: event.type,
         userId,
       });
 
-      await modules.payment.registerCredentials(
+      const paymentCredentials = await modules.payment.registerCredentials(
         paymentProviderId,
         {
           transactionContext: {
@@ -104,29 +117,23 @@ export const stripeHandler = async (request, response) => {
         resolvedContext,
       );
 
-      logger.info(`registered payment credentials with paymentProviderId: ${paymentProviderId}`, {
+      logger.info(`payment credentials registration successful`, {
         userId,
+        paymentProviderId,
+        paymentCredentialsId: paymentCredentials?._id,
         type: event.type,
       });
-    } else {
-      logger.verbose(`unhandled type`, {
-        type: event.type,
+      response.writeHead(200);
+      response.end({
+        message: 'payment credentials registration successful',
+        paymentCredentialsId: paymentCredentials?._id,
       });
-      response.writeHead(404);
-      response.end();
-      return;
     }
-  } catch (err) {
-    logger.error(`failed with: ${err.message}`, {
+  } catch (error) {
+    logger.error(error, {
       type: event.type,
     });
-    response.writeHead(400);
-    response.end(err.message || 'Error');
-    return;
+    response.writeHead(500);
+    response.end(error.message);
   }
-  // Return a 200 response to acknowledge receipt of the event
-  logger.verbose(`event processed`, {
-    type: event.type,
-  });
-  response.end(JSON.stringify({ received: true }));
 };

package/src/plugins-index.ts

@@ -19,6 +19,8 @@ import { appleIAPHandler, configureAppleTransactionsModule } from './payment/app
 import { stripeHandler } from './payment/stripe/index.js';
 import { postfinanceCheckoutHandler } from './payment/postfinance-checkout/index.js';
 
+import { payrexxHandler } from './payment/payrexx/index.js';
+
 // Warehousing
 import './warehousing/store.js';
 import './warehousing/eth-minter.js';
@@ -79,6 +81,7 @@ import './accounts/linkedin-oauth.js';
 const {
   CRYPTOPAY_WEBHOOK_PATH = '/payment/cryptopay',
   STRIPE_WEBHOOK_PATH = '/payment/stripe',
+  PAYREXX_WEBHOOK_PATH = '/payment/payrexx',
   PFCHECKOUT_WEBHOOK_PATH = '/payment/postfinance-checkout',
   DATATRANS_WEBHOOK_PATH = '/payment/datatrans/webhook',
   APPLE_IAP_WEBHOOK_PATH = '/payment/apple-iap',
@@ -146,6 +149,13 @@ export const connectDefaultPluginsToExpress4 = (
     appleIAPHandler,
   );
 
+  useMiddlewareWithCurrentContext(
+    app,
+    PAYREXX_WEBHOOK_PATH,
+    express.json({ type: 'application/json' }),
+    payrexxHandler,
+  );
+
   // useMiddlewareWithCurrentContext(
   //   app,
   //   MINIO_PUT_SERVER_PATH,

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

@@ -1,7 +1,8 @@
 import { IDiscountAdapter } from '@unchainedshop/types/discount.js';
 import { OrderDiscountDirector, OrderDiscountAdapter } from '@unchainedshop/core-orders';
+import { OrderDiscountConfiguration } from '@unchainedshop/core-orders/director/OrderDiscountConfiguration.js';
 
-export const HundredOff: IDiscountAdapter = {
+export const HundredOff: IDiscountAdapter<OrderDiscountConfiguration> = {
   ...OrderDiscountAdapter,
 
   key: 'shop.unchained.discount.100-off',

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

@@ -1,7 +1,8 @@
 import { IDiscountAdapter } from '@unchainedshop/types/discount.js';
 import { OrderDiscountDirector, OrderDiscountAdapter } from '@unchainedshop/core-orders';
+import { ProductDiscountConfiguration } from '@unchainedshop/core-products/director/ProductDiscountConfiguration.js';
 
-export const HalfPriceManual: IDiscountAdapter = {
+export const HalfPriceManual: IDiscountAdapter<ProductDiscountConfiguration> = {
   ...OrderDiscountAdapter,
 
   key: 'shop.unchained.discount.half-price-manual',

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

@@ -1,7 +1,8 @@
 import { IDiscountAdapter } from '@unchainedshop/types/discount.js';
 import { OrderDiscountDirector, OrderDiscountAdapter } from '@unchainedshop/core-orders';
+import { ProductDiscountConfiguration } from '@unchainedshop/core-products/director/ProductDiscountConfiguration.js';
 
-export const HalfPrice: IDiscountAdapter = {
+export const HalfPrice: IDiscountAdapter<ProductDiscountConfiguration> = {
   ...OrderDiscountAdapter,
 
   key: 'shop.unchained.discount.half-price',

package/src/pricing/order-discount.ts

@@ -1,8 +1,9 @@
 import { IOrderPricingAdapter, OrderPricingRowCategory } from '@unchainedshop/types/orders.pricing.js';
 import { OrderPricingDirector, OrderPricingAdapter } from '@unchainedshop/core-orders';
 import { calculation as calcUtils } from '@unchainedshop/utils';
+import { OrderDiscountConfiguration } from '@unchainedshop/core-orders/director/OrderDiscountConfiguration.js';
 
-export const OrderDiscount: IOrderPricingAdapter = {
+export const OrderDiscount: IOrderPricingAdapter<OrderDiscountConfiguration> = {
   ...OrderPricingAdapter,
 
   key: 'shop.unchained.pricing.order-discount',
@@ -22,9 +23,6 @@ export const OrderDiscount: IOrderPricingAdapter = {
       ...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.total({
           category: OrderPricingRowCategory.Items,
           useNetPrice: false,
@@ -61,10 +59,8 @@ export const OrderDiscount: IOrderPricingAdapter = {
 
         params.discounts.forEach(({ configuration, discountId }) => {
           // First, we deduce the discount from the items
-          let alreadyDeducted = 0;
-
           const leftInDiscountToSplit = calcUtils.calculateAmountToSplit(
-            { ...configuration, alreadyDeducted },
+            { ...configuration },
             totalAmountOfItems,
           );
           const [itemsDiscountAmount, itemsTaxAmount] = calcUtils.applyDiscountToMultipleShares(
@@ -72,11 +68,10 @@ export const OrderDiscount: IOrderPricingAdapter = {
             Math.max(0, Math.min(amountLeft, leftInDiscountToSplit)),
           );
           amountLeft -= itemsDiscountAmount;
-          alreadyDeducted += itemsDiscountAmount;
 
           // After the items, we deduct the remaining discount from payment & delivery fees
           const leftInFeesToSplit = calcUtils.calculateAmountToSplit(
-            { ...configuration, alreadyDeducted },
+            { ...configuration },
             totalAmountOfPaymentAndDelivery,
           );
           const [deliveryAndPaymentDiscountAmount, deliveryAndPaymentTaxAmount] =
@@ -85,7 +80,6 @@ export const OrderDiscount: IOrderPricingAdapter = {
               Math.max(0, Math.min(amountLeft, leftInFeesToSplit)),
             );
           amountLeft -= deliveryAndPaymentDiscountAmount;
-          alreadyDeducted += itemsDiscountAmount;
 
           const discountAmount = (itemsDiscountAmount + deliveryAndPaymentDiscountAmount) * -1;
           const taxAmount = (itemsTaxAmount + deliveryAndPaymentTaxAmount) * -1;

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

@@ -1,8 +1,9 @@
 import { IOrderPricingAdapter, OrderPricingRowCategory } from '@unchainedshop/types/orders.pricing.js';
 import { OrderPricingDirector, OrderPricingAdapter } from '@unchainedshop/core-orders';
 import { calculation as calcUtils } from '@unchainedshop/utils';
+import { OrderDiscountConfiguration } from '@unchainedshop/core-orders/director/OrderDiscountConfiguration.js';
 
-const OrderItemsDiscount: IOrderPricingAdapter = {
+const OrderItemsDiscount: IOrderPricingAdapter<OrderDiscountConfiguration> = {
   ...OrderPricingAdapter,
 
   key: 'shop.unchained.pricing.order-items-discount',
@@ -38,15 +39,19 @@ const OrderItemsDiscount: IOrderPricingAdapter = {
           ),
         );
 
-        let alreadyDeducted = 0;
+        let amountLeft = totalAmountOfItems;
 
         params.discounts.forEach(({ configuration, discountId }) => {
           // First, we deduce the discount from the items
+          const leftInItemsToSplit = calcUtils.calculateAmountToSplit(
+            { ...configuration },
+            totalAmountOfItems,
+          );
           const [itemsDiscountAmount, itemsTaxAmount] = calcUtils.applyDiscountToMultipleShares(
             itemShares,
-            calcUtils.calculateAmountToSplit({ ...configuration, alreadyDeducted }, totalAmountOfItems),
+            Math.max(0, Math.min(amountLeft, leftInItemsToSplit)),
           );
-          alreadyDeducted = +itemsDiscountAmount;
+          amountLeft -= itemsDiscountAmount;
 
           const discountAmount = itemsDiscountAmount * -1;
           const taxAmount = itemsTaxAmount * -1;

package/src/pricing/product-discount.ts

@@ -5,8 +5,9 @@ import {
 } from '@unchainedshop/types/products.pricing.js';
 import { ProductPricingDirector, ProductPricingAdapter } from '@unchainedshop/core-products';
 import { calculation as calcUtils } from '@unchainedshop/utils';
+import { ProductDiscountConfiguration } from '@unchainedshop/core-products/director/ProductDiscountConfiguration.js';
 
-const ProductDiscount: IProductPricingAdapter = {
+const ProductDiscount: IProductPricingAdapter<ProductDiscountConfiguration> = {
   ...ProductPricingAdapter,
 
   key: 'shop.unchained.pricing.product-discount',
@@ -21,11 +22,15 @@ const ProductDiscount: IProductPricingAdapter = {
   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 = calcUtils.applyRate(configuration, total);
-
+    const addDiscounts = (
+      discount: Discount<ProductDiscountConfiguration>,
+      total: number,
+      resolvedConfiguration: ProductDiscountConfiguration,
+    ) => {
+      const { discountId } = discount;
+      const { isNetPrice = false, taxRate, ...meta } = resolvedConfiguration;
+      const amount = calcUtils.applyRate(resolvedConfiguration, total);
+      const isTaxable = taxRate === undefined || taxRate === null;
       pricingAdapter.resultSheet().addDiscount({
         amount: amount * -1,
         discountId,
@@ -33,28 +38,39 @@ const ProductDiscount: IProductPricingAdapter = {
         isTaxable,
         meta: { adapter: ProductDiscount.key, ...meta },
       });
+      if (!isTaxable && taxRate) {
+        const taxAmount = calcUtils.getTaxAmount(amount, taxRate, isNetPrice);
+        pricingAdapter.resultSheet().addTax({
+          amount: taxAmount * -1,
+          rate: taxRate,
+          meta: { adapter: ProductDiscount.key, discountId, ...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);
-          }
+          const { configuration } = discount;
+
+          const resolvedConfiguration = configuration.customPriceConfigurationResolver
+            ? configuration.customPriceConfigurationResolver(
+                params.context.product,
+                params.context.quantity,
+                params.context.configuration,
+              )
+            : configuration;
+
+          if (!resolvedConfiguration) return;
+
+          const total = params.calculationSheet.total({
+            category: ProductPricingRowCategory.Item,
+            useNetPrice: resolvedConfiguration.isNetPrice,
+          });
+
+          addDiscounts(discount, total.amount, resolvedConfiguration);
         });
 
         return pricingAdapter.calculate();