@sumup/react-native-checkout 0.0.0-alpha.1

package/android/src/main/java/com/sumupreactnative/PaymentUtil.java

@@ -0,0 +1,111 @@
+package com.sumupreactnative;
+
+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 PaymentUtil {
+
+  private PaymentUtil() {
+  }
+
+  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"));
+          }
+        }
+      });
+    }};
+  }
+
+  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 = PaymentUtil.getBaseRequest();
+      paymentDataRequest.put(
+        "allowedPaymentMethods", new JSONArray().put(PaymentUtil.getCardPaymentMethod(requestData.getMap("cardPaymentMethod"))));
+      paymentDataRequest.put("transactionInfo", PaymentUtil.getTransactionInfo(requestData.getMap("transaction")));
+      paymentDataRequest.put("merchantInfo", PaymentUtil.getMerchantInfo(requestData.getString("merchantName")));
+
+      return paymentDataRequest;
+    } catch (JSONException e) {
+      return null;
+    }
+  }
+}

package/android/src/main/java/com/sumupreactnative/SumupReactNativeModule.java

@@ -0,0 +1,187 @@
+package com.sumupreactnative;
+
+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.facebook.react.module.annotations.ReactModule;
+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 androidx.annotation.NonNull;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+@ReactModule(name = SumupReactNativeModule.NAME)
+public class SumupReactNativeModule extends ReactContextBaseJavaModule {
+  public static final String NAME = "SumupReactNative";
+  private static final int LOAD_PAYMENT_DATA_REQUEST_CODE = 991;
+
+  private PaymentsClient mPaymentsClient;
+  private Promise requestPaymentPromise = null;
+  private final ReactApplicationContext reactContext;
+
+  private static final String ENVIRONMENT_PRODUCTION_KEY = "ENVIRONMENT_PRODUCTION";
+
+  private static final String ENVIRONMENT_TEST_KEY = "ENVIRONMENT_TEST";
+
+  public SumupReactNativeModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+    this.reactContext = reactContext;
+    reactContext.addActivityEventListener(activityEventListener);
+  }
+
+  @Override
+  @NonNull
+  public String getName() {
+    return NAME;
+  }
+
+  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(NAME, "[GooglePay] " + errorMessage);
+              requestPaymentPromise.reject("PAYMENT_RESULT_ERROR", errorMessage);
+              break;
+            default:
+              // Do nothing.
+          }
+          break;
+      }
+    }
+  };
+
+  @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;
+  }
+
+  // Example method
+  // See https://reactnative.dev/docs/native-modules-android
+  @ReactMethod
+  public void setEnvironment(int environment) {
+    final Activity activity = getCurrentActivity();
+    if (activity == null) {
+      return;
+    }
+
+    mPaymentsClient = PaymentUtil.createPaymentsClient(environment, activity);
+  }
+
+  @ReactMethod
+  public void isReadyToPay(ReadableArray allowedCardNetworks, ReadableArray allowedCardAuthMethods, final Promise promise) {
+    final Activity activity = getCurrentActivity();
+    if (activity == null) {
+      Log.w(NAME, "[GooglePay] activity is null");
+      promise.resolve(false);
+      return;
+    }
+
+    final JSONObject isReadyToPayJson = PaymentUtil.getIsReadyToPayRequest(allowedCardNetworks.toArrayList(), allowedCardAuthMethods.toArrayList());
+    if (isReadyToPayJson == null) {
+      Log.w(NAME, "[GooglePay] isReadyToPayJson == null");
+      promise.resolve(false);
+      return;
+    }
+    IsReadyToPayRequest request = IsReadyToPayRequest.fromJson(isReadyToPayJson.toString());
+    if (request == null) {
+      Log.w(NAME, "[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(NAME, "[GooglePay] Not available");
+              promise.resolve(false);
+            }
+          } else {
+            Log.w(NAME, "[GooglePay] isReadyToPay failed");
+            promise.resolve(false);
+          }
+        }
+      });
+  }
+
+  @ReactMethod
+  public void requestPayment(ReadableMap requestData, final Promise promise) {
+    final Activity activity = getCurrentActivity();
+    if (activity == null) {
+      Log.w(NAME, "[GooglePay] activity is null");
+      promise.reject("NO_ACTIVITY", "activity is null");
+      return;
+    }
+
+    JSONObject paymentDataRequestJson = PaymentUtil.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;
+    }
+
+    requestPaymentPromise.resolve(paymentInformation);
+  }
+}

package/android/src/main/java/com/sumupreactnative/SumupReactNativePackage.java

@@ -0,0 +1,28 @@
+package com.sumupreactnative;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class SumupReactNativePackage implements ReactPackage {
+  @NonNull
+  @Override
+  public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+    List<NativeModule> modules = new ArrayList<>();
+    modules.add(new SumupReactNativeModule(reactContext));
+    return modules;
+  }
+
+  @NonNull
+  @Override
+  public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+    return Collections.emptyList();
+  }
+}

package/ios/SumupReactNative-Bridging-Header.h

@@ -0,0 +1,2 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>

package/ios/SumupReactNative.m

@@ -0,0 +1,18 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(SumupReactNative, NSObject)
+
+RCT_EXTERN_METHOD(configure:(NSDictionary)method details:(NSDictionary)details)
+
+RCT_EXTERN_METHOD(presentApplePay:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(canMakePayments:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return YES;
+}
+
+@end

package/ios/SumupReactNative.swift

@@ -0,0 +1,164 @@
+import PassKit
+
+@objc(SumupReactNative)
+class SumupReactNative: UIViewController {
+
+    private var request: PKPaymentRequest = PKPaymentRequest()
+    private var resolve: RCTPromiseResolveBlock?
+    private var paymentNetworks: [PKPaymentNetwork]?
+    
+    @objc(configure:details:)
+    private func configure(withMethod method: NSDictionary, details: NSDictionary) -> Void {
+
+        self.paymentNetworks = method["supportedNetworks"] as? [PKPaymentNetwork]
+
+        guard let paymentNetworks = paymentNetworks,
+              PKPaymentAuthorizationViewController.canMakePayments(usingNetworks: paymentNetworks),
+              let total = details["total"] as? NSDictionary,
+              let label = total["label"] as? String,
+              let amount = total["amount"] as? Double,
+              let currencyCode = method["currencyCode"] as? String,
+              let countryCode = method["countryCode"] as? String,
+              let merchantIdentifier = method["merchantIdentifier"] as? String else {
+            print("SumupReactNative: params are not valid")
+            return
+        }
+        
+        let paymentItem = PKPaymentSummaryItem.init(label: label,
+                                                    amount: NSDecimalNumber(value: amount))
+        request.currencyCode = currencyCode
+        request.countryCode = countryCode
+        request.merchantIdentifier = merchantIdentifier
+        request.merchantCapabilities = PKMerchantCapability.capability3DS
+        request.supportedNetworks = paymentNetworks
+        request.paymentSummaryItems = [paymentItem]
+    }
+
+    @objc(presentApplePay:withRejecter:)
+    func presentApplePay(resolve: @escaping RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) -> Void {
+        guard let paymentNetworks = paymentNetworks,
+              PKPaymentAuthorizationViewController.canMakePayments(usingNetworks: paymentNetworks) else {
+            print("SumupReactNative: Can not make payment")
+            return
+        }
+        
+        self.resolve = resolve
+        
+        if let controller = PKPaymentAuthorizationViewController(paymentRequest: request) {
+            controller.delegate = self
+
+            DispatchQueue.main.async {
+                var rootViewController = UIApplication.shared.keyWindow?.rootViewController
+                if let presentedViewController = rootViewController?.presentedViewController {
+                    rootViewController = presentedViewController
+                }
+
+                guard let rootViewController = rootViewController else {
+                    print("SumupReactNative: unable to find rootViewController")
+                    return
+                }
+
+                rootViewController.present(controller, animated: true, completion: nil)
+            }
+        }
+    }
+
+    @objc(canMakePayments:withRejecter:)
+    func canMakePayments(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) -> Void {
+        if let paymentNetworks = paymentNetworks,
+           PKPaymentAuthorizationViewController.canMakePayments(usingNetworks: paymentNetworks) {
+            resolve(true)
+        } else {
+            resolve(false)
+        }
+    }
+}
+
+extension SumupReactNative: PKPaymentAuthorizationViewControllerDelegate {
+    func paymentAuthorizationViewControllerDidFinish(_ controller: PKPaymentAuthorizationViewController) {
+        controller.dismiss(animated: true, completion: nil)
+    }
+
+    func paymentAuthorizationViewController(_ controller: PKPaymentAuthorizationViewController, didAuthorizePayment payment: PKPayment, completion: @escaping (PKPaymentAuthorizationStatus) -> Void) {
+
+        self.resolve?(payment.toDictionary())
+        completion(.success)
+    }
+}
+
+extension PKPayment {
+
+    func toDictionary() -> [String: Any] {
+        var paymentResponse = [String: Any]()
+
+        let transactionId = self.token.transactionIdentifier
+        paymentResponse["transactionIdentifier"] = transactionId
+
+        if let paymentData = String(data: self.token.paymentData, encoding: .utf8) {
+            paymentResponse["paymentData"] = paymentData
+        }
+
+        paymentResponse["paymentMethod"] = self.token.paymentMethod.toDictionary()
+        
+        return paymentResponse
+    }
+}
+
+extension PKPaymentMethod {
+
+    func toDictionary() -> [String: Any] {
+        var result = [String: Any]()
+        
+        if let displayName = self.displayName {
+            result["displayName"] = displayName
+        }
+        
+        if let network = self.network {
+            result["network"] = network
+        }
+        
+        let type = self.type.toString()
+        result["type"] = type
+        
+        if let paymentPass = self.paymentPass {
+            let paymentPassDict = paymentPass.toDictionary()
+            result["paymentPass"] = paymentPassDict
+        }
+        
+        return result
+    }
+}
+
+extension PKPaymentMethodType {
+
+    func toString() -> String {
+        let arr = ["unknown", "debit", "credit", "prepaid", "store", "eMoney"]
+        return arr[Int(self.rawValue)]
+    }
+}
+
+extension PKPaymentPass {
+
+    func toDictionary() -> [String: Any] {
+        return [
+            "primaryAccountIdentifier": self.primaryAccountIdentifier,
+            "primaryAccountNumberSuffix": self.primaryAccountNumberSuffix,
+            "deviceAccountIdentifier": self.deviceAccountIdentifier,
+            "deviceAccountNumberSuffix": self.deviceAccountNumberSuffix,
+            "activationState": self.activationState.toString()
+        ]
+    }
+}
+
+extension PKPaymentPassActivationState {
+
+    func toString() -> String {
+        let arr = ["PKPaymentPassActivationStateActivated",
+                   "PKPaymentPassActivationStateRequiresActivation",
+                   "PKPaymentPassActivationStateActivating",
+                   "PKPaymentPassActivationStateSuspended",
+                   "PKPaymentPassActivationStateDeactivated"]
+
+        return arr[Int(self.rawValue)]
+    }
+}