@connexup/react-native-square-mobile-payment-sdk 0.1.0

package/ios/MobilePaymentPayment.swift

@@ -0,0 +1,478 @@
+//
+//  RNMobilePaymentPayment.swift
+//
+//  Created by chancetio on 2023/9/13.
+//
+
+import Foundation
+import SquareMobilePaymentsSDK
+
+let PaymentErrorNoNetwork = "PAYMENT_ERROR_NO_NETWORK"
+let PaymentErrorNotAuthorized = "PAYMENT_ERROR_NOT_AUTHORIZED"
+let PaymentErrorInvalidPaymentParameters = "PAYMENT_ERROR_INVALID_PAYMENT_PARAMETERS"
+let PaymentErrorTimedOut = "PAYMENT_ERROR_TIMED_OUT"
+let PaymentErrorLocationPermissionNeeded = "PAYMENT_ERROR_LOCATION_PERMISSION_NEEDED"
+let PaymentErrorPaymentAlreadyInProgress = "PAYMENT_ERROR_PAYMENT_ALREADY_IN_PROGRESS"
+let PaymentErrorIdempotencyKeyReused = "PAYMENT_ERROR_IDEMPOTENCY_KEY_REUSED"
+let PaymentErrorInvalidPaymentSource = "PAYMENT_ERROR_INVALID_PAYMENT_SOURCE"
+let PaymentErrorUnexpected = "PAYMENT_ERROR_UNEXPECTED"
+let PaymentErrorMerchantNotOptedIntoOfflineProcessing =
+  "PAYMENT_ERROR_MERCHANT_NOT_OPTED_INTO_OFFLINE_PROCESSING"
+let PaymentErrorOfflineTransactionAmountExceeded =
+  "PAYMENT_ERROR_OFFLINE_TRANSACTION_AMOUNT_EXCEEDED"
+let PaymentErrorOfflineStoredAmountExceeded =
+  "PAYMENT_ERROR_OFFLINE_STORED_AMOUNT_EXCEEDED"
+let PaymentErrorSandboxUnsupportedForOfflineProcessing =
+  "PAYMENT_ERROR_SANDBOX_UNSUPPORTED_FOR_OFFLINE_PROCESSING"
+let PaymentDeviceClockSkewed = "PAYMENT_DEVICE_CLOCK_SKEWED"
+let PaymentErrorUnsupportedMode = "PAYMENT_ERROR_UNSUPPORTED_MODE"
+let PaymentTrackingConsentIsPending = "PAYMENT_TRACKING_CONSENT_IS_PENDING"
+let PaymentAttemptIdRequiredForSca = "PAYMENT_ATTEMPT_ID_REQUIRED_FOR_SCA"
+let PaymentAttemptIdReused = "PAYMENT_ATTEMPT_ID_REUSED"
+
+@objc public protocol RCTMobilePaymentPaymentEventEmitter {
+  func onAvailableCardInputMethodsChange(_ value: [String])
+  func onPaymentFlowStatusChange(_ value: [String: Any])
+}
+
+@objcMembers
+public class MobilePaymentPayment: NSObject {
+  private lazy var observer = MobilePaymentPaymentObserver(owner: self)
+
+  public weak var emitter: RCTMobilePaymentPaymentEventEmitter?
+
+  deinit {
+    invalidate()
+  }
+
+  public func initialize() {
+    NotificationUtils.addObserver(self, selector: #selector(onSDKInitialize), name: MobilePaymentNotificationKeys.sdkInitialized.rawValue)
+    if MobilePaymentSDK.shared.isInitialized {
+      onSDKInitialize()
+    }
+  }
+
+  public func invalidate() {
+    NotificationUtils.removeObserver(self)
+    if MobilePaymentSDK.shared.isInitialized {
+      MobilePaymentsSDK.shared.paymentManager.remove(observer)
+      DispatchQueue.main.async {
+        if let paymentHandle = MobilePaymentsSDK.shared.paymentManager.currentPaymentHandle, paymentHandle.isPaymentCancelable {
+          paymentHandle.cancelPayment()
+        }
+      }
+    }
+  }
+
+  @objc
+  private func onSDKInitialize() {
+    MobilePaymentsSDK.shared.paymentManager.remove(observer)
+    MobilePaymentsSDK.shared.paymentManager.add(observer)
+  }
+
+  public func startPayment(paymentParameters: RCTPaymentParameters,
+                           promptParameters: RCTPromptParameters,
+                           completion: @escaping (_ error: NativeErrorInfo?) -> Void)
+  {
+    DispatchQueue.main.async {
+      guard let paymentParameters = self.makePaymentParameters(from: paymentParameters) else {
+        completion(NativeErrorInfo(code: ErrorUtilities.PARAMS_ERROR, message: ErrorUtilities.createNativeModuleError(code: ErrorUtilities.PARAMS_ERROR, message: "PaymentParameters Error"), error: nil))
+        return
+      }
+
+      guard let promptParameters = self.makePromptParameters(from: promptParameters) else {
+        completion(NativeErrorInfo(code: ErrorUtilities.PARAMS_ERROR, message: ErrorUtilities.createNativeModuleError(code: ErrorUtilities.PARAMS_ERROR, message: "PromptParameters Error"), error: nil))
+        return
+      }
+
+      guard let rootViewController = UIApplication.shared.delegate?.window??.rootViewController else {
+        completion(NativeErrorInfo(code: ErrorUtilities.UNKNOWN_ERROR, message: ErrorUtilities.createNativeModuleError(code: ErrorUtilities.UNKNOWN_ERROR, message: "RootViewController Not Found"), error: nil))
+        return
+      }
+
+      if let paymentHandle = MobilePaymentsSDK.shared.paymentManager.currentPaymentHandle, paymentHandle.isPaymentCancelable {
+        paymentHandle.cancelPayment()
+      }
+
+      MobilePaymentsSDK.shared.paymentManager.startPayment(paymentParameters, promptParameters: promptParameters, from: rootViewController, delegate: self.observer)
+      completion(nil)
+    }
+  }
+
+  public func availableCardInputMethods() -> [String] {
+    return MobilePaymentsSDK.shared.paymentManager.availableCardInputMethods.jsonValue
+  }
+
+  public func additionalPaymentMethods() -> [[String: Any]] {
+    return MobilePaymentsSDK.shared.paymentManager.currentPaymentHandle?.additionalPaymentMethods.map { $0.jsonDictionary } ?? []
+  }
+
+  public func triggerPaymentWithAdditionalPaymentMethod(_ paymentSource: [String: Any], completion: @escaping (_ error: NativeErrorInfo?) -> Void)
+  {
+    DispatchQueue.main.async {
+      guard let sourceType = paymentSource["type"] as? String, let realSourceType = AdditionalPaymentMethodType.make(from: sourceType) else {
+        completion(NativeErrorInfo(code: ErrorUtilities.PARAMS_ERROR, message: ErrorUtilities.createNativeModuleError(code: ErrorUtilities.PARAMS_ERROR, message: "Params sourceType Not Found"), error: nil))
+        return
+      }
+
+      guard let paymentHandle = MobilePaymentsSDK.shared.paymentManager.currentPaymentHandle else {
+        completion(NativeErrorInfo(code: ErrorUtilities.UNKNOWN_ERROR, message: ErrorUtilities.createNativeModuleError(code: ErrorUtilities.UNKNOWN_ERROR, message: "PaymentHandle Not Found"), error: nil))
+        return
+      }
+
+      guard let additionalPaymentMethod = paymentHandle.additionalPaymentMethods.first(where: { $0.type == realSourceType }) else {
+        completion(NativeErrorInfo(code: ErrorUtilities.UNKNOWN_ERROR, message: ErrorUtilities.createNativeModuleError(code: ErrorUtilities.UNKNOWN_ERROR, message: "AdditionalPaymentMethod Not Found"), error: nil))
+        return
+      }
+
+      var realPaymenSouce: PaymentSource?
+      switch additionalPaymentMethod.type {
+      case .keyed:
+        realPaymenSouce = KeyedCardPaymentSource()
+      case .cardOnFile:
+        guard let cardID = paymentSource["cardID"] as? String else {
+          completion(NativeErrorInfo(code: ErrorUtilities.PARAMS_ERROR, message: ErrorUtilities.createNativeModuleError(code: ErrorUtilities.PARAMS_ERROR, message: "Params cardID Not Found"), error: nil))
+          return
+        }
+        realPaymenSouce = CardOnFilePaymentSource(cardID: cardID)
+      case .houseAccount:
+        guard let houseAccountPaymentSourceId = paymentSource["houseAccountPaymentSourceId"] as? String else {
+          completion(NativeErrorInfo(code: ErrorUtilities.PARAMS_ERROR, message: ErrorUtilities.createNativeModuleError(code: ErrorUtilities.PARAMS_ERROR, message: "Params houseAccountPaymentSourceId Not Found"), error: nil))
+          return
+        }
+        realPaymenSouce = HouseAccountPaymentSource(paymentSourceID: houseAccountPaymentSourceId)
+      case .tapToPay:
+        realPaymenSouce = TapToPayPaymentSource()
+      case .cash:
+        realPaymenSouce = CashPaymentSource()
+      @unknown default:
+        realPaymenSouce = nil
+      }
+
+      guard let realPaymenSouce = realPaymenSouce else {
+        completion(NativeErrorInfo(code: ErrorUtilities.UNKNOWN_ERROR, message: ErrorUtilities.createNativeModuleError(code: ErrorUtilities.UNKNOWN_ERROR, message: "RealPaymenSouce is nil"), error: nil))
+        return
+      }
+
+      do {
+        try additionalPaymentMethod.triggerPayment(with: realPaymenSouce)
+        completion(nil)
+      } catch {
+        completion(NativeErrorInfo(code: ErrorUtilities.UNKNOWN_ERROR, message: ErrorUtilities.serializeErrorToJson(code: ErrorUtilities.UNKNOWN_ERROR, error: error as NSError), error: error))
+      }
+    }
+  }
+
+  public func currentPayment() -> [String: Any]? {
+    return MobilePaymentsSDK.shared.paymentManager.currentPaymentHandle?.payment.jsonDictionary
+  }
+
+  public func isCurrentPaymentCancelable() -> Bool {
+    return MobilePaymentsSDK.shared.paymentManager.currentPaymentHandle?.isPaymentCancelable ?? true
+  }
+
+  public func cancelCurrentPayment(resolve: @escaping (_ value: Bool) -> Void,
+                                   reject: @escaping (_ error: NativeErrorInfo) -> Void)
+  {
+    DispatchQueue.main.async {
+      guard let paymentHandle = MobilePaymentsSDK.shared.paymentManager.currentPaymentHandle else {
+        resolve(true)
+        return
+      }
+      if !paymentHandle.isPaymentCancelable {
+        resolve(false)
+        return
+      }
+      resolve(paymentHandle.cancelPayment())
+    }
+  }
+
+  private func makePaymentParameters(from parameters: RCTPaymentParameters) -> PaymentParameters? {
+    guard let amountMoney = Money.make(from: parameters.amountMoney) else {
+      return nil
+    }
+
+    guard let processingMode = ProcessingMode.make(from: parameters.processingMode) else {
+      return nil
+    }
+
+    let result = PaymentParameters(paymentAttemptID: parameters.paymentAttemptId, amountMoney: amountMoney, processingMode: processingMode)
+
+    if let acceptPartialAuthorization = parameters.acceptPartialAuthorization {
+      result.acceptPartialAuthorization = acceptPartialAuthorization
+    }
+
+    if let autocomplete = parameters.autocomplete {
+      result.autocomplete = autocomplete
+    }
+
+    if let delayAction = parameters.delayAction {
+      switch delayAction {
+      case "CANCEL":
+        result.delayAction = .cancel
+      case "COMPLETE":
+        result.delayAction = .complete
+      default:
+        break
+      }
+    }
+
+    if let delayDuration = parameters.delayDuration {
+      result.delayDuration = delayDuration
+    }
+
+    if let tipMoney = Money.make(from: parameters.tipMoney) {
+      result.tipMoney = tipMoney
+    }
+
+    if let appFeeMoney = Money.make(from: parameters.appFeeMoney) {
+      result.appFeeMoney = appFeeMoney
+    }
+
+    if let locationID = parameters.locationID {
+      result.locationID = locationID
+    }
+
+    if let orderID = parameters.orderID {
+      result.orderID = orderID
+    }
+
+    if let referenceID = parameters.referenceID {
+      result.referenceID = referenceID
+    }
+
+    if let customerID = parameters.customerID {
+      result.customerID = customerID
+    }
+
+    if let teamMemberID = parameters.teamMemberID {
+      result.teamMemberID = teamMemberID
+    }
+
+    if let note = parameters.note {
+      result.note = note
+    }
+
+    if let statementDescriptionIdentifier = parameters.statementDescriptionIdentifier {
+      result.statementDescriptionIdentifier = statementDescriptionIdentifier
+    }
+
+    // TODO: cardHandle
+
+    return result
+  }
+
+  private func makePromptParameters(from parameters: RCTPromptParameters) -> PromptParameters? {
+    var mode = PromptMode.default
+    var additionalMethods = AdditionalPaymentMethods.all
+
+    switch parameters.mode {
+    case "DEFAULT":
+      mode = PromptMode.default
+    case "CUSTOM":
+      mode = PromptMode.custom
+    default:
+      break
+    }
+
+    // TODO: improve this
+    if let additionalMethodsParams = parameters.additionalMethods {
+      switch additionalMethodsParams {
+      case "ALL":
+        additionalMethods = .all
+      case "KEYED":
+        additionalMethods = .keyed
+      default:
+        break
+      }
+    }
+
+    return PromptParameters(mode: mode, additionalMethods: additionalMethods)
+  }
+
+  // TODO: theme
+  /*
+   private func makeTheme(from jsonTheme: [String: Any]?) -> Theme {
+     let result = Theme()
+
+     if let jsonTheme = jsonTheme {
+       if let titleColor = jsonTheme["titleColor"] as? String {
+         result.titleColor = UIColor(fromHex: titleColor)
+       }
+       if let titleFont = jsonTheme["titleFont"] as? [String: Any] {
+         result.titleFont = makeFont(origin: result.titleFont, jsonFont: titleFont)
+       }
+       if let subtitleColor = jsonTheme["subtitleColor"] as? String {
+         result.subtitleColor = UIColor(fromHex: subtitleColor)
+       }
+       if let subtitleFont = jsonTheme["subtitleFont"] as? [String: Any] {
+         result.subtitleFont = makeFont(origin: result.subtitleFont, jsonFont: subtitleFont)
+       }
+       if let tintColor = jsonTheme["tintColor"] as? String {
+         result.tintColor = UIColor(fromHex: tintColor)
+       }
+       if let backgroundColor = jsonTheme["backgroundColor"] as? String {
+         result.backgroundColor = UIColor(fromHex: backgroundColor)
+       }
+       if let buttonTextColor = jsonTheme["buttonTextColor"] as? String {
+         result.buttonTextColor = UIColor(fromHex: buttonTextColor)
+       }
+       if let buttonFont = jsonTheme["buttonFont"] as? [String: Any] {
+         result.buttonFont = makeFont(origin: result.buttonFont, jsonFont: buttonFont)
+       }
+       if let buttonCornerRadius = jsonTheme["buttonCornerRadius"] as? CGFloat {
+         result.buttonCornerRadius = buttonCornerRadius
+       }
+       if let informationIconColor = jsonTheme["informationIconColor"] as? String {
+         result.informationIconColor = UIColor(fromHex: informationIconColor)
+       }
+       if let successIconColor = jsonTheme["successIconColor"] as? String {
+         result.successIconColor = UIColor(fromHex: successIconColor)
+       }
+       if let errorIconColor = jsonTheme["errorIconColor"] as? String {
+         result.errorIconColor = UIColor(fromHex: errorIconColor)
+       }
+       if let cornerRadius = jsonTheme["cornerRadius"] as? CGFloat {
+         result.cornerRadius = cornerRadius
+       }
+       if let presentationStyle = jsonTheme["presentationStyle"] as? String {
+         if presentationStyle == "AUTOMATIC" {
+           result.presentationStyle = .automatic
+         }
+         if presentationStyle == "ALWAYS_FULLSCREEN" {
+           result.presentationStyle = .alwaysFullscreen
+         }
+       }
+       if let inputFieldColor = jsonTheme["inputFieldColor"] as? String {
+         result.inputFieldColor = UIColor(fromHex: inputFieldColor)
+       }
+       if let inputFieldTextColor = jsonTheme["inputFieldTextColor"] as? String {
+         result.inputFieldTextColor = UIColor(fromHex: inputFieldTextColor)
+       }
+       if let inputFieldPlaceholderTextColor = jsonTheme["inputFieldPlaceholderTextColor"] as? String {
+         result.inputFieldPlaceholderTextColor = UIColor(fromHex: inputFieldPlaceholderTextColor)
+       }
+       if let inputFieldErrorColor = jsonTheme["inputFieldErrorColor"] as? String {
+         result.inputFieldErrorColor = UIColor(fromHex: inputFieldErrorColor)
+       }
+     }
+
+     return result
+   }
+    */
+
+  /*
+   private func makeFont(origin: UIFont, jsonFont: [String: Any]) -> UIFont {
+     var targetFontSize = origin.pointSize
+     var targetFontName = origin.fontName
+
+     if let size = jsonFont["size"] as? CGFloat {
+       targetFontSize = size
+     }
+     if let fontName = jsonFont["fontName"] as? String {
+       targetFontName = fontName
+     }
+
+     return UIFont(name: targetFontName, size: targetFontSize) ?? origin.withSize(targetFontSize)
+   }
+   */
+}
+
+class MobilePaymentPaymentObserver {
+  weak var owner: MobilePaymentPayment?
+
+  init(owner: MobilePaymentPayment) {
+    self.owner = owner
+  }
+}
+
+extension MobilePaymentPaymentObserver: AvailableCardInputMethodsObserver {
+  func availableCardInputMethodsDidChange(_ cardInputMethods: CardInputMethods) {
+    owner?.emitter?.onAvailableCardInputMethodsChange(cardInputMethods.jsonValue)
+  }
+}
+
+extension MobilePaymentPaymentObserver: PaymentManagerDelegate {
+  func paymentManager(_ paymentManager: PaymentManager, didStart payment: Payment) {
+    handlePayment(name: "didStart", payment: payment, error: nil)
+  }
+
+  func paymentManager(_ paymentManager: PaymentManager, willFinish payment: Payment) {
+    handlePayment(name: "willFinish", payment: payment, error: nil)
+  }
+
+  func paymentManager(_ paymentManager: PaymentManager, didFinish payment: Payment) {
+    handlePayment(name: "didFinish", payment: payment, error: nil)
+  }
+
+  func paymentManager(_ paymentManager: PaymentManager, didFail payment: Payment, withError error: Error) {
+    handlePayment(name: "didFail", payment: payment, error: error)
+  }
+
+  func paymentManager(_ paymentManager: PaymentManager, willCancel payment: Payment) {
+    handlePayment(name: "willCancel", payment: payment, error: nil)
+  }
+
+  func paymentManager(_ paymentManager: PaymentManager, didCancel payment: Payment) {
+    handlePayment(name: "didCancel", payment: payment, error: nil)
+  }
+
+  private func handlePayment(name: String, payment: Payment, error: Error?) {
+    var body: [String: Any] = [:]
+    body["name"] = name
+    body["payment"] = payment.jsonDictionary
+    if let error = error {
+      let realError = error as NSError
+      let errorCode = paymentErrorCode(nativeErrorCode: realError.code)
+      body["error"] = ErrorUtilities.serializeErrorToJson(code: errorCode, error: realError)
+    }
+    owner?.emitter?.onPaymentFlowStatusChange(body)
+  }
+
+  private func paymentErrorCode(nativeErrorCode: Int) -> String {
+    if let error = PaymentError(rawValue: nativeErrorCode) {
+      switch error {
+      case .noNetwork:
+        return PaymentErrorNoNetwork
+      case .notAuthorized:
+        return PaymentErrorNotAuthorized
+      case .invalidPaymentParameters:
+        return PaymentErrorInvalidPaymentParameters
+      case .timedOut:
+        return PaymentErrorTimedOut
+      case .locationPermissionNeeded:
+        return PaymentErrorLocationPermissionNeeded
+      case .paymentAlreadyInProgress:
+        return PaymentErrorPaymentAlreadyInProgress
+      case .idempotencyKeyReused:
+        return PaymentErrorIdempotencyKeyReused
+      case .invalidPaymentSource:
+        return PaymentErrorInvalidPaymentSource
+      case .unexpected:
+        return PaymentErrorUnexpected
+      case .merchantNotOptedIntoOfflineProcessing:
+        return PaymentErrorMerchantNotOptedIntoOfflineProcessing
+      case .offlineTransactionAmountExceeded:
+        return PaymentErrorOfflineTransactionAmountExceeded
+      case .offlineStoredAmountExceeded:
+        return PaymentErrorOfflineStoredAmountExceeded
+      case .sandboxUnsupportedForOfflineProcessing:
+        return PaymentErrorSandboxUnsupportedForOfflineProcessing
+      case .deviceTimeDoesNotMatchServerTime:
+        return PaymentDeviceClockSkewed
+      case .unsupportedMode:
+        return PaymentErrorUnsupportedMode
+      case .trackingConsentIsPending:
+        return PaymentTrackingConsentIsPending
+      case .paymentAttemptIdRequiredForSca:
+        return PaymentAttemptIdRequiredForSca
+      case .paymentAttemptIdReused:
+        return PaymentAttemptIdReused
+      @unknown default:
+        return ErrorUtilities.UNKNOWN_ERROR
+      }
+    } else {
+      return ErrorUtilities.UNKNOWN_ERROR
+    }
+  }
+}