Implementation

dependencies: [
    .package(url: "https://github.com/PXP-IO/ios-components-sdk", from: "1.0.0")
]

{
  "merchant": "MERCHANT-1",
  "site": "SITE-1",
  "sessionTimeout": 120,
  "merchantTransactionId": "0ce72cfd-014d-4256-a006-a56601b2ffc4",
  "transactionMethod": {
    "intent": {
      "card": "Authorisation",
      "paypal": "Purchase"
    }
  },
  "amounts": {
    "currencyCode": "USD",
    "transactionValue": 25.00
  },
  "allowTransaction": true,
  "serviceType": "CheckoutDropIn"
}

{
  "sessionId": "c5f0799b-0839-43ce-abc5-5b462a98f250",
  "hmacKey": "904bc42395d4af634e2fd48ee8c2c7f52955a1da97a3aa3d82957ff12980a7bb",
  "encryptionKey": "20d175a669ad3f8c195c9c283fc86155",
  "sessionExpiry": "2025-05-19T13:39:20.3843454Z",
  "allowedFundingTypes": {
    "cardSchemes": [
      "Visa",
      "Diners",
      "Mastercard",
      "AmericanExpress"
    ],
    "cards": [],
    "wallets": {
      "paypal": {
        "allowedFundingOptions": [
          "paylater", 
          "paypal"
        ],
        "merchantId": "paypal-merchant-123"
      },
      "applePay": {
        "merchantId": "merchant.com.example.store",
        "merchantName": "Your Store Name"
      }
    }
  }
}

import SwiftUI
import PXPCheckoutSDK

@MainActor
final class CheckoutViewModel: ObservableObject {
    @Published var dropIn: CheckoutDropIn?
    @Published var errorMessage: String?
    
    func loadDropIn() async {
        do {
            // Fetch session data from your backend
            let session = try await fetchSessionFromBackend()
            
            // Build transaction data
            let transactionData = DropInTransactionData(
                amount: Decimal(string: "49.99") ?? 0,
                currency: "USD",
                entryType: .ecom,
                intent: DropInTransactionIntentData(
                    card: .authorisation,
                    paypal: .authorisation
                ),
                merchantTransactionId: UUID().uuidString,
                merchantTransactionDate: { Date() }
            )
            
            // Create Drop-in configuration
            let config = CheckoutDropInConfig(
                environment: .test,
                session: session,
                transactionData: transactionData,
                merchantShopperId: "shopper-123",
                ownerId: "merchant-group-id",
                kountDisabled: false,
                onGetShopper: { async in
                    TransactionShopper(id: "shopper-123")
                },
                onBeforeSubmit: { paymentMethod in
                    // Validate your checkout state
                    return true
                },
                onSubmit: { paymentMethod in
                    print("Payment started: \(paymentMethod.rawValue)")
                },
                onSuccess: { result in
                    // CRITICAL: Verify on backend before fulfilling order
                    print("Payment successful: \(result.systemTransactionId)")
                },
                onError: { paymentMethod, error in
                    print("Payment failed: \(error.errorMessage)")
                }
            )
            
            // Initialise and create Drop-in
            let instance = try CheckoutDropIn(config: config)
            await instance.create()
            dropIn = instance
            
        } catch {
            errorMessage = error.localizedDescription
        }
    }
    
    private func fetchSessionFromBackend() async throws -> SessionData {
        // Implement your backend API call here
        let url = URL(string: "https://your-backend.com/api/create-session")!
        let (data, _) = try await URLSession.shared.data(from: url)
        
        // Decode directly to SessionData to preserve all fields including sessionExpiry and restrictions
        return try JSONDecoder().decode(SessionData.self, from: data)
    }
}

import SwiftUI
import PXPCheckoutSDK

struct CheckoutView: View {
    @StateObject private var viewModel = CheckoutViewModel()
    
    var body: some View {
        Group {
            if let dropIn = viewModel.dropIn {
                dropIn.buildContent()
            } else if let error = viewModel.errorMessage {
                VStack(spacing: 16) {
                    Text("Unable to load checkout")
                        .font(.headline)
                    Text(error)
                        .font(.body)
                        .foregroundColor(.secondary)
                    Button("Retry") {
                        Task {
                            await viewModel.loadDropIn()
                        }
                    }
                }
                .padding()
            } else {
                ProgressView("Loading checkout...")
            }
        }
        .task {
            await viewModel.loadDropIn()
        }
    }
}

onBeforeSubmit: { paymentMethod in
    // Validate terms accepted, shipping address, etc.
    guard hasAcceptedTerms else {
        showError("Please accept terms and conditions")
        return false
    }
    return true
}

onSubmit: { paymentMethod in
    showLoadingIndicator()
    print("Processing \(paymentMethod.rawValue) payment...")
}

onSuccess: { result in
    // result is DropInSubmitResult
    let systemTransactionId = result.systemTransactionId
    let merchantTransactionId = result.merchantTransactionId
    // Verify these identifiers on your backend.
    // paymentData is nil except for Paze (.paze(PazeCheckoutDecoded) when present)
    
    hideLoadingIndicator()
    
    // Send to backend for verification
    Task {
        do {
            try await verifyPaymentOnBackend(
                systemTransactionId: systemTransactionId,
                merchantTransactionId: merchantTransactionId
            )
            showSuccessScreen()
        } catch {
            showError("Payment verification failed")
        }
    }
}

onError: { paymentMethod, error in
    // paymentMethod is DropInPaymentMethod?
    // error is BaseSdkException
    let method = paymentMethod?.rawValue ?? "unknown"
    let code = error.errorCode
    let message = error.errorMessage
    
    hideLoadingIndicator()
    
    switch code {
    case "CARD_DECLINED":
        showError("Your card was declined. Please try another payment method.")
    case "INSUFFICIENT_FUNDS":
        showError("Insufficient funds. Please use a different card.")
    case "SDK1122":
        showError("Paze is unavailable. Please choose another payment method.")
    case "SDK1123":
        showError("Paze payment failed. Please try again.")
    case "SDK1124":
        showError("Paze is only available for e-commerce checkout.")
    case "SDK0118":
        showError("Paze client ID is missing from the session.")
    case "SDK1202A":
        showError("Paze merchant category code is missing from the session.")
    case "SDK1203", "SDK1204", "SDK1205":
        showError("Paze merchant display configuration is too long.")
    case "SDK1209", "SDK1210", "SDK1211", "SDK1212":
        showError("Invalid shopper details for Paze.")
    case "SDK1213":
        showError("Paze only supports USD transactions.")
    default:
        showError("Payment failed. Please try again.")
    }
    
    // Log for debugging
    print("Error for \(method): \(message)")
}

dropIn.destroy()