Terminal SDK 移行ガイド

// Step 1: Collect payment method
Terminal.shared.collectPaymentMethod(paymentIntent, collectConfig: collectConfig) { collectedPaymentIntent, collectError in
    guard let collectedPaymentIntent = collectedPaymentIntent else {
        // Payment method collection failed
        return
    }
    // Step 2: Confirm the payment
    Terminal.shared.confirmPaymentIntent(collectedPaymentIntent) { confirmedPaymentIntent, confirmError in
        if let confirmedPaymentIntent = confirmedPaymentIntent {
            // Payment successful
        } else {
            // Payment confirmation failed
        }
    }
}

// Process and confirm the payment in one step
Terminal.shared.processPaymentIntent(paymentIntent, collectConfig: collectConfig) { processedPaymentIntent, processError in
    if let processedPaymentIntent = processedPaymentIntent {
        // Payment successful
    } else {
        // Payment failed
    }
}

// Step 1: Collect refund payment method
Terminal.shared.collectRefundPaymentMethod(refundParams) { collectError in
    guard collectError == nil else {
        // Refund collection failed
        return
    }
    // Step 2: Confirm the refund
    Terminal.shared.confirmRefund { refund, confirmError in
        if let refund = refund {
            // Refund successful
        } else {
            // Refund confirmation failed
        }
    }
}

// Process the refund in one step
Terminal.shared.processRefund(refundParams) { refund, refundError in
    if let refund = refund {
        // Refund successful
    } else {
        // Refund failed
    }
}

// Step 1: Collect setup intent payment method
Terminal.shared.collectSetupIntentPaymentMethod(setupIntent, customerConsentCollected: true) { collectedSetupIntent, collectError in
    guard let collectedSetupIntent = collectedSetupIntent else {
        // Setup intent collection failed
        return
    }
    // Step 2: Confirm the setup intent
    Terminal.shared.confirmSetupIntent(collectedSetupIntent) { confirmedSetupIntent, confirmError in
        if let confirmedSetupIntent = confirmedSetupIntent {
            // Setup intent successful
        } else {
            // Setup intent confirmation failed
        }
    }
}

// Configure with allowRedisplay
let config = try CollectSetupIntentConfigurationBuilder()
    .setAllowRedisplay(.always)
    .build()

// Process the setup intent in one step
Terminal.shared.processSetupIntent(setupIntent, collectConfig: config) { processedSetupIntent, setupError in
    if let processedSetupIntent = processedSetupIntent {
        // Setup intent successful
    } else {
        // Setup intent failed
    }
}

// In your AppDelegate or scene delegate
Terminal.setTokenProvider(yourTokenProvider)

// In your AppDelegate or scene delegate, at app launch
Terminal.initWithTokenProvider(yourTokenProvider)

let config = SCPInternetDiscoveryConfiguration(isSimulated: true)

let config = InternetDiscoveryConfiguration.Builder()
    .setSimulated(true)
    .build()

func terminal(_ terminal: Terminal, didChange connectionStatus: ConnectionStatus) {
    switch connectionStatus {
    case .notConnected:
        // Handle not connected
    case .connected:
        // Handle connected
    @unknown default:
        break
    }
}

func terminal(_ terminal: Terminal, didChange connectionStatus: ConnectionStatus) {
    switch connectionStatus {
    case .notConnected:
        // Handle not connected
    case .connected:
        // Handle connected
    case .reconnecting:
        // Handle reconnection in progress
    @unknown default:
        break
    }
}

// Step 1: Discover the reader
Terminal.shared.discoverReaders(config, delegate: discoveryDelegate) { error in
    if let error = error {
        // Handle discovery error
    }
}

// In your DiscoveryDelegate
func terminal(_ terminal: Terminal, didUpdateDiscoveredReaders readers: [Reader]) {
    guard let selectedReader = readers.first else { return }
    // Step 2: Connect to the reader
    Terminal.shared.connectReader(selectedReader, connectionConfig: connectionConfig) { reader, error in
        if let reader = reader {
            // Handle successful connection
        } else if let error = error {
            // Handle connection error
        }
    }
}

// Discover and connect in one step by providing discovery filter
let discoveryConfig = try InternetDiscoveryConfigurationBuilder()
    .setLocationId("tml_1234567890") // optional, specify your location ID
    .setDiscoveryFilter(.bySerial("YOUR-READER-SERIAL-NUMBER"))
    .build()

let connectionConfig = try InternetConnectionConfigurationBuilder()
    .setFailIfInUse(false)
    .build()

let easyConnectConfig = InternetEasyConnectConfiguration(
    discoveryConfiguration: discoveryConfig,
    connectionConfiguration: connectionConfig
)

Terminal.shared.easyConnect(
    easyConnectConfig,
    delegate: internetReaderDelegate
) { reader, error in
    if let reader = reader {
        // Handle successful connection
    } else if let error = error {
        // Handle failure
    }
}

let config = InternetDiscoveryConfigurationBuilder()
    .setLocationId("tml_1234567890")
    .build()

let config = try InternetDiscoveryConfigurationBuilder()
    .setLocationId("tml_1234567890") // optional
    .setDiscoveryFilter(.bySerial("READER-SERIAL-NUMBER")) // or .byReaderId("tmr_YOUR-READER-STRIPE-ID") to filter by reader id
    .build()

let collectConfig = try CollectConfigurationBuilder()
    .setEnableCustomerCancellation(false)
    .build()

let collectConfig = try CollectPaymentIntentConfigurationBuilder()
    .setCustomerCancellation(.disableIfAvailable)
    .build()

let refundParams = try RefundParametersBuilder(
    paymentIntentId: "pi_123",
    amount: 1000,
    currency: "cad"
).build()

let refundParams = try RefundParametersBuilder(
    paymentIntentId: "pi_123",
    clientSecret: "pi_123_secret_abc",
    amount: 1000,
    currency: "cad"
).build()