@stripe/stripe-react-native 0.42.0 → 0.43.0

package/android/src/main/java/com/reactnativestripesdk/PaymentMethodCreateParamsFactory.kt

@@ -1,12 +1,21 @@
 package com.reactnativestripesdk
 
 import com.facebook.react.bridge.ReadableMap
-import com.reactnativestripesdk.utils.*
+import com.reactnativestripesdk.utils.getBooleanOrFalse
+import com.reactnativestripesdk.utils.getMapOrNull
+import com.reactnativestripesdk.utils.getValOr
 import com.reactnativestripesdk.utils.mapToBillingDetails
 import com.reactnativestripesdk.utils.mapToMetadata
+import com.reactnativestripesdk.utils.mapToPaymentIntentFutureUsage
 import com.reactnativestripesdk.utils.mapToUSBankAccountHolderType
 import com.reactnativestripesdk.utils.mapToUSBankAccountType
-import com.stripe.android.model.*
+import com.stripe.android.model.ConfirmPaymentIntentParams
+import com.stripe.android.model.ConfirmSetupIntentParams
+import com.stripe.android.model.ConfirmStripeIntentParams
+import com.stripe.android.model.MandateDataParams
+import com.stripe.android.model.PaymentMethod
+import com.stripe.android.model.PaymentMethodCreateParams
+import com.stripe.android.model.PaymentMethodOptionsParams
 
 class PaymentMethodCreateParamsFactory(
   private val paymentMethodData: ReadableMap?,
@@ -14,10 +23,11 @@ class PaymentMethodCreateParamsFactory(
   private val cardFieldView: CardFieldView?,
   private val cardFormView: CardFormView?,
 ) {
-  private val billingDetailsParams = mapToBillingDetails(
-    getMapOrNull(paymentMethodData, "billingDetails"),
-    cardFieldView?.cardAddress ?: cardFormView?.cardAddress
-  )
+  private val billingDetailsParams =
+    mapToBillingDetails(
+      getMapOrNull(paymentMethodData, "billingDetails"),
+      cardFieldView?.cardAddress ?: cardFormView?.cardAddress,
+    )
   private val metadataParams: Map<String, String>? =
     mapToMetadata(getMapOrNull(paymentMethodData, "metadata"))
 
@@ -62,25 +72,25 @@ class PaymentMethodCreateParamsFactory(
     return PaymentMethodCreateParams.create(
       ideal = idealParams,
       billingDetails = billingDetailsParams,
-      metadata = metadataParams
+      metadata = metadataParams,
     )
   }
 
   @Throws(PaymentMethodCreateParamsException::class)
-  private fun createAlipayParams(): PaymentMethodCreateParams {
-    return PaymentMethodCreateParams.createAlipay()
-  }
+  private fun createAlipayParams(): PaymentMethodCreateParams = PaymentMethodCreateParams.createAlipay()
 
   @Throws(PaymentMethodCreateParamsException::class)
   private fun createSofortParams(): PaymentMethodCreateParams {
-    val country = getValOr(paymentMethodData, "country", null) ?: run {
-      throw PaymentMethodCreateParamsException("You must provide bank account country")
-    }
+    val country =
+      getValOr(paymentMethodData, "country", null)
+        ?: run {
+          throw PaymentMethodCreateParamsException("You must provide bank account country")
+        }
 
     return PaymentMethodCreateParams.create(
       PaymentMethodCreateParams.Sofort(country = country),
       billingDetailsParams,
-      metadata = metadataParams
+      metadata = metadataParams,
     )
   }
 
@@ -89,7 +99,7 @@ class PaymentMethodCreateParamsFactory(
     billingDetailsParams?.let {
       return PaymentMethodCreateParams.createBancontact(
         billingDetails = it,
-        metadata = metadataParams
+        metadata = metadataParams,
       )
     }
 
@@ -99,14 +109,14 @@ class PaymentMethodCreateParamsFactory(
   @Throws(PaymentMethodCreateParamsException::class)
   private fun createSepaParams(): PaymentMethodCreateParams {
     billingDetailsParams?.let {
-      val iban = getValOr(paymentMethodData, "iban", null) ?: run {
-        throw PaymentMethodCreateParamsException("You must provide IBAN")
-      }
+      val iban =
+        getValOr(paymentMethodData, "iban", null)
+          ?: run { throw PaymentMethodCreateParamsException("You must provide IBAN") }
 
       return PaymentMethodCreateParams.create(
         sepaDebit = PaymentMethodCreateParams.SepaDebit(iban),
         billingDetails = it,
-        metadata = metadataParams
+        metadata = metadataParams,
       )
     }
 
@@ -116,10 +126,7 @@ class PaymentMethodCreateParamsFactory(
   @Throws(PaymentMethodCreateParamsException::class)
   private fun createOXXOParams(): PaymentMethodCreateParams {
     billingDetailsParams?.let {
-      return PaymentMethodCreateParams.createOxxo(
-        billingDetails = it,
-        metadata = metadataParams
-      )
+      return PaymentMethodCreateParams.createOxxo(billingDetails = it, metadata = metadataParams)
     }
 
     throw PaymentMethodCreateParamsException("You must provide billing details")
@@ -128,10 +135,7 @@ class PaymentMethodCreateParamsFactory(
   @Throws(PaymentMethodCreateParamsException::class)
   private fun createGiropayParams(): PaymentMethodCreateParams {
     billingDetailsParams?.let {
-      return PaymentMethodCreateParams.createGiropay(
-        billingDetails = it,
-        metadata = metadataParams
-      )
+      return PaymentMethodCreateParams.createGiropay(billingDetails = it, metadata = metadataParams)
     }
 
     throw PaymentMethodCreateParamsException("You must provide billing details")
@@ -140,10 +144,7 @@ class PaymentMethodCreateParamsFactory(
   @Throws(PaymentMethodCreateParamsException::class)
   private fun createEPSParams(): PaymentMethodCreateParams {
     billingDetailsParams?.let {
-      return PaymentMethodCreateParams.createEps(
-        billingDetails = it,
-        metadata = metadataParams
-      )
+      return PaymentMethodCreateParams.createEps(billingDetails = it, metadata = metadataParams)
     }
 
     throw PaymentMethodCreateParamsException("You must provide billing details")
@@ -158,10 +159,7 @@ class PaymentMethodCreateParamsFactory(
   @Throws(PaymentMethodCreateParamsException::class)
   private fun createP24Params(): PaymentMethodCreateParams {
     billingDetailsParams?.let {
-      return PaymentMethodCreateParams.createP24(
-        billingDetails = it,
-        metadata = metadataParams
-      )
+      return PaymentMethodCreateParams.createP24(billingDetails = it, metadata = metadataParams)
     }
 
     throw PaymentMethodCreateParamsException("You must provide billing details")
@@ -172,7 +170,7 @@ class PaymentMethodCreateParamsFactory(
     val bank = getBooleanOrFalse(paymentMethodData, "testOfflineBank").let { "test_offline_bank" }
     return PaymentMethodCreateParams.create(
       PaymentMethodCreateParams.Fpx(bank),
-      metadata = metadataParams
+      metadata = metadataParams,
     )
   }
 
@@ -181,7 +179,7 @@ class PaymentMethodCreateParamsFactory(
     billingDetailsParams?.let {
       return PaymentMethodCreateParams.createAfterpayClearpay(
         billingDetails = it,
-        metadata = metadataParams
+        metadata = metadataParams,
       )
     }
 
@@ -190,27 +188,30 @@ class PaymentMethodCreateParamsFactory(
 
   @Throws(PaymentMethodCreateParamsException::class)
   private fun createAuBecsDebitParams(): PaymentMethodCreateParams {
-    val formDetails = getMapOrNull(paymentMethodData, "formDetails") ?: run {
-      throw PaymentMethodCreateParamsException("You must provide form details")
-    }
+    val formDetails =
+      getMapOrNull(paymentMethodData, "formDetails")
+        ?: run { throw PaymentMethodCreateParamsException("You must provide form details") }
 
     val bsbNumber = getValOr(formDetails, "bsbNumber") as String
     val accountNumber = getValOr(formDetails, "accountNumber") as String
     val name = getValOr(formDetails, "name") as String
     val email = getValOr(formDetails, "email") as String
 
-    val billingDetails = PaymentMethod.BillingDetails.Builder()
-      .setName(name)
-      .setEmail(email)
-      .build()
+    val billingDetails =
+      PaymentMethod.BillingDetails
+        .Builder()
+        .setName(name)
+        .setEmail(email)
+        .build()
 
     return PaymentMethodCreateParams.create(
-      auBecsDebit = PaymentMethodCreateParams.AuBecsDebit(
-        bsbNumber = bsbNumber,
-        accountNumber = accountNumber
-      ),
+      auBecsDebit =
+        PaymentMethodCreateParams.AuBecsDebit(
+          bsbNumber = bsbNumber,
+          accountNumber = accountNumber,
+        ),
       billingDetails = billingDetails,
-      metadata = metadataParams
+      metadata = metadataParams,
     )
   }
 
@@ -220,60 +221,52 @@ class PaymentMethodCreateParamsFactory(
       billingDetailsParams.address?.country.isNullOrBlank() ||
       billingDetailsParams.email.isNullOrBlank()
     ) {
-      throw PaymentMethodCreateParamsException("Klarna requires that you provide the following billing details: email, country")
+      throw PaymentMethodCreateParamsException(
+        "Klarna requires that you provide the following billing details: email, country",
+      )
     }
 
     return PaymentMethodCreateParams.createKlarna(
       billingDetails = billingDetailsParams,
-      metadata = metadataParams
+      metadata = metadataParams,
     )
   }
 
   @Throws(PaymentMethodCreateParamsException::class)
-  private fun createPayPalParams(): PaymentMethodCreateParams {
-    return PaymentMethodCreateParams.createPayPal(
-      metadata = metadataParams
-    )
-  }
+  private fun createPayPalParams(): PaymentMethodCreateParams = PaymentMethodCreateParams.createPayPal(metadata = metadataParams)
 
   @Throws(PaymentMethodCreateParamsException::class)
-  private fun createAffirmParams(): PaymentMethodCreateParams {
-    return PaymentMethodCreateParams.createAffirm(
+  private fun createAffirmParams(): PaymentMethodCreateParams =
+    PaymentMethodCreateParams.createAffirm(
       billingDetails = billingDetailsParams,
-      metadata = metadataParams
+      metadata = metadataParams,
     )
-  }
 
   @Throws(PaymentMethodCreateParamsException::class)
-  private fun createCashAppParams(): PaymentMethodCreateParams {
-    return PaymentMethodCreateParams.createCashAppPay(
+  private fun createCashAppParams(): PaymentMethodCreateParams =
+    PaymentMethodCreateParams.createCashAppPay(
       billingDetails = billingDetailsParams,
-      metadata = metadataParams
+      metadata = metadataParams,
     )
-  }
 
   @Throws(PaymentMethodCreateParamsException::class)
-  private fun createRevolutPayParams(): PaymentMethodCreateParams {
-    return PaymentMethodCreateParams.createRevolutPay(
+  private fun createRevolutPayParams(): PaymentMethodCreateParams =
+    PaymentMethodCreateParams.createRevolutPay(
       billingDetails = billingDetailsParams,
-      metadata = metadataParams
+      metadata = metadataParams,
     )
-  }
 
   @Throws(PaymentMethodCreateParamsException::class)
   fun createParams(
     clientSecret: String,
     paymentMethodType: PaymentMethod.Type?,
-    isPaymentIntent: Boolean
+    isPaymentIntent: Boolean,
   ): ConfirmStripeIntentParams {
     try {
       return when (paymentMethodType) {
         PaymentMethod.Type.Card -> createCardStripeIntentParams(clientSecret, isPaymentIntent)
-        PaymentMethod.Type.USBankAccount -> createUSBankAccountStripeIntentParams(
-          clientSecret,
-          isPaymentIntent
-        )
-
+        PaymentMethod.Type.USBankAccount ->
+          createUSBankAccountStripeIntentParams(clientSecret, isPaymentIntent)
         PaymentMethod.Type.Affirm -> createAffirmStripeIntentParams(clientSecret, isPaymentIntent)
         PaymentMethod.Type.Ideal,
         PaymentMethod.Type.Alipay,
@@ -291,31 +284,26 @@ class PaymentMethodCreateParamsFactory(
         PaymentMethod.Type.Klarna,
         PaymentMethod.Type.PayPal,
         PaymentMethod.Type.CashAppPay,
-        PaymentMethod.Type.RevolutPay -> {
+        PaymentMethod.Type.RevolutPay,
+        -> {
           val params = createPaymentMethodParams(paymentMethodType)
 
           return if (isPaymentIntent) {
-            ConfirmPaymentIntentParams
-              .createWithPaymentMethodCreateParams(
-                paymentMethodCreateParams = params,
-                clientSecret = clientSecret,
-                setupFutureUsage = mapToPaymentIntentFutureUsage(
-                  getValOr(
-                    options,
-                    "setupFutureUsage"
-                  )
-                ),
-                mandateData = buildMandateDataParams()
-              )
+            ConfirmPaymentIntentParams.createWithPaymentMethodCreateParams(
+              paymentMethodCreateParams = params,
+              clientSecret = clientSecret,
+              setupFutureUsage =
+                mapToPaymentIntentFutureUsage(getValOr(options, "setupFutureUsage")),
+              mandateData = buildMandateDataParams(),
+            )
           } else {
             ConfirmSetupIntentParams.create(
               paymentMethodCreateParams = params,
               clientSecret = clientSecret,
-              mandateData = buildMandateDataParams()
+              mandateData = buildMandateDataParams(),
             )
           }
         }
-
         null -> ConfirmPaymentIntentParams.create(clientSecret)
         else -> {
           throw Exception("This paymentMethodType is not supported yet")
@@ -345,7 +333,7 @@ class PaymentMethodCreateParamsFactory(
   @Throws(PaymentMethodCreateParamsException::class)
   private fun createCardStripeIntentParams(
     clientSecret: String,
-    isPaymentIntent: Boolean
+    isPaymentIntent: Boolean,
   ): ConfirmStripeIntentParams {
     val paymentMethodId = getValOr(paymentMethodData, "paymentMethodId", null)
     val setupFutureUsage = mapToPaymentIntentFutureUsage(getValOr(options, "setupFutureUsage"))
@@ -356,51 +344,50 @@ class PaymentMethodCreateParamsFactory(
         if (cvc != null) PaymentMethodOptionsParams.Card(cvc) else null
 
       return (
-        if (isPaymentIntent)
+        if (isPaymentIntent) {
           ConfirmPaymentIntentParams.createWithPaymentMethodId(
             paymentMethodId,
             paymentMethodOptions = paymentMethodOptionParams,
             clientSecret = clientSecret,
-            setupFutureUsage = setupFutureUsage
-          )
-        else
-          ConfirmSetupIntentParams.create(
-            paymentMethodId,
-            clientSecret
+            setupFutureUsage = setupFutureUsage,
           )
-        )
+        } else {
+          ConfirmSetupIntentParams.create(paymentMethodId, clientSecret)
+        }
+      )
     } else {
       val paymentMethodCreateParams = createCardPaymentMethodParams()
       return (
-        if (isPaymentIntent)
-          ConfirmPaymentIntentParams
-            .createWithPaymentMethodCreateParams(
-              paymentMethodCreateParams,
-              clientSecret,
-              setupFutureUsage = setupFutureUsage
-            )
-        else
-          ConfirmSetupIntentParams
-            .create(paymentMethodCreateParams, clientSecret)
-        )
+        if (isPaymentIntent) {
+          ConfirmPaymentIntentParams.createWithPaymentMethodCreateParams(
+            paymentMethodCreateParams,
+            clientSecret,
+            setupFutureUsage = setupFutureUsage,
+          )
+        } else {
+          ConfirmSetupIntentParams.create(paymentMethodCreateParams, clientSecret)
+        }
+      )
     }
   }
 
   @Throws(PaymentMethodCreateParamsException::class)
   private fun createUSBankAccountStripeIntentParams(
     clientSecret: String,
-    isPaymentIntent: Boolean
+    isPaymentIntent: Boolean,
   ): ConfirmStripeIntentParams {
     // If payment method data is supplied, assume they are passing in the bank details manually
     paymentMethodData?.let {
       if (billingDetailsParams?.name.isNullOrBlank()) {
-        throw PaymentMethodCreateParamsException("When creating a US bank account payment method, you must provide the following billing details: name")
+        throw PaymentMethodCreateParamsException(
+          "When creating a US bank account payment method, you must provide the following billing details: name",
+        )
       }
       return if (isPaymentIntent) {
         ConfirmPaymentIntentParams.createWithPaymentMethodCreateParams(
           paymentMethodCreateParams = createUSBankAccountParams(paymentMethodData),
           clientSecret,
-          setupFutureUsage = mapToPaymentIntentFutureUsage(getValOr(options, "setupFutureUsage"))
+          setupFutureUsage = mapToPaymentIntentFutureUsage(getValOr(options, "setupFutureUsage")),
         )
       } else {
         ConfirmSetupIntentParams.create(
@@ -408,27 +395,27 @@ class PaymentMethodCreateParamsFactory(
           clientSecret = clientSecret,
         )
       }
-    } ?: run {
-      // Payment method is assumed to be already attached through via collectBankAccount
-      return if (isPaymentIntent) {
-        ConfirmPaymentIntentParams.create(
-          clientSecret = clientSecret,
-          paymentMethodType = PaymentMethod.Type.USBankAccount,
-
-        )
-      } else {
-        ConfirmSetupIntentParams.create(
-          clientSecret = clientSecret,
-          paymentMethodType = PaymentMethod.Type.USBankAccount
-        )
-      }
     }
+      ?: run {
+        // Payment method is assumed to be already attached through via collectBankAccount
+        return if (isPaymentIntent) {
+          ConfirmPaymentIntentParams.create(
+            clientSecret = clientSecret,
+            paymentMethodType = PaymentMethod.Type.USBankAccount,
+          )
+        } else {
+          ConfirmSetupIntentParams.create(
+            clientSecret = clientSecret,
+            paymentMethodType = PaymentMethod.Type.USBankAccount,
+          )
+        }
+      }
   }
 
   @Throws(PaymentMethodCreateParamsException::class)
   private fun createAffirmStripeIntentParams(
     clientSecret: String,
-    isPaymentIntent: Boolean
+    isPaymentIntent: Boolean,
   ): ConfirmStripeIntentParams {
     if (!isPaymentIntent) {
       throw PaymentMethodCreateParamsException("Affirm is not yet supported through SetupIntents.")
@@ -436,13 +423,12 @@ class PaymentMethodCreateParamsFactory(
 
     val params = createAffirmParams()
 
-    return ConfirmPaymentIntentParams
-      .createWithPaymentMethodCreateParams(
-        paymentMethodCreateParams = params,
-        clientSecret = clientSecret,
-        setupFutureUsage = mapToPaymentIntentFutureUsage(getValOr(options, "setupFutureUsage")),
-        mandateData = buildMandateDataParams(),
-      )
+    return ConfirmPaymentIntentParams.createWithPaymentMethodCreateParams(
+      paymentMethodCreateParams = params,
+      clientSecret = clientSecret,
+      setupFutureUsage = mapToPaymentIntentFutureUsage(getValOr(options, "setupFutureUsage")),
+      mandateData = buildMandateDataParams(),
+    )
   }
 
   @Throws(PaymentMethodCreateParamsException::class)
@@ -451,34 +437,27 @@ class PaymentMethodCreateParamsFactory(
     val routingNumber = getValOr(params, "routingNumber", null)
 
     if (accountNumber.isNullOrBlank()) {
-      throw PaymentMethodCreateParamsException("When creating a US bank account payment method, you must provide the bank account number")
+      throw PaymentMethodCreateParamsException(
+        "When creating a US bank account payment method, you must provide the bank account number",
+      )
     } else if (routingNumber.isNullOrBlank()) {
-      throw PaymentMethodCreateParamsException("When creating a US bank account payment method, you must provide the bank routing number")
+      throw PaymentMethodCreateParamsException(
+        "When creating a US bank account payment method, you must provide the bank routing number",
+      )
     }
 
-    val usBankAccount = PaymentMethodCreateParams.USBankAccount(
-      accountNumber,
-      routingNumber,
-      mapToUSBankAccountType(
-        getValOr(
-          params,
-          "accountType",
-          null
-        )
-      ),
-      mapToUSBankAccountHolderType(
-        getValOr(
-          params,
-          "accountHolderType",
-          null
-        )
+    val usBankAccount =
+      PaymentMethodCreateParams.USBankAccount(
+        accountNumber,
+        routingNumber,
+        mapToUSBankAccountType(getValOr(params, "accountType", null)),
+        mapToUSBankAccountHolderType(getValOr(params, "accountHolderType", null)),
       )
-    )
 
     return PaymentMethodCreateParams.Companion.create(
       usBankAccount,
       billingDetailsParams,
-      metadataParams
+      metadataParams,
     )
   }
 
@@ -490,7 +469,7 @@ class PaymentMethodCreateParamsFactory(
             MandateDataParams.Type.Online(
               ipAddress = getValOr(onlineParams, "ipAddress", "") ?: "",
               userAgent = getValOr(onlineParams, "userAgent", "") ?: "",
-            )
+            ),
           )
         }
       }
@@ -499,4 +478,6 @@ class PaymentMethodCreateParamsFactory(
   }
 }
 
-class PaymentMethodCreateParamsException(message: String) : Exception(message)
+class PaymentMethodCreateParamsException(
+  message: String,
+) : Exception(message)