[Woo POS][Historical Orders] Order Details: Email Receipt action (Wireframe UI) (1/1)

Modules/Sources/Networking/Remote/ReceiptRemote.swift

@@ -53,27 +53,31 @@ public final class ReceiptRemote: Remote {
     /// - Parameters:
     ///   - siteID: Site which hosts the Order.
     ///   - orderID: ID of the order that the receipt is associated to.
-    public func sendPOSReceipt(siteID: Int64, orderID: Int64) async throws {
+    public func sendPOSReceipt(siteID: Int64, orderID: Int64, emailAddress: String) async throws {
         let sendEmailPath = "\(Constants.ordersPath)/\(orderID)/\(Constants.actionsPath)/send_email"
         let sendEmailRequest = JetpackRequest(wooApiVersion: .mark3,
                                               method: .post,
                                               siteID: siteID,
                                               path: sendEmailPath,
                                               parameters: [
-                                                ParameterKeys.templateID: POSConstants.receiptTemplateID
+                                                ParameterKeys.templateID: POSConstants.receiptTemplateID,
+                                                ParameterKeys.email: emailAddress,
+                                                ParameterKeys.forceEmailUpdate: true
                                               ],
                                               availableAsRESTRequest: true)
         try await enqueue(sendEmailRequest)
     }
 }
 
-extension ReceiptRemote: POSReceiptsRemoteProtocol { }
+extension ReceiptRemote: POSReceiptsRemoteProtocol {}
 
 private extension ReceiptRemote {
     enum ParameterKeys {
         static let expirationDays: String = "expiration_days"
         static let forceRegenerate: String = "force_new"
         static let templateID: String = "template_id"
+        static let forceEmailUpdate: String = "force_email_update"
+        static let email: String = "email"
     }
 
     enum Constants {

Modules/Sources/NetworkingCore/Remote/OrdersRemote.swift

@@ -451,6 +451,24 @@ extension OrdersRemote: POSOrdersRemoteProtocol {
         }
     }
 
+    public func updatePOSOrderEmail(siteID: Int64, orderID: Int64, emailAddress: String) async throws {
+        let parameters: [String: Any] = [
+            "billing": [
+                "email": emailAddress
+            ]
+        ]
+
+        let path = "\(Constants.ordersPath)/\(orderID)"
+        let request = JetpackRequest(wooApiVersion: .mark3,
+                                     method: .post,
+                                     siteID: siteID,
+                                     path: path,
+                                     parameters: parameters,
+                                     availableAsRESTRequest: true)
+
+        try await enqueue(request)
+    }
+
     public func loadPOSOrders(siteID: Int64, pageNumber: Int, pageSize: Int) async throws -> PagedItems<Order> {
         let parameters: [String: Any] = [
             ParameterKeys.page: String(pageNumber),

Modules/Sources/NetworkingCore/Remote/POSOrdersRemoteProtocol.swift

@@ -2,7 +2,7 @@ import Foundation
 
 public protocol POSReceiptsRemoteProtocol {
     func sendReceipt(siteID: Int64, orderID: Int64) async throws
-    func sendPOSReceipt(siteID: Int64, orderID: Int64) async throws
+    func sendPOSReceipt(siteID: Int64, orderID: Int64, emailAddress: String) async throws
 }
 
 public protocol POSOrdersRemoteProtocol {
@@ -11,6 +11,10 @@ public protocol POSOrdersRemoteProtocol {
                         cashPaymentChangeDueAmount: String?,
                         fields: [OrdersRemote.UpdateOrderField]) async throws -> Order
 
+    func updatePOSOrderEmail(siteID: Int64,
+                             orderID: Int64,
+                             emailAddress: String) async throws
+
     func createPOSOrder(siteID: Int64,
                         order: Order,
                         fields: [OrdersRemote.CreateOrderField]) async throws -> Order

Modules/Sources/Yosemite/Tools/POS/POSOrderService.swift

@@ -9,7 +9,7 @@ public protocol POSOrderServiceProtocol {
     ///   - cart: Cart with different types of items and quantities.
     /// - Returns: Order from the remote sync.
     func syncOrder(cart: POSCart, currency: CurrencyCode) async throws -> Order
-    func updatePOSOrder(order: Order, recipientEmail: String) async throws
+    func updatePOSOrder(orderID: Int64, recipientEmail: String) async throws
     func markOrderAsCompletedWithCashPayment(order: Order, changeDueAmount: String?) async throws
 }
 
@@ -46,20 +46,9 @@ public final class POSOrderService: POSOrderServiceProtocol {
         return try await ordersRemote.createPOSOrder(siteID: siteID, order: order, fields: [.items, .status, .currency, .couponLines])
     }
 
-    public func updatePOSOrder(order: Order, recipientEmail: String) async throws {
-        guard order.billingAddress?.email == nil || order.billingAddress?.email == "" else {
-            throw POSOrderServiceError.emailAlreadySet
-        }
-        let updatedBillingAddress = order.billingAddress?.copy(email: recipientEmail)
-        let updatedOrder = order.copy(billingAddress: updatedBillingAddress)
-
+    public func updatePOSOrder(orderID: Int64, recipientEmail: String) async throws {
         do {
-            let _ = try await ordersRemote.updatePOSOrder(
-                siteID: siteID,
-                order: updatedOrder,
-                cashPaymentChangeDueAmount: nil,
-                fields: [.billingAddress]
-            )
+            try await ordersRemote.updatePOSOrderEmail(siteID: siteID, orderID: orderID, emailAddress: recipientEmail)
         } catch {
             throw POSOrderServiceError.updateOrderFailed
         }
@@ -105,7 +94,6 @@ private extension Order {
 
 private extension POSOrderService {
     enum POSOrderServiceError: Error {
-        case emailAlreadySet
         case updateOrderFailed
     }
 }

Modules/Sources/Yosemite/Tools/POS/POSReceiptService.swift

@@ -2,7 +2,7 @@ import SwiftUI
 import Networking
 
 public protocol POSReceiptServiceProtocol {
-    func sendReceipt(order: Order, recipientEmail: String, isEligibleForPOSReceipt: Bool) async throws
+    func sendReceipt(orderID: Int64, recipientEmail: String, isEligibleForPOSReceipt: Bool) async throws
 }
 
 public final class POSReceiptService: POSReceiptServiceProtocol {
@@ -25,12 +25,12 @@ public final class POSReceiptService: POSReceiptServiceProtocol {
         self.receiptsRemote = receiptsRemote
     }
 
-    public func sendReceipt(order: Yosemite.Order, recipientEmail: String, isEligibleForPOSReceipt: Bool) async throws {
+    public func sendReceipt(orderID: Int64, recipientEmail: String, isEligibleForPOSReceipt: Bool) async throws {
         do {
             if isEligibleForPOSReceipt {
-                try await receiptsRemote.sendPOSReceipt(siteID: siteID, orderID: order.orderID)
+                try await receiptsRemote.sendPOSReceipt(siteID: siteID, orderID: orderID, emailAddress: recipientEmail)
             } else {
-                try await receiptsRemote.sendReceipt(siteID: siteID, orderID: order.orderID)
+                try await receiptsRemote.sendReceipt(siteID: siteID, orderID: orderID)
             }
         } catch {
             throw POSReceiptServiceError.sendReceiptFailed(underlyingError: error as NSError)

Modules/Tests/NetworkingTests/Remote/ReceiptRemoteTests.swift

@@ -129,29 +129,33 @@ final class ReceiptRemoteTests: XCTestCase {
         // Given
         let remote = ReceiptRemote(network: network)
         let posReceiptTemplateID = "customer_pos_completed_order"
+        let testEmail = "[email protected]"
 
         network.simulateResponse(
             requestUrlSuffix: "orders/\(sampleOrderID)/actions/send_email",
             filename: "orders-actions-send-email-success"
         )
 
         // When
-        try await remote.sendPOSReceipt(siteID: sampleSiteID, orderID: sampleOrderID)
+        try await remote.sendPOSReceipt(siteID: sampleSiteID, orderID: sampleOrderID, emailAddress: testEmail)
 
         // Then the send email request was made with correct parameters.
         let sendEmailRequest = try XCTUnwrap(network.requestsForResponseData.last as? JetpackRequest)
         XCTAssertEqual(sendEmailRequest.method, .post)
         XCTAssertEqual(sendEmailRequest.path, "orders/\(sampleOrderID)/actions/send_email")
         XCTAssertEqual(sendEmailRequest.parameters["template_id"] as? String, posReceiptTemplateID)
+        XCTAssertEqual(sendEmailRequest.parameters["email"] as? String, testEmail)
+        XCTAssertEqual(sendEmailRequest.parameters["force_email_update"] as? Bool, true)
     }
 
     func test_sendPOSReceipt_when_no_reponse_exist_throws_error() async {
         // Given
         let remote = ReceiptRemote(network: network)
+        let testEmail = "[email protected]"
 
         await assertThrowsError({
             // When
-            try await remote.sendPOSReceipt(siteID: sampleSiteID, orderID: sampleOrderID)
+            try await remote.sendPOSReceipt(siteID: sampleSiteID, orderID: sampleOrderID, emailAddress: testEmail)
         }, errorAssert: { error in
             // Then
             return error is NetworkError

Modules/Tests/YosemiteTests/Mocks/MockPOSOrdersRemote.swift

@@ -22,6 +22,25 @@ final class MockPOSOrdersRemote: POSOrdersRemoteProtocol {
         }
     }
 
+    var updatePOSOrderEmailCalled: Bool = false
+    var spyUpdatePOSOrderEmailSiteID: Int64?
+    var spyUpdatePOSOrderEmailOrderID: Int64?
+    var spyUpdatePOSOrderEmailAddress: String?
+    var updatePOSOrderEmailResult: Result<Void, Error> = .success(())
+
+    func updatePOSOrderEmail(siteID: Int64, orderID: Int64, emailAddress: String) async throws {
+        updatePOSOrderEmailCalled = true
+        spyUpdatePOSOrderEmailSiteID = siteID
+        spyUpdatePOSOrderEmailOrderID = orderID
+        spyUpdatePOSOrderEmailAddress = emailAddress
+        switch updatePOSOrderEmailResult {
+        case .success:
+            return
+        case .failure(let error):
+            throw error
+        }
+    }
+
     var createPOSOrderCalled: Bool = false
     var spyCreatePOSOrder: Order?
     var spyCreatePOSOrderFields: [OrdersRemote.CreateOrderField]?

Modules/Tests/YosemiteTests/Mocks/MockPOSReceiptsRemote.swift

@@ -5,6 +5,7 @@ final class MockPOSReceiptsRemote: POSReceiptsRemoteProtocol {
     var sendPOSReceiptCalled = false
     var spySiteID: Int64?
     var spyOrderID: Int64?
+    var spyEmail: String?
     var shouldThrowError: Error?
 
     func sendReceipt(siteID: Int64, orderID: Int64) async throws {
@@ -17,7 +18,14 @@ final class MockPOSReceiptsRemote: POSReceiptsRemoteProtocol {
         }
     }
 
-    func sendPOSReceipt(siteID: Int64, orderID: Int64) async throws {
+    func sendPOSReceipt(siteID: Int64, orderID: Int64, emailAddress: String) async throws {
         sendPOSReceiptCalled = true
+        spySiteID = siteID
+        spyOrderID = orderID
+        spyEmail = emailAddress
+
+        if let shouldThrowError {
+            throw shouldThrowError
+        }
     }
 }

Modules/Tests/YosemiteTests/Tools/POS/POSOrderServiceTests.swift

@@ -166,6 +166,35 @@ struct POSOrderServiceTests {
             return true
         })
     }
+
+    @Test func updatePOSOrder_calls_remote_updatePOSOrderEmail_with_correct_parameters() async throws {
+        // Given
+        let siteID: Int64 = 123
+        let orderID: Int64 = 456
+        let recipientEmail = "[email protected]"
+
+        // When
+        try await sut.updatePOSOrder(orderID: orderID, recipientEmail: recipientEmail)
+
+        // Then
+        #expect(mockOrdersRemote.updatePOSOrderEmailCalled == true)
+        #expect(mockOrdersRemote.spyUpdatePOSOrderEmailSiteID == siteID)
+        #expect(mockOrdersRemote.spyUpdatePOSOrderEmailOrderID == orderID)
+        #expect(mockOrdersRemote.spyUpdatePOSOrderEmailAddress == recipientEmail)
+    }
+
+    @Test func updatePOSOrder_throws_error_when_remote_call_fails() async throws {
+        // Given
+        mockOrdersRemote.updatePOSOrderEmailResult = .failure(NSError(domain: "", code: 0))
+
+        // When/Then
+        await #expect(performing: {
+            try await sut.updatePOSOrder(orderID: 456, recipientEmail: "[email protected]")
+        }, throws: { _ in
+            // The actual error `POSOrderServiceError.updateOrderFailed` is private, thus we cannot check against the exact error.
+            return true
+        })
+    }
 }
 
 private func makePOSCartItem(

Modules/Tests/YosemiteTests/Tools/POS/POSReceiptServiceTests.swift

@@ -20,7 +20,7 @@ struct POSReceiptServiceTests {
         let email = "[email protected]"
 
         // When
-        try await sut.sendReceipt(order: order, recipientEmail: email, isEligibleForPOSReceipt: false)
+        try await sut.sendReceipt(orderID: order.orderID, recipientEmail: email, isEligibleForPOSReceipt: false)
 
         // Then
         #expect(receiptsRemote.sendReceiptCalled)
@@ -36,7 +36,7 @@ struct POSReceiptServiceTests {
 
         // When/Then
         do {
-            try await sut.sendReceipt(order: order, recipientEmail: "[email protected]", isEligibleForPOSReceipt: false)
+            try await sut.sendReceipt(orderID: order.orderID, recipientEmail: "[email protected]", isEligibleForPOSReceipt: false)
             XCTFail("Expected error to be thrown")
         } catch {
             guard case POSReceiptService.POSReceiptServiceError.sendReceiptFailed = error else {
@@ -48,10 +48,17 @@ struct POSReceiptServiceTests {
 
     @Test
     func sendReceipt_calls_remote_when_isEligibleForPOSReceipt_is_true() async throws {
+        // Given
+        let email = "[email protected]"
+        let orderID: Int64 = 789
+
         // When
-        try await sut.sendReceipt(order: Order.fake(), recipientEmail: "[email protected]", isEligibleForPOSReceipt: true)
+        try await sut.sendReceipt(orderID: orderID, recipientEmail: email, isEligibleForPOSReceipt: true)
 
         // Then
         #expect(receiptsRemote.sendPOSReceiptCalled)
+        #expect(receiptsRemote.spySiteID == 123)
+        #expect(receiptsRemote.spyOrderID == orderID)
+        #expect(receiptsRemote.spyEmail == email)
     }
 }