6643 Allow retries of failed interac refunds

When an interac refund fails, we show an error with a “Try again” button.

When the user taps that, we attempt to cancel the Interac refund “intent” using the `refundCancelable` that Stripe Terminal gives us in response to `SCPTerminal.collectRefundPaymentMethod()`

When there’s been a failure or error in the refund, the `refundCancelable` that Stripe gave us ends up in an unexpected situation: it’s not `completed`, but it also doesn’t call back the completion handler when we call `cancel`. This meant that our previous “Try again” handler did not start the new refund attempt.

Cancelling a refund after Stripe have called the completion handler from `processRefund`, or given us an error from `collectRefundPaymentMethod`, shouldn’t be required: those calls from Stripe have already told us that the original refund attempt is complete (even if failed), so we can’t cancel it anyway.

This change sets the `refundCancelable` to nil when Stripe have told us that the refund is complete, resulting in a `noRefundInProgress` error being returned to the `handleRefundFailureAndRetryRefund` handler. We don’t need to worry about this error or whether the cancellation was successful: in either case, we should try the refund again.

This change does not address that some refund errors should not be retriable: that will follow in future work.

Author: joshheald

Hardware/Hardware/CardReader/StripeCardReader/StripeCardReaderService.swift

@@ -518,10 +518,12 @@ extension StripeCardReaderService {
         return Future() { [weak self] promise in
             self?.refundCancellable = Terminal.shared.collectRefundPaymentMethod(parameters) { collectError in
                 if let error = collectError {
+                    self?.refundCancellable = nil
                     promise(.failure(CardReaderServiceError.refundPayment(underlyingError: UnderlyingError(with: error))))
                 } else {
                     // Process refund
                     Terminal.shared.processRefund { processedRefund, processError in
+                        self?.refundCancellable = nil
                         if let error = processError {
                             promise(.failure(CardReaderServiceError.refundPayment(underlyingError: UnderlyingError(with: error))))
                         } else if let refund = processedRefund {

WooCommerce/Classes/ViewRelated/Orders/Refund/RefundSubmissionUseCase.swift

@@ -107,6 +107,11 @@ final class RefundSubmissionUseCase: NSObject, RefundSubmissionProtocol {
         self.stores = stores
         self.storageManager = storageManager
         self.analytics = analytics
+
+        // Instantiates the alerts coordinator.
+        let alerts = OrderDetailsPaymentAlerts(transactionType: .refund,
+                                               presentingController: rootViewController)
+        self.alerts = alerts
     }
 
     /// Starts the refund submission flow.
@@ -232,13 +237,8 @@ private extension RefundSubmissionUseCase {
             return
         }
 
-        // Instantiates the alerts coordinator.
-        let alerts = OrderDetailsPaymentAlerts(transactionType: .refund,
-                                               presentingController: rootViewController)
-        self.alerts = alerts
-
         // Shows reader ready alert.
-        alerts.readerIsReady(title: Localization.refundPaymentTitle(username: order.billingAddress?.firstName),
+        self.alerts?.readerIsReady(title: Localization.refundPaymentTitle(username: order.billingAddress?.firstName),
                              amount: formattedAmount,
                              onCancel: { [weak self] in
             self?.cancelRefund()
@@ -275,20 +275,12 @@ private extension RefundSubmissionUseCase {
         // TODO: 5984 - tracks in-person refund error
         DDLogError("Failed to refund: \(error.localizedDescription)")
         // Informs about the error.
+        //TODO: Check which refund errors can't be retried, and use that to call nonRetryableError(from: self.rootViewController, error: cancelError)
         alerts?.error(error: error) { [weak self] in
-            // Cancels current payment.
-            self?.cardPresentRefundOrchestrator.cancelRefund { [weak self] result in
-                guard let self = self else { return }
-
-                switch result {
-                case .success:
-                    // Retries refund.
-                    self.attemptCardPresentRefund(refundAmount: refundAmount, charge: charge, onCompletion: onCompletion)
-                case .failure(let cancelError):
-                    // Informs that payment can't be retried.
-                    self.alerts?.nonRetryableError(from: self.rootViewController, error: cancelError)
-                    onCompletion(.failure(error))
-                }
+            // Cancels current refund, if possible.
+            self?.cardPresentRefundOrchestrator.cancelRefund { [weak self] _ in
+                // Regardless of whether the refund could be cancelled (e.g. it completed but failed), retry the refund.
+                self?.attemptCardPresentRefund(refundAmount: refundAmount, charge: charge, onCompletion: onCompletion)
             }
         }
     }