[Order Details] Allow failed orders to show receipt if eligible

WooCommerce/Classes/ViewModels/Order Details/OrderDetailsDataSource.swift

@@ -1517,11 +1517,27 @@ extension OrderDetailsDataSource {
     }
 
     private func isEligibleForBackendReceipt(completion: @escaping (Bool) -> Void) {
-        guard !isEligibleForPayment else {
+        guard isOrderStatusEligibleForReceipt else {
             return completion(false)
         }
-        ReceiptEligibilityUseCase().isEligibleForBackendReceipts { isEligibleForReceipt in
-            completion(isEligibleForReceipt)
+        let receiptEligibility = ReceiptEligibilityUseCase()
+
+        switch order.status {
+        case .completed, .processing, .refunded:
+            receiptEligibility.isEligibleForBackendReceipts { isEligibleForReceipt in
+                completion(isEligibleForReceipt)
+        }
+        case .failed:
+            receiptEligibility.selectedPaymentGatewayID { gatewayID in
+                guard let gatewayID = gatewayID else {
+                    return completion(false)
+                }
+                receiptEligibility.isEligibleForFailedPaymentEmailReceipts(paymentGatewayID: gatewayID) { isEligibleForReceipt in
+                    completion(isEligibleForReceipt)
+                }
+            }
+        default:
+            completion(false)
         }
     }
 
@@ -2033,3 +2049,13 @@ extension OrderDetailsDataSource {
         static let cellDefaultMargin: CGFloat = 16
     }
 }
+
+// MARK: - Receipts helpers
+private extension OrderDetailsDataSource {
+    var isOrderStatusEligibleForReceipt: Bool {
+        order.status == .completed ||
+        order.status == .processing ||
+        order.status == .refunded ||
+        order.status == .failed
+    }
+}

WooCommerce/Classes/ViewModels/Order Details/Receipts/ReceiptEligibilityUseCase.swift

@@ -27,15 +27,11 @@ final class ReceiptEligibilityUseCase: ReceiptEligibilityUseCaseProtocol {
             guard let wcPlugin = wcPlugin, wcPlugin.active else {
                 return onCompletion(false)
             }
-            // 2. If WooCommerce version is any of the specific API development branches, mark as eligible
-            if Constants.BackendReceipt.wcPluginDevVersion.contains(wcPlugin.version) {
-                onCompletion(true)
-            } else {
-                // 3. Else, if WooCommerce version is higher than minimum required version, mark as eligible
-                let isSupported = VersionHelpers.isVersionSupported(version: wcPlugin.version,
-                                                                    minimumRequired: Constants.BackendReceipt.wcPluginMinimumVersion)
-                onCompletion(isSupported)
-            }
+
+            // 2. If WooCommerce version is higher than minimum required version, mark as eligible
+            let isSupported = VersionHelpers.isVersionSupported(version: wcPlugin.version,
+                                                                minimumRequired: Constants.BackendReceipt.wcPluginMinimumVersion)
+            onCompletion(isSupported)
         }
         stores.dispatch(action)
     }
@@ -69,30 +65,52 @@ final class ReceiptEligibilityUseCase: ReceiptEligibilityUseCaseProtocol {
     /// WooCommerce Stripe Gateway 9.1.0 aligns the app with the web and automatically sets the order as failed when the payment processing fails.
     ///
     func isEligibleForFailedPaymentEmailReceipts(paymentGatewayID: String, onCompletion: @escaping (Bool) -> Void) {
-        Task { @MainActor in
-            async let wooCommerceSupported = isPluginSupported(Constants.wcPluginName,
-                                                               minimumVersion: Constants.ReceiptAfterPayment.wcPluginMinimumVersion)
-
-            async let gatewaySupported: Bool = {
-                switch paymentGatewayID {
-                case CardPresentPaymentsPlugin.wcPay.gatewayID:
-                    return await isPluginSupported(CardPresentPaymentsPlugin.wcPay.pluginName,
-                                                   minimumVersion: Constants.ReceiptAfterPayment.wcPayPluginMinimumVersion)
-                case CardPresentPaymentsPlugin.stripe.gatewayID:
-                    return await isPluginSupported(CardPresentPaymentsPlugin.stripe.pluginName,
-                                                   minimumVersion: Constants.ReceiptAfterPayment.stripePluginMinimumVersion)
-                default:
-                    return false
-                }
-            }()
+        isPluginSupported(Constants.wcPluginName, minimumVersion: Constants.FailedReceiptAfterPayment.wcPluginMinimumVersion) { isWooCommerceSupported in
+            guard isWooCommerceSupported else {
+                return onCompletion(false)
+            }
+
+            switch paymentGatewayID {
+            case CardPresentPaymentsPlugin.wcPay.gatewayID:
+                self.isPluginSupported(CardPresentPaymentsPlugin.wcPay.pluginName,
+                                       minimumVersion: Constants.FailedReceiptAfterPayment.wcPayPluginMinimumVersion,
+                                       onCompletion: onCompletion)
+            case CardPresentPaymentsPlugin.stripe.gatewayID:
+                self.isPluginSupported(CardPresentPaymentsPlugin.stripe.pluginName,
+                                       minimumVersion: Constants.FailedReceiptAfterPayment.stripePluginMinimumVersion,
+                                       onCompletion: onCompletion)
+            default:
+                onCompletion(false)
+            }
+        }
+    }
 
-            let (isWooCommerceSupported, isGatewaySupported) = await (wooCommerceSupported, gatewaySupported)
-            onCompletion(isWooCommerceSupported && isGatewaySupported)
+    // Returns the current payment gateway ID, needed when checking if a transaction is eligible for receipts
+    // based on which plugin and versions are active
+    func selectedPaymentGatewayID(onCompletion: @escaping (String?) -> Void) {
+        let action = CardPresentPaymentAction.selectedPaymentGatewayAccount { paymentGatewayAccount in
+            onCompletion(paymentGatewayAccount?.gatewayID)
         }
+        stores.dispatch(action)
     }
 }
 
 private extension ReceiptEligibilityUseCase {
+    func isPluginSupported(_ pluginName: String, minimumVersion: String, onCompletion: @escaping (Bool) -> Void) {
+        let action = SystemStatusAction.fetchSystemPlugin(siteID: siteID, systemPluginName: pluginName) { plugin in
+            // Plugin must be installed and active
+            guard let plugin, plugin.active else {
+                return onCompletion(false)
+            }
+
+            // If plugin version is higher than minimum required version, mark as eligible
+            let isSupported = VersionHelpers.isVersionSupported(version: plugin.version,
+                                                                minimumRequired: minimumVersion)
+            onCompletion(isSupported)
+        }
+        stores.dispatch(action)
+    }
+
     @MainActor
     func isPluginSupported(_ pluginName: String, minimumVersion: String) async -> Bool {
         await withCheckedContinuation { continuation in
@@ -102,11 +120,6 @@ private extension ReceiptEligibilityUseCase {
                     return continuation.resume(returning: false)
                 }
 
-                // Checking for concrete versions to cover dev and beta versions
-                if plugin.version.contains(minimumVersion) {
-                    return continuation.resume(returning: true)
-                }
-
                 // If plugin version is higher than minimum required version, mark as eligible
                 let isSupported = VersionHelpers.isVersionSupported(version: plugin.version,
                                                                     minimumRequired: minimumVersion)
@@ -123,10 +136,9 @@ private extension ReceiptEligibilityUseCase {
 
         enum BackendReceipt {
             static let wcPluginMinimumVersion = "8.7.0"
-            static let wcPluginDevVersion: [String] = ["8.7.0-dev", "8.6.0-dev"]
         }
 
-        enum ReceiptAfterPayment {
+        enum FailedReceiptAfterPayment {
             static let wcPluginMinimumVersion = "9.5.0"
             static let wcPayPluginMinimumVersion = "8.6.0"
             static let stripePluginMinimumVersion = "9.1.0"

WooCommerce/WooCommerceTests/ViewModels/Receipts/ReceiptEligibilityUseCaseTests.swift

@@ -3,63 +3,6 @@ import Yosemite
 @testable import WooCommerce
 
 final class ReceiptEligibilityUseCaseTests: XCTestCase {
-
-    func test_when_WooCommerce_version_is_incorrect_dev_version_then_returns_false() {
-        // Given
-        let stores = MockStoresManager(sessionManager: .makeForTesting())
-        let plugin = SystemPlugin.fake().copy(name: "WooCommerce",
-                                              version: "8.6.0-dev-wrong-version",
-                                              active: true)
-
-        stores.whenReceivingAction(ofType: SystemStatusAction.self) { action in
-            switch action {
-            case let .fetchSystemPlugin(_, _, onCompletion):
-                onCompletion(plugin)
-            default:
-                XCTFail("Unexpected action")
-            }
-        }
-        let sut = ReceiptEligibilityUseCase(stores: stores)
-
-        // When
-        let isEligible: Bool = waitFor { promise in
-            sut.isEligibleForBackendReceipts(onCompletion: { result in
-                promise(result)
-            })
-        }
-
-        // Then
-        XCTAssertFalse(isEligible)
-    }
-
-    func test_when_WooCommerce_version_is_correct_dev_version_then_returns_true() {
-        // Given
-        let stores = MockStoresManager(sessionManager: .makeForTesting())
-        let plugin = SystemPlugin.fake().copy(name: "WooCommerce",
-                                              version: "8.6.0-dev",
-                                              active: true)
-
-        stores.whenReceivingAction(ofType: SystemStatusAction.self) { action in
-            switch action {
-            case let .fetchSystemPlugin(_, _, onCompletion):
-                onCompletion(plugin)
-            default:
-                XCTFail("Unexpected action")
-            }
-        }
-        let sut = ReceiptEligibilityUseCase(stores: stores)
-
-        // When
-        let isEligible: Bool = waitFor { promise in
-            sut.isEligibleForBackendReceipts(onCompletion: { result in
-                promise(result)
-            })
-        }
-
-        // Then
-        XCTAssertTrue(isEligible)
-    }
-
     func test_when_WooCommerce_version_is_below_minimum_then_returns_false() {
         // Given
         let stores = MockStoresManager(sessionManager: .makeForTesting())
@@ -182,38 +125,6 @@ final class ReceiptEligibilityUseCaseTests: XCTestCase {
         XCTAssertTrue(isEligible)
     }
 
-    func test_isEligibleForFailedPaymentEmailReceipts_when_plugins_are_supported_dev_then_returns_true() {
-        // Given
-        let stores = MockStoresManager(sessionManager: .makeForTesting())
-        let wooCommercePlugin = SystemPlugin.fake().copy(name: "WooCommerce", version: "9.6.0-dev-1181231238", active: true)
-        let wooPaymentsPlugin = SystemPlugin.fake().copy(name: CardPresentPaymentsPlugin.wcPay.pluginName, version: "8.6.0-test-1", active: true)
-
-        stores.whenReceivingAction(ofType: SystemStatusAction.self) { action in
-            switch action {
-            case let .fetchSystemPlugin(_, systemPluginName, onCompletion):
-                if systemPluginName == "WooCommerce" {
-                    onCompletion(wooCommercePlugin)
-                } else if systemPluginName == CardPresentPaymentsPlugin.wcPay.pluginName {
-                    onCompletion(wooPaymentsPlugin)
-                }
-            default:
-                XCTFail("Unexpected action")
-            }
-        }
-
-        let sut = ReceiptEligibilityUseCase(stores: stores)
-
-        // When
-        let isEligible: Bool = waitFor { promise in
-            sut.isEligibleForFailedPaymentEmailReceipts(paymentGatewayID: CardPresentPaymentsPlugin.wcPay.gatewayID, onCompletion: { result in
-                promise(result)
-            })
-        }
-
-        // Then
-        XCTAssertTrue(isEligible)
-    }
-
     func test_isEligibleForFailedPaymentEmailReceipts_when_woopayments_version_is_incorrect_then_returns_false() {
         // Given
         let stores = MockStoresManager(sessionManager: .makeForTesting())