@unchainedshop/plugins 1.1.3 → 1.1.7

package/src/payment/datatrans-v2/splitProperties.ts

@@ -0,0 +1,63 @@
+// This method splits the return data of alias registration to the important properties needed for validation and the additional data
+import crypto from 'crypto';
+
+export default function splitProperties({ objectKey, payload }: { objectKey?: string; payload: any }): {
+  token?: string;
+  info: any;
+  _id?: string;
+} {
+  if (!payload || !objectKey) return { info: {} };
+
+  if (objectKey === 'card') {
+    const { expiryMonth, alias, expiryYear, ...info } = payload;
+    if (!alias) return { info };
+    const is3DActive = !!payload['3D']?.xid;
+    if (is3DActive) {
+      delete info['3D'];
+    }
+    const token = JSON.stringify({
+      alias,
+      expiryMonth,
+      expiryYear,
+      '3D': is3DActive ? payload['3D'] : undefined,
+    });
+    const _id = crypto.createHash('sha256').update(token).digest('hex');
+
+    return {
+      token,
+      info,
+      _id,
+    };
+  }
+
+  if (objectKey === 'PAY') {
+    const { signature, protocolVersion, signedMessage, ...info } = payload;
+    if (!signedMessage) return { info };
+    return {
+      token: JSON.stringify({
+        signature,
+        protocolVersion,
+        signedMessage,
+      }),
+      info,
+    };
+  }
+
+  if (objectKey === 'APL') {
+    const { data, header, signature, version, ...info } = payload;
+    if (!data) return { info };
+    delete info['3D'];
+    return {
+      token: JSON.stringify({
+        data,
+        header,
+        signature,
+        version,
+      }),
+      info,
+    };
+  }
+
+  const { alias, ...info } = payload;
+  return { token: alias ? JSON.stringify({ alias }) : undefined, info };
+}

package/src/payment/invoice-prepaid.ts

@@ -0,0 +1,40 @@
+import { IPaymentAdapter } from '@unchainedshop/types/payments';
+import { PaymentDirector, PaymentAdapter, PaymentProviderType } from '@unchainedshop/core-payment';
+
+const InvoicePrepaid: IPaymentAdapter = {
+  ...PaymentAdapter,
+
+  key: 'shop.unchained.invoice-prepaid',
+  label: 'Invoice Prepaid (manually)',
+  version: '1.0',
+
+  initialConfiguration: [],
+
+  typeSupported: (type) => {
+    return type === PaymentProviderType.INVOICE;
+  },
+
+  actions: (params) => {
+    return {
+      ...PaymentAdapter.actions(params),
+
+      configurationError: () => {
+        return null;
+      },
+
+      isActive: () => {
+        return true;
+      },
+
+      isPayLaterAllowed: () => {
+        return false;
+      },
+
+      charge: async () => {
+        return false;
+      },
+    };
+  },
+};
+
+PaymentDirector.registerAdapter(InvoicePrepaid);

package/src/payment/invoice.ts

@@ -0,0 +1,36 @@
+import { IPaymentAdapter } from '@unchainedshop/types/payments';
+import { PaymentDirector, PaymentAdapter, PaymentProviderType } from '@unchainedshop/core-payment';
+
+const Invoice: IPaymentAdapter = {
+  ...PaymentAdapter,
+
+  key: 'shop.unchained.invoice',
+  label: 'Invoice (manually)',
+  version: '1.0',
+
+  initialConfiguration: [],
+
+  typeSupported: (type) => {
+    return type === PaymentProviderType.INVOICE;
+  },
+
+  actions: (params) => {
+    return {
+      ...PaymentAdapter.actions(params),
+
+      configurationError: () => {
+        return null;
+      },
+
+      isActive: () => {
+        return true;
+      },
+
+      isPayLaterAllowed: () => {
+        return true;
+      },
+    };
+  },
+};
+
+PaymentDirector.registerAdapter(Invoice);

package/src/payment/paypal-checkout.ts

@@ -0,0 +1,107 @@
+import { IPaymentAdapter } from '@unchainedshop/types/payments';
+import { PaymentDirector, PaymentAdapter, PaymentError } from '@unchainedshop/core-payment';
+import { createLogger } from '@unchainedshop/logger';
+
+const checkoutNodeJssdk = require('@paypal/checkout-server-sdk'); // eslint-disable-line
+
+const logger = createLogger('unchained:core-payment');
+
+const { PAYPAL_CLIENT_ID, PAYPAL_SECRET, PAYPAL_ENVIRONMENT = 'sandbox' } = process.env;
+
+/**
+ *
+ * Set up and return PayPal JavaScript SDK environment with PayPal access credentials.
+ * This sample uses SandboxEnvironment. In production, use ProductionEnvironment.
+ *
+ */
+const environment = () => {
+  const clientId = PAYPAL_CLIENT_ID;
+  const clientSecret = PAYPAL_SECRET;
+
+  return PAYPAL_ENVIRONMENT !== 'live'
+    ? new checkoutNodeJssdk.core.SandboxEnvironment(clientId, clientSecret)
+    : new checkoutNodeJssdk.core.LiveEnvironment(clientId, clientSecret);
+};
+
+const PaypalCheckout: IPaymentAdapter = {
+  ...PaymentAdapter,
+
+  key: 'com.paypal.checkout',
+  label: 'Paypal (Checkout / Native)',
+  version: '1.0',
+
+  initialConfiguration: [],
+
+  typeSupported: (type) => {
+    return type === 'GENERIC';
+  },
+
+  actions: (params) => {
+    const adapter = {
+      ...PaymentAdapter.actions(params),
+
+      configurationError: () => {
+        const publicCredentialsValid = PAYPAL_CLIENT_ID && PAYPAL_SECRET;
+
+        if (!publicCredentialsValid) {
+          return PaymentError.WRONG_CREDENTIALS;
+        }
+        return null;
+      },
+
+      isActive: () => {
+        if (adapter.configurationError() === null) return true;
+        return false;
+      },
+
+      isPayLaterAllowed: () => {
+        return false;
+      },
+
+      sign: async () => {
+        return PAYPAL_CLIENT_ID;
+      },
+
+      charge: async ({ orderID }) => {
+        const { modules } = params.context;
+        const { order } = params.paymentContext;
+
+        if (!orderID) {
+          logger.warn('Paypal Native Plugin: PRICE MATCH');
+          throw new Error('You have to provide orderID in paymentContext');
+        }
+
+        try {
+          const request = new checkoutNodeJssdk.orders.OrdersGetRequest(orderID);
+          const client = new checkoutNodeJssdk.core.PayPalHttpClient(environment());
+          const paypalOrder = await client.execute(request);
+
+          const pricing = modules.orders.pricingSheet(order);
+          const ourTotal = (pricing.total({ useNetPrice: false }).amount / 100).toFixed(2);
+          const paypalTotal = paypalOrder.result.purchase_units[0].amount.value;
+
+          if (ourTotal === paypalTotal) {
+            logger.info('Paypal Native Plugin: PRICE MATCH');
+            return order;
+          }
+
+          logger.warn(
+            'Paypal Native Plugin: Missmatch PAYPAL ORDER',
+            JSON.stringify(paypalOrder.result, null, 2),
+          );
+
+          logger.debug('Paypal Native Plugin: OUR ORDER', order);
+          logger.debug('Paypal Native Plugin: OUR PRICE', pricing);
+
+          throw new Error(`Payment mismatch`);
+        } catch (e) {
+          logger.warn('Paypal Native Plugin: Failed', e);
+          throw new Error(e);
+        }
+      },
+    };
+    return adapter;
+  },
+};
+
+PaymentDirector.registerAdapter(PaypalCheckout);

package/src/payment/postfinance-checkout/api.ts

@@ -0,0 +1,142 @@
+import { PostFinanceCheckout } from 'postfinancecheckout';
+import { RefundCreate } from 'postfinancecheckout/src/models/RefundCreate';
+import { RefundType } from 'postfinancecheckout/src/models/RefundType';
+
+const { PFCHECKOUT_SPACE_ID, PFCHECKOUT_USER_ID, PFCHECKOUT_SECRET } = process.env;
+const SPACE_ID = parseInt(PFCHECKOUT_SPACE_ID as string, 10);
+const USER_ID = parseInt(PFCHECKOUT_USER_ID as string, 10);
+
+const getConfig = () => {
+  return {
+    space_id: SPACE_ID,
+    user_id: USER_ID,
+    api_secret: PFCHECKOUT_SECRET,
+  };
+};
+
+const getTransactionService = () => {
+  return new PostFinanceCheckout.api.TransactionService(getConfig());
+};
+
+const getTransactionCompletionService = () => {
+  return new PostFinanceCheckout.api.TransactionCompletionService(getConfig());
+};
+
+const getTransactionVoidService = () => {
+  return new PostFinanceCheckout.api.TransactionVoidService(getConfig());
+};
+
+const getRefundService = () => {
+  return new PostFinanceCheckout.api.RefundService(getConfig());
+};
+
+const getTransactionPaymentPageService = () => {
+  return new PostFinanceCheckout.api.TransactionPaymentPageService(getConfig());
+};
+
+const getTransactionIframeService = () => {
+  return new PostFinanceCheckout.api.TransactionIframeService(getConfig());
+};
+
+const getTransactionLightboxService = () => {
+  return new PostFinanceCheckout.api.TransactionLightboxService(getConfig());
+};
+
+const getTokenService = () => {
+  return new PostFinanceCheckout.api.TokenService(getConfig());
+};
+
+export const getTransaction = async (
+  transactionId: string,
+): Promise<PostFinanceCheckout.model.Transaction> => {
+  const transactionService = getTransactionService();
+  const transaction = await transactionService.read(SPACE_ID, parseInt(transactionId, 10));
+  return transaction.body;
+};
+
+export const getTransactionCompletion = async (
+  entityId: string,
+): Promise<PostFinanceCheckout.model.TransactionCompletion> => {
+  const transactionCompletionService = getTransactionCompletionService();
+  const transactionCompletion = await transactionCompletionService.read(
+    SPACE_ID,
+    parseInt(entityId, 10),
+  );
+  return transactionCompletion.body;
+};
+
+export const getToken = async (
+  spaceId: number,
+  tokenId: number,
+): Promise<PostFinanceCheckout.model.Token> => {
+  const tokenService = getTokenService();
+  const token = await tokenService.read(spaceId || SPACE_ID, tokenId);
+  return token.body;
+};
+
+export const createTransaction = async (
+  transaction: PostFinanceCheckout.model.TransactionCreate,
+): Promise<number | null> => {
+  const transactionService = getTransactionService();
+  const transactionCreateRes = await transactionService.create(SPACE_ID, transaction);
+  const transactionCreate = transactionCreateRes.body;
+  return transactionCreate.id || null;
+};
+
+export const voidTransaction = async (transactionId: string): Promise<boolean> => {
+  const transactionVoidService = getTransactionVoidService();
+  try {
+    await transactionVoidService.voidOnline(SPACE_ID, parseInt(transactionId, 10));
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+
+export const refundTransaction = async (
+  transactionId: string,
+  orderId: string,
+  amount: number,
+): Promise<boolean> => {
+  const refundService = getRefundService();
+  const refund: RefundCreate = {
+    transaction: parseInt(transactionId, 10),
+    externalId: orderId,
+    amount,
+    type: RefundType.MERCHANT_INITIATED_ONLINE,
+  };
+  try {
+    await refundService.refund(SPACE_ID, refund);
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+
+export const confirmDeferredTransaction = async (transactionId: string): Promise<boolean> => {
+  const transactionCompletionService = getTransactionCompletionService();
+  try {
+    await transactionCompletionService.completeOnline(SPACE_ID, parseInt(transactionId, 10));
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+
+export const getPaymentPageUrl = async (transactionId: number): Promise<string> => {
+  const transactionPaymentPageService = getTransactionPaymentPageService();
+  const paymentPageUrl = await transactionPaymentPageService.paymentPageUrl(SPACE_ID, transactionId);
+  return paymentPageUrl.body;
+};
+
+export const getLightboxJavascriptUrl = async (transactionId: number): Promise<string> => {
+  const transactionLightboxService = getTransactionLightboxService();
+  const javascriptUrl = await transactionLightboxService.javascriptUrl(SPACE_ID, transactionId);
+  return javascriptUrl.body;
+};
+
+export const getIframeJavascriptUrl = async (transactionId: number): Promise<string> => {
+  const transactionIframeService = getTransactionIframeService();
+  const javascriptUrl = await transactionIframeService.javascriptUrl(SPACE_ID, transactionId);
+  return javascriptUrl.body;
+};

package/src/payment/postfinance-checkout/index.ts

@@ -0,0 +1,241 @@
+import { IPaymentActions, IPaymentAdapter } from '@unchainedshop/types/payments';
+import { PaymentAdapter, PaymentDirector, PaymentError } from '@unchainedshop/core-payment';
+import { TransactionCompletionBehavior } from 'postfinancecheckout/src/models/TransactionCompletionBehavior';
+import { PostFinanceCheckout } from 'postfinancecheckout';
+import { createLogger } from '@unchainedshop/logger';
+import { CreationEntityState } from 'postfinancecheckout/src/models/CreationEntityState';
+import { TransactionState } from 'postfinancecheckout/src/models/TransactionState';
+import {
+  confirmDeferredTransaction,
+  createTransaction,
+  getIframeJavascriptUrl,
+  getLightboxJavascriptUrl,
+  getPaymentPageUrl,
+  getToken,
+  getTransaction,
+  refundTransaction,
+  voidTransaction,
+} from './api';
+import { orderIsPaid } from './utils';
+import './middleware';
+import { CompletionModes, IntegrationModes, SignResponse } from './types';
+
+const {
+  PFCHECKOUT_SPACE_ID,
+  PFCHECKOUT_USER_ID,
+  PFCHECKOUT_SECRET,
+  PFCHECKOUT_SUCCESS_URL,
+  PFCHECKOUT_FAILED_URL,
+} = process.env;
+
+const logger = createLogger('unchained:core-payment:postfinance');
+
+const newError = ({ code, message }: { code: string; message: string }) => {
+  const error = new Error(message);
+  error.name = `POSTFINANCE_${code}`;
+  return error;
+};
+
+const PostfinanceCheckout: IPaymentAdapter = {
+  ...PaymentAdapter,
+
+  key: 'shop.unchained.payment.postfinance-checkout',
+  label: 'Postfinance Checkout',
+  version: '1.0',
+
+  typeSupported(type) {
+    return type === 'GENERIC';
+  },
+
+  actions: (params) => {
+    const { modules } = params.context;
+
+    const adapter: IPaymentActions & {
+      getCompletionMode: () => CompletionModes;
+    } = {
+      ...PaymentAdapter.actions(params),
+
+      getCompletionMode() {
+        return (
+          (params.config.find((item) => item.key === 'completionMode')?.value as CompletionModes) ||
+          CompletionModes.Deferred
+        );
+      },
+
+      // eslint-disable-next-line
+      configurationError() {
+        // eslint-disable-line
+        if (
+          !PFCHECKOUT_SPACE_ID ||
+          !PFCHECKOUT_USER_ID ||
+          !PFCHECKOUT_SECRET ||
+          !PFCHECKOUT_SUCCESS_URL ||
+          !PFCHECKOUT_FAILED_URL
+        ) {
+          return PaymentError.INCOMPLETE_CONFIGURATION;
+        }
+        return null;
+      },
+
+      isActive() {
+        if (adapter.configurationError() === null) return true;
+        return false;
+      },
+
+      isPayLaterAllowed() {
+        return false;
+      },
+
+      async validate(credentials) {
+        if (!credentials.meta) return false;
+        const { linkedSpaceId } = credentials.meta;
+        const tokenData = await getToken(linkedSpaceId, credentials.token);
+        return tokenData.state === CreationEntityState.ACTIVE;
+      },
+
+      sign: async (transactionContext: any = {}) => {
+        const { integrationMode = IntegrationModes.PaymentPage }: { integrationMode: IntegrationModes } =
+          transactionContext;
+        const completionMode = adapter.getCompletionMode();
+        const { orderPayment } = params.paymentContext;
+        const order = await modules.orders.findOrder({
+          orderId: orderPayment.orderId,
+        });
+        const pricing = modules.orders.pricingSheet(order);
+        const totalAmount = pricing?.total({ useNetPrice: false }).amount;
+        const transaction = new PostFinanceCheckout.model.TransactionCreate();
+        transaction.currency = order.currency;
+        transaction.metaData = {
+          orderPaymentId: orderPayment._id,
+        };
+        transaction.successUrl = `${transactionContext?.successUrl || PFCHECKOUT_SUCCESS_URL}?order_id=${
+          orderPayment.orderId
+        }`;
+        transaction.failedUrl = `${transactionContext?.failedUrl || PFCHECKOUT_FAILED_URL}?order_id=${
+          orderPayment.orderId
+        }`;
+        transaction.customerId = params.context.user._id;
+        transaction.tokenizationMode =
+          PostFinanceCheckout.model.TokenizationMode.ALLOW_ONE_CLICK_PAYMENT;
+        if (completionMode === CompletionModes.Immediate) {
+          transaction.completionBehavior = TransactionCompletionBehavior.COMPLETE_IMMEDIATELY;
+        } else if (completionMode === CompletionModes.Deferred) {
+          transaction.completionBehavior = TransactionCompletionBehavior.COMPLETE_DEFERRED;
+        }
+        if (totalAmount) {
+          const lineItemSum = new PostFinanceCheckout.model.LineItemCreate();
+          lineItemSum.name = `Bestellung ${orderPayment.orderId}`;
+          lineItemSum.type = PostFinanceCheckout.model.LineItemType.FEE;
+          lineItemSum.quantity = 1;
+          lineItemSum.uniqueId = orderPayment.orderId;
+          lineItemSum.amountIncludingTax = totalAmount / 100;
+          transaction.lineItems = [lineItemSum];
+        }
+        const transactionId = await createTransaction(transaction);
+        let location = null;
+        if (integrationMode === IntegrationModes.PaymentPage) {
+          location = await getPaymentPageUrl(transactionId);
+        } else if (integrationMode === IntegrationModes.Lightbox) {
+          location = await getLightboxJavascriptUrl(transactionId);
+        } else if (integrationMode === IntegrationModes.iFrame) {
+          location = await getIframeJavascriptUrl(transactionId);
+        }
+        const res: SignResponse = {
+          transactionId,
+          location,
+        };
+
+        return JSON.stringify(res);
+      },
+
+      charge: async ({
+        transactionId,
+        paymentCredentials,
+      }: {
+        transactionId: string;
+        paymentCredentials: any;
+      }) => {
+        if (paymentCredentials && !transactionId) {
+          // Directly charge the customer based on existing token!
+          throw new Error('Not implemented yet');
+        }
+        if (!transactionId) return false; // checkout without payment
+
+        const transaction = await getTransaction(transactionId);
+
+        if (!transaction) {
+          logger.error(`Transaction #${transactionId}: Transaction not found`);
+          throw newError({
+            code: `TRANSACTION_NOT_FOUND`,
+            message: 'Payment declined',
+          });
+        }
+
+        const isPaid = await orderIsPaid(params.paymentContext.order, transaction, modules.orders);
+        if (!isPaid) {
+          logger.error(`Transaction #${transactionId}: Invalid state / Amount incorrect`);
+          throw newError({
+            code: `STATE_${transaction.state?.toUpperCase()}`,
+            message: 'Invalid state / Amount incorrect',
+          });
+        }
+
+        if (transaction.metaData.orderPaymentId !== params.paymentContext.orderPayment._id) {
+          logger.error(`Transaction #${transactionId}: Invalid state / Amount incorrect`);
+          throw newError({
+            code: `TRANSACTION_ALREADY_USED`,
+            message: 'Transaction already used in previous checkout',
+          });
+        }
+
+        const { token: { id, ...tokenMeta } = {} } = transaction;
+
+        return {
+          transaction,
+          transactionId,
+          credentials: id && {
+            ...tokenMeta,
+            token: id,
+          },
+        };
+      },
+
+      cancel: async () => {
+        const { orderPayment } = params.paymentContext;
+        const { transactionId } = orderPayment;
+        if (!transactionId) {
+          return false;
+        }
+        const transaction = await getTransaction(transactionId);
+        const refund = transaction.state === TransactionState.FULFILL;
+        const order = await modules.orders.findOrder({
+          orderId: orderPayment.orderId,
+        });
+        const pricing = modules.orders.pricingSheet(order);
+        const totalAmount = pricing?.total({ useNetPrice: false }).amount;
+        // For immediate settlements, try refunding. For deferred settlements, void the transaction.
+        return (
+          (refund && refundTransaction(transactionId, order._id, totalAmount / 100)) ||
+          voidTransaction(transactionId)
+        );
+      },
+
+      confirm: async () => {
+        const { orderPayment } = params.paymentContext;
+        const { transactionId } = orderPayment;
+        if (!transactionId) {
+          return false;
+        }
+        const transaction = await getTransaction(transactionId);
+        if (transaction.state === TransactionState.AUTHORIZED) {
+          return confirmDeferredTransaction(transactionId);
+        }
+        return false;
+      },
+    };
+
+    return adapter;
+  },
+};
+
+PaymentDirector.registerAdapter(PostfinanceCheckout);

package/src/payment/postfinance-checkout/middleware.ts

@@ -0,0 +1,54 @@
+import bodyParser from 'body-parser';
+import { useMiddlewareWithCurrentContext } from '@unchainedshop/api';
+import { Context } from '@unchainedshop/types/api';
+import { createLogger } from '@unchainedshop/logger';
+import { WebhookData } from './types';
+import { getTransaction, getTransactionCompletion } from './api';
+
+const { PFCHECKOUT_WEBHOOK_PATH = '/graphql/postfinance-checkout' } = process.env;
+
+const logger = createLogger('unchained:core-payment:postfinance-checkout');
+
+useMiddlewareWithCurrentContext(PFCHECKOUT_WEBHOOK_PATH, bodyParser.json());
+
+useMiddlewareWithCurrentContext(PFCHECKOUT_WEBHOOK_PATH, async (req, res) => {
+  const context = req.unchainedContext as Context;
+  const data = req.body as WebhookData;
+  if (data.listenerEntityTechnicalName === 'TransactionCompletion') {
+    try {
+      const transactionCompletion = await getTransactionCompletion(data.entityId as unknown as string);
+      const transaction = await getTransaction(
+        transactionCompletion.linkedTransaction as unknown as string,
+      );
+      const { orderPaymentId } = transaction.metaData as { orderPaymentId: string };
+      const orderPayment = await context.modules.orders.payments.findOrderPayment({
+        orderPaymentId,
+      });
+      if (!orderPayment) throw new Error('Order Payment not found');
+      const order = await context.modules.orders.checkout(
+        orderPayment.orderId,
+        {
+          paymentContext: {
+            transactionId: transactionCompletion.linkedTransaction,
+          },
+        },
+        context,
+      );
+      logger.info(
+        `PostFinance Checkout Webhook: Transaction ${transactionCompletion.linkedTransaction} marked order payment ID ${transaction.metaData.orderPaymentId} as paid`,
+      );
+      res.writeHead(200);
+      res.end(`Order marked as paid: ${order.orderNumber}`);
+    } catch (e) {
+      logger.error(`PostFinance Checkout Webhook: Unchained rejected to checkout with message`, e);
+      res.writeHead(500);
+      res.end(JSON.stringify(e));
+    }
+  } else {
+    logger.error(
+      `PostFinance Checkout Webhook: Received unknown listenerEntityTechnicalName ${data.listenerEntityTechnicalName}`,
+    );
+    res.writeHead(404);
+    res.end();
+  }
+});