@unchainedshop/plugins 2.6.1 → 2.7.1

package/src/payment/payrexx/index.ts

@@ -0,0 +1,184 @@
+import { IPaymentAdapter } from '@unchainedshop/types/payments.js';
+import { PaymentAdapter, PaymentDirector, PaymentError } from '@unchainedshop/core-payment';
+import { createLogger } from '@unchainedshop/logger';
+import { mapOrderDataToGatewayObject } from './payrexx.js';
+import createPayrexxAPI, { GatewayObjectStatus } from './api/index.js';
+
+export * from './middleware.js';
+
+const logger = createLogger('unchained:core-payment:payrexx');
+
+const Payrexx: IPaymentAdapter = {
+  ...PaymentAdapter,
+
+  key: 'shop.unchained.payment.payrexx',
+  label: 'Payrexx',
+  version: '1.0.0',
+
+  typeSupported(type) {
+    return type === 'GENERIC';
+  },
+
+  actions: (params) => {
+    const { modules } = params.context;
+
+    const getInstance = () => {
+      return params.config.find((c) => c.key === 'instance')?.value;
+    };
+
+    const api = createPayrexxAPI(getInstance(), process.env.PAYREXX_SECRET);
+
+    const adapterActions = {
+      ...PaymentAdapter.actions(params),
+
+      configurationError() {
+        if (!process.env.PAYREXX_SECRET) {
+          return PaymentError.INCOMPLETE_CONFIGURATION;
+        }
+        if (!getInstance()) {
+          return PaymentError.INCOMPLETE_CONFIGURATION;
+        }
+        return null;
+      },
+
+      isActive: () => {
+        if (adapterActions.configurationError() === null) return true;
+        return false;
+      },
+
+      isPayLaterAllowed() {
+        return false;
+      },
+
+      validate: async ({ token }) => {
+        throw new Error('Token Registration Flow not implemented yet');
+      },
+
+      register: async ({ setupIntentId }) => {
+        throw new Error('Token Registration Flow not implemented yet');
+      },
+
+      sign: async (transactionContext = {}) => {
+        const { orderPayment, order } = params.paymentContext;
+        if (orderPayment) {
+          const pricing = await modules.orders.pricingSheet(order);
+          const gatewayObject = mapOrderDataToGatewayObject(
+            { order, orderPayment, pricing },
+            transactionContext,
+          );
+          const gateway = await api.createGateway(gatewayObject);
+          return JSON.stringify(gateway);
+        }
+
+        throw new Error('Token Registration Flow not implemented yet');
+      },
+
+      async confirm() {
+        const { orderPayment } = params.paymentContext;
+        const { transactionId } = orderPayment;
+
+        if (!transactionId) {
+          return false;
+        }
+
+        const gatewayObject = await api.getGateway(transactionId);
+
+        if (!gatewayObject) {
+          return false;
+        }
+
+        if (
+          gatewayObject.status === GatewayObjectStatus.authorized ||
+          gatewayObject.status === GatewayObjectStatus.reserved
+        ) {
+          const allTransactions = gatewayObject.invoices?.flatMap((invoice) => invoice.transactions);
+          await Promise.all(
+            allTransactions.map(async (transaction) =>
+              api.chargePreAuthorized(transaction.id, { referenceId: orderPayment._id }),
+            ),
+          );
+          return true;
+        }
+        return false;
+      },
+
+      async cancel() {
+        const { orderPayment } = params.paymentContext;
+        const { transactionId } = orderPayment;
+        if (!transactionId) {
+          return false;
+        }
+
+        const gatewayObject = await api.getGateway(transactionId);
+
+        if (!gatewayObject) {
+          return false;
+        }
+
+        if (gatewayObject.status === GatewayObjectStatus.reserved) {
+          const allTransactions = gatewayObject.invoices?.flatMap((invoice) => invoice.transactions);
+          await Promise.all(
+            allTransactions.map(async (transaction) => api.deleteReservation(transaction.id)),
+          );
+          return true;
+        }
+        return false;
+      },
+
+      charge: async ({ gatewayId, paymentCredentials }) => {
+        if (!gatewayId && !paymentCredentials) {
+          throw new Error('You have to provide gatewayId or paymentCredentials');
+        }
+
+        const { order } = params.paymentContext;
+        const orderPayment = await modules.orders.payments.findOrderPayment({
+          orderPaymentId: order.paymentId,
+        });
+
+        const gatewayObject = await api.getGateway(gatewayId);
+
+        const pricing = await modules.orders.pricingSheet(order);
+        const { currency, amount } = pricing.total({ useNetPrice: false });
+
+        if (
+          gatewayObject.currency !== currency.toUpperCase() ||
+          gatewayObject.amount !== Math.round(amount)
+        ) {
+          throw new Error('The price has changed since the intent has been created');
+        }
+        if (gatewayObject.referenceId !== orderPayment?._id) {
+          throw new Error('The order payment is different from the initiating intent');
+        }
+
+        switch (gatewayObject.status) {
+          case GatewayObjectStatus.waiting:
+            logger.verbose('Charge postponed because Gateway is pending', {
+              orderPaymentId: gatewayObject.referenceId,
+            });
+            return false;
+          case GatewayObjectStatus.authorized:
+          case GatewayObjectStatus.reserved:
+          case GatewayObjectStatus.confirmed:
+            // confirm will do the transition, to do a checkout those stati above are fine
+            logger.verbose(`Mark as charged, status is ${gatewayObject.status}`, {
+              orderPaymentId: gatewayObject.referenceId,
+            });
+            return {
+              transactionId: gatewayId,
+              gatewayObject,
+            };
+          default:
+            logger.verbose('Charge not possible', {
+              orderPaymentId: gatewayObject.referenceId,
+              status: gatewayObject.status,
+            });
+            throw new Error(`Gateway Status ${gatewayObject.status} does not allow checkout`);
+        }
+      },
+    };
+
+    return adapterActions;
+  },
+};
+
+PaymentDirector.registerAdapter(Payrexx);

package/src/payment/payrexx/middleware.ts

@@ -0,0 +1,64 @@
+import { Context } from '@unchainedshop/types/api.js';
+import { createLogger } from '@unchainedshop/logger';
+
+const logger = createLogger('unchained:core-payment:payrexx:webhook');
+
+export const payrexxHandler = async (request, response) => {
+  const resolvedContext = request.unchainedContext as Context;
+  const { modules } = resolvedContext;
+
+  const { transaction } = request.body;
+
+  if (!transaction) {
+    logger.verbose(`unhandled event type`, {
+      type: Object.keys(request.body).join(','),
+    });
+    response.writeHead(200);
+    response.end({
+      ignored: true,
+      message: `Unhandled event type: ${Object.keys(request.body).join(',')}. Supported type: transaction`,
+    });
+  }
+
+  logger.verbose(`Processing event`, {
+    transactionId: transaction.id,
+  });
+  try {
+    const { referenceId: orderPaymentId } = transaction;
+
+    logger.verbose(`checkout with orderPaymentId: ${orderPaymentId}`);
+    await modules.orders.payments.logEvent(orderPaymentId, {
+      transactionId: transaction.id,
+    });
+    const orderPayment = await modules.orders.payments.findOrderPayment({
+      orderPaymentId,
+    });
+    if (!orderPayment) {
+      throw new Error(`order payment not found with orderPaymentId: ${orderPaymentId}`);
+    }
+    const order = await modules.orders.checkout(
+      orderPayment.orderId,
+      {
+        paymentContext: {
+          transactionId: transaction.id,
+        },
+      },
+      resolvedContext,
+    );
+    logger.info(`checkout successful`, {
+      orderPaymentId,
+      orderId: order._id,
+    });
+    response.writeHead(200);
+    response.end({
+      message: 'checkout successful',
+      orderId: order._id,
+    });
+  } catch (error) {
+    logger.error(error, {
+      transactionId: transaction.id,
+    });
+    response.writeHead(500);
+    response.end(error.message);
+  }
+};

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/delivery-swiss-tax.ts

@@ -1,5 +1,8 @@
 import { DeliveryPricingAdapter, DeliveryPricingDirector } from '@unchainedshop/core-delivery';
-import { IDeliveryPricingAdapter } from '@unchainedshop/types/delivery.pricing.js';
+import {
+  DeliveryPricingRowCategory,
+  IDeliveryPricingAdapter,
+} from '@unchainedshop/types/delivery.pricing.js';
 
 import { Order } from '@unchainedshop/types/orders.js';
 import { DeliveryProvider } from '@unchainedshop/types/delivery.js';
@@ -62,6 +65,7 @@ export const DeliverySwissTax: IDeliveryPricingAdapter = {
             pricingAdapter.resultSheet().addTax({
               amount: taxAmount,
               rate: taxRate,
+              baseCategory: DeliveryPricingRowCategory.Delivery,
               meta: { adapter: DeliverySwissTax.key },
             });
           } else {
@@ -69,6 +73,7 @@ export const DeliverySwissTax: IDeliveryPricingAdapter = {
             pricingAdapter.resultSheet().addTax({
               amount: taxAmount,
               rate: taxRate,
+              baseCategory: DeliveryPricingRowCategory.Delivery,
               meta: { adapter: DeliverySwissTax.key },
             });
           }

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;