Bookings: Update booking list item and booking detail screen with real data (#16247)

Author: itsmeichigo

Modules/Sources/Networking/Model/Bookings/Booking.swift

@@ -22,7 +22,6 @@ public struct Booking: Codable, GeneratedCopiable, Hashable, GeneratedFakeable {
     public let statusKey: String
     public let localTimezone: String
     public let currency: String
-    // periphery: ignore - to be used later
     public let orderInfo: BookingOrderInfo?
 
     public var bookingStatus: BookingStatus {

Modules/Sources/Networking/Model/Bookings/BookingOrderInfo.swift

@@ -16,4 +16,23 @@ public struct BookingOrderInfo: Hashable {
         self.customerInfo = customerInfo
         self.productInfo = productInfo
     }
+
+    public init(booking: Booking, order: Order) {
+        self.customerInfo = {
+            guard let billingAddress = order.billingAddress else {
+                return nil
+            }
+            return BookingCustomerInfo(billingAddress: billingAddress)
+        }()
+        self.productInfo = BookingProductInfo(name: order.items.first(where: { $0.productID == booking.productID })?.name ?? "")
+        self.paymentInfo = BookingPaymentInfo(
+            paymentMethodID: order.paymentMethodID,
+            paymentMethodTitle: order.paymentMethodTitle,
+            subtotal: order.items.map({ Double($0.subtotal) ?? 0 }).reduce(0, +).description,
+            subtotalTax: order.items.map({ Double($0.subtotalTax) ?? 0 }).reduce(0, +).description,
+            total: order.total,
+            totalTax: order.totalTax
+        )
+        self.statusKey = order.status.rawValue
+    }
 }

Modules/Sources/Yosemite/Model/Booking/Booking+ReadOnlyConvertible.swift

@@ -52,3 +52,15 @@ extension Storage.Booking: ReadOnlyConvertible {
                 orderInfo: orderInfo?.toReadOnly())
     }
 }
+
+extension Yosemite.Booking: ReadOnlyType {
+    /// Indicates if the receiver is a representation of a specified Storage.Entity instance.
+    ///
+    public func isReadOnlyRepresentation(of storageEntity: Any) -> Bool {
+        guard let storageBooking = storageEntity as? Storage.Booking else {
+            return false
+        }
+
+        return siteID == Int(storageBooking.siteID) && bookingID == Int(storageBooking.bookingID)
+    }
+}

Modules/Sources/Yosemite/Stores/BookingStore.swift

@@ -197,7 +197,18 @@ private extension BookingStore {
                                                                 startDateAfter: startDateAfter,
                                                                 searchQuery: searchQuery,
                                                                 order: order)
-                onCompletion(.success(bookings))
+                let orders = try await ordersRemote.loadOrders(
+                    for: siteID,
+                    orderIDs: bookings.map { $0.orderID }
+                )
+                let updatedBookings = bookings.map { booking in
+                    guard let order = orders.first(where: { booking.orderID == $0.orderID }) else {
+                        return booking
+                    }
+                    let orderInfo = BookingOrderInfo(booking: booking, order: order)
+                    return booking.copy(orderInfo: orderInfo)
+                }
+                onCompletion(.success(updatedBookings))
             } catch {
                 onCompletion(.failure(error))
             }
@@ -269,31 +280,26 @@ private extension BookingStore {
                 storage.insertNewObject(ofType: StorageBooking.self)
 
             if let associatedOrder = readOnlyOrders.first(where: { $0.orderID == readOnlyBooking.orderID }) {
+                let readOnlyOrderInfo = BookingOrderInfo(booking: readOnlyBooking, order: associatedOrder)
+
                 let orderInfo = storageBooking.orderInfo ?? storage.insertNewObject(ofType: Storage.BookingOrderInfo.self)
 
                 let productInfo = orderInfo.productInfo ?? storage.insertNewObject(ofType: Storage.BookingProductInfo.self)
-                let productName = associatedOrder.items.first(where: { $0.productID == readOnlyBooking.productID })?.name
-                productInfo.update(with: .init(name: productName ?? ""))
+                if let readOnlyProductInfo = readOnlyOrderInfo.productInfo {
+                    productInfo.update(with: readOnlyProductInfo)
+                }
                 orderInfo.productInfo = productInfo
 
-                if let billingAddress = associatedOrder.billingAddress {
-                    let customerInfo = orderInfo.customerInfo ?? storage.insertNewObject(ofType: Storage.BookingCustomerInfo.self)
-                    customerInfo.update(with: .init(billingAddress: billingAddress))
-                    orderInfo.customerInfo = customerInfo
+                let customerInfo = orderInfo.customerInfo ?? storage.insertNewObject(ofType: Storage.BookingCustomerInfo.self)
+                if let readOnlyCustomerInfo = readOnlyOrderInfo.customerInfo {
+                    customerInfo.update(with: readOnlyCustomerInfo)
                 }
+                orderInfo.customerInfo = customerInfo
 
                 let paymentInfo = orderInfo.paymentInfo ?? storage.insertNewObject(ofType: Storage.BookingPaymentInfo.self)
-                paymentInfo.update(with:
-                        BookingPaymentInfo(
-                            paymentMethodID: associatedOrder.paymentMethodID,
-                            paymentMethodTitle: associatedOrder.paymentMethodTitle,
-                            subtotal: associatedOrder.items.map({ Double($0.subtotal) ?? 0 }).reduce(0, +).description,
-                            subtotalTax: associatedOrder.items.map({ Double($0.subtotalTax) ?? 0 }).reduce(0, +).description,
-                            total: associatedOrder.total,
-                            totalTax: associatedOrder.totalTax
-                        )
-                )
-
+                if let readOnlyPaymentInfo = readOnlyOrderInfo.paymentInfo {
+                    paymentInfo.update(with: readOnlyPaymentInfo)
+                }
                 orderInfo.paymentInfo = paymentInfo
 
                 orderInfo.statusKey = associatedOrder.status.rawValue

Modules/Tests/YosemiteTests/Stores/BookingStoreTests.swift

@@ -455,9 +455,14 @@ struct BookingStoreTests {
 
     @Test func searchBookings_returns_bookings_on_success() async throws {
         // Given
-        let booking1 = Booking.fake().copy(siteID: sampleSiteID, bookingID: 123)
-        let booking2 = Booking.fake().copy(siteID: sampleSiteID, bookingID: 456)
+        let booking1 = Booking.fake().copy(siteID: sampleSiteID, bookingID: 123, orderID: 1)
+        let booking2 = Booking.fake().copy(siteID: sampleSiteID, bookingID: 456, orderID: 2)
         remote.whenLoadingAllBookings(thenReturn: .success([booking1, booking2]))
+
+        let order1 = Order.fake().copy(orderID: 1)
+        let order2 = Order.fake().copy(orderID: 2)
+        ordersRemote.whenLoadingOrders(thenReturn: .success([order1, order2]))
+
         let store = BookingStore(dispatcher: Dispatcher(),
                                  storageManager: storageManager,
                                  network: network,
@@ -510,8 +515,12 @@ struct BookingStoreTests {
 
     @Test func searchBookings_does_not_save_results_to_storage() async throws {
         // Given
-        let booking = Booking.fake().copy(siteID: sampleSiteID, bookingID: 123)
+        let booking = Booking.fake().copy(siteID: sampleSiteID, bookingID: 123, orderID: 1)
         remote.whenLoadingAllBookings(thenReturn: .success([booking]))
+
+        let order = Order.fake().copy(orderID: 1)
+        ordersRemote.whenLoadingOrders(thenReturn: .success([order]))
+
         let store = BookingStore(dispatcher: Dispatcher(),
                                  storageManager: storageManager,
                                  network: network,
@@ -535,6 +544,80 @@ struct BookingStoreTests {
         #expect(storedBookingCount == 0)
     }
 
+    @Test func searchBookings_fetches_orders_for_bookings() async throws {
+        // Given
+        let booking1 = Booking.fake().copy(siteID: sampleSiteID, bookingID: 123, orderID: 10)
+        let booking2 = Booking.fake().copy(siteID: sampleSiteID, bookingID: 456, orderID: 20)
+        remote.whenLoadingAllBookings(thenReturn: .success([booking1, booking2]))
+
+        let order1 = Order.fake().copy(orderID: 10)
+        let order2 = Order.fake().copy(orderID: 20)
+        ordersRemote.whenLoadingOrders(thenReturn: .success([order1, order2]))
+
+        let store = BookingStore(dispatcher: Dispatcher(),
+                                 storageManager: storageManager,
+                                 network: network,
+                                 remote: remote,
+                                 ordersRemote: ordersRemote)
+
+        // When
+        let result = await withCheckedContinuation { continuation in
+            store.onAction(BookingAction.searchBookings(siteID: sampleSiteID,
+                                                        searchQuery: "test",
+                                                        pageNumber: defaultPageNumber,
+                                                        pageSize: defaultPageSize,
+                                                        onCompletion: { result in
+                continuation.resume(returning: result)
+            }))
+        }
+
+        // Then
+        #expect(result.isSuccess)
+        #expect(ordersRemote.invokedLoadOrders)
+        #expect(ordersRemote.invokedLoadOrdersParameters?.orderIDs == [10, 20])
+    }
+
+    @Test func searchBookings_returns_bookings_with_orderInfo_when_orders_are_available() async throws {
+        // Given
+        let productID: Int64 = 100
+        let booking = Booking.fake().copy(
+            siteID: sampleSiteID,
+            bookingID: 123,
+            orderID: 1,
+            productID: productID
+        )
+        remote.whenLoadingAllBookings(thenReturn: .success([booking]))
+
+        let orderItem = OrderItem.fake().copy(itemID: 1, name: "Test Product", productID: productID)
+        let order = Order.fake().copy(orderID: 1, status: .processing, items: [orderItem])
+        ordersRemote.whenLoadingOrders(thenReturn: .success([order]))
+
+        let store = BookingStore(dispatcher: Dispatcher(),
+                                 storageManager: storageManager,
+                                 network: network,
+                                 remote: remote,
+                                 ordersRemote: ordersRemote)
+
+        // When
+        let result = await withCheckedContinuation { continuation in
+            store.onAction(BookingAction.searchBookings(siteID: sampleSiteID,
+                                                        searchQuery: "test",
+                                                        pageNumber: defaultPageNumber,
+                                                        pageSize: defaultPageSize,
+                                                        onCompletion: { result in
+                continuation.resume(returning: result)
+            }))
+        }
+
+        // Then
+        let bookings = try result.get()
+        #expect(bookings.count == 1)
+        let returnedBooking = try #require(bookings.first)
+        let orderInfo = try #require(returnedBooking.orderInfo)
+        #expect(orderInfo.productInfo?.name == "Test Product")
+        #expect(orderInfo.statusKey == "processing")
+    }
+
     // MARK: - orderInfo Storage Tests
 
     @Test func synchronizeBookings_stores_complete_orderInfo_with_all_nested_properties() async throws {
@@ -672,6 +755,13 @@ private extension BookingStoreTests {
         storedBooking.update(with: booking)
         return storedBooking
     }
+
+    @discardableResult
+    func storeProduct(_ product: Networking.Product) -> Storage.Product {
+        let storedProduct = storage.insertNewObject(ofType: Storage.Product.self)
+        storedProduct.update(with: product)
+        return storedProduct
+    }
 }
 
 private class MockOrdersRemote: OrdersRemoteProtocol {

WooCommerce/Classes/Bookings/BookingList/BookingListView.swift

@@ -128,8 +128,7 @@ private extension BookingListView {
                     .frame(maxWidth: .infinity, alignment: .leading)
                     .foregroundStyle(Color.primary)
 
-                // TODO: fetch bookable products & customer to get names or wait for API update
-                Text(String(format: "%@  •  %@", "Women's Hair cut", "Marianne"))
+                Text(booking.summaryText)
                     .font(.footnote)
                     .fontWeight(.medium)
                     .foregroundStyle(Color.secondary)

WooCommerce/Classes/Extensions/Booking+Helpers.swift

@@ -0,0 +1,26 @@
+import Foundation
+import struct Yosemite.Booking
+
+extension Booking {
+
+    var summaryText: String {
+        let productName = orderInfo?.productInfo?.name
+        let customerName: String = {
+            guard let name = orderInfo?.customerInfo?.billingAddress.fullName else {
+                return Localization.guest
+            }
+            return name.isEmpty ? Localization.guest : name
+        }()
+        return [productName, customerName]
+            .compactMap { $0 }
+            .joined(separator: "  •  ")
+    }
+
+    private enum Localization {
+        static let guest = NSLocalizedString(
+            "bookings.guest",
+            value: "Guest",
+            comment: "Displayed name on the booking list when no customer is associated with a booking."
+        )
+    }
+}