react-native-tpay 0.3.0

package/src/model/payment_method/blik_alias.ts

@@ -0,0 +1,19 @@
+/**
+ * Class responsible for storing information about BLIK alias
+ */
+export class BlikAlias {
+  isRegistered: boolean;
+  value: string;
+  label: string;
+
+  /**
+   * @param isRegistered - true if this BLIK alias is registered (payer saved it after paying with 6-digit code)
+   * @param value - payer's unique alias value
+   * @param label - alias display name
+   */
+  constructor(isRegistered: boolean, value: string, label: string) {
+    this.isRegistered = isRegistered;
+    this.value = value;
+    this.label = label;
+  }
+}

package/src/model/payment_method/credit_card_brand.ts

@@ -0,0 +1,8 @@
+/**
+ * Enum describing possible credit card brands
+ */
+export enum CreditCardBrand {
+  mastercard = "mastercard",
+  visa = "visa",
+  unknown = "unknown",
+}

package/src/model/payment_method/digital_wallet.ts

@@ -0,0 +1,7 @@
+/**
+ * Enum describing possible digital wallets
+ */
+export enum DigitalWallet {
+  googlePay = "googlePay",
+  applePay = "applePay",
+}

package/src/model/payment_method/installment_payment.ts

@@ -0,0 +1,6 @@
+/**
+ * Enum describing possible installment payments
+ */
+export enum InstallmentPayment {
+  ratyPekao = "ratyPekao",
+}

package/src/model/payment_method/payment_method.ts

@@ -0,0 +1,8 @@
+/**
+ * Enum describing possible payment methods
+ */
+export enum PaymentMethod {
+  blik = "blik",
+  transfer = "transfer",
+  card = "card",
+}

package/src/model/payment_method/payment_methods.ts

@@ -0,0 +1,27 @@
+import type { DigitalWallet } from './digital_wallet';
+import type { InstallmentPayment } from './installment_payment';
+import type { PaymentMethod } from './payment_method';
+
+/**
+ * Class responsible for storing selected payment methods
+ */
+export class PaymentMethods {
+  methods: Array<PaymentMethod>;
+  wallets: Array<DigitalWallet> | null;
+  installmentPayments: Array<InstallmentPayment> | null;
+
+  /**
+   * @param methods - selected payment methods
+   * @param wallets - selected digital wallets
+   * @param installmentPayments - selected installment payments
+   */
+  constructor(
+    methods: Array<PaymentMethod>,
+    wallets: Array<DigitalWallet> | null,
+    installmentPayments: Array<InstallmentPayment> | null
+  ) {
+    this.methods = methods;
+    this.wallets = wallets;
+    this.installmentPayments = installmentPayments;
+  }
+}

package/src/model/payment_method/tokenized_card.ts

@@ -0,0 +1,21 @@
+import type { CreditCardBrand } from "./credit_card_brand";
+
+/**
+ * Class responsible for storing tokenized card information
+ */
+export class TokenizedCard {
+  token: string;
+  cardTail: string;
+  brand: CreditCardBrand;
+
+  /**
+   * @param token - credit card token
+   * @param cardTail - 4 last numbers of credit card number
+   * @param brand - credit card brand
+   */
+  constructor(token: string, cardTail: string, brand: CreditCardBrand) {
+    this.token = token;
+    this.cardTail = cardTail;
+    this.brand = brand;
+  }
+}

package/src/model/result/google_pay_configure_result.ts

@@ -0,0 +1,25 @@
+
+/**
+ * Indicates a result of Google Pay configuration
+ */
+export class GooglePayConfigureResult {}
+
+/**
+ * Indicates that Google Pay configuration was successful
+ */
+export class GooglePayConfigureSuccess extends GooglePayConfigureResult {}
+
+/**
+ * Indicates that there was an error during Google Pay configuration
+ */
+export class GooglePayConfigureError extends GooglePayConfigureResult {
+  /**
+   * Error message
+   */
+  message: string;
+
+  constructor(message: string) {
+    super();
+    this.message = message;
+  }
+}

package/src/model/result/google_pay_open_result.ts

@@ -0,0 +1,58 @@
+/**
+ * Indicates a result of Google Pay open
+ */
+export class GooglePayOpenResult {}
+
+/**
+ * Indicates that Google Pay was successfully opened and user has selected a credit card
+ */
+export class GooglePayOpenSuccess extends GooglePayOpenResult {
+  /**
+   * Google Pay card token, use it with GooglePayPayment
+   */
+  token: string;
+
+  /**
+   * Credit card description, for example "Visa •••• 1111"
+   */
+  description: string;
+
+  /**
+   * Credit card network
+   */
+  cardNetwork: string;
+
+  /**
+   * Last digits of credit card number
+   */
+  cardTail: string;
+
+  constructor(
+    token: string,
+    description: string,
+    cardNetwork: string,
+    cardTail: string
+  ) {
+    super();
+    this.token = token;
+    this.description = description;
+    this.cardNetwork = cardNetwork;
+    this.cardTail = cardTail;
+  }
+}
+
+/**
+ * Indicates that Google Pay was opened successfully but user closed it without selecting a credit card
+ */
+export class GooglePayOpenCancelled extends GooglePayOpenResult {}
+
+/**
+ * Indicates that there was a unknown error
+ */
+export class GooglePayOpenUnknownError extends GooglePayOpenResult {}
+
+/**
+ * Indicates that Google Pay utils were not configured before trying to open Google Pay.
+ * Configure utils via configureGooglePayUtils(...) method
+ */
+export class GooglePayOpenNotConfigured extends GooglePayOpenResult {}

package/src/model/result/payment_channels_result.ts

@@ -0,0 +1,36 @@
+import type { PaymentChannel } from '../payment_channel/payment_channel';
+
+/**
+ * Indicates a result of payment channels
+ */
+export class PaymentChannelsResult {}
+
+/**
+ * Indicates that payment channels were successfully received
+ */
+export class PaymentChannelsSuccess extends PaymentChannelsResult {
+  /**
+   * Payment channels
+   */
+  channels: Array<PaymentChannel>;
+
+  constructor(channels: Array<PaymentChannel>) {
+    super();
+    this.channels = channels;
+  }
+}
+
+/**
+ * Indicates that there was an error while fetching payment channels
+ */
+export class PaymentChannelsError extends PaymentChannelsResult {
+  /**
+   * Error message
+   */
+  message: string;
+
+  constructor(message: string) {
+    super();
+    this.message = message;
+  }
+}

package/src/model/result/result.ts

@@ -0,0 +1,84 @@
+/**
+ * Indicates a result of Tpay UI module action
+ */
+export class Result {}
+
+/**
+ * Indicates that credit card tokenization was successful and module was closed
+ */
+export class TokenizationCompleted extends Result {}
+
+/**
+ * Indicates that credit card tokenization failed and module was closed
+ */
+export class TokenizationFailure extends Result {}
+
+/**
+ * Indicates that configuration was successful
+ */
+export class ConfigurationSuccess extends Result {}
+
+/**
+ * Indicates that user closed the module without making a payment/tokenization
+ */
+export class ModuleClosed extends Result {}
+
+/**
+ * Indicates that some data passed to module is invalid
+ */
+export class ValidationError extends Result {
+  /**
+   * Validation error message
+   */
+  message: string;
+
+  constructor(message: string) {
+    super();
+    this.message = message;
+  }
+}
+
+/**
+ * Indicates that payment was successful and module was closed
+ */
+export class PaymentCompleted extends Result {
+  /**
+   * Transaction id of the completed transaction
+   */
+  transactionId: string;
+
+  constructor(transactionId: string) {
+    super();
+    this.transactionId = transactionId;
+  }
+}
+
+/**
+ * Indicates that payment failed and module was closed
+ */
+export class PaymentCancelled extends Result {
+  /**
+   * If exists, id of the transaction
+   */
+  transactionId: string | null;
+
+  constructor(transactionId: string | null) {
+    super();
+    this.transactionId = transactionId;
+  }
+}
+
+/**
+ * Indicates a module error
+ */
+export class MethodCallError extends Result {
+  /**
+   * Error message
+   */
+  message: string;
+
+  constructor(message: string) {
+    super();
+    this.message = message;
+  }
+}

package/src/model/result/screenless_result.ts

@@ -0,0 +1,138 @@
+import { AmbiguousAlias } from 'react-native-tpay';
+
+/**
+ * Indicates a result of screenless action
+ */
+export class ScreenlessResult {}
+
+/**
+ * Indicates that some data passed to payment is invalid
+ */
+export class ScreenlessValidationError extends ScreenlessResult {
+  /**
+   * Validation error message
+   */
+  message: string;
+
+  constructor(message: string) {
+    super();
+    this.message = message;
+  }
+}
+
+/**
+ * Indicates a module error
+ */
+export class ScreenlessMethodCallError extends ScreenlessResult {
+  /**
+   * Error message
+   */
+  message: string;
+
+  constructor(message: string) {
+    super();
+    this.message = message;
+  }
+}
+
+/**
+ * Indicates that payment was completed successfully
+ */
+export class ScreenlessPaid extends ScreenlessResult {
+  /**
+   * Transaction id of the completed transaction
+   */
+  transactionId: string;
+
+  constructor(transactionId: string) {
+    super();
+    this.transactionId = transactionId;
+  }
+}
+
+/**
+ * Indicates that payment was created.
+ * If it was a credit card or transfer payment you might
+ * have to display paymentUrl to the user to finish the payment.
+ * If it was a BLIK payment user has to accept it in bank app.
+ * It is advised to use long polling mechanism to observe
+ * payment status via transactionId.
+ */
+export class ScreenlessPaymentCreated extends ScreenlessResult {
+  /**
+   * Transaction id of the created transaction
+   */
+  transactionId: string;
+
+  /**
+   * Payment url, needs to be displayed to the user to finish the payment
+   */
+  paymentUrl: string | null;
+
+  constructor(transactionId: string, paymentUrl: string | null) {
+    super();
+    this.transactionId = transactionId;
+    this.paymentUrl = paymentUrl;
+  }
+}
+
+/**
+ * Indicates that creating payment failed because of error with:
+ * - credit card data or credit card token
+ * - BLIK code or BLIK alias
+ */
+export class ScreenlessConfiguredPaymentFailed extends ScreenlessResult {
+  /**
+   * Transaction id of the created transaction
+   */
+  transactionId: string;
+
+  /**
+   * Optional error message
+   */
+  error: string | null;
+
+  constructor(transactionId: string, error: string | null) {
+    super();
+    this.transactionId = transactionId;
+    this.error = error;
+  }
+}
+
+/**
+ * Indicates that payer has the same BLIK alias registered in more than one bank app.
+ * You need to display a list of aliases to user and then use AmbiguousBlikPayment to
+ * continue the payment.
+ */
+export class ScreenlessBlikAmbiguousAlias extends ScreenlessResult {
+  /**
+   * Transaction id of the created transaction
+   */
+  transactionId: string;
+
+  /**
+   * Ambiguous aliases that need to be displayed to the user
+   */
+  aliases: Array<AmbiguousAlias>;
+
+  constructor(transactionId: string, aliases: Array<AmbiguousAlias>) {
+    super();
+    this.transactionId = transactionId;
+    this.aliases = aliases;
+  }
+}
+
+/**
+ * Indicates that payment was not created because of an error
+ */
+export class ScreenlessPaymentError extends ScreenlessResult {
+  /**
+   * Optional error message
+   */
+  error: string | null;
+
+  constructor(error: string | null) {
+    super();
+    this.error = error;
+  }
+}

package/src/model/screenless/ambiguous_alias.ts

@@ -0,0 +1,19 @@
+/**
+ * Class responsible for storing ambiguous alias information
+ */
+export class AmbiguousAlias {
+  /**
+   * Alias display name
+   */
+  name: string;
+
+  /**
+   * Alias identifier
+   */
+  code: string;
+
+  constructor(name: string, code: string) {
+    this.name = name;
+    this.code = code;
+  }
+}

package/src/model/screenless/ambiguous_blik_payment.ts

@@ -0,0 +1,26 @@
+import type { BlikAlias } from "../payment_method/blik_alias";
+import type { AmbiguousAlias } from "./ambiguous_alias";
+
+/**
+ * Class responsible for storing information about ambiguous BLIK payment
+ */
+export class AmbiguousBlikPayment {
+  transactionId: string;
+  blikAlias: BlikAlias;
+  ambiguousAlias: AmbiguousAlias;
+
+  /**
+   * @param transactionId - id of transaction received from ScreenlessBlikAmbiguousAlias result
+   * @param blikAlias - BLIK alias used to create transaction with BlikPayment
+   * @param ambiguousBlik - ambiguous alias selected by user
+   */
+  constructor(
+    transactionId: string,
+    blikAlias: BlikAlias,
+    ambiguousBlik: AmbiguousAlias
+  ) {
+    this.transactionId = transactionId;
+    this.blikAlias = blikAlias;
+    this.ambiguousAlias = ambiguousBlik;
+  }
+}

package/src/model/screenless/apple_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 Apple Pay payment
+ */
+export class ApplePayPayment extends ScreenlessPayment {
+  applePayToken: string;
+
+  /**
+   * @param applePayToken - Token received from Apple Pay
+   */
+  constructor(
+    applePayToken: string,
+    paymentDetails: PaymentDetails,
+    payer: Payer,
+    callbacks: Callbacks | null
+  ) {
+    super(paymentDetails, payer, callbacks);
+    this.applePayToken = applePayToken;
+  }
+}

package/src/model/screenless/blik_payment.ts

@@ -0,0 +1,32 @@
+import type { Payer } from '../payer/payer';
+import type { BlikAlias } from '../payment_method/blik_alias';
+import type { Callbacks } from './callbacks';
+import type { PaymentDetails } from './payment_details';
+import { ScreenlessPayment } from './screenless_payment';
+
+/**
+ * Class responsible for storing BLIK payment information
+ */
+export class BlikPayment extends ScreenlessPayment {
+  code: string | null;
+  alias: BlikAlias | null;
+
+  /**
+   * You have to provide either code or alias.
+   * If you provide both, module will try to register the alias.
+   * 
+   * @param code - 6-digit code
+   * @param alias - BLIK alias to register/pay with
+   */
+  constructor(
+    code: string | null,
+    alias: BlikAlias | null,
+    paymentDetails: PaymentDetails,
+    payer: Payer,
+    callbacks: Callbacks | null
+  ) {
+    super(paymentDetails, payer, callbacks);
+    this.code = code;
+    this.alias = alias;
+  }
+}

package/src/model/screenless/callbacks.ts

@@ -0,0 +1,22 @@
+import type { Notifications } from "./notifications";
+import type { Redirects } from "./redirects";
+
+/**
+ * Class storing the information about callbacks
+ */
+export class Callbacks {
+  redirects: Redirects | null;
+  notifications: Notifications | null;
+
+  /**
+   * @param redirects - where should user be redirected after payment
+   * @param notifications - where should payment notifications be sent
+   */
+  constructor(
+    redirects: Redirects | null,
+    notifications: Notifications | null
+  ) {
+    this.redirects = redirects;
+    this.notifications = notifications;
+  }
+}

package/src/model/screenless/credit_card.ts

@@ -0,0 +1,30 @@
+import type { CreditCardConfig } from "./credit_card_config";
+import type { ExpirationDate } from "./expiration_date";
+
+/**
+ * Class responsible for storing information about a credit card
+ */
+export class CreditCard {
+  cardNumber: string;
+  expiryDate: ExpirationDate;
+  cvv: string;
+  config: CreditCardConfig;
+
+  /**
+   * @param cardNumber - credit card number
+   * @param expiryDate - credit card expiration date
+   * @param cvv - cvv code
+   * @param config - other credit card information
+   */
+  constructor(
+    cardNumber: string,
+    expiryDate: ExpirationDate,
+    cvv: string,
+    config: CreditCardConfig
+  ) {
+    this.cardNumber = cardNumber;
+    this.expiryDate = expiryDate;
+    this.cvv = cvv;
+    this.config = config;
+  }
+}

package/src/model/screenless/credit_card_config.ts

@@ -0,0 +1,18 @@
+/**
+ * Class responsible for storing payment related information about credit card
+ */
+export class CreditCardConfig {
+  shouldSave: boolean;
+  domain: string;
+  rocText: string | null;
+
+  /**
+   * @param shouldSave - whether credit card should be tokenized after payment
+   * @param domain - domain of your store
+   */
+  constructor(shouldSave: boolean, domain: string, rocText: string | null) {
+    this.shouldSave = shouldSave;
+    this.domain = domain;
+    this.rocText = rocText;
+  }
+}

package/src/model/screenless/credit_card_payment.ts

@@ -0,0 +1,32 @@
+import type { Payer } from "../payer/payer";
+import type { Callbacks } from "./callbacks";
+import type { CreditCard } from "./credit_card";
+import type { PaymentDetails } from "./payment_details";
+import { ScreenlessPayment } from "./screenless_payment";
+
+/**
+ * Class responsible for storing information about credit card payment
+ */
+export class CreditCardPayment extends ScreenlessPayment {
+  creditCard: CreditCard | null;
+  creditCardToken: string | null;
+
+  /**
+   * You have to provide either creditCard or creditCardToken.
+   * If you provide both, creditCardToken will be used.
+   * 
+   * @param creditCard - information about credit card
+   * @param creditCardToken - token of tokenized card (for returning customers)
+   */
+  constructor(
+    creditCard: CreditCard | null,
+    creditCardToken: string | null,
+    paymentDetails: PaymentDetails,
+    payer: Payer,
+    callbacks: Callbacks | null
+  ) {
+    super(paymentDetails, payer, callbacks);
+    this.creditCard = creditCard;
+    this.creditCardToken = creditCardToken;
+  }
+}

package/src/model/screenless/expiration_date.ts

@@ -0,0 +1,16 @@
+/**
+ * Class responsible for storing information about expiration date
+ */
+export class ExpirationDate {
+  month: String;
+  year: String;
+
+  /**
+   * @param month - 2-digit month, for example '02'
+   * @param year - 2-digit year, for example '24'
+   */
+  constructor(month: string, year: string) {
+    this.month = month;
+    this.year = year;
+  }
+}

package/src/model/screenless/frequency.ts

@@ -0,0 +1,10 @@
+/**
+ * Enum describing the frequency options
+ */
+export enum Frequency {
+  daily = "daily",
+  weekly = "weekly",
+  monthly = "monthly",
+  quarterly = "quarterly",
+  yearly = "yearly",
+}