react-native-payengine 1.0.5 → 1.0.6

package/android/.idea/compiler.xml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="CompilerConfiguration">
-    <bytecodeTargetLevel target="1.8" />
+    <bytecodeTargetLevel target="11" />
   </component>
 </project>

package/android/.idea/gradle.xml

@@ -7,6 +7,7 @@
         <option name="testRunner" value="GRADLE" />
         <option name="distributionType" value="DEFAULT_WRAPPED" />
         <option name="externalProjectPath" value="$PROJECT_DIR$" />
+        <option name="gradleJvm" value="adopt-11" />
         <option name="modules">
           <set>
             <option value="$PROJECT_DIR$" />

package/android/.idea/misc.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="ExternalStorageConfigurationManager" enabled="true" />
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="true" project-jdk-name="1.8" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_11" project-jdk-name="1.8" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/build/classes" />
   </component>
   <component name="ProjectType">

package/android/build.gradle

@@ -9,8 +9,12 @@ buildscript {
   }
 }
 
+def isAndroidXEnabled() {
+  return rootProject.hasProperty("android.useAndroidX") && rootProject.getProperty("android.useAndroidX") == "true"
+}
+
 def isNewArchitectureEnabled() {
-  return rootProject.hasProperty("newArchEnabled") &&  rootProject.getProperty("newArchEnabled") == "true"
+  return isAndroidXEnabled() && rootProject.hasProperty("newArchEnabled") &&  rootProject.getProperty("newArchEnabled") == "true"
 }
 
 apply plugin: 'com.android.library'
@@ -49,6 +53,19 @@ android {
     sourceCompatibility JavaVersion.VERSION_1_8
     targetCompatibility JavaVersion.VERSION_1_8
   }
+
+  if (!isAndroidXEnabled()) {
+    sourceSets {
+      main {
+        java {
+          srcDir 'src/legacy/java'
+        }
+        resources {
+          srcDir 'src/legacy/resources'
+        }
+      }
+    }
+  }
 }
 
 repositories {
@@ -126,14 +143,12 @@ dependencies {
     //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
 
-  implementation "com.google.android.material:material:1.6.1"
-
-  // https://mvnrepository.com/artifact/com.verygoodsecurity/vgscollect
-//  releaseImplementation 'com.verygoodsecurity:vgscollect:1.7.2'
-  releaseImplementation files('./vgscollect-1.7.2-debug.aar')
-  debugImplementation files('./vgscollect-1.7.2-debug.aar')
-
-
+  if (isAndroidXEnabled()) {
+    implementation "com.google.android.material:material:1.6.1"
+    releaseImplementation files('./vgscollect-1.7.2-debug.aar')
+    debugImplementation files('./vgscollect-1.7.2-debug.aar')
+  }
+  implementation 'com.google.android.gms:play-services-wallet:16.0.0'
 
   // From node_modules
 }

package/android/src/legacy/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.reactnativepayengine">
+
+</manifest>

package/android/src/main/java/com/reactnativepayengine/GooglePayModule.java

@@ -0,0 +1,196 @@
+package com.reactnativepayengine;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.util.Log;
+
+import com.facebook.react.bridge.ActivityEventListener;
+import com.facebook.react.bridge.BaseActivityEventListener;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.Promise;
+
+import com.google.android.gms.wallet.PaymentsClient;
+import com.google.android.gms.wallet.WalletConstants;
+import com.google.android.gms.wallet.IsReadyToPayRequest;
+import com.google.android.gms.wallet.AutoResolveHelper;
+import com.google.android.gms.wallet.PaymentData;
+import com.google.android.gms.wallet.PaymentDataRequest;
+import com.google.android.gms.common.api.Status;
+import com.google.android.gms.tasks.OnCompleteListener;
+import com.google.android.gms.tasks.Task;
+import com.reactnativepayengine.util.PaymentsUtil;
+
+import androidx.annotation.NonNull;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+public class GooglePayModule extends ReactContextBaseJavaModule {
+
+  private static final String TAG = "ReactNative";
+
+  private static final String ENVIRONMENT_PRODUCTION_KEY = "ENVIRONMENT_PRODUCTION";
+
+  private static final String ENVIRONMENT_TEST_KEY = "ENVIRONMENT_TEST";
+
+  private final ReactApplicationContext reactContext;
+
+  private PaymentsClient mPaymentsClient;
+
+  private Promise requestPaymentPromise = null;
+
+  private static final int LOAD_PAYMENT_DATA_REQUEST_CODE = 991;
+
+  private final ActivityEventListener activityEventListener = new BaseActivityEventListener() {
+    @Override
+    public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent data) {
+      switch (requestCode) {
+        // value passed in AutoResolveHelper
+        case LOAD_PAYMENT_DATA_REQUEST_CODE:
+          switch (resultCode) {
+            case Activity.RESULT_OK:
+              PaymentData paymentData = PaymentData.getFromIntent(data);
+              handlePaymentSuccess(paymentData);
+              break;
+            case Activity.RESULT_CANCELED:
+              requestPaymentPromise.reject("PAYMENT_RESULT_CANCELED", "Payment has been canceled");
+              break;
+            case AutoResolveHelper.RESULT_ERROR:
+              Status status = AutoResolveHelper.getStatusFromIntent(data);
+              int statusCode = status.getStatusCode();
+              String errorMessage = String.format("loadPaymentData failed. Error code: %d", statusCode);
+              Log.w(TAG, "[GooglePay] " + errorMessage);
+              requestPaymentPromise.reject("PAYMENT_RESULT_ERROR", errorMessage);
+              break;
+            default:
+              // Do nothing.
+          }
+          break;
+      }
+    }
+  };
+
+  public GooglePayModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+    this.reactContext = reactContext;
+    reactContext.addActivityEventListener(activityEventListener);
+  }
+
+  @Override
+  public Map<String, Object> getConstants() {
+    final Map<String, Object> constants = new HashMap<>();
+    constants.put(ENVIRONMENT_PRODUCTION_KEY, WalletConstants.ENVIRONMENT_PRODUCTION);
+    constants.put(ENVIRONMENT_TEST_KEY, WalletConstants.ENVIRONMENT_TEST);
+    return constants;
+  }
+
+  @ReactMethod
+  public void setEnvironment(int environment) {
+    final Activity activity = getCurrentActivity();
+    if (activity == null) {
+      return;
+    }
+    mPaymentsClient = PaymentsUtil.createPaymentsClient(environment, activity);
+  }
+
+  @ReactMethod
+  public void isReadyToPay(ReadableArray allowedCardNetworks, ReadableArray allowedCardAuthMethods, final Promise promise) {
+    final Activity activity = getCurrentActivity();
+    if (activity == null) {
+      Log.w(TAG, "[GooglePay] activity is null");
+      promise.resolve(false);
+      return;
+    }
+    final JSONObject isReadyToPayJson = PaymentsUtil.getIsReadyToPayRequest(allowedCardNetworks.toArrayList(), allowedCardAuthMethods.toArrayList());
+    if (isReadyToPayJson == null) {
+      Log.w(TAG, "[GooglePay] isReadyToPayJson == null");
+      promise.resolve(false);
+      return;
+    }
+    IsReadyToPayRequest request = IsReadyToPayRequest.fromJson(isReadyToPayJson.toString());
+    if (request == null) {
+      Log.w(TAG, "[GooglePay] IsReadyToPayRequest == null");
+      promise.resolve(false);
+      return;
+    }
+
+    // The call to isReadyToPay is asynchronous and returns a Task. We need to provide an
+    // OnCompleteListener to be triggered when the result of the call is known.
+    Task<Boolean> task = mPaymentsClient.isReadyToPay(request);
+    task.addOnCompleteListener(activity,
+      new OnCompleteListener<Boolean>() {
+        @Override
+        public void onComplete(@NonNull Task<Boolean> task) {
+          if (task.isSuccessful()) {
+            if (task.getResult()) {
+              promise.resolve(true);
+            } else {
+              Log.w(TAG, "[GooglePay] Not available");
+              promise.resolve(false);
+            }
+          } else {
+            Log.w(TAG, "[GooglePay] isReadyToPay failed. May add com.google.android.gms.wallet.api.enabled to your manifest?");
+            promise.resolve(false);
+          }
+        }
+      });
+  }
+
+  @ReactMethod
+  public void requestPayment(ReadableMap requestData, final Promise promise) {
+    final Activity activity = getCurrentActivity();
+    if (activity == null) {
+      Log.w(TAG, "[GooglePay] activity is null");
+      promise.reject("NO_ACTIVITY", "activity is null");
+      return;
+    }
+    JSONObject paymentDataRequestJson = PaymentsUtil.getPaymentDataRequest(requestData);
+    if (paymentDataRequestJson == null) {
+      promise.reject("PAYMENT_DATA_REQUEST_JSON", "paymentDataRequestJson is null");
+      return;
+    }
+
+    this.requestPaymentPromise = promise;
+
+    PaymentDataRequest request = PaymentDataRequest.fromJson(paymentDataRequestJson.toString());
+    if (request != null) {
+      AutoResolveHelper.resolveTask(mPaymentsClient.loadPaymentData(request), activity, LOAD_PAYMENT_DATA_REQUEST_CODE);
+    }
+  }
+
+  private void handlePaymentSuccess(PaymentData paymentData) {
+    String paymentInformation = paymentData.toJson();
+
+    // Token will be null if PaymentDataRequest was not constructed using fromJson(String).
+    if (paymentInformation == null) {
+      requestPaymentPromise.reject("NULL_PAYMENT_INFORMATION", "paymentInformation is null");
+      return;
+    }
+    JSONObject paymentMethodData;
+
+    try {
+      paymentMethodData = new JSONObject(paymentInformation).getJSONObject("paymentMethodData");
+      // If the gateway is set to "example", no payment information is returned - instead, the
+      // token will only consist of "examplePaymentMethodToken".
+
+      // Logging token string.
+      String token = paymentMethodData.getJSONObject("tokenizationData").getString("token");
+      requestPaymentPromise.resolve(token);
+    } catch (JSONException e) {
+      Log.e(TAG, "[GooglePay] handlePaymentSuccess error: " + e.toString());
+      return;
+    }
+  }
+
+  @Override
+  public String getName() {
+    return "GooglePay";
+  }
+}

package/android/src/main/java/com/reactnativepayengine/PayenginePackage.java

@@ -39,6 +39,7 @@ public class PayenginePackage implements ReactPackage, VGSCollectOnCreateViewIns
 
     List<NativeModule> modules = new ArrayList<>();
     modules.add(new PayengineModule(reactContext));
+    modules.add(new GooglePayModule(reactContext));
     modules.add(module);
 
     return modules;

package/android/src/main/java/com/reactnativepayengine/collect/VGSCollectModule.java

@@ -33,6 +33,7 @@ public class VGSCollectModule extends ReactContextBaseJavaModule {
   private static ReactApplicationContext reactContext;
 
   private VGSCollect collect;
+  private String publicKey;
 
   public VGSCollectModule(ReactApplicationContext c) {
     super(c);
@@ -42,9 +43,9 @@ public class VGSCollectModule extends ReactContextBaseJavaModule {
   @Override
   public void initialize() {
     super.initialize();
-//    Activity activity = reactContext.getCurrentActivity();
-//    collect = new VGSCollect.Builder(activity, "")
-//      .create();
+    // Activity activity = reactContext.getCurrentActivity();
+    // collect = new VGSCollect.Builder(activity, "")
+    // .create();
   }
 
   @NonNull
@@ -54,17 +55,19 @@ public class VGSCollectModule extends ReactContextBaseJavaModule {
   }
 
   @ReactMethod
-  public void setConfiguration(String vaultId, String environment, String cname, double vgsSatellitePort) {
+  public void setConfiguration(String publicKey, String vaultId, String environment, String cname,
+      double vgsSatellitePort) {
     Log.e("test", "Create event called with name: " + vaultId + " and location: " + environment + " cname: " + cname);
 
+    this.publicKey = publicKey;
     VGSCollectLogger.INSTANCE.setLogLevel(VGSCollectLogger.Level.DEBUG);
 
     Activity activity = reactContext.getCurrentActivity();
     collect = new VGSCollect.Builder(activity, vaultId)
-      .setEnvironment(environment)
-//      .setHostname(cname)
-//      .setPort((int) Math.round(vgsSatellitePort))
-      .create();
+        .setEnvironment(environment)
+        // .setHostname(cname)
+        // .setPort((int) Math.round(vgsSatellitePort))
+        .create();
 
   }
 
@@ -85,8 +88,10 @@ public class VGSCollectModule extends ReactContextBaseJavaModule {
       customData.put("merchant_id", merchantId);
     }
 
+    String authHeader = "Signature key=\"" + this.publicKey
+        + "\",algorithm=\"hmac-sha256\",identifier=\"secure-fields\",signature=\"\"";
     HashMap<String, String> headers = new HashMap<>();
-    headers.put("CUSTOM-HEADER", "custom-header");
+    headers.put("Authorization", authHeader);
 
     List<FieldState> states = collect.getAllStates();
 
@@ -95,9 +100,9 @@ public class VGSCollectModule extends ReactContextBaseJavaModule {
 
       if (!state.isValid()) {
         String message = new StringBuilder("Field ")
-          .append(state.getFieldName())
-          .append(" is not valid.")
-          .toString();
+            .append(state.getFieldName())
+            .append(" is not valid.")
+            .toString();
         promise.reject("validation_error", message);
         return;
       }
@@ -110,11 +115,11 @@ public class VGSCollectModule extends ReactContextBaseJavaModule {
     }
 
     VGSRequest request = new VGSRequest.VGSRequestBuilder()
-      .setMethod(HTTPMethod.POST)
-      .setPath(path)
-      .setCustomHeader(headers)
-      .setCustomData(customData)
-      .build();
+        .setMethod(HTTPMethod.POST)
+        .setPath(path)
+        .setCustomHeader(headers)
+        .setCustomData(customData)
+        .build();
 
     VGSResponse response = collect.submit(request);
     Log.e("test", "response " + response.getBody());

package/android/src/main/java/com/reactnativepayengine/util/PaymentsUtil.java

@@ -0,0 +1,113 @@
+package com.reactnativepayengine.util;
+import android.app.Activity;
+
+import com.google.android.gms.wallet.PaymentsClient;
+import com.google.android.gms.wallet.Wallet;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.ArrayList;
+
+import com.facebook.react.bridge.ReadableMap;
+
+public class PaymentsUtil {
+
+  private PaymentsUtil() {
+  }
+
+  private static JSONObject getBaseRequest() throws JSONException {
+    return new JSONObject().put("apiVersion", 2).put("apiVersionMinor", 0);
+  }
+
+  private static JSONObject getBaseCardPaymentMethod(ArrayList allowedCardNetworks, ArrayList allowedCardAuthMethods) throws JSONException {
+    JSONObject cardPaymentMethod = new JSONObject();
+    cardPaymentMethod.put("type", "CARD");
+
+    JSONObject parameters = new JSONObject();
+    parameters.put("allowedAuthMethods", new JSONArray(allowedCardAuthMethods));
+    parameters.put("allowedCardNetworks", new JSONArray(allowedCardNetworks));
+
+    cardPaymentMethod.put("parameters", parameters);
+
+    return cardPaymentMethod;
+  }
+
+  public static PaymentsClient createPaymentsClient(int environment, Activity activity) {
+    Wallet.WalletOptions walletOptions = new Wallet.WalletOptions.Builder().setEnvironment(environment).build();
+    return Wallet.getPaymentsClient(activity, walletOptions);
+  }
+
+  public static JSONObject getIsReadyToPayRequest(ArrayList allowedCardNetworks, ArrayList allowedCardAuthMethods) {
+    try {
+      JSONObject isReadyToPayRequest = getBaseRequest();
+      JSONArray allowedPaymentMethods = new JSONArray().put(getBaseCardPaymentMethod(allowedCardNetworks, allowedCardAuthMethods));
+      isReadyToPayRequest.put("allowedPaymentMethods", allowedPaymentMethods);
+      return isReadyToPayRequest;
+    } catch (JSONException e) {
+      return null;
+    }
+  }
+
+  private static JSONObject getTransactionInfo(ReadableMap transaction) throws JSONException {
+    JSONObject transactionInfo = new JSONObject();
+    transactionInfo.put("totalPrice", transaction.getString("totalPrice"));
+    transactionInfo.put("totalPriceStatus", transaction.getString("totalPriceStatus"));
+    transactionInfo.put("currencyCode", transaction.getString("currencyCode"));
+
+    return transactionInfo;
+  }
+
+  private static JSONObject getMerchantInfo(String merchantName) throws JSONException {
+    return new JSONObject().put("merchantName", merchantName);
+  }
+
+  private static JSONObject getTokenizationSpecification(final ReadableMap tokenizationSpecification) throws JSONException {
+    return new JSONObject() {{
+      put("type", tokenizationSpecification.getString("type"));
+      put("parameters", new JSONObject() {
+        {
+          if (tokenizationSpecification.hasKey("gateway")) {
+            put("gateway", tokenizationSpecification.getString("gateway"));
+          }
+          if (tokenizationSpecification.hasKey("gatewayMerchantId")) {
+            put("gatewayMerchantId", tokenizationSpecification.getString("gatewayMerchantId"));
+          }
+          if (tokenizationSpecification.hasKey("publicKey")) {
+            put("protocolVersion", "ECv2");
+            put("publicKey", tokenizationSpecification.getString("publicKey"));
+          }
+          if (tokenizationSpecification.hasKey("stripe")) {
+            final ReadableMap stripe = tokenizationSpecification.getMap("stripe");
+            put("stripe:publishableKey", stripe.getString("publishableKey"));
+            put("stripe:version", stripe.getString("version"));
+          }
+        }
+      });
+    }};
+  }
+
+  private static JSONObject getCardPaymentMethod(ReadableMap cardPaymentMethodData) throws JSONException {
+    ArrayList allowedCardNetworks = cardPaymentMethodData.getArray("allowedCardNetworks").toArrayList();
+    ArrayList allowedCardAuthMethods = cardPaymentMethodData.getArray("allowedCardAuthMethods").toArrayList();
+    JSONObject cardPaymentMethod = getBaseCardPaymentMethod(allowedCardNetworks, allowedCardAuthMethods);
+    cardPaymentMethod.put("tokenizationSpecification", getTokenizationSpecification(cardPaymentMethodData.getMap("tokenizationSpecification")));
+
+    return cardPaymentMethod;
+  }
+
+  public static JSONObject getPaymentDataRequest(ReadableMap requestData) {
+    try {
+      JSONObject paymentDataRequest = PaymentsUtil.getBaseRequest();
+      paymentDataRequest.put(
+        "allowedPaymentMethods", new JSONArray().put(PaymentsUtil.getCardPaymentMethod(requestData.getMap("cardPaymentMethod"))));
+      paymentDataRequest.put("transactionInfo", PaymentsUtil.getTransactionInfo(requestData.getMap("transaction")));
+      paymentDataRequest.put("merchantInfo", PaymentsUtil.getMerchantInfo(requestData.getString("merchantName")));
+
+      return paymentDataRequest;
+    } catch (JSONException e) {
+      return null;
+    }
+  }
+}

package/ios/Payengine.m

@@ -8,6 +8,22 @@ RCT_EXTERN_METHOD(multiply:(float)a withB:(float)b
                  withResolver:(RCTPromiseResolveBlock)resolve
                  withRejecter:(RCTPromiseRejectBlock)reject)
 
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+@end
+
+@interface RCT_EXTERN_MODULE(ApplePay, NSObject)
+
+RCT_EXTERN_METHOD(invokeApplePay:(NSDictionary)method details:(NSDictionary)details)
+
+RCT_EXTERN_METHOD(initApplePay:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(canMakePayments:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+
 + (BOOL)requiresMainQueueSetup
 {
   return NO;
@@ -15,9 +31,10 @@ RCT_EXTERN_METHOD(multiply:(float)a withB:(float)b
 
 @end
 
+
 @interface RCT_EXTERN_MODULE(VGSCollectManager, RCTViewManager)
 
-RCT_EXTERN_METHOD(setConfiguration: (NSString *)vaultId environment:(NSString *)environment hostname:(NSString *)hostname satellitePort:(NSInteger *)satellitePort);
+RCT_EXTERN_METHOD(setConfiguration: (NSString *)pKey vaultId:(NSString *)vaultId environment:(NSString *)environment hostname:(NSString *)hostname satellitePort:(NSInteger *)satellitePort);
 
 RCT_EXTERN_METHOD(createCard: (NSString *)merchantId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject);
 RCT_EXTERN_METHOD(createBankAccount: (NSString *)merchantId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject);