react-native-tpay 0.3.0

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

@@ -0,0 +1,14 @@
+package com.tpay.model
+
+import com.tpay.model.googlePay.GooglePayConfiguration
+import org.json.JSONObject
+
+data class WalletConfiguration(val googlePay: GooglePayConfiguration?) {
+  companion object {
+    private const val GOOGLE_PAY = "googlePay"
+
+    fun fromJson(json: JSONObject): WalletConfiguration = json.run {
+      WalletConfiguration(googlePay = optJSONObject(GOOGLE_PAY)?.run(GooglePayConfiguration::fromJson))
+    }
+  }
+}

package/android/src/main/java/com/tpay/model/googlePay/GooglePayConfiguration.kt

@@ -0,0 +1,13 @@
+package com.tpay.model.googlePay
+
+import org.json.JSONObject
+
+data class GooglePayConfiguration(val merchantId: String) {
+  companion object {
+    private const val MERCHANT_ID = "merchantId"
+
+    fun fromJson(json: JSONObject) = json.run {
+      GooglePayConfiguration(merchantId = getString(MERCHANT_ID))
+    }
+  }
+}

package/android/src/main/java/com/tpay/model/googlePay/GooglePayConfigureResult.kt

@@ -0,0 +1,6 @@
+package com.tpay.model.googlePay
+
+sealed class GooglePayConfigureResult {
+  object Success : GooglePayConfigureResult()
+  data class Error(val errorMessage: String?) : GooglePayConfigureResult()
+}

package/android/src/main/java/com/tpay/model/googlePay/GooglePayUtilsConfiguration.kt

@@ -0,0 +1,57 @@
+package com.tpay.model.googlePay
+
+import com.tpay.sdk.api.screenless.googlePay.GooglePayEnvironment
+import org.json.JSONObject
+import com.tpay.extension.ValidationException
+
+data class GooglePayUtilsConfiguration(
+  val price: Double,
+  val merchantName: String,
+  val merchantId: String,
+  val environment: GooglePayEnvironment,
+  val customRequestCode: Int? = null
+) {
+  fun validate() {
+    if (price <= 0) {
+      throw ValidationException(PRICE_INVALID)
+    }
+    if (merchantName.isBlank()) {
+      throw ValidationException(MERCHANT_NAME_BLANK)
+    }
+    if (merchantId.isBlank()) {
+      throw ValidationException(MERCHANT_ID_BLANK)
+    }
+    customRequestCode?.run {
+      if (this < 0) {
+        throw ValidationException(CUSTOM_REQUEST_CODE_NEGATIVE)
+      }
+    }
+  }
+
+  companion object {
+    private const val PRICE = "price"
+    private const val MERCHANT_NAME = "merchantName"
+    private const val MERCHANT_ID = "merchantId"
+    private const val ENVIRONMENT = "environment"
+    private const val CUSTOM_REQUEST_CODE = "customRequestCode"
+    private const val ENVIRONMENT_PRODUCTION = "production"
+    private const val ENVIRONMENT_TEST = "test"
+    private const val UNKNOWN_ENVIRONMENT_MESSAGE = "Unknown Google Pay environment"
+    private const val PRICE_INVALID = "Price is invalid"
+    private const val MERCHANT_NAME_BLANK = "Merchant name cannot be blank"
+    private const val MERCHANT_ID_BLANK = "Merchant id cannot be blank"
+    private const val CUSTOM_REQUEST_CODE_NEGATIVE = "Custom request code cannot be negative"
+
+    fun fromJson(json: String): GooglePayUtilsConfiguration {
+      val rootJson = JSONObject(json)
+
+      return GooglePayUtilsConfiguration(
+        price = rootJson.getDouble(PRICE),
+        merchantName = rootJson.getString(MERCHANT_NAME),
+        merchantId = rootJson.getString(MERCHANT_ID),
+        environment = GooglePayEnvironment.valueOf(rootJson.getString(ENVIRONMENT).uppercase()),
+        customRequestCode = rootJson.optInt(CUSTOM_REQUEST_CODE)
+      )
+    }
+  }
+}

package/android/src/main/java/com/tpay/model/screenless/AmbiguousBLIKAlias.kt

@@ -0,0 +1,35 @@
+package com.tpay.model.screenless
+
+import org.json.JSONObject
+import com.tpay.sdk.api.screenless.blik.AmbiguousAlias
+
+data class AmbiguousBLIKAlias(
+  val name: String,
+  val code: String
+) {
+  fun toJson(): String {
+    return JSONObject().apply {
+      put(NAME, name)
+      put(CODE, code)
+    }.toString()
+  }
+
+  fun toAmbiguousAlias(): AmbiguousAlias {
+    return AmbiguousAlias(
+      name = name,
+      code = code
+    )
+  }
+
+  companion object {
+    private const val NAME = "name"
+    private const val CODE = "code"
+
+    fun fromJson(jsonObject: JSONObject): AmbiguousBLIKAlias = jsonObject.run {
+      AmbiguousBLIKAlias(
+        name = getString(NAME),
+        code = getString(CODE)
+      )
+    }
+  }
+}

package/android/src/main/java/com/tpay/model/screenless/AmbiguousBLIKPayment.kt

@@ -0,0 +1,26 @@
+package com.tpay.model.screenless
+
+import com.tpay.sdk.api.models.BlikAlias
+import org.json.JSONObject
+import com.tpay.sdk.api.screenless.blik.*
+import com.tpay.extension.*
+
+data class AmbiguousBLIKPayment(
+  val transactionId: String,
+  val blikAlias: BlikAlias,
+  val ambiguousBlikAlias: AmbiguousBLIKAlias
+) {
+  companion object {
+    private const val TRANSACTION_ID = "transactionId"
+    private const val BLIK_ALIAS = "blikAlias"
+    private const val AMBIGUOUS_ALIAS = "ambiguousAlias"
+
+    fun fromJson(json: String): AmbiguousBLIKPayment = JSONObject(json).run {
+      AmbiguousBLIKPayment(
+        transactionId = getString(TRANSACTION_ID),
+        blikAlias = getJSONObject(BLIK_ALIAS).run { getBlikAlias() },
+        ambiguousBlikAlias = AmbiguousBLIKAlias.fromJson(getJSONObject(AMBIGUOUS_ALIAS))
+      )
+    }
+  }
+}

package/android/src/main/java/com/tpay/model/screenless/BLIKScreenlessPayment.kt

@@ -0,0 +1,28 @@
+package com.tpay.model.screenless
+
+import com.tpay.sdk.api.models.BlikAlias
+import org.json.JSONObject
+import com.tpay.util.ValidationMessages
+import com.tpay.extension.*
+
+class BLIKScreenlessPayment(json: String) : ScreenlessPayment(json) {
+  val code: String? = actuallyOptString(CODE)
+  val alias: BlikAlias? = optJSONObject(ALIAS)?.run { getBlikAlias() }
+
+  override fun validate() {
+    super.validate()
+    if (code.isNullOrBlank() && alias == null) {
+      throw ValidationException(ValidationMessages.BLIK_CODE_AND_ALIAS_NULL)
+    }
+    code?.let {
+      if (!code.isValidBLIKCode()) {
+        throw ValidationException(ValidationMessages.BLIK_CODE_INVALID)
+      }
+    }
+  }
+
+  companion object {
+    private const val CODE = "code"
+    private const val ALIAS = "alias"
+  }
+}

package/android/src/main/java/com/tpay/model/screenless/CreditCardData.kt

@@ -0,0 +1,10 @@
+package com.tpay.model.screenless
+
+import com.tpay.sdk.api.screenless.card.CreditCard
+
+data class CreditCardData(
+  val creditCard: CreditCard,
+  val saveCard: Boolean,
+  val domain: String,
+  val rocText: String?
+)

package/android/src/main/java/com/tpay/model/screenless/CreditCardScreenlessPayment.kt

@@ -0,0 +1,75 @@
+package com.tpay.model.screenless
+
+import com.tpay.sdk.api.screenless.card.Recursive
+import com.tpay.sdk.api.screenless.card.CreditCard
+import com.tpay.sdk.api.models.transaction.*
+import java.text.SimpleDateFormat
+import com.tpay.util.ValidationMessages
+import com.tpay.extension.ValidationException
+import com.tpay.extension.actuallyOptString
+
+class CreditCardScreenlessPayment(json: String) : ScreenlessPayment(json) {
+  val creditCardData: CreditCardData? = optJSONObject(CREDIT_CARD)?.let { creditCardJson ->
+    creditCardJson.getJSONObject(CONFIG).let { configJson ->
+      CreditCardData(
+        creditCard = CreditCard(
+          cardNumber = creditCardJson.getString(CARD_NUMBER),
+          expirationDate = ExpirationDate.fromJson(
+            creditCardJson.getJSONObject(EXPIRY_DATE)
+          ).toString(),
+          cvv = creditCardJson.getString(CVV)
+        ),
+        saveCard = configJson.getBoolean(SAVE_CARD),
+        domain = configJson.getString(DOMAIN),
+        rocText = configJson.actuallyOptString(ROC_TEXT)
+      )
+    }
+  }
+
+  val recursive: Recursive? = optJSONObject(RECURSIVE)?.run {
+    Recursive(
+      frequency = Frequency.valueOf(getString(FREQUENCY).uppercase()),
+      quantity = optInt(QUANTITY, -1).let { value ->
+        when (value) {
+          -1 -> Quantity.Indefinite
+          else -> Quantity.Specified(value)
+        }
+      },
+      expirationDate = SimpleDateFormat(DATE_FORMAT).parse(getString(END_DATE))
+    )
+  }
+
+  val cardToken: String? = actuallyOptString(CARD_TOKEN)
+
+  override fun validate() {
+    super.validate()
+
+    if (cardToken == null && creditCardData == null) {
+      throw ValidationException(ValidationMessages.CREDIT_CARD_DATA_NULL)
+    }
+  }
+
+  companion object {
+    private const val CREDIT_CARD = "creditCard"
+    private const val RECURSIVE = "recursive"
+    private const val CARD_NUMBER = "cardNumber"
+    private const val EXPIRY_DATE = "expiryDate"
+    private const val END_DATE = "endDate"
+    private const val CVV = "cvv"
+    private const val FREQUENCY = "frequency"
+    private const val QUANTITY = "quantity"
+    private const val CARD_TOKEN = "creditCardToken"
+    private const val SAVE_CARD = "shouldSave"
+    private const val DOMAIN = "domain"
+    private const val ROC_TEXT = "rocText"
+    private const val CONFIG = "config"
+
+    private const val DAILY = "daily"
+    private const val WEEKLY = "weekly"
+    private const val MONTHLY = "monthly"
+    private const val QUARTERLY = "quarterly"
+    private const val YEARLY = "yearly"
+
+    private const val DATE_FORMAT = "yyyy-MM-dd"
+  }
+}

package/android/src/main/java/com/tpay/model/screenless/ExpirationDate.kt

@@ -0,0 +1,22 @@
+package com.tpay.model.screenless
+
+import org.json.JSONObject
+
+data class ExpirationDate(val month: String, val year: String) {
+  override fun toString(): String {
+    return "$month$SEPARATOR$year"
+  }
+
+  companion object {
+    private const val MONTH = "month"
+    private const val YEAR = "year"
+    private const val SEPARATOR = "/"
+
+    fun fromJson(jsonObject: JSONObject): ExpirationDate {
+      return ExpirationDate(
+        month = jsonObject.getString(MONTH),
+        year = jsonObject.getString(YEAR)
+      )
+    }
+  }
+}

package/android/src/main/java/com/tpay/model/screenless/GooglePayScreenlessPayment.kt

@@ -0,0 +1,19 @@
+package com.tpay.model.screenless
+
+import com.tpay.util.ValidationMessages
+import com.tpay.extension.*
+
+class GooglePayScreenlessPayment(json: String) : ScreenlessPayment(json) {
+  val token: String = getString(TOKEN)
+
+  override fun validate() {
+    super.validate()
+    if (token.isBlank()) {
+      throw ValidationException(ValidationMessages.GOOGLE_PAY_TOKEN_BLANK)
+    }
+  }
+
+  companion object {
+    private const val TOKEN = "token"
+  }
+}

package/android/src/main/java/com/tpay/model/screenless/PaymentConstraintType.kt

@@ -0,0 +1,5 @@
+package com.tpay.model.screenless
+
+enum class PaymentConstraintType {
+  AMOUNT
+}

package/android/src/main/java/com/tpay/model/screenless/RatyPekaoScreenlessPayment.kt

@@ -0,0 +1,9 @@
+package com.tpay.model.screenless
+
+class RatyPekaoScreenlessPayment(json: String) : ScreenlessPayment(json) {
+  val channelId: Int = getInt(CHANNEL_ID)
+
+  companion object {
+    private const val CHANNEL_ID = "channelId"
+  }
+}

package/android/src/main/java/com/tpay/model/screenless/ScreenlessPayment.kt

@@ -0,0 +1,87 @@
+package com.tpay.model.screenless
+
+import org.json.JSONObject
+import com.tpay.util.ValidationMessages
+import com.tpay.extension.*
+import com.tpay.util.JsonUtil
+import com.tpay.sdk.api.models.payer.Payer
+import com.tpay.sdk.api.screenless.Redirects
+import com.tpay.sdk.api.screenless.Notifications
+import com.tpay.sdk.api.models.Language
+
+open class ScreenlessPayment(json: String) : JSONObject(json) {
+  val amount: Double
+  val description: String
+  val hiddenDescription: String?
+  val language: Language?
+  val payer: Payer
+  val redirects: Redirects?
+  val notifications: Notifications?
+
+  init {
+    getJSONObject(PAYMENT_DETAILS).let { paymentDetailsJson ->
+      amount = paymentDetailsJson.getDouble(AMOUNT)
+      description = paymentDetailsJson.getString(DESCRIPTION)
+      hiddenDescription = paymentDetailsJson.actuallyOptString(HIDDEN_DESCRIPTION)
+      language = paymentDetailsJson.actuallyOptString(LANGUAGE)?.uppercase()?.let { lang ->
+        Language.valueOf(lang)
+      }
+    }
+    payer = JsonUtil.getPayer(getJSONObject(PAYER).toString())
+    optJSONObject(CALLBACKS).let { callbacksJson ->
+      if (callbacksJson == null) {
+        redirects = null
+        notifications = null
+      } else {
+        redirects = callbacksJson.optJSONObject(REDIRECTS)?.let { redirectsJson ->
+          Redirects(
+            successUrl = redirectsJson.getString(SUCCESS_URL),
+            errorUrl = redirectsJson.getString(ERROR_URL)
+          )
+        }
+        notifications = callbacksJson.optJSONObject(NOTIFICATIONS)?.let { notificationsJson ->
+          Notifications(
+            notificationUrl = notificationsJson.getString(URL),
+            notificationEmail = notificationsJson.getString(EMAIL)
+          )
+        }
+      }
+    }
+  }
+
+  open fun validate() {
+    if (amount <= 0) {
+      throw ValidationException(ValidationMessages.AMOUNT_NEGATIVE)
+    }
+    if (description.isBlank()) {
+      throw ValidationException(ValidationMessages.DESCRIPTION_BLANK)
+    }
+    if (!payer.email.isEmailValid()) {
+      throw ValidationException(ValidationMessages.PAYER_EMAIL_INVALID)
+    }
+    notifications?.let {
+      if (!notifications.notificationEmail.isEmailValid()) {
+        throw ValidationException(ValidationMessages.NOTIFICATION_EMAIL_INVALID)
+      }
+    }
+  }
+
+  companion object {
+    const val PAYMENT_DETAILS = "paymentDetails"
+    const val AMOUNT = "amount"
+    const val DESCRIPTION = "description"
+    const val HIDDEN_DESCRIPTION = "hiddenDescription"
+    const val LANGUAGE = "language"
+    const val PAYER = "payer"
+    const val CALLBACKS = "callbacks"
+    const val REDIRECTS = "redirects"
+    const val SUCCESS_URL = "successUrl"
+    const val ERROR_URL = "errorUrl"
+    const val NOTIFICATIONS = "notifications"
+    const val URL = "url"
+    const val EMAIL = "email"
+    const val DELAY_MILLIS = "delayMillis"
+    const val MAX_REQUEST_COUNT = "maxRequestCount"
+    const val STOP_ON_FIRST_REQUEST_ERROR = "stopOnFirstRequestError"
+  }
+}

package/android/src/main/java/com/tpay/model/screenless/TransferScreenlessPayment.kt

@@ -0,0 +1,9 @@
+package com.tpay.model.screenless
+
+class TransferScreenlessPayment(json: String) : ScreenlessPayment(json) {
+  val channelId: Int = getInt(CHANNEL_ID)
+
+  companion object {
+    private const val CHANNEL_ID = "channelId"
+  }
+}

package/android/src/main/java/com/tpay/util/JsonUtil.kt

@@ -0,0 +1,178 @@
+package com.tpay.util
+
+import com.tpay.sdk.api.models.transaction.SingleTransaction
+import org.json.JSONObject
+import com.tpay.sdk.api.models.payer.Payer
+import com.tpay.sdk.api.models.*
+import com.tpay.sdk.api.paycard.CreditCardBrand
+import com.tpay.sdk.api.models.PayerContext
+import com.tpay.sdk.api.cardTokenPayment.CardTokenTransaction
+import com.tpay.sdk.api.screenless.Notifications
+import com.tpay.sdk.api.addCard.Tokenization
+import com.tpay.extension.*
+import com.tpay.util.ValidationMessages
+import com.tpay.extension.ValidationException
+
+object JsonUtil {
+  private const val NAME = "name"
+  private const val EMAIL = "email"
+  private const val PHONE = "phone"
+  private const val ADDRESS = "address"
+  private const val CITY = "city"
+  private const val COUNTRY_CODE = "countryCode"
+  private const val POSTAL_CODE = "postalCode"
+  private const val AMOUNT = "amount"
+  private const val DESCRIPTION = "description"
+  private const val PAYER = "payer"
+  private const val CARD_TOKEN = "cardToken"
+  private const val PAYER_CONTEXT = "payerContext"
+  private const val NOTIFICATIONS = "notifications"
+  private const val AUTOMATIC_PAYMENT_METHODS = "automaticPaymentMethods"
+  private const val TOKENIZED_CARDS = "tokenizedCards"
+  private const val BLIK_ALIAS = "blikAlias"
+  private const val TOKEN = "token"
+  private const val CARD_TAIL = "cardTail"
+  private const val BRAND = "brand"
+  private const val MASTERCARD = "mastercard"
+  private const val VISA = "visa"
+  private const val VALUE = "value"
+  private const val LABEL = "label"
+  private const val URL = "url"
+  private const val NOTIFICATION_URL = "notificationUrl"
+  private const val IS_REGISTERED = "isRegistered"
+
+  fun getTokenization(json: String): Tokenization {
+    val rootJson = JSONObject(json)
+
+    return Tokenization(
+      payer = getPayer(rootJson.optJSONObject(PAYER)?.toString()),
+      notificationUrl = rootJson.getString(NOTIFICATION_URL)
+    )
+  }
+
+  fun getPayer(json: String?): Payer {
+    json ?: return Payer(
+      name = "",
+      email = "",
+      phone = null,
+      address = null
+    )
+
+    val rootJson = JSONObject(json)
+
+    val name = rootJson.actuallyOptString(NAME)
+    val email = rootJson.actuallyOptString(EMAIL)
+    val phone = rootJson.actuallyOptString(PHONE)
+
+    val addressJson = rootJson.optJSONObject(ADDRESS)
+    val address = addressJson?.actuallyOptString(ADDRESS)
+    val city = addressJson?.actuallyOptString(CITY)
+    val countryCode = addressJson?.actuallyOptString(COUNTRY_CODE)
+    val postalCode = addressJson?.actuallyOptString(POSTAL_CODE)
+
+    return Payer(
+      name = name ?: "",
+      email = email ?: "",
+      phone = phone,
+      address = address?.run {
+        Payer.Address(
+          address = address,
+          city = city,
+          countryCode = countryCode,
+          postalCode = postalCode
+        )
+      }
+    )
+  }
+
+  fun getCardTokenTransaction(json: String): CardTokenTransaction {
+    val rootJson = JSONObject(json)
+
+    val amount = rootJson.getDouble(AMOUNT)
+    val description = rootJson.getString(DESCRIPTION)
+    val payerJson = rootJson.optJSONObject(PAYER)
+    payerJson ?: throw ValidationException(ValidationMessages.PAYER_REQUIRED_TOKEN_PAYMENT)
+    val payer = getPayer(payerJson.toString())
+    val cardToken = rootJson.getString(CARD_TOKEN)
+
+    val notifications = rootJson.optJSONObject(NOTIFICATIONS)?.let { json ->
+      Notifications(
+        notificationUrl = json.getString(URL),
+        notificationEmail = json.getString(EMAIL)
+      )
+    }
+
+    return CardTokenTransaction(
+      amount = amount,
+      description = description,
+      payer = payer,
+      cardToken = cardToken,
+      notifications = notifications
+    )
+  }
+
+  fun getSingleTransaction(json: String): SingleTransaction {
+    val rootJson = JSONObject(json)
+
+    val amount = rootJson.getDouble(AMOUNT)
+    val description = rootJson.getString(DESCRIPTION)
+
+    val notifications = rootJson.optJSONObject(NOTIFICATIONS)?.let { json ->
+      Notifications(
+        notificationUrl = json.getString(URL),
+        notificationEmail = json.getString(EMAIL)
+      )
+    }
+
+    val payerContextJson = rootJson.getJSONObject(PAYER_CONTEXT)
+
+    val payerJson = payerContextJson.optJSONObject(PAYER)
+    val payer = getPayer(payerJson?.toString())
+
+    val automaticPaymentMethodsJson = payerContextJson.optJSONObject(AUTOMATIC_PAYMENT_METHODS)
+
+    val (tokenizedCards, blikAlias) = automaticPaymentMethodsJson?.let { automaticPaymentsJson ->
+      val tokenizedCardsArray = automaticPaymentMethodsJson.optJSONArray(TOKENIZED_CARDS)
+      val blikAliasJson = automaticPaymentMethodsJson.optJSONObject(BLIK_ALIAS)
+
+      val tokenizedCards: List<TokenizedCard> = tokenizedCardsArray?.run {
+        (0 until length())
+          .map { index -> getJSONObject(index) }
+          .map { tokenizedCardObject ->
+            TokenizedCard(
+              token = tokenizedCardObject.getString(TOKEN),
+              cardTail = tokenizedCardObject.getString(CARD_TAIL),
+              brand = CreditCardBrand.valueOf(tokenizedCardObject.getString(BRAND).uppercase())
+            )
+          }
+      } ?: emptyList<TokenizedCard>()
+
+      val blikAlias: BlikAlias? = blikAliasJson?.run {
+        val label = getString(LABEL)
+        val value = getString(VALUE)
+        if (getBoolean(IS_REGISTERED)) {
+          BlikAlias.Registered(value, label)
+        } else {
+          BlikAlias.NotRegistered(value, label)
+        }
+      } ?: null
+
+      tokenizedCards to blikAlias
+    } ?: emptyList<TokenizedCard>() to null
+
+    val payerContext = PayerContext(
+      payer = payer,
+      automaticPaymentMethods = AutomaticPaymentMethods(
+        blikAlias = blikAlias,
+        tokenizedCards = tokenizedCards
+      )
+    )
+
+    return SingleTransaction(
+      amount = amount,
+      description = description,
+      payerContext = payerContext,
+      notifications = notifications
+    )
+  }
+}

package/android/src/main/java/com/tpay/util/TpayBackpressUtil.kt

@@ -0,0 +1,23 @@
+package com.tpay.util
+
+import com.tpay.sdk.api.models.Presentable
+import java.util.ArrayDeque
+
+object TpayBackpressUtil {
+  private var sheet: Presentable? = null
+
+  val isModuleVisible: Boolean
+    get() = sheet != null
+
+  fun set(sheet: Presentable) {
+    this.sheet = sheet
+  }
+
+  fun remove() {
+    sheet = null
+  }
+
+  fun onBackPressed() {
+    sheet?.onBackPressed()
+  }
+}