Apple Pay

Knižnica obsahuje komponent SecureApplePayButton, ktorý zjednodušuje integráciu Apple Pay do vašej aplikácie. Komponent automaticky:

overí dostupnosť Apple Pay na zariadení a v session,
zobrazí štandardné Apple Pay tlačidlo (PKPaymentButton),
spracuje platobný tok a získa platobný token,
odošle token na spracovanie do platobnej brány.

Informácie

Predpokladom pre využitie Apple Pay je aktivácia Checkout API a správne nastavenie v Apple Developer účte a Apple Pay spracovateľskom certifikáte, ktoré sú popísané nižšie.

1. Apple Developer Account

Pred nasadením Apple Pay je potrebné v Apple Developer portáli vytvoriť Merchant ID.

Prihláste sa do Apple Developer portálu.
Otvorte sekciu Certificates, Identifiers & Profiles → Identifiers.
V ľavom menu zvoľte typ Merchant IDs.
Kliknite na tlačidlo + a zaregistrujte nové Merchant ID vo formáte merchant.<vasa-domena>.<meno> (napr. merchant.sk.example.production).
Odporúčame vytvoriť dva Merchant IDs — jeden pre testovacie prostredie a jeden pre produkciu.

Tieto Merchant IDs následne použijete v ComgateSecureSession ako parameter applePayMerchantIdentifier.

2. Apple Pay Payment Processing Certificate

Pre každé Merchant ID je potrebné vygenerovať Payment Processing Certificate, ktorý umožní šifrovanie platobných údajov.

V detaile Merchant ID v Apple Developer portáli kliknite na sekciu Apple Pay Payment Processing Certificate → Create Certificate.
Apple si vyžiada Certificate Signing Request (CSR).
Tento CSR vám poskytne podpora Comgate — kontaktujte ju pre doručenie správneho CSR súboru.
Nahrajte CSR do Apple Developer portálu, stiahnite vygenerovaný certifikát a odovzdajte ho späť Comgate.
Po nasadení certifikátu na strane Comgate je Apple Pay pre dané Merchant ID pripravené na použitie.

Prvotné sprevádzkovanie

Aktivácia certifikátu na strane Comgate nie je okamžitá — chvíľu trvá. Pri prvotnom sprevádzkovaní Apple Pay dodajte certifikát Comgate s dostatočným časovým predstihom pred plánovaným spustením v produkcii.

Upozornenie

Certifikát Apple Pay je potrebné obnovovať každý rok. Sledovanie platnosti je na strane obchodníka — ideálne 2 mesiace pred vypršaním proaktívne kontaktujte podporu Comgate a začnite obnovu.

3. Implementácia

Nasledujúca časť popisuje jednotlivé komponenty knižnice potrebné na integráciu Apple Pay do vašej aplikácie.

Tip

Knižnica rieši konfiguráciu platobnej brány, zostavenie platobnej požiadavky, extrakciu tokenu aj jeho odoslanie na API automaticky. Stačí použiť komponent SecureApplePayButton a odovzdať potrebné parametre.

Požiadavky

Požiadavka	Popis
Apple Pay capability	V Xcode v záložke Signing & Capabilities pridajte capability Apple Pay.
Merchant ID v entitlemente	Apple Pay Merchant ID musí byť uvedený v `com.apple.developer.in-app-payments` v entitlement súbore.
`applePayMerchantIdentifier`	Apple Pay Merchant ID — povinný pre Apple Pay. Odovzdáva sa do `ComgateSecureSession`.
`applePayDisplayName`	Názov obchodníka zobrazený v Apple Pay sheete (voliteľné, odporúčané).
`threeDSConfig`	Inštancia `ThreeDSConfig` odovzdaná do `ComgateSecureSession` (vyžadované aj pre Apple Pay).
Aktivácia Checkout API	Konfigurácia Apple Pay je počas inicializácie session načítaná interne knižnicou.

Ako získať `applePayMerchantIdentifier`

applePayMerchantIdentifier získate v Apple Developer portáli v detaile vášho Merchant ID:

Prihláste sa do Apple Developer portálu.
Vyberte svoje Merchant ID.
Skopírujte hodnotu Identifier (napr. merchant.sk.example.production).
Túto hodnotu použite ako applePayMerchantIdentifier v ComgateSecureSession.

SecureApplePayButton

import SwiftUI
import ComgateSDK

SecureApplePayButton(
    session: session,
    paymentParams: {
        try! PaymentParams(
            email: "zakaznik@example.com",
            price: 100,
            curr: "EUR",
            country: "SK",
            label: "Názov platby",
            refId: "ref-123",
            fullName: "Ján Novák"
        )
    },
    onResult: { result in
        // Spracovanie výsledku platby
    }
)
.frame(height: 56)

Vzhľad tlačidla

SecureApplePayButton umožňuje prispôsobiť vzhľad a typ Apple Pay tlačidla pomocou štruktúry ApplePayButtonStyle:

Vlastnosť	Typ	Popis
`type`	`PKPaymentButtonType`	Typ popisku tlačidla (napr. `.plain`, `.buy`, `.checkout`, `.continue`, `.donate`, `.subscribe`). Predvolene: `.plain`.
`appearance`	`PKPaymentButtonStyle`	Vizuálna varianta (`.black`, `.white`, `.whiteOutline`, `.automatic`). Predvolene: `.black`.
`cornerRadius`	`CGFloat`	Zaoblenie rohov tlačidla v bodoch. Predvolene: `12`.

SecureApplePayButton(
    session: session,
    paymentParams: { /* ... */ },
    onResult: { _ in },
    style: ApplePayButtonStyle(
        type: .checkout,
        appearance: .black,
        cornerRadius: 16
    )
)
.frame(height: 56)

Automatická väzba na session

SecureApplePayButton sa automaticky naviaže na ComgateSecureSession. Tlačidlo sa zobrazí iba vtedy, keď:

bol pri vytváraní session odovzdaný applePayMerchantIdentifier,
session ohlási isApplePayConfigured == true (po úspešnej inicializácii).

Ak Apple Pay nie je nakonfigurovaný, vráti komponent prázdny EmptyView() — môžete tak na obrazovku bezpečne pridať tlačidlo bez manuálnej kontroly dostupnosti.

PaymentParams

Parametre platby pre Apple Pay využívajú rovnakú štruktúru PaymentParams ako kartové platby. Kompletný popis všetkých parametrov nájdete v sekcii Údaje karty — PaymentParams.

Konfigurácia v ComgateSecureSession

Pre Apple Pay je potrebné v konštruktore ComgateSecureSession odovzdať applePayMerchantIdentifier a voliteľne applePayDisplayName:

let session = ComgateSecureSession(
    checkoutId: "váš-checkout-id",
    applePayMerchantIdentifier: "merchant.sk.example.production",
    applePayDisplayName: "Názov obchodu",
    threeDSConfig: ThreeDSConfig()
)

Kompletný príklad

import SwiftUI
import ComgateSDK

@main
struct ApplePayApp: App {
    @StateObject private var session = ComgateSecureSession(
        checkoutId: "váš-checkout-id",
        applePayMerchantIdentifier: "merchant.sk.example.production",
        applePayDisplayName: "Názov obchodu",
        threeDSConfig: ThreeDSConfig()
    )

    var body: some Scene {
        WindowGroup {
            ApplePayScreen(session: session)
                .task {
                    if case .notInitialized = session.state {
                        try? await session.initialize()
                    }
                }
        }
    }
}

struct ApplePayScreen: View {
    @ObservedObject var session: ComgateSecureSession
    @State private var resultText = ""

    var body: some View {
        VStack(spacing: 16) {
            SecureApplePayButton(
                session: session,
                paymentParams: {
                    try! PaymentParams(
                        email: "zakaznik@example.com",
                        price: 100,
                        curr: "EUR",
                        country: "SK",
                        label: "Objednávka #123",
                        refId: "order-123",
                        fullName: "Ján Novák"
                    )
                },
                onResult: { result in
                    switch result {
                    case .paid: resultText = "Platba úspešná"
                    case .authorized: resultText = "Platba autorizovaná"
                    case .pending: resultText = "Platba sa spracováva…"
                    case .cancelled(let reason, _): resultText = "Platba zamietnutá: \(reason ?? "-")"
                    case .failed(let err): resultText = "Chyba: \(err.message)"
                    }
                }
            )
            .frame(height: 56)

            if !resultText.isEmpty {
                Text(resultText)
            }
        }
        .padding()
    }
}

Kombinácia s kartovou platbou

Apple Pay tlačidlo možno ľahko kombinovať s kartovým formulárom na jednej obrazovke. Oba komponenty zdieľajú rovnakú ComgateSecureSession:

struct CombinedPaymentScreen: View {
    @ObservedObject var session: ComgateSecureSession

    @StateObject private var panState: SecurePanFieldState
    @StateObject private var expiryState: SecureExpiryFieldState
    @StateObject private var cvvState: SecureCvvFieldState
    @StateObject private var statusState = PaymentStatusState()
    @StateObject private var holder: CollectorHolder

    init(session: ComgateSecureSession) {
        self._session = ObservedObject(wrappedValue: session)
        let pan = SecurePanFieldState()
        let expiry = SecureExpiryFieldState()
        let cvv = SecureCvvFieldState()
        _panState = StateObject(wrappedValue: pan)
        _expiryState = StateObject(wrappedValue: expiry)
        _cvvState = StateObject(wrappedValue: cvv)
        _holder = StateObject(wrappedValue: CollectorHolder(pan: pan, expiry: expiry, cvv: cvv))
    }

    private var collector: SecureCardDataCollector { holder.collector }

    private func params() -> PaymentParams {
        try! PaymentParams(
            email: "zakaznik@example.com",
            price: 100,
            curr: "EUR",
            country: "SK",
            label: "Objednávka",
            refId: "order-123",
            fullName: "Ján Novák"
        )
    }

    var body: some View {
        VStack(spacing: 12) {
            SecurePanField(state: panState)
            SecureExpiryField(state: expiryState)
            SecureCvvField(state: cvvState)

            SecurePayButton(
                session: session,
                collector: collector,
                paymentParams: params,
                onResult: { statusState.show(result: $0) }
            )

            Divider()

            SecureApplePayButton(
                session: session,
                paymentParams: params,
                onResult: { statusState.show(result: $0) }
            )
            .frame(height: 56)

            SecurePaymentStatusView(state: statusState)
        }
        .padding()
    }
}

Informácie

Pri použití Apple Pay v rámci Mobile SDK vždy vytvorte a odovzdajte threeDSConfig do ComgateSecureSession.

4. Testovacie prostredie

Sandbox tester

Na testovanie Apple Pay v testovacom prostredí použite Sandbox Tester Account vytvorený v App Store Connect (Users and Access → Sandbox Testers).

Vytvorte Sandbox Tester Account s testovacím Apple ID.
Na fyzickom zariadení sa odhláste z produkčného Apple ID v App Store a prihláste sa Sandbox testerom v Settings → Wallet & Apple Pay.
Pridajte testovacie karty z Apple zoznamu testovacích kariet.

Testovací Merchant ID

Testovací Merchant ID musí byť zaregistrovaný vo vašom Apple Developer účte a musí mať vygenerovaný Payment Processing Certificate napárovaný s Comgate.

Fyzické zariadenie vs. simulátor

Apple Pay má v simulátore obmedzenú funkcionalitu:

Prostredie	Podpora Apple Pay
iOS simulátor	Apple Pay sheet sa zobrazí, ale možno pracovať iba s testovacími kartami uloženými vo Wallet (obmedzená sada). Pre plné testovanie nedostatočné.
Fyzické zariadenie (sandbox)	Plná podpora so Sandbox Tester Accountom a testovacími kartami. Odporúčané pre testovanie.
Fyzické zariadenie (produkcia)	Po schválení certifikátu reálne transakcie.

Upozornenie

Pre plnohodnotné testovanie Apple Pay vždy používajte fyzické zariadenie prihlásené Sandbox Tester Accountom. Simulátor neumožňuje vygenerovať platný platobný token v produkčnom tvare.

1. Apple Developer Account​

2. Apple Pay Payment Processing Certificate​

3. Implementácia​

Požiadavky​

Ako získať applePayMerchantIdentifier​

SecureApplePayButton​

Vzhľad tlačidla​

Automatická väzba na session​

PaymentParams​

Konfigurácia v ComgateSecureSession​

Kompletný príklad​

Kombinácia s kartovou platbou​

4. Testovacie prostredie​

Sandbox tester​

Testovací Merchant ID​

Fyzické zariadenie vs. simulátor​