judokit-react-native 3.3.7 → 3.4.0

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

@@ -9,17 +9,8 @@ import com.judopay.judokit.android.Judo
 import com.judopay.judokit.android.api.model.Authorization
 import com.judopay.judokit.android.api.model.BasicAuthorization
 import com.judopay.judokit.android.api.model.PaymentSessionAuthorization
-import com.judopay.judokit.android.model.Amount
-import com.judopay.judokit.android.model.CardNetwork
-import com.judopay.judokit.android.model.Currency
-import com.judopay.judokit.android.model.GooglePayConfiguration
-import com.judopay.judokit.android.model.JudoResult
-import com.judopay.judokit.android.model.PBBAConfiguration
-import com.judopay.judokit.android.model.PaymentMethod
-import com.judopay.judokit.android.model.PaymentWidgetType
-import com.judopay.judokit.android.model.PrimaryAccountDetails
-import com.judopay.judokit.android.model.Reference
-import com.judopay.judokit.android.model.UiConfiguration
+import com.judopay.judokit.android.api.model.request.Address
+import com.judopay.judokit.android.model.*
 import com.judopay.judokit.android.model.googlepay.GooglePayAddressFormat
 import com.judopay.judokit.android.model.googlepay.GooglePayBillingAddressParameters
 import com.judopay.judokit.android.model.googlepay.GooglePayEnvironment
@@ -118,21 +109,71 @@ internal fun getJudoConfiguration(type: PaymentWidgetType, options: ReadableMap)
     val primaryAccountDetails = getPrimaryAccountDetails(options)
     val googlePayConfiguration = getGooglePayConfiguration(options)
     val pbbaConfiguration = getPBBAConfiguration(options)
+    val timeouts = getNetworkTimeout(options)
+    val challengeRequestIndicator = getChallengeRequestIndicator(options)
+    val scaExemption = getScaExemption(options)
+    val address = getAddress(options)
 
     return Judo.Builder(type)
-            .setAuthorization(authorization)
-            .setIsSandboxed(options.isSandboxed)
-            .setJudoId(options.judoId)
-            .setAmount(amount)
-            .setReference(reference)
-            .setSupportedCardNetworks(cardNetworks)
-            .setPaymentMethods(paymentMethods)
-            .setUiConfiguration(uiConfiguration)
-            .setPrimaryAccountDetails(primaryAccountDetails)
-            .setGooglePayConfiguration(googlePayConfiguration)
-            .setPBBAConfiguration(pbbaConfiguration)
-            .setInitialRecurringPayment(options.isInitialRecurringPayment)
+        .setAuthorization(authorization)
+        .setIsSandboxed(options.isSandboxed)
+        .setJudoId(options.judoId)
+        .setAmount(amount)
+        .setReference(reference)
+        .setSupportedCardNetworks(cardNetworks)
+        .setPaymentMethods(paymentMethods)
+        .setUiConfiguration(uiConfiguration)
+        .setPrimaryAccountDetails(primaryAccountDetails)
+        .setGooglePayConfiguration(googlePayConfiguration)
+        .setPBBAConfiguration(pbbaConfiguration)
+        .setInitialRecurringPayment(options.isInitialRecurringPayment)
+        .setNetworkTimeout(timeouts)
+        .setChallengeRequestIndicator(challengeRequestIndicator)
+        .setScaExemption(scaExemption)
+        .setMobileNumber(options.mobileNumber)
+        .setEmailAddress(options.emailAddress)
+        .setThreeDSTwoMaxTimeout(options.threeDSTwoMaxTimeout)
+        .setThreeDSTwoMessageVersion(options.threeDSTwoMessageVersion)
+        .setPhoneCountryCode(options.phoneCountryCode)
+        .setAddress(address)
+        .build()
+}
+
+internal fun getAddress(options: ReadableMap): Address? {
+    if (options.cardAddress != null) {
+        return Address.Builder()
+            .setLine1(options.cardAddressLine1)
+            .setLine2(options.cardAddressLine2)
+            .setLine3(options.cardAddressLine3)
+            .setTown(options.cardAddressTown)
+            .setPostCode(options.cardAddressPostCode)
+            .setBillingCountry(options.cardAddressBillingCountry)
+            .setCountryCode(options.cardAddressCountryCode)
             .build()
+    }
+    return null
+}
+
+internal fun getNetworkTimeout(options: ReadableMap): NetworkTimeout? {
+    val networkTimeout = options.networkTimeout
+    if (networkTimeout != null) {
+        return NetworkTimeout.Builder()
+            .setConnectTimeout(options.networkConnectTimeout)
+            .setReadTimeout(options.networkReadTimeout)
+            .setWriteTimeout(options.networkWriteTimeout)
+            .build()
+    }
+    return null
+}
+
+internal fun getChallengeRequestIndicator(options: ReadableMap): ChallengeRequestIndicator? {
+    val challengeRequestIndicator = ChallengeRequestIndicator.values().firstOrNull { it.value == options.challengeRequestIndicator }
+    return challengeRequestIndicator ?: ChallengeRequestIndicator.CHALLENGE_AS_MANDATE
+}
+
+internal fun getScaExemption(options: ReadableMap): ScaExemption {
+    val scaExemption = ScaExemption.values().firstOrNull { it.value == options.scaExemption }
+    return scaExemption ?: ScaExemption.LOW_VALUE
 }
 
 internal fun getAuthorization(options: ReadableMap): Authorization {
@@ -140,16 +181,16 @@ internal fun getAuthorization(options: ReadableMap): Authorization {
 
     options.secret?.let { secret ->
         return BasicAuthorization.Builder()
-                .setApiToken(token)
-                .setApiSecret(secret)
-                .build()
+            .setApiToken(token)
+            .setApiSecret(secret)
+            .build()
     }
 
     options.paymentSession?.let { paymentSession ->
         return PaymentSessionAuthorization.Builder()
-                .setApiToken(token)
-                .setPaymentSession(paymentSession)
-                .build()
+            .setApiToken(token)
+            .setPaymentSession(paymentSession)
+            .build()
     }
 
     throw IllegalArgumentException("No secret or payment session in the authorization")
@@ -174,16 +215,16 @@ internal fun getAmount(options: ReadableMap): Amount {
         else -> Currency.valueOf(currencyValue)
     }
     return Amount.Builder()
-            .setAmount(options.amountValue)
-            .setCurrency(currency)
-            .build()
+        .setAmount(options.amountValue)
+        .setCurrency(currency)
+        .build()
 }
 
 internal fun getReference(options: ReadableMap): Reference? {
 
     var builder = Reference.Builder()
-            .setConsumerReference(options.consumerReference)
-            .setPaymentReference(options.paymentReference)
+        .setConsumerReference(options.consumerReference)
+        .setPaymentReference(options.paymentReference)
 
     val metadataMap = options.metadata
     metadataMap?.let {
@@ -291,11 +332,12 @@ internal fun getPaymentMethods(options: ReadableMap): Array<PaymentMethod>? {
 internal fun getUIConfiguration(options: ReadableMap): UiConfiguration? {
     return if (options.uiConfiguration != null) {
         UiConfiguration.Builder()
-                .setAvsEnabled(options.isAVSEnabled)
-                .setShouldPaymentMethodsDisplayAmount(options.shouldPaymentMethodsDisplayAmount)
-                .setShouldPaymentButtonDisplayAmount(options.shouldPaymentButtonDisplayAmount)
-                .setShouldPaymentMethodsVerifySecurityCode(options.shouldPaymentMethodsVerifySecurityCode)
-                .build()
+            .setAvsEnabled(options.isAVSEnabled)
+            .setShouldPaymentMethodsDisplayAmount(options.shouldPaymentMethodsDisplayAmount)
+            .setShouldPaymentButtonDisplayAmount(options.shouldPaymentButtonDisplayAmount)
+            .setShouldPaymentMethodsVerifySecurityCode(options.shouldPaymentMethodsVerifySecurityCode)
+            .setShouldAskForBillingInformation(options.shouldAskForBillingInformation)
+            .build()
     } else {
         null
     }
@@ -326,14 +368,14 @@ internal fun getGooglePayConfiguration(options: ReadableMap): GooglePayConfigura
 
     return if (options.googlePayConfiguration != null) {
         GooglePayConfiguration.Builder()
-                .setTransactionCountryCode(options.countryCode)
-                .setEnvironment(environment)
-                .setIsEmailRequired(options.isEmailRequired)
-                .setIsBillingAddressRequired(options.isBillingAddressRequired)
-                .setBillingAddressParameters(billingParameters)
-                .setIsShippingAddressRequired(options.isShippingAddressRequired)
-                .setShippingAddressParameters(shippingParameters)
-                .build()
+            .setTransactionCountryCode(options.countryCode)
+            .setEnvironment(environment)
+            .setIsEmailRequired(options.isEmailRequired)
+            .setIsBillingAddressRequired(options.isBillingAddressRequired)
+            .setBillingAddressParameters(billingParameters)
+            .setIsShippingAddressRequired(options.isShippingAddressRequired)
+            .setShippingAddressParameters(shippingParameters)
+            .build()
     } else {
         null
     }
@@ -345,8 +387,8 @@ internal fun getBillingParameters(options: ReadableMap): GooglePayBillingAddress
         else -> GooglePayAddressFormat.FULL
     }
     return GooglePayBillingAddressParameters(
-            addressFormat,
-            options.isBillingPhoneNumberRequired
+        addressFormat,
+        options.isBillingPhoneNumberRequired
     )
 }
 
@@ -361,8 +403,8 @@ internal fun getShippingParameters(options: ReadableMap): GooglePayShippingAddre
     }
 
     return GooglePayShippingAddressParameters(
-            allowedCountryCodes,
-            options.isShippingPhoneNumberRequired
+        allowedCountryCodes,
+        options.isShippingPhoneNumberRequired
     )
 }
 
@@ -375,11 +417,11 @@ internal fun getPBBAConfiguration(options: ReadableMap): PBBAConfiguration? {
         }
 
         PBBAConfiguration.Builder()
-                .setMobileNumber(options.mobileNumber)
-                .setEmailAddress(options.emailAddress)
-                .setDeepLinkURL(deeplinkUri)
-                .setDeepLinkScheme(options.deeplinkScheme)
-                .build()
+            .setMobileNumber(options.pbbaMobileNumber)
+            .setEmailAddress(options.pbbaEmailAddress)
+            .setDeepLinkURL(deeplinkUri)
+            .setDeepLinkScheme(options.deeplinkScheme)
+            .build()
     } else {
         null
     }

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

@@ -15,9 +15,9 @@ import com.judopay.judokit.android.api.model.response.Receipt
 import com.judopay.judokit.android.api.model.response.toCardVerificationModel
 import com.judopay.judokit.android.api.model.response.toJudoPaymentResult
 import com.judopay.judokit.android.api.model.response.toJudoResult
-import com.judopay.judokit.android.model.JudoPaymentResult
-import com.judopay.judokit.android.model.JudoResult
-import com.judopay.judokit.android.model.PaymentWidgetType
+import com.judopay.judokit.android.model.*
+import com.judopay.judokit.android.service.CardTransactionManager
+import com.judopay.judokit.android.service.CardTransactionManagerResultListener
 import com.judopay.judokit.android.toTokenRequest
 import com.judopay.judokit.android.ui.cardverification.THREE_DS_ONE_DIALOG_FRAGMENT_TAG
 import com.judopay.judokit.android.ui.cardverification.ThreeDSOneCardVerificationDialogFragment
@@ -33,9 +33,10 @@ const val JUDO_PAYMENT_WIDGET_REQUEST_CODE = 65520
 const val JUDO_PROMISE_REJECTION_CODE = "JUDO_ERROR"
 
 class JudoReactNativeModule internal constructor(val context: ReactApplicationContext) :
-    ReactContextBaseJavaModule(context) {
+    ReactContextBaseJavaModule(context), CardTransactionManagerResultListener {
 
     private val listener = JudoReactNativeActivityEventListener()
+    internal var transactionPromise: Promise? = null
 
     /**
      * A broadcast receiver to catch Pay by Bank app /order/bank/sale response event.
@@ -106,59 +107,75 @@ class JudoReactNativeModule internal constructor(val context: ReactApplicationCo
     @ReactMethod
     fun performTokenTransaction(options: ReadableMap, promise: Promise) {
         try {
+            val activity = context.currentActivity as FragmentActivity
+            val manager = CardTransactionManager.getInstance(activity)
 
             val judo = getTokenTransactionConfiguration(options)
 
-            val service = JudoApiServiceFactory.createApiService(context, judo)
-
             val cardToken = options.cardToken
-            val securityCode = options.securityCode
 
             if (cardToken == null) {
                 promise.reject(JUDO_PROMISE_REJECTION_CODE, "No card token found")
                 return
             }
 
-            val tokenTransactionCallback = object : Callback<JudoApiCallResult<Receipt>> {
-
-                override fun onFailure(call: Call<JudoApiCallResult<Receipt>>, t: Throwable) {
-                    promise.reject(t)
-                }
-
-                override fun onResponse(call: Call<JudoApiCallResult<Receipt>>, response: Response<JudoApiCallResult<Receipt>>) {
-
-                    if (response.body() == null) {
-                        promise.reject(JUDO_PROMISE_REJECTION_CODE, "Response body is empty")
-                        return
-                    }
-
-                    when (val data = response.body()?.toJudoPaymentResult(context.resources)) {
-                        is JudoPaymentResult.Success -> {
-                            val receipt = (response.body() as JudoApiCallResult.Success).data
-                            if (receipt != null && receipt.is3dSecureRequired) {
-                                handleThreeDSAuthentication(promise, service, receipt)
-                            } else {
-                                promise.resolve(getMappedResult(receipt?.toJudoResult()))
-                            }
-                        }
-                        is JudoPaymentResult.Error -> {
-                            promise.reject(JUDO_PROMISE_REJECTION_CODE, data.error.message)
-                        }
-                    }
-                }
-            }
+            val details = TransactionDetails.Builder()
+                .setCardHolderName(options.cardholderName)
+                .setSecurityNumber(options.securityCode)
+                .setCardType(options.cardType)
+                .setCardToken(cardToken)
+                .setEmail(judo.emailAddress)
+                .setCountryCode(judo.address?.countryCode.toString())
+                .setPhoneCountryCode(judo.phoneCountryCode)
+                .setMobileNumber(judo.mobileNumber)
+                .setAddressLine1(judo.address?.line1)
+                .setAddressLine2(judo.address?.line2)
+                .setAddressLine3(judo.address?.line3)
+                .setCity(judo.address?.town)
+                .setPostalCode(judo.address?.postCode)
+                .build()
+
+            transactionPromise = promise
 
             when (judo.paymentWidgetType) {
-                PaymentWidgetType.CARD_PAYMENT -> service.tokenPayment(judo.toTokenRequest(cardToken, securityCode)).enqueue(tokenTransactionCallback)
-                PaymentWidgetType.PRE_AUTH -> service.preAuthTokenPayment(judo.toTokenRequest(cardToken, securityCode)).enqueue(tokenTransactionCallback)
+                PaymentWidgetType.CARD_PAYMENT -> manager.paymentWithToken(details, JudoReactNativeModule::class.java.name)
+                PaymentWidgetType.PRE_AUTH -> manager.preAuthWithToken(details, JudoReactNativeModule::class.java.name)
                 else -> promise.reject(JUDO_PROMISE_REJECTION_CODE, "${judo.paymentWidgetType.name} payment widget type is not valid for token transactions")
             }
-
         } catch (exception: Exception) {
             promise.reject(exception)
         }
     }
 
+    override fun initialize() {
+        super.initialize()
+
+        val activity =  context.currentActivity as FragmentActivity
+        CardTransactionManager.getInstance(activity).registerResultListener(this)
+    }
+
+    override fun invalidate() {
+        super.invalidate()
+
+        val activity =  context.currentActivity as FragmentActivity
+        CardTransactionManager.getInstance(activity).unRegisterResultListener(this)
+    }
+
+    override fun onCardTransactionResult(result: JudoPaymentResult) {
+        transactionPromise?.let {
+            if (result is JudoPaymentResult.Success) {
+                it.resolve(getMappedResult(result.result))
+            } else {
+                val message = when (result) {
+                    is JudoPaymentResult.Error -> result.error.message
+                    is JudoPaymentResult.UserCancelled -> result.error.message
+                    else -> "The transaction was unsuccessful"
+                }
+                it.reject(JUDO_PROMISE_REJECTION_CODE, message)
+            }
+        }
+    }
+
     @ReactMethod
     fun isBankingAppAvailable(promise: Promise) {
         try {
@@ -173,40 +190,4 @@ class JudoReactNativeModule internal constructor(val context: ReactApplicationCo
         val intent = configuration.toJudoActivityIntent(it)
         it.startActivityForResult(intent, JUDO_PAYMENT_WIDGET_REQUEST_CODE)
     }
-
-    private fun handleThreeDSAuthentication(promise: Promise, service: JudoApiService, receipt: Receipt) {
-        val callback = object : ThreeDSOneCompletionCallback {
-            override fun onSuccess(success: JudoPaymentResult) {
-                handleSuccessfulThreeDSTransaction(success, promise)
-            }
-
-            override fun onFailure(error: JudoPaymentResult) {
-                handleFailedThreeDSTransaction(error, promise)
-            }
-        }
-
-        val fragment = ThreeDSOneCardVerificationDialogFragment(
-                service,
-                receipt.toCardVerificationModel(),
-                callback
-        )
-        fragment.show((context.currentActivity as FragmentActivity).supportFragmentManager, THREE_DS_ONE_DIALOG_FRAGMENT_TAG)
-    }
-
-    private fun handleFailedThreeDSTransaction(error: JudoPaymentResult, promise: Promise) {
-        val message = when (error) {
-            is JudoPaymentResult.Error -> error.error.message
-            is JudoPaymentResult.UserCancelled -> error.error.message
-            else -> "The transaction was unsuccessful"
-        }
-        promise.reject(JUDO_PROMISE_REJECTION_CODE, message)
-    }
-
-    private fun handleSuccessfulThreeDSTransaction(success: JudoPaymentResult, promise: Promise) {
-        if (success is JudoPaymentResult.Success) {
-            promise.resolve(getMappedResult(success.result))
-        } else {
-            promise.reject(JUDO_PROMISE_REJECTION_CODE, "Unknown error occured")
-        }
-    }
 }

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

@@ -1,17 +1,17 @@
 package com.reactlibrary
 
+import android.widget.Button
 import com.facebook.react.uimanager.SimpleViewManager
 import com.facebook.react.uimanager.ThemedReactContext
-import com.judopay.judokit.android.ui.common.PayByBankButton
 
-class JudoReactNativePBBAManager: SimpleViewManager<PayByBankButton>() {
+class JudoReactNativePBBAManager: SimpleViewManager<Button>() {
 
     override fun getName(): String {
         return "RNPBBAButton"
     }
 
-    override fun createViewInstance(reactContext: ThemedReactContext): PayByBankButton {
-        return PayByBankButton(reactContext)
+    override fun createViewInstance(reactContext: ThemedReactContext): Button {
+        return Button(reactContext)
     }
 
 }

package/ios/Classes/RNJudo.m

@@ -42,7 +42,7 @@ typedef NS_ENUM(NSUInteger, JudoSDKInvocationType) {
 
 @property (nonatomic, strong) JudoKit *judoKit;
 @property (nonatomic, strong) JPApiService *apiService;
-@property (nonatomic, strong) JP3DSService *threeDSService;
+@property (nonatomic, strong) JPCardTransactionService *transactionService;
 @property (nonatomic, strong) JPCompletionBlock completionBlock;
 
 @end
@@ -104,31 +104,24 @@ RCT_REMAP_METHOD(performTokenTransaction,
                  performTokenTransactionWithResolver:(RCTPromiseResolveBlock)resolve
                  rejecter:(RCTPromiseRejectBlock)reject) {
 
-    self.apiService = [RNWrappers apiServiceFromProperties:properties];
-    self.threeDSService = [[JP3DSService alloc] initWithApiService:self.apiService];
+    self.transactionService = [RNWrappers cardTransactionServiceFromProperties:properties];
     self.completionBlock = [self completionBlockWithResolve:resolve andReject:reject];
 
     JPTransactionMode transactionMode = [RNWrappers transactionModeFromProperties:properties];
     JPConfiguration *configuration = [RNWrappers configurationFromProperties:properties];
-
-    NSString *cardToken = [RNWrappers cardTokenFromProperties:properties];
-    JPTokenRequest *tokenRequest = [[JPTokenRequest alloc] initWithConfiguration:configuration
-                                                                    andCardToken:cardToken];
-
-    __weak typeof(self) weakSelf = self;
-
+    
+    JPCardTransactionDetails *details = [[JPCardTransactionDetails new] initWithConfiguration:configuration];
+    details.cardToken = [RNWrappers cardTokenFromProperties:properties];
+    details.secureCode = [RNWrappers securityCodeFromProperties:properties];
+    details.cardholderName = [RNWrappers cardholderNameFromProperties:properties];
+    details.cardType = [RNWrappers cardTypeFromProperties:properties];
+    
     if (transactionMode == JPTransactionModePreAuth) {
-        [self.apiService invokePreAuthTokenPaymentWithRequest:tokenRequest
-                                                andCompletion:^(JPResponse *response, JPError *error) {
-            [weakSelf handleResponse:response andError:error];
-        }];
+        [self.transactionService invokePreAuthTokenPaymentWithDetails:details andCompletion:self.completionBlock];
         return;
     }
 
-    [self.apiService invokeTokenPaymentWithRequest:tokenRequest
-                                     andCompletion:^(JPResponse *response, JPError *error) {
-        [weakSelf handleResponse:response andError:error];
-    }];
+    [self.transactionService invokeTokenPaymentWithDetails:details andCompletion:self.completionBlock];
 }
 
 RCT_REMAP_METHOD(fetchTransactionDetails,
@@ -191,46 +184,27 @@ RCT_REMAP_METHOD(fetchTransactionDetails,
         NSError *error = [[NSError alloc] initWithDomain:RNJudoErrorDomain
                                                     code:0
                                                 userInfo:exception.userInfo];
-
         reject(kJudoPromiseRejectionCode, exception.reason, error);
     }
 }
 
-- (void)handleResponse:(JPResponse *)response andError:(JPError *)error {
-
-    if (error.code != Judo3DSRequestError) {
-        self.completionBlock(response, error);
-        return;
-    }
-
-    JP3DSConfiguration *configuration = [JP3DSConfiguration configurationWithError:error];
-    [self.threeDSService invoke3DSecureWithConfiguration:configuration completion:self.completionBlock];
-}
-
-//----------------------------------------------
-// MARK: - React Native methods
-//----------------------------------------------
-
-- (dispatch_queue_t)methodQueue {
-    return dispatch_get_main_queue();
-}
-
-+ (BOOL)requiresMainQueueSetup {
-    return YES;
-}
-
 - (JPCompletionBlock)completionBlockWithResolve:(RCTPromiseResolveBlock)resolve
                                       andReject:(RCTPromiseRejectBlock)reject {
-
     return ^(JPResponse *response, NSError *error) {
         if (error) {
-
             if (error.code == JPError.judoUserDidCancelError.code) {
                 reject(kJudoPromiseRejectionCode, @"Transaction cancelled",  error);
                 return;
             }
-
-            reject(kJudoPromiseRejectionCode, @"Transaction failed",  error);
+            
+            NSString *description = error.userInfo[NSLocalizedDescriptionKey];
+            NSString *message = @"Transaction failed";
+            
+            if (description && description.length > 0) {
+                message = description;
+            }
+            
+            reject(kJudoPromiseRejectionCode, message, error);
         } else {
             NSDictionary *mappedResponse = [RNWrappers dictionaryFromResponse:response];
             resolve(mappedResponse);
@@ -238,4 +212,16 @@ RCT_REMAP_METHOD(fetchTransactionDetails,
     };
 }
 
+//----------------------------------------------
+// MARK: - React Native methods
+//----------------------------------------------
+
+- (dispatch_queue_t)methodQueue {
+    return dispatch_get_main_queue();
+}
+
++ (BOOL)requiresMainQueueSetup {
+    return YES;
+}
+
 @end

package/ios/Classes/Wrappers/RNWrappers.h

@@ -46,6 +46,10 @@
  */
 + (JPApiService *)apiServiceFromProperties:(NSDictionary *)properties;
 
++ (JPCardTransactionService *)cardTransactionServiceFromProperties:(NSDictionary *)properties;
+
++ (id<JPAuthorization>)authorizationFromProperties:(NSDictionary *)properties;
+
 /**
  * A method that returns the correct TransactionType value based on the passed dictionary parameters
  * TransactionType is set to switch between Payment, PreAuth, Register Card, Check Card and Save Card transactions
@@ -96,6 +100,12 @@
 */
 + (NSString *)cardTokenFromProperties:(NSDictionary *)properties;
 
++ (NSString *)securityCodeFromProperties:(NSDictionary *)properties;
+
++ (NSString *)cardholderNameFromProperties:(NSDictionary *)properties;
+
++ (JPCardNetworkType)cardTypeFromProperties:(NSDictionary *)properties;
+
 /**
 * A method that returns the receipt ID contained in the properties dictionary
 *