react-native-tpay 0.3.0

package/src/index.tsx

@@ -0,0 +1,267 @@
+import { NativeModules, Platform } from 'react-native';
+import type { TpayConfiguration } from './model/tpay_configuration';
+import { mapResult } from './util/result_util';
+import { Result } from './model/result/result';
+import type { SingleTransaction } from './model/transaction/single_transaction';
+import type { Tokenization } from './model/tokenization/tokenization';
+import type { TokenPayment } from './model/transaction/token_payment';
+import type { ScreenlessResult } from './model/result/screenless_result';
+import { mapScreenlessResult } from './util/screenless_result_util';
+import type { AmbiguousBlikPayment } from './model/screenless/ambiguous_blik_payment';
+import type { TransferPayment } from './model/screenless/transfer_payment';
+import type { CreditCardPayment } from './model/screenless/credit_card_payment';
+import type { GooglePayPayment } from './model/screenless/google_pay_payment';
+import type { GooglePayUtilsConfiguration } from './model/screenless/google_pay_utils_configuration';
+import type { GooglePayConfigureResult } from './model/result/google_pay_configure_result';
+import { mapGooglePayConfigurationResult } from './util/google_pay_configuration_util';
+import type { GooglePayOpenResult } from './model/result/google_pay_open_result';
+import { mapGooglePayOpenResult } from './util/google_pay_open_util';
+import type { PaymentChannelsResult } from './model/result/payment_channels_result';
+import { mapPaymentChannelsResult } from './util/payment_channels_util';
+import type { RatyPekaoPayment } from './model/screenless/raty_pekao_payment';
+import type { BlikPayment } from './model/screenless/blik_payment';
+import type { ApplePayPayment } from './model/screenless/apple_pay_payment';
+
+const LINKING_ERROR =
+  `The package 'react-native-tpay' doesn't seem to be linked. Make sure: \n\n` +
+  Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
+  '- You rebuilt the app after installing the package\n' +
+  '- You are not using Expo Go\n';
+
+const Tpay = NativeModules.TpayRNModule
+  ? NativeModules.TpayRNModule
+  : new Proxy(
+      {},
+      {
+        get() {
+          throw new Error(LINKING_ERROR);
+        },
+      }
+    );
+
+export * from './model/language/language';
+export * from './model/language/languages';
+export * from './model/language/localized_string';
+export * from './model/merchant/apple_pay_configuration';
+export * from './model/merchant/certificate_configuration';
+export * from './model/merchant/google_pay_configuration';
+export * from './model/merchant/merchant_authorization';
+export * from './model/merchant/merchant_details';
+export * from './model/merchant/merchant';
+export * from './model/merchant/tpay_environment';
+export * from './model/merchant/wallet_configuration';
+export * from './model/payer/address';
+export * from './model/payer/payer_context';
+export * from './model/payer/payer';
+export * from './model/payment_channel/payment_channel';
+export * from './model/payment_channel/payment_constraint';
+export * from './model/payment_channel/payment_group';
+export * from './model/payment_method/automatic_payment_methods';
+export * from './model/payment_method/blik_alias';
+export * from './model/payment_method/credit_card_brand';
+export * from './model/payment_method/digital_wallet';
+export * from './model/payment_method/installment_payment';
+export * from './model/payment_method/payment_method';
+export * from './model/payment_method/payment_methods';
+export * from './model/payment_method/tokenized_card';
+export * from './model/result/google_pay_configure_result';
+export * from './model/result/google_pay_open_result';
+export * from './model/result/payment_channels_result';
+export * from './model/result/result';
+export * from './model/result/screenless_result';
+export * from './model/screenless/ambiguous_alias';
+export * from './model/screenless/ambiguous_blik_payment';
+export * from './model/screenless/apple_pay_payment';
+export * from './model/screenless/blik_payment';
+export * from './model/screenless/callbacks';
+export * from './model/screenless/credit_card_config';
+export * from './model/screenless/credit_card_payment';
+export * from './model/screenless/credit_card';
+export * from './model/screenless/expiration_date';
+export * from './model/screenless/frequency';
+export * from './model/screenless/google_pay_environment';
+export * from './model/screenless/google_pay_payment';
+export * from './model/screenless/google_pay_utils_configuration';
+export * from './model/screenless/notifications';
+export * from './model/screenless/payment_details';
+export * from './model/screenless/raty_pekao_payment';
+export * from './model/screenless/recursive';
+export * from './model/screenless/redirects';
+export * from './model/screenless/screenless_payment';
+export * from './model/screenless/transfer_payment';
+export * from './model/tokenization/tokenization';
+export * from './model/transaction/single_transaction';
+export * from './model/transaction/token_payment';
+export * from './model/transaction/transaction';
+export * from './model/tpay_configuration';
+export * from './component/tpay_button';
+
+/**
+ * Method used to configure Tpay UI Module
+ *
+ * @returns {Result} ConfigurationSuccess when Tpay module was successfully configured
+ */
+export async function configure(
+  configuration: TpayConfiguration
+): Promise<Result> {
+  const result = await Tpay.configure(JSON.stringify(configuration));
+  return mapResult(result);
+}
+
+/**
+ * Method used to start standard payment with Tpay UI Module
+ */
+export async function startPayment(
+  transaction: SingleTransaction
+): Promise<Result> {
+  const result = await Tpay.startPayment(JSON.stringify(transaction));
+  return mapResult(result);
+}
+
+/**
+ * Method used to start credit card tokenization with Tpay UI Module
+ */
+export async function tokenizeCard(
+  tokenization: Tokenization
+): Promise<Result> {
+  const result = await Tpay.tokenizeCard(JSON.stringify(tokenization));
+  return mapResult(result);
+}
+
+/**
+ * Method used to start credit card token payment with Tpay UI Module
+ */
+export async function startCardTokenPayment(
+  tokenPayment: TokenPayment
+): Promise<Result> {
+  const result = await Tpay.startCardTokenPayment(JSON.stringify(tokenPayment));
+  return mapResult(result);
+}
+
+/**
+ * Method used to start screenless BLIK payment
+ */
+export async function screenlessBLIKPayment(
+  blikPayment: BlikPayment
+): Promise<ScreenlessResult> {
+  const result = await Tpay.screenlessBLIKPayment(JSON.stringify(blikPayment));
+  return mapScreenlessResult(result);
+}
+
+/**
+ * Method used to continue BLIK one click payment if ambiguous aliases were returned
+ */
+export async function screenlessAmbiguousBLIKPayment(
+  ambiguousBlikPayment: AmbiguousBlikPayment
+): Promise<ScreenlessResult> {
+  const result = await Tpay.screenlessAmbiguousBLIKPayment(
+    JSON.stringify(ambiguousBlikPayment)
+  );
+  return mapScreenlessResult(result);
+}
+
+/**
+ * Method used to start screenless transfer payment
+ */
+export async function screenlessTransferPayment(
+  transferPayment: TransferPayment
+): Promise<ScreenlessResult> {
+  const result = await Tpay.screenlessTransferPayment(
+    JSON.stringify(transferPayment)
+  );
+  return mapScreenlessResult(result);
+}
+
+/**
+ * Method used to start screenless Raty Pekao payment
+ */
+export async function screenlessRatyPekaoPayment(
+  ratyPekaoPayment: RatyPekaoPayment
+): Promise<ScreenlessResult> {
+  const result = await Tpay.screenlessRatyPekaoPayment(
+    JSON.stringify(ratyPekaoPayment)
+  );
+  return mapScreenlessResult(result);
+}
+
+/**
+ * Method used to start screenless credit card payment
+ */
+export async function screenlessCreditCardPayment(
+  creditCardPayment: CreditCardPayment
+): Promise<ScreenlessResult> {
+  const result = await Tpay.screenlessCreditCardPayment(
+    JSON.stringify(creditCardPayment)
+  );
+  return mapScreenlessResult(result);
+}
+
+/**
+ * Method used to start screenless Google Pay payment
+ */
+export async function screenlessGooglePayPayment(
+  googlePayPayment: GooglePayPayment
+): Promise<ScreenlessResult> {
+  const result = await Tpay.screenlessGooglePayPayment(
+    JSON.stringify(googlePayPayment)
+  );
+  return mapScreenlessResult(result);
+}
+
+/**
+ * Method used to start screenless Apple Pay payment
+ */
+export async function screenlessApplePayPayment(
+  applePayPayment: ApplePayPayment
+): Promise<ScreenlessResult> {
+  const result = await Tpay.screenlessApplePayPayment(
+    JSON.stringify(applePayPayment)
+  );
+  return mapScreenlessResult(result);
+}
+
+/**
+ * Method used to configure Google Pay utils.
+ * Call this method before using isGooglePayAvailable and openGooglePay methods.
+ *
+ * Android only
+ */
+export async function configureGooglePayUtils(
+  googlePayUtilsConfiguration: GooglePayUtilsConfiguration
+): Promise<GooglePayConfigureResult> {
+  const result = await Tpay.configureGooglePayUtils(
+    JSON.stringify(googlePayUtilsConfiguration)
+  );
+  return mapGooglePayConfigurationResult(result);
+}
+
+/**
+ * Method used to check if Google Pay is available
+ *
+ * Android only
+ *
+ * @returns true if Google Pay is available on the device
+ */
+export async function isGooglePayAvailable(): Promise<Boolean> {
+  return await Tpay.isGooglePayAvailable();
+}
+
+/**
+ * Method used to open Google Pay
+ *
+ * Android only
+ *
+ * @returns GooglePayOpenSuccess object if user successfully selects the credit card
+ */
+export async function openGooglePay(): Promise<GooglePayOpenResult> {
+  const result = await Tpay.openGooglePay();
+  return mapGooglePayOpenResult(result);
+}
+
+/**
+ * Method used to fetch payment channels from Tpay
+ */
+export async function getAvailablePaymentChannels(): Promise<PaymentChannelsResult> {
+  const result = await Tpay.getAvailablePaymentChannels();
+  return mapPaymentChannelsResult(result);
+}

package/src/model/language/language.ts

@@ -0,0 +1,4 @@
+export enum Language {
+  pl = "pl",
+  en = "en",
+}

package/src/model/language/languages.ts

@@ -0,0 +1,21 @@
+import type { Language } from "./language";
+
+/**
+ * Class responsible for storing information about module languages.
+ */
+export class Languages {
+  preferredLanguage: Language;
+  supportedLanguages: Array<Language>;
+
+  /**
+   * @param {Language} preferredLanguage - module will open in this language
+   * @param {Array<Language>} supportedLanguages - languages that user will be able to use in module
+   */
+  constructor(
+    preferredLanguage: Language,
+    supportedLanguages: Array<Language>
+  ) {
+    this.preferredLanguage = preferredLanguage;
+    this.supportedLanguages = supportedLanguages;
+  }
+}

package/src/model/language/localized_string.ts

@@ -0,0 +1,14 @@
+import type { Language } from "./language";
+
+/**
+ * Class responsible for storing a localized string
+ */
+export class LocalizedString {
+  language: Language;
+  value: string;
+
+  constructor(language: Language, value: string) {
+    this.language = language;
+    this.value = value;
+  }
+}

package/src/model/merchant/apple_pay_configuration.ts

@@ -0,0 +1,17 @@
+/**
+ * Class responsible for storing information about Apple Pay configuration.
+ */
+export class ApplePayConfiguration {
+  merchantIdentifier: string;
+  countryCode: string;
+
+  /**
+   * 
+   * @param merchantIdentifier - unique id that identifies your business as a merchant able to accept apple payments
+   * @param countryCode - country code, for example "PL"
+   */
+  constructor(merchantIdentifier: string, countryCode: string) {
+    this.merchantIdentifier = merchantIdentifier;
+    this.countryCode = countryCode;
+  }
+}

package/src/model/merchant/certificate_configuration.ts

@@ -0,0 +1,15 @@
+/**
+ * Class responsible for storing information about certificate pinning.
+ */
+export class CertificatePinningConfiguration {
+  pinnedDomain: string;
+  publicKeyHash: string;
+
+  /**
+   * @param publicKeyHash - public key used to encrypt credit card data during payment/tokenization.
+   */
+  constructor(publicKeyHash: string) {
+    this.publicKeyHash = publicKeyHash;
+    this.pinnedDomain = 'api.tpay.com';
+  }
+}

package/src/model/merchant/google_pay_configuration.ts

@@ -0,0 +1,13 @@
+/**
+ * Class responsible for storing information about GooglePay configuration
+ */
+export class GooglePayConfiguration {
+  merchantId: string;
+
+  /**
+   * @param merchantId - your merchant id in Tpay system
+   */
+  constructor(merchantId: string) {
+    this.merchantId = merchantId;
+  }
+}

package/src/model/merchant/merchant.ts

@@ -0,0 +1,36 @@
+import type { CertificatePinningConfiguration } from "./certificate_configuration";
+import type { MerchantAuthorization } from "./merchant_authorization";
+import type { TpayEnvironment } from "./tpay_environment";
+import type { WalletConfiguration } from "./wallet_configuration";
+
+/**
+ * Class responsible for storing merchant information
+ */
+export class Merchant {
+  authorization: MerchantAuthorization;
+  environment: TpayEnvironment;
+  certificatePinningConfiguration: CertificatePinningConfiguration;
+  blikAliasToRegister: string;
+  walletConfiguration: WalletConfiguration | null;
+
+  /**
+   * @param authorization - merchant credentials
+   * @param environment - environment that the module will use
+   * @param certificatePinningConfiguration - encryption information
+   * @param blikAliasToRegister - BLIK that will be registered with payment
+   * @param walletConfiguration - configuration of digital wallets
+   */
+  constructor(
+    authorization: MerchantAuthorization,
+    environment: TpayEnvironment,
+    certificatePinningConfiguration: CertificatePinningConfiguration,
+    blikAliasToRegister: string,
+    walletConfiguration: WalletConfiguration | null
+  ) {
+    this.authorization = authorization;
+    this.environment = environment;
+    this.certificatePinningConfiguration = certificatePinningConfiguration;
+    this.blikAliasToRegister = blikAliasToRegister;
+    this.walletConfiguration = walletConfiguration;
+  }
+}

package/src/model/merchant/merchant_authorization.ts

@@ -0,0 +1,16 @@
+/**
+ * Class responsible for storing merchant's authorization
+ */
+export class MerchantAuthorization {
+  clientId: string;
+  clientSecret: string;
+
+  /**
+   * @param clientId - your client id in Tpay system
+   * @param clientSecret - your client secret in Tpay system
+   */
+  constructor(clientId: string, clientSecret: string) {
+    this.clientId = clientId;
+    this.clientSecret = clientSecret;
+  }
+}

package/src/model/merchant/merchant_details.ts

@@ -0,0 +1,25 @@
+import type { LocalizedString } from "../language/localized_string";
+
+/**
+ * Class responsible for storing localized information about merchant
+ */
+export class MerchantDetails {
+  merchantDisplayName: Array<LocalizedString>;
+  merchantHeadquarters: Array<LocalizedString>;
+  regulations: Array<LocalizedString>;
+
+  /**
+   * @param merchantDisplayNames - localized display names
+   * @param merchantHeadquarters - localized headquarters
+   * @param regulationUrls - localized regulation urls
+   */
+  constructor(
+    merchantDisplayNames: Array<LocalizedString>,
+    merchantHeadquarters: Array<LocalizedString>,
+    regulationUrls: Array<LocalizedString>
+  ) {
+    this.merchantDisplayName = merchantDisplayNames;
+    this.merchantHeadquarters = merchantHeadquarters;
+    this.regulations = regulationUrls;
+  }
+}

package/src/model/merchant/tpay_environment.ts

@@ -0,0 +1,4 @@
+export enum TpayEnvironment {
+  production = "production",
+  sandbox = "sandbox",
+}

package/src/model/merchant/wallet_configuration.ts

@@ -0,0 +1,22 @@
+import type { ApplePayConfiguration } from './apple_pay_configuration';
+import type { GooglePayConfiguration } from './google_pay_configuration';
+
+/**
+ * Class responsible for storing wallet configuration
+ */
+export class WalletConfiguration {
+  googlePay: GooglePayConfiguration | null;
+  applePay: ApplePayConfiguration | null;
+
+  /**
+   * @param googlePay - Google Pay configuration
+   * @param applePay - Apple Pay configuration
+   */
+  constructor(
+    googlePay: GooglePayConfiguration | null,
+    applePay: ApplePayConfiguration | null
+  ) {
+    this.googlePay = googlePay;
+    this.applePay = applePay;
+  }
+}

package/src/model/payer/address.ts

@@ -0,0 +1,27 @@
+/**
+ * Class responsible for storing payer address
+ */
+export class Address {
+  address: string | null;
+  city: string | null;
+  countryCode: string | null;
+  postalCode: string | null;
+
+  /**
+   * @param address - street number
+   * @param city - city name
+   * @param countryCode - country code, for example 'PL'
+   * @param postalCode - postal code
+   */
+  constructor(
+    address: string | null,
+    city: string | null,
+    countryCode: string | null,
+    postalCode: string | null
+  ) {
+    this.address = address;
+    this.city = city;
+    this.countryCode = countryCode;
+    this.postalCode = postalCode;
+  }
+}

package/src/model/payer/payer.ts

@@ -0,0 +1,29 @@
+import type { Address } from "./address";
+
+/**
+ * Class responsible for storing information about payer
+ */
+export class Payer {
+  name: string;
+  email: string;
+  phone: string | null;
+  address: Address | null;
+
+  /**
+   * @param name - payer's full name
+   * @param email - payer's email
+   * @param phone - payer's phone number
+   * @param address - payer's address
+   */
+  constructor(
+    name: string,
+    email: string,
+    phone: string | null,
+    address: Address | null
+  ) {
+    this.name = name;
+    this.email = email;
+    this.phone = phone;
+    this.address = address;
+  }
+}

package/src/model/payer/payer_context.ts

@@ -0,0 +1,22 @@
+import type { AutomaticPaymentMethods } from "../payment_method/automatic_payment_methods";
+import type { Payer } from "./payer";
+
+/**
+ * Class responsible for storing information about payer and automatic payment methods
+ */
+export class PayerContext {
+  payer: Payer | null;
+  automaticPaymentMethods: AutomaticPaymentMethods | null;
+
+  /**
+   * @param payer - payer information
+   * @param automaticPaymentMethods - automatic payment methods for payer
+   */
+  constructor(
+    payer: Payer | null,
+    automaticPaymentMethods: AutomaticPaymentMethods | null
+  ) {
+    this.payer = payer;
+    this.automaticPaymentMethods = automaticPaymentMethods;
+  }
+}

package/src/model/payment_channel/payment_channel.ts

@@ -0,0 +1,38 @@
+import type { PaymentConstraint } from './payment_constraint';
+
+/**
+ * Class responsible for storing information about a payment channel
+ */
+export class PaymentChannel {
+  /**
+   * id of the payment channel
+   */
+  id: string;
+
+  /**
+   * channel display name
+   */
+  name: string;
+
+  /**
+   * channel image url
+   */
+  imageUrl: string;
+
+  /**
+   * channel constraints
+   */
+  constraints: Array<PaymentConstraint>;
+
+  constructor(
+    id: string,
+    name: string,
+    imageUrl: string,
+    constraints: Array<PaymentConstraint>
+  ) {
+    this.id = id;
+    this.name = name;
+    this.imageUrl = imageUrl;
+    this.constraints = constraints;
+  }
+}

package/src/model/payment_channel/payment_constraint.ts

@@ -0,0 +1,41 @@
+/**
+ * Class indicating that there is a payment constraint on a payment channel
+ */
+export class PaymentConstraint {
+  /**
+   * type of a payment constraint
+   */
+  type: PaymentConstraintType;
+
+  constructor(type: PaymentConstraintType) {
+    this.type = type;
+  }
+}
+
+/**
+ * Enum describing available payment constraint types
+ */
+export enum PaymentConstraintType {
+  amount = "amount",
+}
+
+/**
+ * Class responsible for storing information about amount payment constraint
+ */
+export class AmountPaymentConstraint extends PaymentConstraint {
+  /**
+   * minimum price that can be used while creating the transaction
+   */
+  minimum: number | null | undefined;
+
+  /**
+   * maximum price that can be used while creating the transaction
+   */
+  maximum: number | null | undefined;
+
+  constructor(minimum: number | null, maximum: number | null) {
+    super(PaymentConstraintType.amount);
+    this.minimum = minimum;
+    this.maximum = maximum;
+  }
+}

package/src/model/payment_channel/payment_group.ts

@@ -0,0 +1,25 @@
+/**
+ * Class responsible for storing payment group's information
+ */
+export class PaymentGroup {
+  /**
+   * id of the group
+   */
+  id: string;
+
+  /**
+   * group's display name
+   */
+  name: string;
+
+  /**
+   * group's image url
+   */
+  imageUrl: string;
+
+  constructor(id: string, name: string, imageUrl: string) {
+    this.id = id;
+    this.name = name;
+    this.imageUrl = imageUrl;
+  }
+}

package/src/model/payment_method/automatic_payment_methods.ts

@@ -0,0 +1,22 @@
+import type { BlikAlias } from "./blik_alias";
+import type { TokenizedCard } from "./tokenized_card";
+
+/**
+ * Class responsible for storing information about payer's automatic payment methods
+ */
+export class AutomaticPaymentMethods {
+  tokenizedCards: Array<TokenizedCard> | null;
+  blikAlias: BlikAlias | null;
+
+  /**
+   * @param tokenizedCards - tokenized cards created after successful credit card payment
+   * @param blikAlias - BLIK alias that will be registered after payment or used to pay (if registered)
+   */
+  constructor(
+    tokenizedCards: Array<TokenizedCard> | null,
+    blikAlias: BlikAlias | null
+  ) {
+    this.tokenizedCards = tokenizedCards;
+    this.blikAlias = blikAlias;
+  }
+}