@unchainedshop/plugins 1.1.3 → 1.1.7

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

@@ -0,0 +1,27 @@
+export enum IntegrationModes { // eslint-disable-line
+  PaymentPage = 'PaymentPage',
+  Lightbox = 'Lightbox',
+  iFrame = 'iFrame',
+}
+
+export enum CompletionModes { // eslint-disable-line
+  Immediate = 'Immediate',
+  Deferred = 'Deferred',
+}
+
+export type SignResponse = {
+  transactionId: number;
+  location: string | null;
+};
+
+export type listenerEntityTechnicalNames = 'TransactionCompletion';
+
+export type WebhookData = {
+  eventId: number;
+  entityId: number;
+  listenerEntityId: number;
+  listenerEntityTechnicalName: listenerEntityTechnicalNames;
+  spaceId: number;
+  webhookListenerId: number;
+  timestamp: string; // "YYYY-MM-DDTHH:MM:ss+0000", e.g. "2022-02-18T12:40:42+0000"
+};

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

@@ -0,0 +1,35 @@
+import { Order, OrdersModule } from '@unchainedshop/types/orders';
+import { Transaction } from 'postfinancecheckout/src/models/Transaction';
+import { TransactionState } from 'postfinancecheckout/src/models/TransactionState';
+
+export const transactionIsPaid = async (
+  transaction: Transaction,
+  expectedCurrency: string,
+  expectedAmount: number,
+): Promise<boolean> => {
+  if (transaction.state === TransactionState.FULFILL) {
+    return (
+      transaction.completedAmount !== undefined &&
+      transaction.completedAmount.toFixed(2) === expectedAmount.toFixed(2) &&
+      transaction.currency === expectedCurrency
+    );
+  }
+  if (transaction.state === TransactionState.AUTHORIZED) {
+    return (
+      transaction.authorizationAmount !== undefined &&
+      transaction.authorizationAmount.toFixed(2) === expectedAmount.toFixed(2) &&
+      transaction.currency === expectedCurrency
+    );
+  }
+  return false;
+};
+
+export const orderIsPaid = async (
+  order: Order,
+  transaction: Transaction,
+  orderModule: OrdersModule,
+): Promise<boolean> => {
+  const pricing = orderModule.pricingSheet(order);
+  const totalAmount = pricing.total({ useNetPrice: false }).amount / 100;
+  return transactionIsPaid(transaction, order.currency, totalAmount);
+};

package/src/payment/stripe.ts

@@ -0,0 +1,278 @@
+import { Context } from '@unchainedshop/types/api';
+import { IPaymentAdapter } from '@unchainedshop/types/payments';
+import bodyParser from 'body-parser';
+import { useMiddlewareWithCurrentContext } from '@unchainedshop/api';
+import { PaymentAdapter, PaymentDirector, PaymentError } from '@unchainedshop/core-payment';
+import { createLogger } from '@unchainedshop/logger';
+
+const logger = createLogger('unchained:core-payment:stripe');
+
+const {
+  STRIPE_SECRET,
+  STRIPE_ENDPOINT_SECRET,
+  EMAIL_WEBSITE_NAME,
+  STRIPE_WEBHOOK_PATH = '/graphql/stripe',
+} = process.env;
+
+/*
+Test Webhooks:
+
+brew install stripe/stripe-cli/stripe
+stripe login --api-key sk_....
+stripe listen --forward-to http://localhost:3000/graphql/stripe
+stripe trigger payment_intent.succeeded
+*/
+
+const stripe = require('stripe')(STRIPE_SECRET); // eslint-disable-line
+
+useMiddlewareWithCurrentContext(STRIPE_WEBHOOK_PATH, bodyParser.raw({ type: 'application/json' }));
+
+useMiddlewareWithCurrentContext(STRIPE_WEBHOOK_PATH, async (request, response) => {
+  const sig = request.headers['stripe-signature'];
+  const resolvedContext = request.unchainedContext as Context;
+  const { modules, services } = resolvedContext;
+
+  let event;
+
+  try {
+    event = stripe.webhooks.constructEvent(request.body, sig, STRIPE_ENDPOINT_SECRET);
+  } catch (err) {
+    response.writeHead(400);
+    response.end(`Webhook Error: ${err.message}`);
+    return;
+  }
+
+  try {
+    if (event.type === 'payment_intent.succeeded') {
+      const paymentIntent = event.data.object;
+      const orderPaymentId = paymentIntent.metadata?.orderPaymentId;
+
+      await modules.orders.payments.logEvent(orderPaymentId, event, resolvedContext.userId);
+
+      const orderPayment = await modules.orders.payments.findOrderPayment({
+        orderPaymentId,
+      });
+
+      const order = await modules.orders.checkout(
+        orderPayment.orderId,
+        {
+          transactionContext: {
+            paymentIntentId: paymentIntent.id,
+          },
+          paymentContext: {
+            paymentIntentId: paymentIntent.id,
+          },
+        },
+        resolvedContext,
+      );
+
+      logger.info(`Stripe Webhook: Unchained confirmed checkout for order ${order.orderNumber}`, {
+        orderId: order._id,
+      });
+    } else if (event.type === 'setup_intent.succeeded') {
+      const setupIntent = event.data.object;
+      const { paymentProviderId, userId } = setupIntent.metadata;
+
+      await services.payment.registerPaymentCredentials(
+        paymentProviderId,
+        {
+          transactionContext: {
+            setupIntentId: setupIntent.id,
+          },
+        },
+        resolvedContext,
+      );
+
+      logger.info(`Stripe Webhook: Unchained registered payment credentials for ${userId}`, {
+        userId,
+      });
+    } else {
+      response.writeHead(404);
+      response.end();
+      return;
+    }
+  } catch (err) {
+    response.writeHead(400);
+    response.end(`Webhook Error: ${err.message}`);
+    return;
+  }
+  // Return a 200 response to acknowledge receipt of the event
+  response.end(JSON.stringify({ received: true }));
+});
+
+const createRegistrationIntent = async ({ userId, name, email, paymentProviderId }, options = {}) => {
+  const customer = await stripe.customers.create({
+    metadata: {
+      userId,
+    },
+    name,
+    email,
+  });
+  const setupIntent = await stripe.setupIntents.create({
+    customer: customer.id,
+    metadata: {
+      userId,
+      paymentProviderId,
+    },
+    ...options,
+  });
+  return setupIntent;
+};
+
+const createOrderPaymentIntent = async ({ order, orderPayment, pricing }, options = {}) => {
+  const reference = EMAIL_WEBSITE_NAME || order._id;
+  const { currency, amount } = pricing.total({ useNetPrice: false });
+  const paymentIntent = await stripe.paymentIntents.create({
+    amount: Math.round(amount),
+    currency: currency.toLowerCase(),
+    description: `${reference} #${order.orderNumber}`,
+    statement_descriptor: order.orderNumber,
+    statement_descriptor_suffix: reference,
+    receipt_email: order.contact?.emailAddress,
+    setup_future_usage: 'off_session', // Verify your integration in this guide by including this parameter
+    metadata: {
+      orderPaymentId: orderPayment._id,
+    },
+    ...options,
+  });
+  return paymentIntent;
+};
+
+const Stripe: IPaymentAdapter = {
+  ...PaymentAdapter,
+
+  key: 'shop.unchained.payment.stripe',
+  label: 'Stripe',
+  version: '2.0',
+
+  typeSupported(type) {
+    return type === 'GENERIC';
+  },
+
+  actions: (params) => {
+    const { modules } = params.context;
+
+    const adapterActions = {
+      ...PaymentAdapter.actions(params),
+
+      // eslint-disable-next-line
+      configurationError() {
+        // eslint-disable-line
+        if (!STRIPE_SECRET || !STRIPE_ENDPOINT_SECRET) {
+          return PaymentError.INCOMPLETE_CONFIGURATION;
+        }
+        return null;
+      },
+
+      isActive: () => {
+        if (adapterActions.configurationError() === null) return true;
+        return false;
+      },
+
+      isPayLaterAllowed() {
+        return false;
+      },
+
+      validate: async ({ token }) => {
+        const paymentMethod = await stripe.paymentMethods.retrieve(token);
+        // TODO: Add further checks like expiration of cards
+        return !!paymentMethod;
+      },
+
+      register: async ({ setupIntentId }) => {
+        if (!setupIntentId) {
+          throw new Error('You have to provide a setup intent id');
+        }
+
+        const setupIntent = await stripe.setupIntents.retrieve(setupIntentId);
+
+        if (setupIntent.status === 'succeeded') {
+          return {
+            token: setupIntent.payment_method,
+            customer: setupIntent.customer,
+            // payment_method_options: setupIntent.payment_method_options,
+            payment_method_types: setupIntent.payment_method_types,
+            usage: setupIntent.usage,
+          };
+        }
+
+        logger.warn('Stripe Plugin: Registration declined', setupIntentId);
+        return null;
+      },
+
+      sign: async (transactionContext = {}) => {
+        // eslint-disable-line
+        const { orderPayment, paymentProviderId } = params.paymentContext;
+        const { userId } = params.context;
+
+        if (orderPayment) {
+          const order = await modules.orders.findOrder({ orderId: orderPayment.orderId });
+          const pricing = await modules.orders.pricingSheet(order);
+          const paymentIntent = await createOrderPaymentIntent(
+            { order, orderPayment, pricing },
+            transactionContext,
+          );
+          return paymentIntent.client_secret;
+        }
+
+        const user = await modules.users.findUserById(userId);
+        const email = modules.users.primaryEmail(user)?.address;
+        const name = user.profile.displayName || user.username || email;
+
+        const paymentIntent = await createRegistrationIntent(
+          { userId, name, email, paymentProviderId },
+          transactionContext,
+        );
+        return paymentIntent.client_secret;
+      },
+
+      charge: async ({ paymentIntentId, paymentCredentials }) => {
+        if (!paymentIntentId && !paymentCredentials) {
+          throw new Error('You have to provide an existing intent or a payment method');
+        }
+
+        const { order } = params.paymentContext;
+        const orderPayment = await modules.orders.payments.findOrderPayment({
+          orderPaymentId: order.paymentId,
+        });
+
+        const pricing = await modules.orders.pricingSheet(order);
+
+        const paymentIntentObject = paymentIntentId
+          ? await stripe.paymentIntents.retrieve(paymentIntentId)
+          : await createOrderPaymentIntent(
+              { orderPayment, order, pricing },
+              {
+                customer: paymentCredentials.meta?.customer,
+                confirm: true,
+                payment_method: paymentCredentials.token,
+                payment_method_types: paymentCredentials.meta?.payment_method_types, // eslint-disable-line
+                // payment_method_options: paymentCredentials.meta?.payment_method_options, // eslint-disable-line
+              },
+            );
+
+        const { currency, amount } = pricing.total({ useNetPrice: false });
+
+        if (
+          paymentIntentObject.currency !== currency.toLowerCase() ||
+          paymentIntentObject.amount !== Math.round(amount)
+        ) {
+          throw new Error('The price has changed since you have created the intent!');
+        }
+        if (paymentIntentObject.metadata?.orderPaymentId !== orderPayment?._id) {
+          throw new Error('The order payment is different from the initiating intent!');
+        }
+
+        if (paymentIntentObject.status === 'succeeded') {
+          return paymentIntentObject;
+        }
+
+        return false;
+      },
+    };
+
+    return adapterActions;
+  },
+};
+
+PaymentDirector.registerAdapter(Stripe);

package/src/payment/worldline-saferpay/index.ts

@@ -0,0 +1,140 @@
+import { IPaymentAdapter } from '@unchainedshop/types/payments';
+import { PaymentAdapter, PaymentDirector, PaymentError } from '@unchainedshop/core-payment';
+import { PaymentPageInitializeInput, SaferpayClient } from './worldline-saferpay-client';
+
+const {
+  WORLDLINE_BASE_URL = 'https://test.saferpay.com/api',
+  WORLDLINE_CUSTOMER_ID,
+  WORLDLINE_USER,
+  WORLDLINE_PW,
+  WORLDLINE_SUCCESS_URL,
+  WORLDLINE_FAILED_URL,
+} = process.env;
+
+const WordlineSaferpay: IPaymentAdapter = {
+  ...PaymentAdapter,
+
+  key: 'shop.unchained.payment.worldline-saferpay',
+  label: 'Worldline Saferpay',
+  version: '1.0',
+
+  typeSupported(type) {
+    return type === 'GENERIC';
+  },
+
+  actions: (params) => {
+    const { modules } = params.context;
+
+    const saferpayClient = new SaferpayClient(
+      WORLDLINE_BASE_URL,
+      WORLDLINE_CUSTOMER_ID,
+      WORLDLINE_USER,
+      WORLDLINE_PW,
+    );
+
+    const adapter = {
+      ...PaymentAdapter.actions(params),
+
+      getTerminalId() {
+        return params.config.find((item) => item.key === 'terminalId')?.value;
+      },
+
+      // eslint-disable-next-line
+      configurationError() {
+        // eslint-disable-line
+        if (
+          !WORLDLINE_BASE_URL ||
+          !WORLDLINE_CUSTOMER_ID ||
+          !WORLDLINE_USER ||
+          !WORLDLINE_PW ||
+          !adapter.getTerminalId()
+        ) {
+          return PaymentError.INCOMPLETE_CONFIGURATION;
+        }
+        return null;
+      },
+
+      isActive() {
+        if (adapter.configurationError() === null) return true;
+        return false;
+      },
+
+      isPayLaterAllowed() {
+        return false;
+      },
+
+      sign: async (transactionContext: any = {}) => {
+        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 paymentPageInitInput: PaymentPageInitializeInput = {
+          RequestHeader: saferpayClient.buildRequestHeader(orderPayment._id, 0),
+          TerminalId: adapter.getTerminalId(),
+          Payment: {
+            Amount: {
+              Value: totalAmount.toString(),
+              CurrencyCode: order.currency,
+            },
+            OrderId: order._id,
+            Description: transactionContext.description || 'Bestellung',
+          },
+          ReturnUrls: {
+            Success: `${WORLDLINE_SUCCESS_URL}?order_id=${order._id}`,
+            Fail: `${WORLDLINE_FAILED_URL}?order_id=${order._id}`,
+            Abort: `${WORLDLINE_FAILED_URL}?order_id=${order._id}`,
+          },
+        };
+        const paymentPageInit = await saferpayClient.paymentPageInitialize(paymentPageInitInput);
+        return JSON.stringify({
+          location: paymentPageInit.RedirectUrl,
+          transactionId: paymentPageInit.Token,
+        });
+      },
+
+      charge: async ({ transactionId }: { transactionId: string }) => {
+        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 paymentPageAssert = await saferpayClient.paymentPageAssert({
+          RequestHeader: saferpayClient.buildRequestHeader(orderPayment._id, 0),
+          Token: transactionId,
+        });
+        return (
+          !paymentPageAssert.ErrorMessage &&
+          paymentPageAssert.Transaction.Amount.Value === totalAmount.toString() &&
+          paymentPageAssert.Transaction.Amount.CurrencyCode === order.currency &&
+          (paymentPageAssert.Transaction.Status === 'AUTHORIZED' ||
+            paymentPageAssert.Transaction.Status === 'CAPTURED')
+        );
+      },
+
+      cancel: async () => {
+        const { orderPayment } = params.paymentContext;
+        if (!orderPayment) return false;
+        const token = orderPayment.context?.token;
+        if (!token) return false;
+        const paymentPageAssert = await saferpayClient.paymentPageAssert({
+          RequestHeader: saferpayClient.buildRequestHeader(orderPayment._id, 0),
+          Token: token,
+        });
+        const transactionId = paymentPageAssert.Transaction?.Id;
+        if (paymentPageAssert.Transaction.Status !== 'AUTHORIZED' || !transactionId) return false;
+        const transactionCancelRes = await saferpayClient.transactionCancel({
+          RequestHeader: saferpayClient.buildRequestHeader(orderPayment._id, 0),
+          TransactionReference: {
+            TransactionId: transactionId,
+          },
+        });
+        return transactionCancelRes.TransactionId === transactionId;
+      },
+    };
+
+    return adapter;
+  },
+};
+
+PaymentDirector.registerAdapter(WordlineSaferpay);

package/src/payment/worldline-saferpay/worldline-saferpay-client/api/SaferpayClient.ts

@@ -0,0 +1,54 @@
+import { TransactionCancelInput, TransactionCancelResponse } from '../models/TransactionCancel';
+import { PaymentPageAssertInput, PaymentPageAssertResponse } from '../models/PaymentPageAssert';
+import {
+  PaymentPageInitializeInput,
+  PaymentPageInitializeResponse,
+} from '../models/PaymentPageInitialize';
+import { RequestHeader } from '../models/Request';
+import { SaferpayConnection } from './SaferpayConnection';
+
+export class SaferpayClient {
+  private conn: SaferpayConnection;
+
+  private customerId: string;
+
+  private specVersion: string;
+
+  public constructor(
+    baseUrl: string,
+    customerId: string,
+    user: string,
+    password: string,
+    specVersion?: string,
+  ) {
+    this.customerId = customerId;
+    this.specVersion = specVersion || '1.27';
+    this.conn = new SaferpayConnection(baseUrl, user, password);
+  }
+
+  public buildRequestHeader(requestId: string, retryIndicator: number): RequestHeader {
+    return {
+      SpecVersion: this.specVersion,
+      CustomerId: this.customerId,
+      RequestId: requestId,
+      RetryIndicator: retryIndicator,
+    };
+  }
+
+  public async paymentPageInitialize(
+    input: PaymentPageInitializeInput,
+  ): Promise<PaymentPageInitializeResponse> {
+    return this.conn.post(
+      '/Payment/v1/PaymentPage/Initialize',
+      input,
+    ) as Promise<PaymentPageInitializeResponse>;
+  }
+
+  public async paymentPageAssert(input: PaymentPageAssertInput): Promise<PaymentPageAssertResponse> {
+    return this.conn.post('/Payment/v1/PaymentPage/Assert', input) as Promise<PaymentPageAssertResponse>;
+  }
+
+  public async transactionCancel(input: TransactionCancelInput): Promise<TransactionCancelResponse> {
+    return this.conn.post('/Payment/v1/Transaction/Cancel', input) as Promise<TransactionCancelResponse>;
+  }
+}

package/src/payment/worldline-saferpay/worldline-saferpay-client/api/SaferpayConnection.ts

@@ -0,0 +1,36 @@
+import fetch from 'node-fetch';
+
+export class SaferpayConnection {
+  private baseUrl: string;
+
+  private user: string;
+
+  private password: string;
+
+  public constructor(baseUrl: string, user: string, password: string) {
+    this.baseUrl = baseUrl;
+    this.user = user;
+    this.password = password;
+  }
+
+  private buildUrl(uri: string): string {
+    return this.baseUrl + uri;
+  }
+
+  private getHeaders() {
+    return {
+      'Content-Type': 'application/json',
+      Authorization: `Basic ${Buffer.from(`${this.user}:${this.password}`, 'binary').toString(
+        'base64',
+      )}`,
+    };
+  }
+
+  public async post(uri: string, data: object): Promise<any> {
+    return fetch(this.buildUrl(uri), {
+      method: 'POST',
+      body: JSON.stringify(data),
+      headers: this.getHeaders(),
+    }).then((res: any) => res.json());
+  }
+}

package/src/payment/worldline-saferpay/worldline-saferpay-client/index.ts

@@ -0,0 +1,8 @@
+export { SaferpayClient } from './api/SaferpayClient';
+
+export {
+  PaymentPageInitializeInput,
+  PaymentPageInitializeResponse,
+} from './models/PaymentPageInitialize';
+export { PaymentPageAssertInput, PaymentPageAssertResponse } from './models/PaymentPageAssert';
+export { TransactionCancelInput, TransactionCancelResponse } from './models/TransactionCancel';

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

@@ -0,0 +1,26 @@
+export type PaymentMethods =
+  | 'ALIPAY'
+  | 'AMEX'
+  | 'BANCONTACT'
+  | 'BONUS'
+  | 'DINERS'
+  | 'DIRECTDEBIT'
+  | 'EPRZELEWY'
+  | 'EPS'
+  | 'GIROPAY'
+  | 'IDEAL'
+  | 'INVOICE'
+  | 'JCB'
+  | 'KLARNA'
+  | 'MAESTRO'
+  | 'MASTERCARD'
+  | 'MYONE'
+  | 'PAYPAL'
+  | 'PAYDIREKT'
+  | 'POSTCARD'
+  | 'POSTFINANCE'
+  | 'SOFORT'
+  | 'TWINT'
+  | 'UNIONPAY'
+  | 'VISA'
+  | 'WLCRYPTOPAYMENTS';

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

@@ -0,0 +1,75 @@
+import { Response } from './Response';
+import { Request } from './Request';
+import { TransactionAmount, TransactionStatus } from './Transaction';
+import { PaymentMethods } from './PaymentMethods';
+
+export interface PaymentPageAssertInput extends Request {
+  Token: string;
+}
+
+export interface PaymentPageAssertResponse extends Response {
+  Transaction: {
+    Type: 'PAYMENT';
+    Status: TransactionStatus;
+    Id: string;
+    CaptureId?: string;
+    Date: string;
+    Amount: TransactionAmount;
+    OrderId?: string;
+    AcquirerName?: string;
+    AcquirerReference?: string;
+    SixTransactionReference: string;
+    ApprovalCode?: string;
+    DirectDebit?: string;
+    MandateId: string;
+    CreditorId: string;
+    Invoice: {
+      Payee: Map<string, string>;
+    };
+    ReasonForTransfer?: string;
+    DueDate?: string;
+    IssuerReference?: Map<string, string>;
+  };
+  PaymentMeans: {
+    Brand: {
+      PaymentMethod?: PaymentMethods;
+      Name: string;
+    };
+  };
+  DisplayText: string;
+  Wallet?: string;
+  Card: {
+    MaskedNumber: string;
+    ExpYear: number;
+    ExpMonth: number;
+    HolderName?: string;
+    HolderSegment?: string;
+    CountryCode?: string;
+    HashValue?: string;
+  };
+  BankAccount?: Map<string, string>;
+  Twint?: Map<string, string>;
+  Paypal?: Map<string, string>;
+  Payer?: object;
+  BillingAddress?: Map<string, string>;
+  RegistrationResult?: {
+    Success: boolean;
+    Alias?: string;
+    Id: string;
+    Lifetime: number;
+    Error?: {
+      ErrorName?: string;
+      ErrorMessage?: string;
+    };
+    AuthenticationResult?: {
+      Result: 'OK' | 'NOT_SUPPORTED';
+    };
+    Message: string;
+  };
+  Liability?: object;
+  Dcc?: object;
+  MastercardIssuerInstallments?: object;
+  FraudPrevention?: {
+    Result?: 'APPROVED' | 'MANUAL_REVIEW';
+  };
+}