react-native-tpay 0.3.0

package/src/model/screenless/google_pay_environment.ts

@@ -0,0 +1,7 @@
+/**
+ * Enum describing Google Pay environment options
+ */
+export enum GooglePayEnvironment {
+  production = "production",
+  test = "test",
+}

package/src/model/screenless/google_pay_payment.ts

@@ -0,0 +1,24 @@
+import type { Payer } from "../payer/payer";
+import type { Callbacks } from "./callbacks";
+import type { PaymentDetails } from "./payment_details";
+import { ScreenlessPayment } from "./screenless_payment";
+
+/**
+ * Class responsible for storing information about Google Pay payment
+ */
+export class GooglePayPayment extends ScreenlessPayment {
+  token: string;
+
+  /**
+   * @param token - token received from Google Pay
+   */
+  constructor(
+    token: string,
+    paymentDetails: PaymentDetails,
+    payer: Payer,
+    callbacks: Callbacks | null
+  ) {
+    super(paymentDetails, payer, callbacks);
+    this.token = token;
+  }
+}

package/src/model/screenless/google_pay_utils_configuration.ts

@@ -0,0 +1,33 @@
+import type { GooglePayEnvironment } from "./google_pay_environment";
+
+/**
+ * Class responsible for storing information about Google Pay utils configuration
+ */
+export class GooglePayUtilsConfiguration {
+  price: number;
+  merchantName: string;
+  merchantId: string;
+  environment: GooglePayEnvironment;
+  customRequestCode: number | null;
+
+  /**
+   * @param price - price that will be displayed in Google Pay
+   * @param merchantName - store name displayed in Google Pay
+   * @param merchantId - your merchantId in Tpay system
+   * @param environment - Google Pay environment
+   * @param customRequestCode - alternative request code that will be used to manage Google Pay data
+   */
+  constructor(
+    price: number,
+    merchantName: string,
+    merchantId: string,
+    environment: GooglePayEnvironment,
+    customRequestCode: number | null
+  ) {
+    this.price = price;
+    this.merchantName = merchantName;
+    this.merchantId = merchantId;
+    this.environment = environment;
+    this.customRequestCode = customRequestCode;
+  }
+}

package/src/model/screenless/notifications.ts

@@ -0,0 +1,16 @@
+/** 
+ * Class responsible for storing information about notifications
+ */
+export class Notifications {
+  url: string;
+  email: string;
+
+  /**
+   * @param url - notification url, payment notifications will be sent there
+   * @param email - notification email, payment notifications will be sent there
+   */
+  constructor(url: string, email: string) {
+    this.url = url;
+    this.email = email;
+  }
+}

package/src/model/screenless/payment_details.ts

@@ -0,0 +1,29 @@
+import type { Language } from "../language/language";
+
+/**
+ * Class responsible for storing information about payment details
+ */
+export class PaymentDetails {
+  amount: number;
+  description: string;
+  hiddenDescription: string | null;
+  language: Language | null;
+
+  /**
+   * @param amount - amount of money payer has to pay
+   * @param description - description of payment shown to payer
+   * @param hiddenDescription - description visible to store
+   * @param language - language of the transaction
+   */
+  constructor(
+    amount: number,
+    description: string,
+    hiddenDescription: string | null,
+    language: Language | null
+  ) {
+    this.amount = amount;
+    this.description = description;
+    this.hiddenDescription = hiddenDescription;
+    this.language = language;
+  }
+}

package/src/model/screenless/raty_pekao_payment.ts

@@ -0,0 +1,24 @@
+import type { Payer } from "../payer/payer";
+import type { Callbacks } from "./callbacks";
+import type { PaymentDetails } from "./payment_details";
+import { ScreenlessPayment } from "./screenless_payment";
+
+/**
+ * Class responsible for storing information about Raty Pekao payment
+ */
+export class RatyPekaoPayment extends ScreenlessPayment {
+  channelId: number;
+
+  /**
+   * @param channelId - id of Raty Pekao payment channel
+   */
+  constructor(
+    channelId: number,
+    paymentDetails: PaymentDetails,
+    payer: Payer,
+    callbacks: Callbacks | null
+  ) {
+    super(paymentDetails, payer, callbacks);
+    this.channelId = channelId;
+  }
+}

package/src/model/screenless/recursive.ts

@@ -0,0 +1,21 @@
+import type { Frequency } from "./frequency";
+
+/**
+ * Class responsible for storing information about recurring payments
+ */
+export class Recursive {
+  frequency: Frequency;
+  quantity: number | null;
+  endDate: string;
+
+  /**
+   * @param frequency - how often payment should be repeated
+   * @param quantity - how many times payment should be repeated. If null, quantity = infinity
+   * @param endDate - date in yyyy-MM-dd format
+   */
+  constructor(frequency: Frequency, quantity: number | null, endDate: string) {
+    this.frequency = frequency;
+    this.quantity = quantity;
+    this.endDate = endDate;
+  }
+}

package/src/model/screenless/redirects.ts

@@ -0,0 +1,16 @@
+/**
+ * Class responsible for storing information about redirect urls
+ */
+export class Redirects {
+  successUrl: string;
+  errorUrl: string;
+
+  /**
+   * @param successUrl - payer will be redirected to this url after successful payment
+   * @param errorUrl - payer will be redirected to this url after unsuccessful payment
+   */
+  constructor(successUrl: string, errorUrl: string) {
+    this.successUrl = successUrl;
+    this.errorUrl = errorUrl;
+  }
+}

package/src/model/screenless/screenless_payment.ts

@@ -0,0 +1,27 @@
+import type { Payer } from "../payer/payer";
+import type { Callbacks } from "./callbacks";
+import type { PaymentDetails } from "./payment_details";
+
+/**
+ * Class responsible for storing information about screenless payment details
+ */
+export class ScreenlessPayment {
+  paymentDetails: PaymentDetails;
+  payer: Payer;
+  callbacks: Callbacks | null;
+
+  /**
+   * @param paymentDetails - information about price and description
+   * @param payer - information about payer
+   * @param callbacks - redirects and notification information
+   */
+  constructor(
+    paymentDetails: PaymentDetails,
+    payer: Payer,
+    callbacks: Callbacks | null
+  ) {
+    this.paymentDetails = paymentDetails;
+    this.payer = payer;
+    this.callbacks = callbacks;
+  }
+}

package/src/model/screenless/transfer_payment.ts

@@ -0,0 +1,24 @@
+import type { Payer } from "../payer/payer";
+import type { Callbacks } from "./callbacks";
+import type { PaymentDetails } from "./payment_details";
+import { ScreenlessPayment } from "./screenless_payment";
+
+/**
+ * Class responsible for storing information about transfer payment
+ */
+export class TransferPayment extends ScreenlessPayment {
+  channelId: number;
+
+  /**
+   * @param channelId - channel id of a bank in Tpay system
+   */
+  constructor(
+    channelId: number,
+    paymentDetails: PaymentDetails,
+    payer: Payer,
+    callbacks: Callbacks | null
+  ) {
+    super(paymentDetails, payer, callbacks);
+    this.channelId = channelId;
+  }
+}

package/src/model/tokenization/tokenization.ts

@@ -0,0 +1,18 @@
+import type { Payer } from "../payer/payer";
+
+/**
+ * Class responsible for storing information needed to start UI tokenization.
+ */
+export class Tokenization {
+  payer: Payer;
+  notificationUrl: string;
+
+  /**
+   * @param payer - information about payer 
+   * @param notificationUrl - url for tokenization notifications
+   */
+  constructor(payer: Payer, notificationUrl: string) {
+    this.payer = payer;
+    this.notificationUrl = notificationUrl;
+  }
+}

package/src/model/tpay_configuration.ts

@@ -0,0 +1,32 @@
+import type { Languages } from './language/languages';
+import type { Merchant } from './merchant/merchant';
+import type { MerchantDetails } from './merchant/merchant_details';
+import type { PaymentMethods } from './payment_method/payment_methods';
+
+/**
+ * Class responsible for storing information about Tpay configuration
+ */
+export class TpayConfiguration {
+  merchant: Merchant;
+  merchantDetails: MerchantDetails;
+  languages: Languages;
+  paymentMethods: PaymentMethods;
+
+  /**
+   * @param merchant - configuration information about merchant
+   * @param merchantDetails - information about merchant in different languages
+   * @param languages - languages that user will be able to use in Tpay UI module
+   * @param paymentMethods - payment methods that user will be able to use in Tpay UI module
+   */
+  constructor(
+    merchant: Merchant,
+    merchantDetails: MerchantDetails,
+    languages: Languages,
+    paymentMethods: PaymentMethods
+  ) {
+    this.merchant = merchant;
+    this.merchantDetails = merchantDetails;
+    this.languages = languages;
+    this.paymentMethods = paymentMethods;
+  }
+}

package/src/model/transaction/single_transaction.ts

@@ -0,0 +1,26 @@
+import type { PayerContext } from "../payer/payer_context";
+import type { Notifications } from "../screenless/notifications";
+import { Transaction } from "./transaction";
+
+/**
+ * Class responsible for storing information about standard Tpay UI module payment
+ */
+export class SingleTransaction extends Transaction {
+  payerContext: PayerContext;
+
+  /**
+   * @param payerContext - information about payer and automatic payment methods
+   * @param amount - amount of money payer has to pay
+   * @param description - description of payment shown to payer
+   * @param notifications - payment notification url and email
+   */
+  constructor(
+    payerContext: PayerContext,
+    amount: number,
+    description: string,
+    notifications: Notifications | null
+  ) {
+    super(amount, description, notifications);
+    this.payerContext = payerContext;
+  }
+}

package/src/model/transaction/token_payment.ts

@@ -0,0 +1,30 @@
+import type { Payer } from "../payer/payer";
+import type { Notifications } from "../screenless/notifications";
+import { Transaction } from "./transaction";
+
+/**
+ * Class responsible for storing information about credit card token payment with Tpay UI module.
+ */
+export class TokenPayment extends Transaction {
+  cardToken: string;
+  payer: Payer;
+
+  /**
+   * @param cardToken - token of tokenized card
+   * @param payer - payer information
+   * @param amount - amount of money payer has to pay
+   * @param description - description of payment shown to payer
+   * @param notifications - payment notification url and email
+   */
+  constructor(
+    cardToken: string,
+    payer: Payer,
+    amount: number,
+    description: string,
+    notifications: Notifications | null
+  ) {
+    super(amount, description, notifications);
+    this.cardToken = cardToken;
+    this.payer = payer;
+  }
+}

package/src/model/transaction/transaction.ts

@@ -0,0 +1,25 @@
+import type { Notifications } from "../screenless/notifications";
+
+/**
+ * Class responsible for storing information about UI module transaction
+ */
+export class Transaction {
+  amount: number;
+  description: string;
+  notifications: Notifications | null;
+
+  /**
+   * @param amount - amount of money payer has to pay
+   * @param description - description of payment shown to payer
+   * @param notifications - payment notification url and email
+   */
+  constructor(
+    amount: number,
+    description: string,
+    notifications: Notifications | null
+  ) {
+    this.amount = amount;
+    this.description = description;
+    this.notifications = notifications;
+  }
+}

package/src/util/google_pay_configuration_util.ts

@@ -0,0 +1,25 @@
+import {
+  GooglePayConfigureError,
+  type GooglePayConfigureResult,
+  GooglePayConfigureSuccess,
+} from '../model/result/google_pay_configure_result';
+
+const success = 'success';
+const error = 'error';
+const unknownGooglePayConfigurationResult =
+  'Unknown Google Pay configuration result';
+
+export function mapGooglePayConfigurationResult(
+  json: string
+): GooglePayConfigureResult {
+  const object = JSON.parse(json);
+
+  switch (object.type) {
+    case success:
+      return new GooglePayConfigureSuccess();
+    case error:
+      return new GooglePayConfigureError(object.message);
+    default:
+      throw Error(unknownGooglePayConfigurationResult);
+  }
+}

package/src/util/google_pay_open_util.ts

@@ -0,0 +1,31 @@
+import {
+  GooglePayOpenCancelled,
+  GooglePayOpenNotConfigured,
+  type GooglePayOpenResult,
+  GooglePayOpenSuccess,
+  GooglePayOpenUnknownError,
+} from '../model/result/google_pay_open_result';
+
+const success = 'success';
+const cancelled = 'cancelled';
+const unknownError = 'unknownError';
+
+export function mapGooglePayOpenResult(json: string): GooglePayOpenResult {
+  const object = JSON.parse(json);
+
+  switch (object.type) {
+    case success:
+      return new GooglePayOpenSuccess(
+        object.token,
+        object.description,
+        object.cardNetwork,
+        object.cardTail
+      );
+    case cancelled:
+      return new GooglePayOpenCancelled();
+    case unknownError:
+      return new GooglePayOpenUnknownError();
+    default:
+      return new GooglePayOpenNotConfigured();
+  }
+}

package/src/util/payment_channels_util.ts

@@ -0,0 +1,22 @@
+import {
+  PaymentChannelsError,
+  type PaymentChannelsResult,
+  PaymentChannelsSuccess,
+} from '../model/result/payment_channels_result';
+
+const success = 'success';
+const error = 'error';
+const unknownType = 'Unknown result type';
+
+export function mapPaymentChannelsResult(json: string): PaymentChannelsResult {
+  const object = JSON.parse(json);
+
+  switch (object.type) {
+    case success:
+      return new PaymentChannelsSuccess(object.channels);
+    case error:
+      return new PaymentChannelsError(object.message);
+    default:
+      throw Error(unknownType);
+  }
+}

package/src/util/result_util.ts

@@ -0,0 +1,44 @@
+import { MethodCallError } from '../model/result/result';
+import { PaymentCompleted } from '../model/result/result';
+import { ConfigurationSuccess } from '../model/result/result';
+import { PaymentCancelled } from '../model/result/result';
+import { ValidationError } from '../model/result/result';
+import { TokenizationCompleted } from '../model/result/result';
+import { TokenizationFailure } from '../model/result/result';
+import { ModuleClosed } from '../model/result/result';
+import { Result } from '../model/result/result';
+
+const configurationSuccess = 'configurationSuccess';
+const validationError = 'validationError';
+const paymentCompleted = 'paymentCompleted';
+const paymentCancelled = 'paymentCancelled';
+const tokenizationCompleted = 'tokenizationCompleted';
+const tokenizationFailure = 'tokenizationFailure';
+const methodCallError = 'methodCallError';
+const moduleClosed = 'moduleClosed';
+const unknownResult = 'Unknown result type';
+
+export function mapResult(json: string): Result {
+  const object = JSON.parse(json);
+
+  switch (object.type) {
+    case configurationSuccess:
+      return new ConfigurationSuccess();
+    case validationError:
+      return new ValidationError(object.value);
+    case paymentCompleted:
+      return new PaymentCompleted(object.value);
+    case paymentCancelled:
+      return new PaymentCancelled(object.value);
+    case tokenizationCompleted:
+      return new TokenizationCompleted();
+    case tokenizationFailure:
+      return new TokenizationFailure();
+    case methodCallError:
+      return new MethodCallError(object.value);
+    case moduleClosed:
+      return new ModuleClosed();
+    default:
+      throw Error(unknownResult);
+  }
+}

package/src/util/screenless_result_util.ts

@@ -0,0 +1,50 @@
+import {
+  ScreenlessBlikAmbiguousAlias,
+  ScreenlessConfiguredPaymentFailed,
+  ScreenlessMethodCallError,
+  ScreenlessPaid,
+  ScreenlessPaymentCreated,
+  ScreenlessPaymentError,
+  type ScreenlessResult,
+  ScreenlessValidationError,
+} from '../model/result/screenless_result';
+import { AmbiguousAlias } from 'react-native-tpay';
+
+const paid = 'paid';
+const configuredPaymentFailed = 'configuredPaymentFailed';
+const ambiguousAlias = 'ambiguousAlias';
+const error = 'error';
+const paymentCreated = 'paymentCreated';
+const validationError = 'validationError';
+const methodCallError = 'methodCallError';
+const unknownScreenlessResult = 'Unknown screenless result type';
+
+export function mapScreenlessResult(json: string): ScreenlessResult {
+  const object = JSON.parse(json);
+
+  switch (object.type) {
+    case paid:
+      return new ScreenlessPaid(object.transactionId);
+    case configuredPaymentFailed:
+      return new ScreenlessConfiguredPaymentFailed(
+        object.transactionId,
+        object.message
+      );
+    case paymentCreated:
+      return new ScreenlessPaymentCreated(
+        object.transactionId,
+        object.paymentUrl
+      );
+    case ambiguousAlias:
+      const aliases: Array<AmbiguousAlias> = object.aliases;
+      return new ScreenlessBlikAmbiguousAlias(object.transactionId, aliases);
+    case methodCallError:
+      return new ScreenlessMethodCallError(object.message);
+    case error:
+      return new ScreenlessPaymentError(object.message);
+    case validationError:
+      return new ScreenlessValidationError(object.message);
+    default:
+      throw Error(unknownScreenlessResult);
+  }
+}