demo app changes for checkout app switch

Author: KunJeongPark

Demo/Demo/CardPayments/CardPaymentViewModel/CardPaymentViewModel.swift

@@ -12,6 +12,9 @@ class CardPaymentViewModel: ObservableObject {
 
     private var cardClient: CardClient?
 
+    /// Card supports:
+    /// - S1: no vault (paymentSource = nil)
+    /// - S5: vault (paymentSource.card.attributes.vault)
     func createOrder(
         amount: String,
         selectedMerchantIntegration: MerchantIntegration,
@@ -21,37 +24,26 @@ class CardPaymentViewModel: ObservableObject {
     ) async throws {
 
         let amountRequest = Amount(currencyCode: "USD", value: amount)
-        // TODO: might need to pass in payee as payee object or as auth header
 
-        var vaultCardPaymentSource: VaultCardPaymentSource?
+        var paymentSource: OrderPaymentSource?
         if shouldVault {
-            var customer: Customer?
-            if let customerID {
-                customer = Customer(id: customerID)
-            }
+            let customer = customerID.map { Customer(id: $0) }
             let attributes = Attributes(vault: Vault(storeInVault: "ON_SUCCESS"), customer: customer)
-            let card = VaultCard(attributes: attributes)
-            vaultCardPaymentSource = VaultCardPaymentSource(card: card)
-        }
-
-        var vaultPaymentSource: VaultPaymentSource?
-        if let vaultCardPaymentSource {
-            vaultPaymentSource = .card(vaultCardPaymentSource)
+            let card = CardSource(attributes: attributes)
+            paymentSource = .card(OrderCardPaymentSource(card: card))
         }
 
-        let orderRequestParams = CreateOrderParams(
+        let params = CreateOrderParams(
             applicationContext: nil,
             intent: intent,
             purchaseUnits: [PurchaseUnit(amount: amountRequest)],
-            paymentSource: vaultPaymentSource
+            paymentSource: paymentSource
         )
 
         do {
-            DispatchQueue.main.async {
-                self.state.createdOrderResponse = .loading
-            }
+            DispatchQueue.main.async { self.state.createdOrderResponse = .loading }
             let order = try await DemoMerchantAPI.sharedService.createOrder(
-                orderParams: orderRequestParams, selectedMerchantIntegration: selectedMerchantIntegration
+                orderParams: params, selectedMerchantIntegration: selectedMerchantIntegration
             )
             DispatchQueue.main.async {
                 self.state.createdOrderResponse = .loaded(order)

Demo/Demo/Models/CreateOrderParams.swift

@@ -1,70 +1,81 @@
 struct CreateOrderParams: Encodable {
 
-    let applicationContext: ApplicationContext?
-    let intent: String
-    var purchaseUnits: [PurchaseUnit]?
-    var paymentSource: VaultPaymentSource?
+    var applicationContext: ApplicationContext?
+    var intent: String
+    var purchaseUnits: [PurchaseUnit]
+    var paymentSource: OrderPaymentSource?
 }
 
 struct ApplicationContext: Codable {
 
     let userAction: String
     let shippingPreference: String
-
-    enum CodingKeys: String, CodingKey {
-        case userAction
-        case shippingPreference
-    }
 }
 
-enum VaultPaymentSource: Encodable {
-    case card(VaultCardPaymentSource)
-    case paypal(VaultPayPalPaymentSource)
+// MARK: - Payment source (general, for both vault, and non-vault)
+
+enum OrderPaymentSource: Encodable {
+
+    case paypal(OrderPayPalPaymentSource)
+    case card(OrderCardPaymentSource)
 
     func encode(to encoder: Encoder) throws {
         var container = encoder.singleValueContainer()
         switch self {
-        case .card(let cardSource):
-            try container.encode(cardSource)
-        case .paypal(let paypalSource):
-            try container.encode(paypalSource)
+        case .paypal(let source): try container.encode(source)
+        case .card(let source):   try container.encode(source)
         }
     }
 }
 
-struct VaultPayPalPaymentSource: Encodable {
+struct OrderPayPalPaymentSource: Encodable {
 
-    let paypal: VaultPayPal
+    let paypal: PayPalSource
 }
 
-struct VaultPayPal: Encodable {
+struct OrderCardPaymentSource: Encodable {
 
-    let attributes: Attributes
-    let experienceContext: ExperienceContext
+    let card: CardSource
 }
 
-struct ExperienceContext: Encodable {
+// Attributes are only for vault now
+struct PayPalSource: Encodable {
+
+    var attributes: Attributes?
+    var experienceContext: PayPalExperienceContext?
+}
+
+struct CardSource: Encodable {
+
+    var attributes: Attributes?
+}
+
+// MARK: - PayPal experience context
+
+struct PayPalExperienceContext: Encodable {
 
-    // these fields are not encoded for our SDK but are required for create order with PayPal vault option
     let returnUrl: String
     let cancelUrl: String
+    var appSwitchContext: AppSwitchContext?
 }
 
-struct VaultCardPaymentSource: Encodable {
+struct AppSwitchContext: Encodable {
 
-    let card: VaultCard
+    let nativeApp: NativeApp
 }
 
-struct VaultCard: Encodable {
+struct NativeApp: Encodable {
 
-    let attributes: Attributes
+    let osType: String
+    let appUrl: String
 }
 
+// MARK: - Vault attributes
+
 struct Attributes: Encodable {
 
     let vault: Vault
     let customer: Customer?
-
     init(vault: Vault, customer: Customer? = nil) {
         self.vault = vault
         self.customer = customer
@@ -76,7 +87,6 @@ struct Vault: Encodable {
     let storeInVault: String
     let usageType: String?
     let customerType: String?
-
     init(storeInVault: String, usageType: String? = nil, customerType: String? = nil) {
         self.storeInVault = storeInVault
         self.usageType = usageType
@@ -132,7 +142,7 @@ struct Amount: Encodable {
     let currencyCode: String
     let value: String
     var breakdown: Breakdown?
-    
+
     struct Breakdown: Encodable {
 
         let shipping: ItemTotal

Demo/Demo/PayPalWebPayments/PayPalWebViewModel/PayPalWebViewModel.swift

@@ -10,6 +10,8 @@ class PayPalWebViewModel: ObservableObject {
     @Published var order: Order?
     @Published var checkoutResult: PayPalWebCheckoutResult?
 
+    let appSwitchURL = "https://ppcp-mobile-demo-sandbox-87bbd7f0a27f.herokuapp.com"
+
     var payPalWebCheckoutClient: PayPalWebCheckoutClient?
 
     var orderID: String? {
@@ -19,42 +21,46 @@ class PayPalWebViewModel: ObservableObject {
     let configManager = CoreConfigManager(domain: "PayPalWeb Payments")
     private var payPalDataCollector: PayPalDataCollector?
 
-    func createOrder(shouldVault: Bool) async throws {
+    /// S1: No payment source (non app-switch, non vault)
+    /// S2: PayPal app-switch (no vault) -> experienceContext with appSwitchContext
+    /// S3: PayPal vault (no app-switch)  -> attributes.vault + experienceContext
+    /// S4: PayPal vault + app-switch     -> attributes.vault + experienceContext.appSwitchContext
+    func createOrder(shouldVault: Bool, appSwitch: Bool = false) async throws {
         let amountRequest = Amount(currencyCode: "USD", value: "10.00")
 
-        // TODO: might need to pass in payee as payee object or as auth header
-        var vaultPayPalPaymentSource: VaultPayPalPaymentSource?
-        if shouldVault {
-            let attributes = Attributes(vault: Vault(storeInVault: "ON_SUCCESS", usageType: "MERCHANT", customerType: "CONSUMER"))
-            // The returnURL is not used in our mobile SDK, but a required field for create order with PayPal payment source. DTPPCPSDK-1492 to track this issue
-            let paypal = VaultPayPal(
-                attributes: attributes,
-                experienceContext: ExperienceContext(
-                    returnUrl: "https://example.com/returnUrl",
-                    cancelUrl: "https://example.com/cancelUrl"
-                )
+        var paymentSource: OrderPaymentSource?
+
+        if appSwitch || shouldVault {
+            // experienceContext is required for PayPal vault and for app switch
+            let nativeApp = NativeApp(osType: "IOS", appUrl: appSwitchURL)
+            let experience = PayPalExperienceContext(
+                returnUrl: appSwitchURL + "/success",
+                cancelUrl: appSwitchURL + "/cancel",
+                appSwitchContext: appSwitch ? AppSwitchContext(nativeApp: nativeApp) : nil
             )
-            vaultPayPalPaymentSource = VaultPayPalPaymentSource(paypal: paypal)
-        }
 
-        var vaultPaymentSource: VaultPaymentSource?
-        if let vaultPayPalPaymentSource {
-            vaultPaymentSource = .paypal(vaultPayPalPaymentSource)
+            let attributes: Attributes? = shouldVault
+            ? Attributes(vault: Vault(
+                storeInVault: "ON_SUCCESS",
+                usageType: "MERCHANT",
+                customerType: "CONSUMER"))
+            : nil
+
+            let paypal = PayPalSource(attributes: attributes, experienceContext: experience)
+            paymentSource = .paypal(OrderPayPalPaymentSource(paypal: paypal))
         }
 
-        let orderRequestParams = CreateOrderParams(
+        let params = CreateOrderParams(
             applicationContext: nil,
             intent: intent.rawValue,
             purchaseUnits: [PurchaseUnit(amount: amountRequest)],
-            paymentSource: vaultPaymentSource
+            paymentSource: paymentSource
         )
 
         do {
-            DispatchQueue.main.async {
-                self.state.createdOrderResponse = .loading
-            }
+            DispatchQueue.main.async { self.state.createdOrderResponse = .loading }
             let order = try await DemoMerchantAPI.sharedService.createOrder(
-                orderParams: orderRequestParams,
+                orderParams: params,
                 selectedMerchantIntegration: DemoSettings.merchantIntegration
             )
             DispatchQueue.main.async {