react-native-tpay 0.3.0

package/android/src/main/java/com/tpay/TpayScreenlessResultHandler.kt

@@ -0,0 +1,121 @@
+package com.tpay
+
+import com.tpay.model.screenless.*
+import com.tpay.sdk.api.screenless.blik.*
+import com.tpay.sdk.api.screenless.transfer.*
+import com.tpay.sdk.api.screenless.card.*
+import com.tpay.sdk.api.screenless.googlePay.*
+import com.tpay.sdk.api.screenless.PaymentDetails
+import com.tpay.sdk.api.screenless.LongPollingConfig
+import com.tpay.sdk.api.screenless.TransactionState
+import com.tpay.sdk.api.screenless.pekaoInstallment.*
+
+object TpayScreenlessResultHandler {
+  fun handleCreditCardCreateResult(
+    createResult: CreateCreditCardTransactionResult
+  ): TpayScreenlessResult {
+    return when (createResult) {
+      is CreateCreditCardTransactionResult.Created -> {
+        TpayScreenlessResult.PaymentCreated(
+          createResult.transactionId,
+          createResult.paymentUrl
+        )
+      }
+
+      is CreateCreditCardTransactionResult.CreatedAndPaid -> {
+        TpayScreenlessResult.Paid(createResult.transactionId)
+      }
+
+      is CreateCreditCardTransactionResult.Error -> {
+        TpayScreenlessResult.Error(createResult.errorMessage)
+      }
+    }
+  }
+
+  fun handleTransferCreateResult(
+    createResult: CreateTransferTransactionResult
+  ): TpayScreenlessResult {
+    return when (createResult) {
+      is CreateTransferTransactionResult.Created -> {
+        TpayScreenlessResult.PaymentCreated(
+          createResult.transactionId,
+          createResult.paymentUrl
+        )
+      }
+
+      is CreateTransferTransactionResult.Error -> {
+        TpayScreenlessResult.Error(createResult.errorMessage)
+      }
+    }
+  }
+
+  fun handleRatyPekaoCreateResult(
+    createResult: CreatePekaoInstallmentTransactionResult
+  ): TpayScreenlessResult {
+    return when (createResult) {
+      is CreatePekaoInstallmentTransactionResult.Created -> {
+        TpayScreenlessResult.PaymentCreated(
+          createResult.transactionId,
+          createResult.paymentUrl
+        )
+      }
+
+      is CreatePekaoInstallmentTransactionResult.Error -> {
+        TpayScreenlessResult.Error(createResult.devErrorMessage)
+      }
+    }
+  }
+
+  fun handleBLIKCreateResult(
+    createResult: CreateBLIKTransactionResult
+  ): TpayScreenlessResult {
+    return when (createResult) {
+      is CreateBLIKTransactionResult.Created -> {
+        TpayScreenlessResult.PaymentCreated(createResult.transactionId, null)
+      }
+
+      is CreateBLIKTransactionResult.CreatedAndPaid -> {
+        TpayScreenlessResult.Paid(createResult.transactionId)
+      }
+
+      is CreateBLIKTransactionResult.ConfiguredPaymentFailed -> {
+        TpayScreenlessResult.ConfiguredPaymentFailed(
+          createResult.transactionId,
+          createResult.errorMessage
+        )
+      }
+
+      is CreateBLIKTransactionResult.AmbiguousBlikAlias -> {
+        TpayScreenlessResult.BlikAmbiguousAlias(
+          createResult.transactionId,
+          createResult.aliases
+        )
+      }
+
+      is CreateBLIKTransactionResult.Error -> {
+        TpayScreenlessResult.Error(createResult.errorMessage)
+      }
+    }
+  }
+
+  fun handleGooglePayCreateResult(
+    createResult: CreateGooglePayTransactionResult
+  ): TpayScreenlessResult {
+    return when (createResult) {
+      is CreateGooglePayTransactionResult.Created -> {
+        TpayScreenlessResult.PaymentCreated(
+          createResult.transactionId,
+          createResult.paymentUrl
+        )
+      }
+
+      is CreateGooglePayTransactionResult.CreatedAndPaid -> {
+        TpayScreenlessResult.Paid(createResult.transactionId)
+      }
+
+      is CreateGooglePayTransactionResult.Error -> {
+        TpayScreenlessResult.Error(createResult.errorMessage)
+      }
+    }
+  }
+}

package/android/src/main/java/com/tpay/delegate/AddCardDelegateImpl.kt

@@ -0,0 +1,30 @@
+package com.tpay.delegate
+
+import com.tpay.sdk.api.addCard.*
+import com.tpay.TpayResult
+import com.tpay.util.TpayBackpressUtil
+
+class AddCardDelegateImpl(
+  private val sheet: AddCard.Sheet,
+  private val onResult: (TpayResult) -> Unit
+) : AddCardDelegate {
+  override fun onAddCardSuccess(tokenizationId: String?) {
+    onResult(TpayResult.TokenizationCompleted)
+    remove()
+  }
+
+  override fun onAddCardFailure() {
+    onResult(TpayResult.TokenizationFailure)
+    remove()
+  }
+
+  override fun onModuleClosed() {
+    onResult(TpayResult.ModuleClosed)
+    remove()
+  }
+
+  private fun remove() {
+    sheet.removeObserver()
+    TpayBackpressUtil.remove()
+  }
+}

package/android/src/main/java/com/tpay/delegate/PaymentDelegateImpl.kt

@@ -0,0 +1,33 @@
+package com.tpay.delegate
+
+import com.tpay.sdk.api.payment.PaymentDelegate
+import com.tpay.sdk.api.models.ObservablePayment
+import com.tpay.TpayResult
+import com.tpay.util.TpayBackpressUtil
+
+class PaymentDelegateImpl(
+  private val sheet: ObservablePayment,
+  private val onResult: (TpayResult) -> Unit
+) : PaymentDelegate {
+  override fun onPaymentCreated(transactionId: String?) {}
+
+  override fun onPaymentCompleted(transactionId: String?) {
+    onResult(TpayResult.PaymentCompleted(transactionId))
+    remove()
+  }
+
+  override fun onPaymentCancelled(transactionId: String?) {
+    onResult(TpayResult.PaymentCancelled(transactionId))
+    remove()
+  }
+
+  override fun onModuleClosed() {
+    onResult(TpayResult.ModuleClosed)
+    remove()
+  }
+
+  private fun remove() {
+    sheet.removeObserver()
+    TpayBackpressUtil.remove()
+  }
+}

package/android/src/main/java/com/tpay/extension/AmbiguousAlias+.kt

@@ -0,0 +1,11 @@
+package com.tpay.extension
+
+import org.json.JSONObject
+import com.tpay.sdk.api.screenless.blik.AmbiguousAlias
+
+fun AmbiguousAlias.toJson(): String {
+  return JSONObject().apply {
+    put("name", name)
+    put("code", code)
+  }.toString()
+}

package/android/src/main/java/com/tpay/extension/BlikAlias+.kt

@@ -0,0 +1,18 @@
+package com.tpay.extension
+
+import com.tpay.sdk.api.models.BlikAlias
+import org.json.JSONObject
+
+private const val VALUE = "value"
+private const val LABEL = "label"
+private const val IS_REGISTERED = "isRegistered"
+
+fun JSONObject.getBlikAlias(): BlikAlias {
+  val value = getString(VALUE)
+  val label = getString(LABEL)
+  return if (getBoolean(IS_REGISTERED)) {
+    BlikAlias.Registered(value, label)
+  } else {
+    BlikAlias.NotRegistered(value, label)
+  }
+}

package/android/src/main/java/com/tpay/extension/CardTokenTransaction+.kt

@@ -0,0 +1,19 @@
+package com.tpay.extension
+
+import com.tpay.sdk.api.cardTokenPayment.CardTokenTransaction
+import com.tpay.util.ValidationMessages
+
+fun CardTokenTransaction.validate() {
+  if (amount <= 0) {
+    throw ValidationException(ValidationMessages.AMOUNT_NEGATIVE)
+  }
+  if (description.isBlank()) {
+    throw ValidationException(ValidationMessages.DESCRIPTION_BLANK)
+  }
+  if (cardToken.isBlank()) {
+    throw ValidationException(ValidationMessages.CARD_TOKEN_BLANK)
+  }
+  if (payer.name.isBlank() || payer.email.isBlank()) {
+    throw ValidationException(ValidationMessages.PAYER_REQUIRED_TOKEN_PAYMENT)
+  }
+}

package/android/src/main/java/com/tpay/extension/Exception.kt

@@ -0,0 +1,3 @@
+package com.tpay.extension
+
+class ValidationException(message: String) : Exception(message)

package/android/src/main/java/com/tpay/extension/JSONObject+.kt

@@ -0,0 +1,10 @@
+package com.tpay.extension
+
+import org.json.JSONObject
+
+fun JSONObject.actuallyOptString(key: String): String? {
+  return optString(key).let { text ->
+    if (text == "null" || text.isBlank()) null
+    else text
+  }
+}

package/android/src/main/java/com/tpay/extension/PaymentChannel+.kt

@@ -0,0 +1,22 @@
+package com.tpay.extension
+
+import com.tpay.sdk.api.screenless.channelMethods.*
+import org.json.JSONArray
+import org.json.JSONObject
+
+fun List<PaymentChannel>.toJsonArray(): JSONArray {
+  return JSONArray().apply {
+    forEach { channel ->
+      put(channel.toJsonObject())
+    }
+  }
+}
+
+fun PaymentChannel.toJsonObject(): JSONObject {
+  return JSONObject().apply {
+    put("id", id)
+    put("name", name)
+    put("imageUrl", imageUrl)
+    put("constraints", constraints.toJsonArray())
+  }
+}

package/android/src/main/java/com/tpay/extension/PaymentConstraint+.kt

@@ -0,0 +1,24 @@
+package com.tpay.extension
+
+import com.tpay.sdk.api.screenless.channelMethods.*
+import com.tpay.model.screenless.PaymentConstraintType
+import org.json.JSONObject
+import org.json.JSONArray
+
+fun List<PaymentConstraint>.toJsonArray(): JSONArray {
+  return JSONArray().apply {
+    forEach { constraint -> put(constraint.toJsonObject()) }
+  }
+}
+
+fun PaymentConstraint.toJsonObject(): JSONObject {
+  return JSONObject().apply {
+    when (this@toJsonObject) {
+      is PaymentConstraint.Amount -> {
+        put("type", PaymentConstraintType.AMOUNT.name.lowercase())
+        put("minimum", minimum)
+        put("maximum", maximum)
+      }
+    }
+  }
+}

package/android/src/main/java/com/tpay/extension/PaymentGroup+.kt

@@ -0,0 +1,21 @@
+package com.tpay.extension
+
+import com.tpay.sdk.api.screenless.channelMethods.*
+import org.json.JSONObject
+import org.json.JSONArray
+
+fun List<PaymentGroup>.toJsonArray(): JSONArray {
+  return JSONArray().apply {
+    forEach { group ->
+      put(group.toJsonObject())
+    }
+  }
+}
+
+fun PaymentGroup.toJsonObject(): JSONObject {
+  return JSONObject().apply {
+    put("id", id)
+    put("name", name)
+    put("imageUrl", imageUrl)
+  }
+}

package/android/src/main/java/com/tpay/extension/SingleTransaction+.kt

@@ -0,0 +1,14 @@
+package com.tpay.extension
+
+import com.tpay.sdk.api.models.transaction.SingleTransaction
+import com.tpay.util.ValidationMessages
+import com.tpay.extension.ValidationException
+
+fun SingleTransaction.validate() {
+  if (amount <= 0) {
+    throw ValidationException(ValidationMessages.AMOUNT_NEGATIVE)
+  }
+  if (description.isBlank()) {
+    throw ValidationException(ValidationMessages.DESCRIPTION_BLANK)
+  }
+}

package/android/src/main/java/com/tpay/extension/String+.kt

@@ -0,0 +1,30 @@
+package com.tpay.extension
+
+import java.util.regex.Matcher
+import java.util.regex.Pattern
+import com.tpay.sdk.api.models.Environment
+import com.tpay.util.ValidationMessages
+
+fun String.isValidBLIKCode(): Boolean {
+  return this.matches(Regex("^[0-9]{6}$"))
+}
+
+fun String.isEmailValid(): Boolean {
+  return if (isBlank()) {
+    false
+  } else {
+    val matcher: Matcher =
+      Pattern
+        .compile("(?:[a-zA-Z0-9!#\$%&'*+/=?^_`{|}~-]+(?:\\.[a-zA-Z0-9!#\$%&'*+/=?^_`{|}~-]+)*|\"(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21\\x23-\\x5b\\x5d-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])*\")@(?:(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?\\.)+[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?|\\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-zA-Z0-9-]*[a-zA-Z0-9]:(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21-\\x5a\\x53-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])+)])")
+        .matcher(this)
+    return matcher.matches()
+  }
+}
+
+fun String.toEnvironment(): Environment {
+  return when (this) {
+    Environment.PRODUCTION.name.lowercase() -> Environment.PRODUCTION
+    Environment.SANDBOX.name.lowercase() -> Environment.SANDBOX
+    else -> throw IllegalArgumentException(ValidationMessages.UNKNOWN_ENVIRONMENT)
+  }
+}

package/android/src/main/java/com/tpay/model/CertificateConfiguration.kt

@@ -0,0 +1,20 @@
+package com.tpay.model
+
+import org.json.JSONObject
+
+data class CertificateConfiguration(
+  val pinnedDomain: String,
+  val publicKeyHash: String
+) {
+  companion object {
+    private const val PINNED_DOMAIN = "pinnedDomain"
+    private const val PUBLIC_KEY_HASH = "publicKeyHash"
+
+    fun fromJson(json: JSONObject): CertificateConfiguration {
+      return CertificateConfiguration(
+        pinnedDomain = json.getString(PINNED_DOMAIN),
+        publicKeyHash = json.getString(PUBLIC_KEY_HASH)
+      )
+    }
+  }
+}

package/android/src/main/java/com/tpay/model/Configuration.kt

@@ -0,0 +1,5 @@
+package com.tpay.model
+
+interface Configuration {
+  fun validate()
+}

package/android/src/main/java/com/tpay/model/ConfigurationMerchant.kt

@@ -0,0 +1,33 @@
+package com.tpay.model
+
+import org.json.JSONObject
+import com.tpay.sdk.api.models.PaymentMethod
+import com.tpay.extension.ValidationException
+import com.tpay.util.*
+import com.tpay.sdk.api.models.Environment
+import com.tpay.extension.*
+
+data class ConfigurationMerchant(
+  val authorization: MerchantAuthorization,
+  val environment: Environment,
+  val certificateConfiguration: CertificateConfiguration,
+  val walletConfiguration: WalletConfiguration?
+) {
+  companion object {
+    private const val AUTHORIZATION = "authorization"
+    private const val ENVIRONMENT = "environment"
+    private const val CERTIFICATE_PINNING_CONFIGURATION = "certificatePinningConfiguration"
+    private const val WALLET_CONFIGURATION = "walletConfiguration"
+
+    fun fromJson(json: JSONObject): ConfigurationMerchant = json.run {
+      ConfigurationMerchant(
+        authorization = MerchantAuthorization.fromJson(getJSONObject(AUTHORIZATION)),
+        environment = getString(ENVIRONMENT).toEnvironment(),
+        certificateConfiguration = CertificateConfiguration.fromJson(
+          getJSONObject(CERTIFICATE_PINNING_CONFIGURATION)
+        ),
+        walletConfiguration = optJSONObject(WALLET_CONFIGURATION)?.run(WalletConfiguration::fromJson)
+      )
+    }
+  }
+}

package/android/src/main/java/com/tpay/model/Languages.kt

@@ -0,0 +1,24 @@
+package com.tpay.model
+
+import com.tpay.sdk.api.models.Language
+import org.json.JSONObject
+
+data class Languages(
+  val preferredLanguage: Language,
+  val supportedLanguages: List<Language>
+) {
+  companion object {
+    private const val PREFERRED_LANGUAGE = "preferredLanguage"
+    private const val SUPPORTED_LANGUAGES_ARRAY = "supportedLanguages"
+
+    fun fromJson(json: JSONObject): Languages {
+      val supportedLanguagesArray = json.getJSONArray(SUPPORTED_LANGUAGES_ARRAY)
+      return Languages(
+        preferredLanguage = Language.valueOf(json.getString(PREFERRED_LANGUAGE).uppercase()),
+        supportedLanguages = (0 until supportedLanguagesArray.length()).map { index ->
+          Language.valueOf(supportedLanguagesArray.getString(index).uppercase())
+        }
+      )
+    }
+  }
+}

package/android/src/main/java/com/tpay/model/LocalizedString.kt

@@ -0,0 +1,21 @@
+package com.tpay.model
+
+import com.tpay.sdk.api.models.Language
+import org.json.JSONObject
+
+class LocalizedString(
+  val language: Language,
+  val value: String
+) {
+  companion object {
+    private const val LANGUAGE = "language"
+    private const val VALUE = "value"
+
+    fun fromJson(json: JSONObject): LocalizedString {
+      return LocalizedString(
+        language = Language.valueOf(json.getString(LANGUAGE).uppercase()),
+        value = json.getString(VALUE)
+      )
+    }
+  }
+}

package/android/src/main/java/com/tpay/model/MerchantAuthorization.kt

@@ -0,0 +1,20 @@
+package com.tpay.model
+
+import org.json.JSONObject
+
+data class MerchantAuthorization(
+  val clientId: String,
+  val clientSecret: String
+) {
+  companion object {
+    private const val CLIENT_ID = "clientId"
+    private const val CLIENT_SECRET = "clientSecret"
+
+    fun fromJson(json: JSONObject): MerchantAuthorization {
+      return MerchantAuthorization(
+        clientId = json.getString(CLIENT_ID),
+        clientSecret = json.getString(CLIENT_SECRET)
+      )
+    }
+  }
+}

package/android/src/main/java/com/tpay/model/MerchantDetails.kt

@@ -0,0 +1,32 @@
+package com.tpay.model
+
+import org.json.JSONObject
+
+data class MerchantDetails(
+  val displayNames: List<LocalizedString>,
+  val merchantHeadquarters: List<LocalizedString>,
+  val regulations: List<LocalizedString>,
+) {
+  companion object {
+    private const val MERCHANT_DISPLAY_NAMES = "merchantDisplayName"
+    private const val MERCHANT_CITIES = "merchantHeadquarters"
+    private const val REGULATIONS = "regulations"
+
+    fun fromJson(json: JSONObject): MerchantDetails {
+      val displayNamesArray = json.getJSONArray(MERCHANT_DISPLAY_NAMES)
+      val merchantHeadquartersArray = json.getJSONArray(MERCHANT_CITIES)
+      val regulationsArray = json.getJSONArray(REGULATIONS)
+      return MerchantDetails(
+        displayNames = (0 until displayNamesArray.length()).map {
+          LocalizedString.fromJson(displayNamesArray.getJSONObject(it))
+        },
+        merchantHeadquarters = (0 until merchantHeadquartersArray.length()).map {
+          LocalizedString.fromJson(merchantHeadquartersArray.getJSONObject(it))
+        },
+        regulations = (0 until regulationsArray.length()).map {
+          LocalizedString.fromJson(regulationsArray.getJSONObject(it))
+        }
+      )
+    }
+  }
+}

package/android/src/main/java/com/tpay/model/PaymentMethods.kt

@@ -0,0 +1,90 @@
+package com.tpay.model
+
+import org.json.JSONObject
+import com.tpay.sdk.api.models.PaymentMethod
+import com.tpay.sdk.api.models.DigitalWallet
+import com.tpay.sdk.api.models.InstallmentPayment
+import com.tpay.extension.ValidationException
+
+class PaymentMethods(val methods: List<PaymentMethod>) {
+  companion object {
+    private const val UNKNOWN_PAYMENT_METHOD_MESSAGE = "Unknown payment method"
+    private const val UNKNOWN_DIGITAL_WALLET_MESSAGE = "Unknown digital wallet"
+    private const val UNKNOWN_INSTALLMENT_PAYMENT_MESSAGE = "Unknown installment payment"
+    private const val DEFINE_PAYMENT_METHODS_MESSAGE = "Define payment methods"
+    private const val APPLE_PAY_INDEX = 1
+    private const val METHODS_ARRAY = "methods"
+    private const val WALLETS_ARRAY = "wallets"
+    private const val INSTALLMENT_PAYMENTS_ARRAY = "installmentPayments"
+    private const val BLIK_INDEX = 0
+    private const val TRANSFER_INDEX = 1
+    private const val CARD_INDEX = 2
+    private const val RATY_PEKAO_INDEX = 0
+    private const val APPLE_PAY = "applePay"
+    private const val GOOGLE_PAY = "googlePay"
+    private const val RATY_PEKAO = "ratyPekao"
+    private const val BLIK = "blik"
+    private const val CARD = "card"
+    private const val TRANSFER = "transfer"
+
+    fun fromJson(json: JSONObject): PaymentMethods {
+      val paymentMethodsArray = json.getJSONArray(METHODS_ARRAY)
+      val digitalWalletsArray = json.optJSONArray(WALLETS_ARRAY)
+      val installmentPaymentsArray = json.optJSONArray(INSTALLMENT_PAYMENTS_ARRAY)
+
+      val wallets = digitalWalletsArray?.let { array ->
+        (0 until array.length())
+          .map { index -> array.getString(index) }
+          .filter { value -> value != APPLE_PAY }
+          .map { value ->
+            when (value) {
+              GOOGLE_PAY -> DigitalWallet.GOOGLE_PAY
+              else -> throw ValidationException(UNKNOWN_DIGITAL_WALLET_MESSAGE)
+            }
+          }
+      } ?: emptyList()
+
+      val installmentPayments = installmentPaymentsArray?.let { array ->
+        (0 until array.length())
+          .map { index -> array.getString(index) }
+          .map { value ->
+            when (value) {
+              RATY_PEKAO -> InstallmentPayment.RATY_PEKAO
+              else -> throw ValidationException(UNKNOWN_INSTALLMENT_PAYMENT_MESSAGE)
+            }
+          }
+      } ?: emptyList()
+
+      val paymentMethods = (0 until paymentMethodsArray.length())
+        .map { index -> paymentMethodsArray.getString(index) }
+        .map { index ->
+          when (index) {
+            BLIK -> PaymentMethod.Blik
+            TRANSFER -> PaymentMethod.Pbl
+            CARD -> PaymentMethod.Card
+            else -> throw ValidationException(UNKNOWN_PAYMENT_METHOD_MESSAGE)
+          }
+        }
+        .let { methods ->
+          if (wallets.isNotEmpty()) {
+            methods + PaymentMethod.DigitalWallets(wallets)
+          } else {
+            methods
+          }
+        }
+        .let { methods ->
+          if (installmentPayments.isNotEmpty()) {
+            methods + PaymentMethod.InstallmentPayments(installmentPayments)
+          } else {
+            methods
+          }
+        }
+
+      if (paymentMethods.isEmpty()) {
+        throw ValidationException(DEFINE_PAYMENT_METHODS_MESSAGE)
+      }
+
+      return PaymentMethods(methods = paymentMethods)
+    }
+  }
+}

package/android/src/main/java/com/tpay/model/TpayConfiguration.kt

@@ -0,0 +1,50 @@
+package com.tpay.model
+
+import org.json.JSONObject
+import com.tpay.sdk.api.models.PaymentMethod
+import com.tpay.extension.ValidationException
+import com.tpay.util.*
+import com.tpay.sdk.api.models.Environment
+import com.tpay.extension.*
+
+data class TpayConfiguration(
+  val merchant: ConfigurationMerchant,
+  val merchantDetails: MerchantDetails,
+  val languages: Languages,
+  val paymentMethods: PaymentMethods,
+) : Configuration {
+  override fun validate() {
+    val allLanguages = (languages.supportedLanguages + languages.preferredLanguage).distinct()
+    val displayNameLanguages = merchantDetails.displayNames.map { localization -> localization.language }
+    val merchantHeadquartersLanguages = merchantDetails.merchantHeadquarters.map { localization -> localization.language }
+    val regulationLanguages = merchantDetails.regulations.map { localization -> localization.language }
+    if (
+      !displayNameLanguages.containsAll(allLanguages) ||
+      !merchantHeadquartersLanguages.containsAll(allLanguages) ||
+      !regulationLanguages.containsAll(allLanguages)
+    ) {
+      throw ValidationException(ValidationMessages.PROVIDE_LOCALIZATION_MESSAGE)
+    }
+
+    if (merchant.authorization.clientId.isBlank() || merchant.authorization.clientSecret.isBlank()) {
+      throw ValidationException(ValidationMessages.CREDENTIALS_BLANK)
+    }
+  }
+
+  companion object {
+    private const val MERCHANT = "merchant"
+    private const val MERCHANT_DETAILS = "merchantDetails"
+    private const val LANGUAGES = "languages"
+    private const val PAYMENT_METHODS = "paymentMethods"
+
+    fun fromJson(json: String): TpayConfiguration = JSONObject(json).run {
+      TpayConfiguration(
+        merchant = ConfigurationMerchant.fromJson(getJSONObject(MERCHANT)),
+        merchantDetails = MerchantDetails.fromJson(getJSONObject(MERCHANT_DETAILS)),
+        languages = Languages.fromJson(getJSONObject(LANGUAGES)),
+        paymentMethods = PaymentMethods.fromJson(getJSONObject(PAYMENT_METHODS)),
+      )
+    }
+  }
+}
+