react-native-smallcase-gateway 0.7.0

package/android/src/main/java/com/smallcase/gateway/reactnative/SmallcaseGatewayModule.kt

@@ -0,0 +1,260 @@
+package com.smallcase.gateway.reactnative
+
+import android.content.ClipboardManager
+import android.content.Context
+import android.util.Log
+import android.widget.Toast
+import com.facebook.react.bridge.*
+import com.smallcase.gateway.data.SmallcaseGatewayListeners
+import com.smallcase.gateway.data.SmallcaseLogoutListener
+import com.smallcase.gateway.data.listeners.DataListener
+import com.smallcase.gateway.data.listeners.TransactionResponseListener
+import com.smallcase.gateway.data.models.Environment
+import com.smallcase.gateway.data.models.InitialisationResponse
+import com.smallcase.gateway.data.models.SmallcaseGatewayDataResponse
+import com.smallcase.gateway.data.models.TransactionResult
+import com.smallcase.gateway.data.requests.InitRequest
+import com.smallcase.gateway.portal.SmallcaseGatewaySdk
+
+
+class SmallcaseGatewayModule(reactContext: ReactApplicationContext?) : ReactContextBaseJavaModule(reactContext!!) {
+    companion object {
+        const val TAG = "SmallcaseGatewayModule"
+    }
+
+    override fun getName(): String {
+        return "SmallcaseGateway"
+    }
+
+    @ReactMethod
+    fun setConfigEnvironment(
+            envName: String,
+            gateway: String,
+            isLeprechaunActive: Boolean,
+            isAmoEnabled: Boolean,
+            preProvidedBrokers: ReadableArray,
+            promise: Promise) {
+        Log.d(TAG, "setConfigEnvironment: start")
+
+        try {
+            val brokerList = ArrayList<String>()
+            for (index in 0 until preProvidedBrokers.size()) {
+                val broker = preProvidedBrokers.getString(index)
+                if (broker != null) {
+                    brokerList.add(broker)
+                }
+            }
+
+            val protocol = getProtocol(envName)
+
+            val env = Environment(
+                    gateway = gateway,
+                    buildType = protocol,
+                    isAmoEnabled = isAmoEnabled,
+                    preProvidedBrokers = brokerList,
+                    isLeprachaunActive = isLeprechaunActive
+            )
+
+            SmallcaseGatewaySdk.setConfigEnvironment(
+                    environment = env,
+                    smallcaseGatewayListeners = object : SmallcaseGatewayListeners {
+                        override fun onGatewaySetupSuccessfull() {
+                            promise.resolve(true)
+                        }
+
+                        override fun onGatewaySetupFailed(error: String) {
+                            promise.reject(Throwable(error))
+                        }
+                    })
+        } catch (e: Exception) {
+            promise.reject(e)
+        }
+    }
+
+    @ReactMethod
+    fun init(sdkToken: String, promise: Promise) {
+        Log.d(TAG, "init: start")
+
+        val initReq = InitRequest(sdkToken)
+        SmallcaseGatewaySdk.init(
+                authRequest = initReq,
+                gatewayInitialisationListener = object : DataListener<InitialisationResponse> {
+                    override fun onFailure(errorCode: Int, errorMessage: String) {
+                        val err = createErrorJSON(errorCode, errorMessage)
+                        promise.reject("error", err)
+                    }
+
+                    override fun onSuccess(response: InitialisationResponse) {
+                        promise.resolve(true)
+                    }
+
+                })
+    }
+
+    @ReactMethod
+    fun triggerTransaction(transactionId: String, utmParams: ReadableMap?, brokerList: ReadableArray?, promise: Promise) {
+        Log.d(TAG, "triggerTransaction: start")
+
+        var safeBrokerList = listOf<String>()
+
+        if (brokerList != null) {
+            safeBrokerList = brokerList.toArrayList().map { it as String }
+        }
+
+
+        val activity = currentActivity;
+        if (activity != null) {
+            val utm = readableMapToStrHashMap(utmParams)
+            SmallcaseGatewaySdk.triggerTransaction(
+                    utmParams = utm,
+                    activity = activity,
+                    transactionId = transactionId,
+                    preProvidedBrokers = safeBrokerList,
+                    transactionResponseListener = object : TransactionResponseListener {
+                        override fun onSuccess(transactionResult: TransactionResult) {
+                            if (transactionResult.success) {
+                                val res = resultToWritableMap(transactionResult)
+                                promise.resolve(res)
+                            } else {
+                                val err = createErrorJSON(
+                                        transactionResult.errorCode,
+                                        transactionResult.error
+                                )
+                                promise.reject("error", err)
+                            }
+
+                        }
+
+                        override fun onError(errorCode: Int, errorMessage: String) {
+                            val err = createErrorJSON(errorCode, errorMessage)
+                            promise.reject("error", err)
+                        }
+                    })
+        } else {
+            promise.reject(Throwable("no activity"))
+        }
+    }
+
+    @ReactMethod
+    fun archiveSmallcase(iscid: String, promise: Promise) {
+        Log.d(TAG, "markSmallcaseArchive: start")
+
+        SmallcaseGatewaySdk.markSmallcaseArchived(iscid, object : DataListener<SmallcaseGatewayDataResponse> {
+
+            override fun onSuccess(response: SmallcaseGatewayDataResponse) {
+                promise.resolve(response)
+            }
+
+            override fun onFailure(errorCode: Int, errorMessage: String) {
+                val err = createErrorJSON(errorCode, errorMessage)
+                promise.reject("error", err)
+            }
+        })
+    }
+
+    @ReactMethod
+    fun logoutUser(promise: Promise) {
+        val activity = currentActivity;
+        if (activity != null) {
+            SmallcaseGatewaySdk.logoutUser(
+                    activity = activity,
+                    logoutListener = object : SmallcaseLogoutListener {
+                        override fun onLogoutSuccessfull() {
+                            promise.resolve(true)
+                        }
+
+                        override fun onLogoutFailed(errorCode: Int, error: String) {
+                            val err = createErrorJSON(errorCode, error)
+                            promise.reject("error", err)
+                        }
+                    })
+        }
+    }
+
+    @ReactMethod
+    fun triggerLeadGen(userDetails: ReadableMap, utmData: ReadableMap) {
+        val activity = currentActivity;
+        if (activity != null) {
+            SmallcaseGatewaySdk.triggerLeadGen(
+                    activity=activity,
+                    utmParams = readableMapToStrHashMap(utmData),
+                    params = readableMapToStrHashMap(userDetails)
+            )
+        }
+    }
+
+    @ReactMethod
+    fun triggerLeadGenWithStatus(userDetails: ReadableMap, promise: Promise) {
+        val activity = currentActivity;
+        if (activity != null) {
+            SmallcaseGatewaySdk.triggerLeadGen(activity,readableMapToStrHashMap(userDetails), object : TransactionResponseListener {
+                override fun onSuccess(transactionResult: TransactionResult) {
+                    if (transactionResult.success) {
+                        val res = resultToWritableMap(transactionResult)
+                        promise.resolve(res)
+                    } else {
+                        val err = createErrorJSON(
+                                transactionResult.errorCode,
+                                transactionResult.error
+                        )
+                        promise.reject("error", err)
+                    }
+                }
+
+                override fun onError(errorCode: Int, errorMessage: String) {
+                    val err = createErrorJSON(errorCode, errorMessage)
+                    promise.reject("error", err)
+                }
+
+            })
+        }
+    }
+
+    private fun getProtocol(envName: String): Environment.PROTOCOL {
+        return when (envName) {
+            "production" -> Environment.PROTOCOL.PRODUCTION
+            "development" -> Environment.PROTOCOL.DEVELOPMENT
+            "staging" -> Environment.PROTOCOL.STAGING
+            else -> Environment.PROTOCOL.PRODUCTION
+        }
+    }
+
+    private fun readableMapToStrHashMap(params: ReadableMap?): HashMap<String, String> {
+        val data = HashMap<String, String>()
+
+        if (params != null) {
+            val keyIterator = params.keySetIterator()
+
+            while (keyIterator.hasNextKey()) {
+                val key = keyIterator.nextKey()
+                params.getString(key)?.let {
+                    data.put(key, it)
+                }
+            }
+        }
+
+        return data
+    }
+
+    private fun resultToWritableMap(result: TransactionResult): WritableMap {
+        val writableMap: WritableMap = Arguments.createMap()
+
+        writableMap.putString("data", result.data)
+        writableMap.putBoolean("success", result.success)
+        writableMap.putString("error", result.error)
+        result.errorCode?.let {
+            writableMap.putInt("errorCode", it)
+        }
+        writableMap.putString("transaction", result.transaction.name)
+        return writableMap
+    }
+
+    private fun createErrorJSON(errorCode: Int?, errorMessage: String?): WritableMap {
+        val errObj = Arguments.createMap()
+
+        errorCode?.let { errObj.putInt("errorCode", it) }
+        errorMessage?.let { errObj.putString("errorMessage", it) }
+
+        return errObj
+    }
+}

package/android/src/main/java/com/smallcase/gateway/reactnative/SmallcaseGatewayPackage.kt

@@ -0,0 +1,18 @@
+package com.smallcase.gateway.reactnative
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.JavaScriptModule
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+import java.util.*
+
+class SmallcaseGatewayPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return Arrays.asList<NativeModule>(SmallcaseGatewayModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}

package/index.js

@@ -0,0 +1,4 @@
+import SmallcaseGateway from "./src/SmallcaseGateway";
+import { ENV, TRANSACTION_TYPE, ERROR_MSG } from "./src/constants";
+
+export default { ...SmallcaseGateway, ENV, ERROR_MSG, TRANSACTION_TYPE };

package/ios/SmallcaseGateway.h

@@ -0,0 +1,5 @@
+#import <React/RCTBridgeModule.h>
+
+@interface SmallcaseGateway : NSObject <RCTBridgeModule>
+
+@end

package/ios/SmallcaseGateway.m

@@ -0,0 +1,287 @@
+#import "SmallcaseGateway.h"
+
+#import <SCGateway/SCGateway.h>
+#import <SCGateway/SCGateway-Swift.h>
+
+
+@implementation SmallcaseGateway
+
+RCT_EXPORT_MODULE()
+
+RCT_REMAP_METHOD(setConfigEnvironment,
+                 envName:(NSString *)envName
+                 gateway:(NSString *)gateway
+                 isLeprechaunActive: (BOOL *)isLeprechaunActive
+                 isAmoEnabled: (BOOL *)isAmoEnabled
+                 preProvidedBrokers: (NSArray *)preProvidedBrokers
+                 setConfigEnvironmentWithResolver:(RCTPromiseResolveBlock)resolve
+                 rejecter:(RCTPromiseRejectBlock)reject)
+{
+    NSInteger environment = EnvironmentProduction;
+
+    if([envName isEqualToString:@"production"]) {
+        environment = EnvironmentProduction;
+    }
+    else if([envName isEqualToString:@"development"]) {
+        environment = EnvironmentDevelopment;
+    } else {
+        environment = EnvironmentStaging;
+    }
+
+    GatewayConfig *config = [[GatewayConfig alloc]
+                             initWithGatewayName:gateway
+                             brokerConfig:preProvidedBrokers
+                             apiEnvironment:environment
+                             isLeprechaunActive:isLeprechaunActive
+                             isAmoEnabled:isAmoEnabled];
+
+    [SCGateway.shared setupWithConfig: config completion:^(BOOL success,NSError * error)
+     {
+        if(success)
+        {
+            resolve(@(YES));
+        } else {
+            NSMutableDictionary *responseDict = [[NSMutableDictionary alloc] init];
+            [responseDict setValue:[NSNumber numberWithInteger:error.code]  forKey:@"errorCode"];
+            [responseDict setValue:error.domain  forKey:@"errorMessage"];
+
+            NSError *err = [[NSError alloc] initWithDomain:error.domain code:error.code userInfo:responseDict];
+
+            reject(@"setConfigEnvironment", @"Env setup failed", err);
+        }
+    }];
+}
+
+RCT_REMAP_METHOD(init,
+                 sdkToken:(NSString *)sdkToken
+                 initWithResolver:(RCTPromiseResolveBlock)resolve
+                 rejecter:(RCTPromiseRejectBlock)reject)
+{
+    [SCGateway.shared initializeGatewayWithSdkToken:sdkToken completion:^(BOOL success, NSError * error) {
+        if(success){
+            resolve(@(YES));
+        } else {
+            if(error != nil)
+            {
+                NSMutableDictionary *responseDict = [[NSMutableDictionary alloc] init];
+                [responseDict setValue:[NSNumber numberWithInteger:error.code]  forKey:@"errorCode"];
+                [responseDict setValue:error.domain  forKey:@"errorMessage"];
+
+                NSError *err = [[NSError alloc] initWithDomain:error.domain code:error.code userInfo:responseDict];
+
+                reject(@"init", @"Error during init", err);
+                return;
+            }
+            reject(@"init", @"Error during init", error);
+        }
+    }];
+
+
+}
+
+RCT_REMAP_METHOD(archiveSmallcase,
+                 iscid:(NSString *)iscid
+                 initWithResolver:(RCTPromiseResolveBlock)resolve
+                 rejecter:(RCTPromiseRejectBlock)reject)
+{
+    [SCGateway.shared markSmallcaseArchiveWithIscid:iscid completion: ^(id response, NSError * error) {
+        if(error != nil) {
+            NSMutableDictionary *responseDict = [[NSMutableDictionary alloc] init];
+            [responseDict setValue:[NSNumber numberWithInteger:error.code]  forKey:@"errorCode"];
+            [responseDict setValue:error.domain  forKey:@"errorMessage"];
+            
+            NSError *err = [[NSError alloc] initWithDomain:error.domain code:error.code userInfo:responseDict];
+            
+            reject(@"archiveSmallcase", @"Error during transaction", err);
+            return;
+        }
+        
+        NSString *archiveResponseString = [[NSString alloc] initWithData:response encoding:NSUTF8StringEncoding];
+        
+        NSMutableDictionary *responseDict =  [[NSMutableDictionary alloc] init];
+        [responseDict setValue:[NSNumber numberWithBool:true] forKey:@"success"];
+       
+        [responseDict setObject:archiveResponseString forKey:@"data"];
+        resolve(responseDict);
+        return;
+    }];
+}
+
+RCT_REMAP_METHOD(triggerTransaction,
+                 transactionId:(NSString *)transactionId
+                 utmParams:(NSDictionary *)utmParams
+                 brokerList:(NSArray *)brokerList
+                 triggerTransactionWithResolver:(RCTPromiseResolveBlock)resolve
+                 rejecter:(RCTPromiseRejectBlock)reject)
+{
+    dispatch_async(dispatch_get_main_queue(), ^(void) {
+        [SCGateway.shared
+         triggerTransactionFlowWithTransactionId:transactionId
+         presentingController:[[[UIApplication sharedApplication] keyWindow] rootViewController]
+         utmParams:utmParams
+         brokerConfig:brokerList
+         completion: ^(id response, NSError * error) {
+            if (error != nil) {
+                NSMutableDictionary *responseDict = [[NSMutableDictionary alloc] init];
+                [responseDict setValue:[NSNumber numberWithInteger:error.code]  forKey:@"errorCode"];
+                [responseDict setValue:error.domain  forKey:@"errorMessage"];
+
+                NSError *err = [[NSError alloc] initWithDomain:error.domain code:error.code userInfo:responseDict];
+
+                reject(@"triggerTransaction", @"Error during transaction", err);
+                return;
+            }
+
+            NSMutableDictionary *responseDict =  [[NSMutableDictionary alloc] init];
+            [responseDict setValue:[NSNumber numberWithBool:true] forKey:@"success"];
+
+            // intent - transaction
+            if ([response isKindOfClass: [ObjcTransactionIntentTransaction class]]) {
+                ObjcTransactionIntentTransaction *trxResponse = response;
+                [responseDict setObject:@"TRANSACTION"  forKey:@"transaction"];
+
+                NSData *decodedStringData = [[NSData alloc] initWithBase64EncodedString:trxResponse.transaction options: 0];
+                NSString *decodedResponse = [[NSString alloc] initWithData:decodedStringData encoding:1];
+
+                [responseDict setObject:decodedResponse forKey:@"data"];
+                resolve(responseDict);
+                return;
+            }
+
+            // intent - connect
+            if([response isKindOfClass: [ObjCTransactionIntentConnect class]]) {
+                ObjCTransactionIntentConnect *trxResponse = response;
+                [responseDict setValue:@"CONNECT"  forKey:@"transaction"];
+
+                if (trxResponse.response != nil) {
+                    [responseDict setValue:trxResponse.response forKey:@"data"];
+                }
+                
+                resolve(responseDict);
+                return;
+            }
+
+            // intent - holdings import
+            if([response isKindOfClass: [ObjcTransactionIntentHoldingsImport class]]) {
+                ObjcTransactionIntentHoldingsImport *trxResponse = response;
+                [responseDict setValue:@"HOLDING_IMPORT"  forKey:@"transaction"];
+
+                NSMutableDictionary *dict = [[NSMutableDictionary alloc] init];
+                [dict setValue: trxResponse.authToken  forKey:@"smallcaseAuthToken"];
+                [dict setValue: trxResponse.transactionId forKey:@"transactionId"];
+                [dict setValue: trxResponse.broker forKey:@"broker"];
+
+                [responseDict setValue:dict forKey:@"data"];
+                resolve(responseDict);
+                return;
+            }
+
+            // intent - fetch funds
+            if([response isKindOfClass: [ObjcTransactionIntentFetchFunds class]]) {
+                ObjcTransactionIntentFetchFunds *trxResponse = response;
+                [responseDict setValue:@"FETCH_FUNDS"  forKey:@"transaction"];
+
+                NSMutableDictionary *dict = [[NSMutableDictionary alloc] init];
+                [dict setValue: trxResponse.authToken  forKey:@"smallcaseAuthToken"];
+                [dict setValue: trxResponse.transactionId forKey:@"transactionId"];
+
+                [dict setValue:[NSNumber numberWithDouble:trxResponse.fund] forKey:@"fund"];
+
+                [responseDict setValue:dict forKey:@"data"];
+                resolve(responseDict);
+                return;
+            }
+
+            // intent - sip setup
+            if([response isKindOfClass: [ObjcTransactionIntentSipSetup class]]) {
+                ObjcTransactionIntentSipSetup *trxResponse = response;
+                [responseDict setValue:@"SIP_SETUP"  forKey:@"transaction"];
+
+                NSMutableDictionary *dict = [[NSMutableDictionary alloc] init];
+                [dict setValue: trxResponse.authToken  forKey:@"smallcaseAuthToken"];
+                [dict setValue: trxResponse.transactionId forKey:@"transactionId"];
+                [dict setValue: trxResponse.sipAction forKey:@"sipAction"];
+                [dict setValue: trxResponse.sipType forKey:@"sipType"];
+                [dict setValue: trxResponse.frequency forKey:@"frequency"];
+                [dict setValue: trxResponse.iscid forKey:@"iscid"];
+                [dict setValue: trxResponse.scheduledDate forKey:@"scheduledDate"];
+                [dict setValue: trxResponse.scid forKey:@"scid"];
+                [dict setValue: trxResponse.sipActive ? @"YES" : @"NO" forKey:@"sipActive"];
+                [dict setValue: [NSNumber numberWithDouble: trxResponse.sipAmount] forKey:@"sipAmount"];
+
+                [responseDict setValue:dict forKey:@"data"];
+                resolve(responseDict);
+                return;
+            }
+
+
+            // intent - authorize holdings
+            if([response isKindOfClass: [ObjcTransactionIntentAuthoriseHoldings class]]) {
+                ObjcTransactionIntentAuthoriseHoldings *trxResponse = response;
+                [responseDict setValue:@"AUTHORISE_HOLDINGS"  forKey:@"transaction"];
+
+                NSMutableDictionary *dict = [[NSMutableDictionary alloc] init];
+                [dict setValue: trxResponse.authToken  forKey:@"smallcaseAuthToken"];
+                [dict setValue: trxResponse.transactionId forKey:@"transactionId"];
+
+                [dict setValue: [NSNumber numberWithBool:trxResponse.status] forKey:@"status"];
+
+                [responseDict setValue:dict forKey:@"data"];
+                resolve(responseDict);
+                return;
+            }
+
+            // no matching intent type
+            NSError *err = [[NSError alloc] initWithDomain:@"com.smallcase.gateway" code:0 userInfo:@{@"Error reason": @"no matching response type"}];
+            reject(@"triggerTransaction", @"no matching response type", err);
+        }];
+    });
+}
+
+RCT_REMAP_METHOD(logoutUser,
+                 logoutUserWithResolver:(RCTPromiseResolveBlock)resolve
+                 rejecter:(RCTPromiseRejectBlock)reject)
+{
+    dispatch_async(dispatch_get_main_queue(), ^(void) {
+        [SCGateway.shared
+            logoutUserWithPresentingController:[[[UIApplication sharedApplication] keyWindow] rootViewController]
+            completion:^(BOOL success, NSError * error) {
+                if(success){
+                    resolve(@(YES));
+                } else {
+                    reject(@"logout", @"Error during logout", error);
+                }
+        }];
+    });
+}
+
+
+RCT_REMAP_METHOD(triggerLeadGenWithStatus,
+                  userParams: (NSDictionary *)userParams
+                  leadGenGenWithResolver: (RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    dispatch_async(dispatch_get_main_queue(), ^(void) {
+        
+        [SCGateway.shared triggerLeadGenWithPresentingController:[[[UIApplication sharedApplication] keyWindow] rootViewController] params:userParams
+                                                      completion:^(NSString * leadGenResponse) {
+            resolve(leadGenResponse);
+        }
+         ];
+        
+    });
+}
+
+RCT_EXPORT_METHOD(triggerLeadGen: (NSDictionary *)userParams utmParams:(NSDictionary *)utmParams)
+{
+    dispatch_async(dispatch_get_main_queue(), ^(void) {
+        [SCGateway.shared triggerLeadGenWithPresentingController:[[[UIApplication sharedApplication] keyWindow] rootViewController] params:userParams utmParams: utmParams];
+    });
+}
+
+@end
+
+
+
+
+