judokit-react-native 3.4.9 → 4.0.0

package/android/src/main/java/com/reactlibrary/Helpers.kt

@@ -5,6 +5,11 @@ import android.os.Bundle
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.WritableMap
+import com.judopay.judo3ds2.customization.ButtonCustomization
+import com.judopay.judo3ds2.customization.LabelCustomization
+import com.judopay.judo3ds2.customization.TextBoxCustomization
+import com.judopay.judo3ds2.customization.ToolbarCustomization
+import com.judopay.judo3ds2.customization.UiCustomization
 import com.judopay.judokit.android.Judo
 import com.judopay.judokit.android.api.model.Authorization
 import com.judopay.judokit.android.api.model.BasicAuthorization
@@ -16,6 +21,41 @@ import com.judopay.judokit.android.model.googlepay.GooglePayBillingAddressParame
 import com.judopay.judokit.android.model.googlepay.GooglePayEnvironment
 import com.judopay.judokit.android.model.googlepay.GooglePayShippingAddressParameters
 
+// For consistency with:
+// https://github.com/Judopay/JudoKit-iOS/blob/master/Source/Models/Response/JPResponse.m#L36
+private const val TRANSACTION_TYPE_PAYMENT = "payment"
+private const val TRANSACTION_TYPE_PRE_AUTH = "preauth"
+private const val TRANSACTION_TYPE_REGISTER = "register"
+private const val TRANSACTION_TYPE_REGISTER_CARD = "registercard"
+private const val TRANSACTION_TYPE_SAVE_CARD = "save"
+private const val TRANSACTION_TYPE_CHECK_CARD = "checkcard"
+
+// For consistency with:
+// https://github.com/Judopay/JudoKit-iOS/blob/master/Source/Models/Transaction/JPTransactionType.h#L30
+private enum class TransactionType(val value: Int, val typeAsStrings: List<String>? = null) {
+    PAYMENT(1, listOf(TRANSACTION_TYPE_PAYMENT)),
+    PRE_AUTH(2, listOf(TRANSACTION_TYPE_PRE_AUTH)),
+    REGISTER_CARD(3, listOf(TRANSACTION_TYPE_REGISTER, TRANSACTION_TYPE_REGISTER_CARD)),
+    CHECK_CARD(4, listOf(TRANSACTION_TYPE_CHECK_CARD)),
+    SAVE_CARD(5, listOf(TRANSACTION_TYPE_SAVE_CARD)),
+    UNKNOWN(-1)
+}
+
+// For consistency with:
+// https://github.com/Judopay/JudoKit-iOS/blob/master/Source/Models/Response/JPResponse.m#L32
+private const val STATUS_DECLINED = "declined"
+private const val STATUS_SUCCESS = "success"
+private const val STATUS_ERROR = "error"
+
+// For consistency with:
+// https://github.com/Judopay/JudoKit-iOS/blob/abd34bbfe4784fb5f074ed30f93d6743ba295622/Source/Models/Transaction/JPTransactionResult.h#L27
+private enum class TransactionResult(val value: Int, val status: String? = null) {
+    ERROR(0, STATUS_ERROR),
+    SUCCESS(1, STATUS_SUCCESS),
+    DECLINED(2, STATUS_DECLINED),
+    UNKNOWN(-1)
+}
+
 internal fun getTransactionConfiguration(options: ReadableMap): Judo {
     val widgetType = getTransactionTypeWidget(options)
     return getJudoConfiguration(widgetType, options)
@@ -45,20 +85,19 @@ internal fun getPaymentMethodsConfiguration(options: ReadableMap): Judo {
 }
 
 internal fun getMappedType(type: String?): Int {
-    return when (type) {
-        "PreAuth" -> 1
-        "RegisterCard" -> 2
-        "CheckCard" -> 3
-        "Save" -> 4
-        else -> 0
-    }
+    val typeInLowercase = type?.lowercase()
+    val typeValue = TransactionType.values().firstOrNull { it.typeAsStrings?.contains(typeInLowercase) ?: false }
+
+    return typeValue?.value ?: TransactionType.UNKNOWN.value
 }
 
+// consistent with:
+// https://github.com/Judopay/JudoKit-iOS/blob/master/Source/Models/Response/JPResponse.m#L125
 internal fun getMappedResult(result: String?): Int {
-    return when (result) {
-        "Declined" -> 1
-        else -> 0
-    }
+    val resultInLowercase = result?.lowercase()
+    val resultValue = TransactionResult.values().firstOrNull { it.status == resultInLowercase }
+
+    return resultValue?.value ?: TransactionResult.UNKNOWN.value
 }
 
 internal fun getMappedResult(result: JudoResult?): WritableMap {
@@ -87,6 +126,7 @@ internal fun getMappedResult(result: JudoResult?): WritableMap {
     cardDetailsMap.putString("cardCountry", result?.cardDetails?.country)
     cardDetailsMap.putString("cardFunding", result?.cardDetails?.funding)
     cardDetailsMap.putString("cardScheme", result?.cardDetails?.scheme)
+    cardDetailsMap.putString("cardHolderName", result?.cardDetails?.cardHolderName)
 
     map.putMap("cardDetails", cardDetailsMap)
 
@@ -99,6 +139,27 @@ internal fun getMappedResult(result: JudoResult?): WritableMap {
     return map
 }
 
+internal fun getJudoConfigurationForApiService(options: ReadableMap): Judo {
+    val authorization = getAuthorization(options)
+
+    val amount = Amount.Builder()
+        .setAmount("0.00")
+        .setCurrency(Currency.GBP)
+        .build()
+
+    val reference = Reference.Builder()
+        .setConsumerReference("reference")
+        .build()
+
+    return Judo.Builder(PaymentWidgetType.CARD_PAYMENT)
+        .setIsSandboxed(options.isSandboxed)
+        .setJudoId("000000")
+        .setAuthorization(authorization)
+        .setAmount(amount)
+        .setReference(reference)
+        .build()
+}
+
 internal fun getJudoConfiguration(type: PaymentWidgetType, options: ReadableMap): Judo {
     val authorization = getAuthorization(options)
     val amount = getAmount(options)
@@ -127,6 +188,7 @@ internal fun getJudoConfiguration(type: PaymentWidgetType, options: ReadableMap)
         .setGooglePayConfiguration(googlePayConfiguration)
         .setPBBAConfiguration(pbbaConfiguration)
         .setInitialRecurringPayment(options.isInitialRecurringPayment)
+        .setDelayedAuthorisation(options.isDelayedAuthorisation)
         .setNetworkTimeout(timeouts)
         .setChallengeRequestIndicator(challengeRequestIndicator)
         .setScaExemption(scaExemption)
@@ -191,11 +253,12 @@ internal fun getAuthorization(options: ReadableMap): Authorization {
 }
 
 internal fun getTransactionTypeWidget(options: ReadableMap) = when (options.getInt("transactionType")) {
-    1 -> PaymentWidgetType.PRE_AUTH
-    2 -> PaymentWidgetType.REGISTER_CARD
-    3 -> PaymentWidgetType.CHECK_CARD
-    4 -> PaymentWidgetType.CREATE_CARD_TOKEN
-    else -> PaymentWidgetType.CARD_PAYMENT
+    1 -> PaymentWidgetType.CARD_PAYMENT
+    2 -> PaymentWidgetType.PRE_AUTH
+    3 -> PaymentWidgetType.REGISTER_CARD
+    4 -> PaymentWidgetType.CHECK_CARD
+    5 -> PaymentWidgetType.CREATE_CARD_TOKEN
+    else -> throw IllegalArgumentException("Unknown transaction type")
 }
 
 internal fun getTransactionModeWidget(options: ReadableMap) = when (options.getInt("transactionMode")) {
@@ -331,12 +394,110 @@ internal fun getUIConfiguration(options: ReadableMap): UiConfiguration? {
             .setShouldPaymentButtonDisplayAmount(options.shouldPaymentButtonDisplayAmount)
             .setShouldPaymentMethodsVerifySecurityCode(options.shouldPaymentMethodsVerifySecurityCode)
             .setShouldAskForBillingInformation(options.shouldAskForBillingInformation)
+            .setThreeDSUiCustomization(getThreeDSUiCustomization(options))
             .build()
     } else {
         null
     }
 }
 
+internal fun getThreeDSUiCustomization(options: ReadableMap): UiCustomization? {
+    return if (options.threeDSUIConfiguration != null) {
+
+        val uiCustomization = UiCustomization()
+
+        options.threeDSUIToolbarCustomization?.let {
+            uiCustomization.setToolbarCustomization(ToolbarCustomization().apply {
+                setTextFontName(it.textFontName)
+                setTextColor(it.textColor)
+                setTextFontSize(it.textFontSize)
+                setBackgroundColor(it.backgroundColor)
+                setHeaderText(it.headerText)
+                setButtonText(it.buttonText)
+            })
+        }
+
+        options.threeDSUILabelCustomization?.let {
+            uiCustomization.setLabelCustomization(LabelCustomization().apply {
+                setTextFontName(it.textFontName)
+                setTextColor(it.textColor)
+                setTextFontSize(it.textFontSize)
+                setHeadingTextFontName(it.headingTextFontName)
+                setHeadingTextColor(it.headingTextColor)
+                setHeadingTextFontSize(it.headingTextFontSize)
+            })
+        }
+
+        options.threeDSUITextBoxCustomization?.let {
+            uiCustomization.setTextBoxCustomization(TextBoxCustomization().apply {
+                setTextFontName(it.textFontName)
+                setTextColor(it.textColor)
+                setTextFontSize(it.textFontSize)
+                setBorderWidth(it.borderWidth)
+                setBorderColor(it.borderColor)
+                setCornerRadius(it.cornerRadius)
+            })
+        }
+
+        if (options.threeDSUIButtonCustomizations != null) {
+
+            options.threeDSUISubmitButtonCustomization?.let {
+                uiCustomization.setButtonCustomization(ButtonCustomization().apply {
+                    setTextFontName(it.textFontName)
+                    setTextColor(it.textColor)
+                    setTextFontSize(it.textFontSize)
+                    setBackgroundColor(it.backgroundColor)
+                    setCornerRadius(it.cornerRadius)
+                }, UiCustomization.ButtonType.SUBMIT)
+            }
+
+            options.threeDSUINextButtonCustomization?.let {
+                uiCustomization.setButtonCustomization(ButtonCustomization().apply {
+                    setTextFontName(it.textFontName)
+                    setTextColor(it.textColor)
+                    setTextFontSize(it.textFontSize)
+                    setBackgroundColor(it.backgroundColor)
+                    setCornerRadius(it.cornerRadius)
+                }, UiCustomization.ButtonType.NEXT)
+            }
+
+            options.threeDSUIContinueButtonCustomization?.let {
+                uiCustomization.setButtonCustomization(ButtonCustomization().apply {
+                    setTextFontName(it.textFontName)
+                    setTextColor(it.textColor)
+                    setTextFontSize(it.textFontSize)
+                    setBackgroundColor(it.backgroundColor)
+                    setCornerRadius(it.cornerRadius)
+                }, UiCustomization.ButtonType.CONTINUE)
+            }
+
+            options.threeDSUICancelButtonCustomization?.let {
+                uiCustomization.setButtonCustomization(ButtonCustomization().apply {
+                    setTextFontName(it.textFontName)
+                    setTextColor(it.textColor)
+                    setTextFontSize(it.textFontSize)
+                    setBackgroundColor(it.backgroundColor)
+                    setCornerRadius(it.cornerRadius)
+                }, UiCustomization.ButtonType.CANCEL)
+            }
+
+            options.threeDSUIResendButtonCustomization?.let {
+                uiCustomization.setButtonCustomization(ButtonCustomization().apply {
+                    setTextFontName(it.textFontName)
+                    setTextColor(it.textColor)
+                    setTextFontSize(it.textFontSize)
+                    setBackgroundColor(it.backgroundColor)
+                    setCornerRadius(it.cornerRadius)
+                }, UiCustomization.ButtonType.RESEND)
+            }
+        }
+
+        uiCustomization
+    } else {
+        null
+    }
+}
+
 internal fun getPrimaryAccountDetails(options: ReadableMap): PrimaryAccountDetails? {
     return if (options.primaryAccountDetails != null) {
         PrimaryAccountDetails.Builder()

package/android/src/main/java/com/reactlibrary/JudoReactNativeModule.kt

@@ -9,6 +9,7 @@ import androidx.localbroadcastmanager.content.LocalBroadcastManager
 import com.facebook.react.bridge.*
 import com.judopay.judokit.android.Judo
 import com.judopay.judokit.android.api.JudoApiService
+import com.judopay.judokit.android.api.error.toJudoError
 import com.judopay.judokit.android.api.factory.JudoApiServiceFactory
 import com.judopay.judokit.android.api.model.response.JudoApiCallResult
 import com.judopay.judokit.android.api.model.response.Receipt
@@ -31,6 +32,7 @@ import retrofit2.Response
 
 const val JUDO_PAYMENT_WIDGET_REQUEST_CODE = 65520
 const val JUDO_PROMISE_REJECTION_CODE = "JUDO_ERROR"
+const val REQUEST_FAILED_MESSAGE = "The request was unsuccessful."
 
 class JudoReactNativeModule internal constructor(val context: ReactApplicationContext) :
     ReactContextBaseJavaModule(context), CardTransactionManagerResultListener {
@@ -114,7 +116,6 @@ class JudoReactNativeModule internal constructor(val context: ReactApplicationCo
             val manager = CardTransactionManager.getInstance(activity)
 
             val judo = getTokenTransactionConfiguration(options)
-
             val cardToken = options.cardToken
 
             if (cardToken == null) {
@@ -122,6 +123,8 @@ class JudoReactNativeModule internal constructor(val context: ReactApplicationCo
                 return
             }
 
+            manager.configureWith(judo)
+
             val details = TransactionDetails.Builder()
                 .setCardHolderName(options.cardholderName)
                 .setSecurityNumber(options.securityCode)
@@ -150,6 +153,56 @@ class JudoReactNativeModule internal constructor(val context: ReactApplicationCo
         }
     }
 
+    @ReactMethod
+    fun fetchTransactionDetails(options: ReadableMap, promise: Promise) {
+        try {
+            val judo = getJudoConfigurationForApiService(options)
+            val receiptId = options.receiptId ?: ""
+
+            val service = JudoApiServiceFactory.createApiService(context, judo)
+
+            val fetchTransactionDetailsCallback = object : Callback<JudoApiCallResult<Receipt>> {
+                override fun onResponse(
+                    call: Call<JudoApiCallResult<Receipt>>,
+                    response: Response<JudoApiCallResult<Receipt>>
+                ) {
+                    when (val result = response.body()) {
+                        is JudoApiCallResult.Success -> {
+                            val receipt = result.data
+                            if (receipt != null) {
+                                val judoResult = receipt.toJudoResult()
+                                promise.resolve(getMappedResult(judoResult))
+                            } else {
+                                promise.reject(JUDO_PROMISE_REJECTION_CODE, REQUEST_FAILED_MESSAGE)
+                            }
+                        }
+                        is JudoApiCallResult.Failure -> {
+                            val message = result.error?.message ?: REQUEST_FAILED_MESSAGE
+                            promise.reject(JUDO_PROMISE_REJECTION_CODE, message)
+                        }
+                        else -> {
+                            promise.reject(JUDO_PROMISE_REJECTION_CODE, REQUEST_FAILED_MESSAGE)
+                        }
+                    }
+                }
+
+                override fun onFailure(
+                    call: Call<JudoApiCallResult<Receipt>>,
+                    throwable: Throwable
+                ) {
+                    promise.reject(JUDO_PROMISE_REJECTION_CODE, throwable.localizedMessage, throwable)
+                }
+            }
+
+            service
+                .fetchTransactionWithReceiptId(receiptId)
+                .enqueue(fetchTransactionDetailsCallback)
+
+        } catch (error: Exception) {
+            promise.reject(JUDO_PROMISE_REJECTION_CODE, error.localizedMessage, error)
+        }
+    }
+
     private fun ensureIsSubscribedToCardTransactionResults() {
         if (isSubscribedToCardTransactionResults) {
             return

package/ios/.xcode.env

@@ -0,0 +1,11 @@
+# This `.xcode.env` file is versioned and is used to source the environment
+# used when running script phases inside Xcode.
+# To customize your local environment, you can create an `.xcode.env.local`
+# file that is not versioned.
+
+# NODE_BINARY variable contains the PATH to the node executable.
+#
+# Customize the NODE_BINARY variable here.
+# For example, to use nvm with brew, add the following line
+# . "$(brew --prefix nvm)/nvm.sh" --no-use
+export NODE_BINARY=$(command -v node)

package/ios/Classes/RNJudo.m

@@ -128,13 +128,19 @@ RCT_REMAP_METHOD(fetchTransactionDetails,
                  properties:(NSDictionary *)properties
                  fetchTransactionDetailsWithResolver:(RCTPromiseResolveBlock)resolve
                  rejecter:(RCTPromiseRejectBlock)reject) {
+    @try {
+        self.apiService = [RNWrappers apiServiceFromProperties:properties];
+        self.completionBlock = [self completionBlockWithResolve:resolve andReject:reject];
 
-    self.apiService = [RNWrappers apiServiceFromProperties:properties];
-    self.completionBlock = [self completionBlockWithResolve:resolve andReject:reject];
-
-    NSString *receiptId = [RNWrappers receiptIdFromProperties:properties];
+        NSString *receiptId = [RNWrappers receiptIdFromProperties:properties];
 
-    [self.apiService fetchTransactionWithReceiptId:receiptId completion:self.completionBlock];
+        [self.apiService fetchTransactionWithReceiptId:receiptId completion:self.completionBlock];
+    } @catch (NSException *exception) {
+        NSError *error = [[NSError alloc] initWithDomain:RNJudoErrorDomain
+                                                    code:0
+                                                userInfo:exception.userInfo];
+        reject(kJudoPromiseRejectionCode, exception.reason, error);
+    }
 }
 
 //----------------------------------------------
@@ -204,7 +210,17 @@ RCT_REMAP_METHOD(fetchTransactionDetails,
                 message = description;
             }
             
-            reject(kJudoPromiseRejectionCode, message, error);
+            // TODO: RCTJSErrorFromCodeMessageAndNSError expects an NSError instane in userInfo[NSUnderlyingErrorKey]
+            // which in case of a 3DS SDK error is a NSString ('JP3DSSDKRuntimeException') - so it crashes
+            // ! this should be fixed in JudoKit-iOS, and the folowing workaround removed ASAP
+            NSMutableDictionary *userInfo = [NSMutableDictionary dictionaryWithDictionary:error.userInfo];
+            [userInfo removeObjectForKey:NSUnderlyingErrorKey];
+            NSError *myError = [[NSError alloc] initWithDomain:error.domain
+                                                          code:error.code
+                                                      userInfo:[NSDictionary dictionaryWithDictionary:userInfo]];
+            
+            
+            reject(kJudoPromiseRejectionCode, message, myError);
         } else {
             NSDictionary *mappedResponse = [RNWrappers dictionaryFromResponse:response];
             resolve(mappedResponse);