Experiment/enum and concrete types for variable products

Networking/Networking/Remote/ProductVariationsRemote.swift

@@ -32,12 +32,15 @@ public protocol ProductVariationsRemoteProtocol {
                                  productVariations: [ProductVariation],
                                  completion: @escaping (Result<[ProductVariation], Error>) -> Void)
     func deleteProductVariation(siteID: Int64, productID: Int64, variationID: Int64, completion: @escaping (Result<ProductVariation, Error>) -> Void)
+    func fetchProductVariations(for siteID: Int64,
+                                parentProductID: Int64,
+                                pageNumber: Int,
+                                pageSize: Int) async throws -> [ProductVariation]
 }
 
 /// ProductVariation: Remote Endpoints
 ///
 public class ProductVariationsRemote: Remote, ProductVariationsRemoteProtocol {
-
     /// Retrieves all of the `ProductVariation`s available.
     ///
     /// - Parameters:
@@ -57,6 +60,36 @@ public class ProductVariationsRemote: Remote, ProductVariationsRemoteProtocol {
                                          pageNumber: Int = Default.pageNumber,
                                          pageSize: Int = Default.pageSize,
                                          completion: @escaping ([ProductVariation]?, Error?) -> Void) {
+        let request = productVariationsRequest(for: siteID,
+                                               productID: productID,
+                                               variationIDs: variationIDs,
+                                               context: context,
+                                               pageNumber: pageNumber,
+                                               pageSize: pageSize)
+        let mapper = ProductVariationListMapper(siteID: siteID, productID: productID)
+        enqueue(request, mapper: mapper, completion: completion)
+    }
+
+    public func fetchProductVariations(for siteID: Int64,
+                                       parentProductID: Int64,
+                                       pageNumber: Int,
+                                       pageSize: Int = Default.pageSize) async throws -> [ProductVariation] {
+        let request = productVariationsRequest(for: siteID,
+                                               productID: parentProductID,
+                                               variationIDs: [],
+                                               context: nil,
+                                               pageNumber: pageNumber,
+                                               pageSize: pageSize)
+        let mapper = ProductVariationListMapper(siteID: siteID, productID: parentProductID)
+        return try await enqueue(request, mapper: mapper)
+    }
+
+    private func productVariationsRequest(for siteID: Int64,
+                                          productID: Int64,
+                                          variationIDs: [Int64],
+                                          context: String?,
+                                          pageNumber: Int,
+                                          pageSize: Int) -> JetpackRequest {
         let stringOfVariationIDs = variationIDs.map { String($0) }
             .joined(separator: ",")
         let parameters = [
@@ -74,8 +107,7 @@ public class ProductVariationsRemote: Remote, ProductVariationsRemoteProtocol {
                                      path: path,
                                      parameters: parameters,
                                      availableAsRESTRequest: true)
-        let mapper = ProductVariationListMapper(siteID: siteID, productID: productID)
-        enqueue(request, mapper: mapper, completion: completion)
+        return request
     }
 
     /// Retrieves a specific `ProductVariation`.

Networking/Networking/Remote/ProductsRemote.swift

@@ -207,7 +207,6 @@ public final class ProductsRemote: Remote, ProductsRemoteProtocol {
         let parameters = [
             ParameterKey.page: String(pageNumber),
             ParameterKey.perPage: POSConstants.productsPerPage,
-            ParameterKey.productType: POSConstants.productType,
             ParameterKey.orderBy: OrderKey.name.value,
             ParameterKey.order: Order.ascending.value,
             ParameterKey.productStatus: POSConstants.productStatus,

WooCommerce/Classes/POS/Controllers/PointOfSaleItemsController.swift

@@ -1,26 +1,35 @@
 import Foundation
 import Combine
-import protocol Yosemite.POSDisplayableItem
+import enum Yosemite.POSItem
+import struct Yosemite.POSParentProduct
 import protocol Yosemite.PointOfSaleItemServiceProtocol
 import enum Yosemite.PointOfSaleProductServiceError
+import protocol Yosemite.PointOfSaleVariationServiceProtocol
 
 protocol PointOfSaleItemsControllerProtocol {
     var itemListStatePublisher: any Publisher<ItemListState, Never> { get }
     func loadInitialItems() async
     func loadNextItems() async
     func reload() async
+    func loadChildItems(for parentItem: POSParentProduct) async
+    func goBack()
 }
 
 class PointOfSaleItemsController: PointOfSaleItemsControllerProtocol {
     private(set) var itemListStatePublisher: any Publisher<ItemListState, Never>
     private var itemListStateSubject: PassthroughSubject<ItemListState, Never> = .init()
-    private var allItems: [POSDisplayableItem] = []
+    private var allItems: [POSItem] = []
     private var currentPage: Int = Constants.initialPage
     private var mightHaveMorePages: Bool = true
-    private let itemProvider: PointOfSaleItemServiceProtocol
+    private let rootItemProvider: PointOfSaleItemServiceProtocol
 
-    init(itemProvider: PointOfSaleItemServiceProtocol) {
-        self.itemProvider = itemProvider
+    private var allChildItems: [UUID: [POSItem]] = [:]
+    private let variationProvider: PointOfSaleVariationServiceProtocol
+
+    init(rootItemProvider: PointOfSaleItemServiceProtocol,
+         variationProvider: PointOfSaleVariationServiceProtocol) {
+        self.rootItemProvider = rootItemProvider
+        self.variationProvider = variationProvider
         itemListStatePublisher = itemListStateSubject.eraseToAnyPublisher()
     }
 
@@ -37,7 +46,7 @@ class PointOfSaleItemsController: PointOfSaleItemsControllerProtocol {
             guard mightHaveMorePages else {
                 return
             }
-            itemListStateSubject.send(.loading(allItems))
+            itemListStateSubject.send(.loading(allItems, context: .root, pageInfo: PageInfo(currentPage: currentPage, hasMorePages: true)))
 
             let nextPage = currentPage + 1
             try await load(pageNumber: nextPage)
@@ -52,7 +61,7 @@ class PointOfSaleItemsController: PointOfSaleItemsControllerProtocol {
         allItems.removeAll()
         currentPage = Constants.initialPage
         mightHaveMorePages = true
-        itemListStateSubject.send(.loading(allItems))
+        itemListStateSubject.send(.loading(allItems, context: .root, pageInfo: PageInfo(currentPage: currentPage, hasMorePages: true)))
         try? await load(pageNumber: currentPage)
     }
 
@@ -74,9 +83,9 @@ class PointOfSaleItemsController: PointOfSaleItemsControllerProtocol {
 
     @MainActor
     private func fetchItems(pageNumber: Int) async throws {
-        let newItems = try await itemProvider.providePointOfSaleItems(pageNumber: pageNumber)
+        let newItems = try await rootItemProvider.providePointOfSaleItems(pageNumber: pageNumber)
         let uniqueNewItems = newItems.filter { newItem in
-            !allItems.contains(where: { $0.isEqual(to: newItem) })
+            !allItems.contains(newItem)
         }
         allItems.append(contentsOf: uniqueNewItems)
     }
@@ -85,10 +94,30 @@ class PointOfSaleItemsController: PointOfSaleItemsControllerProtocol {
         if allItems.isEmpty {
             itemListStateSubject.send(.empty)
         } else {
-            itemListStateSubject.send(.loaded(allItems))
+            itemListStateSubject.send(.loaded(allItems, context: .root, pageInfo: PageInfo(currentPage: currentPage, hasMorePages: true)))
         }
     }
 
+    @MainActor
+    func loadChildItems(for parentProduct: POSParentProduct) async {
+        do {
+            let existingItems = allChildItems[parentProduct.id] ?? []
+            itemListStateSubject.send(.loading(existingItems, context: .child(parent: parentProduct, parentItem: .parentProduct(parentProduct)), pageInfo: PageInfo(currentPage: Constants.initialPage, hasMorePages: true)))
+
+            let newItems = try await variationProvider.providePointOfSaleItems(for: parentProduct, pageNumber: Constants.initialPage)
+            let updatedItems = existingItems + newItems
+
+            allChildItems[parentProduct.id] = updatedItems
+            itemListStateSubject.send(.loaded(updatedItems, context: .child(parent: parentProduct, parentItem: .parentProduct(parentProduct)), pageInfo: PageInfo(currentPage: Constants.initialPage, hasMorePages: true)))
+        } catch {
+            DDLogError("Error loading child items for \(parentProduct): \(error)")
+        }
+    }
+
+    func goBack() {
+        updateItemListStateAfterLoadAttempt()
+    }
+
     private enum Constants {
         static let initialPage: Int = 1
     }

WooCommerce/Classes/POS/Models/ItemListState.swift

@@ -1,11 +1,11 @@
-import protocol Yosemite.POSDisplayableItem
-import protocol Yosemite.POSOrderableItem
+import enum Yosemite.POSItem
+import struct Yosemite.POSParentProduct
 
 enum ItemListState: Equatable {
     case empty
     case initialLoading
-    case loading(_ currentItems: [POSDisplayableItem])
-    case loaded(_ items: [POSDisplayableItem])
+    case loading(_ currentItems: [POSItem], context: NavigationContext, pageInfo: PageInfo)
+    case loaded(_ items: [POSItem], context: NavigationContext, pageInfo: PageInfo)
     case error(PointOfSaleErrorState)
 
     var isLoadingAfterInitialLoad: Bool {
@@ -16,19 +16,14 @@ enum ItemListState: Equatable {
             return false
         }
     }
+}
 
-    static func == (lhs: ItemListState, rhs: ItemListState) -> Bool {
-        switch (lhs, rhs) {
-        case (.empty, .empty),
-            (.initialLoading, .initialLoading):
-            return true
-        case (.loading(let lhsItems), .loading(let rhsItems)),
-            (.loaded(let lhsItems), .loaded(let rhsItems)):
-            return lhsItems.isEqual(to: rhsItems)
-        case (.error(let lhsError), .error(let rhsError)):
-            return lhsError == rhsError
-        default:
-            return false
-        }
-    }
+struct PageInfo: Equatable {
+    let currentPage: Int
+    let hasMorePages: Bool
+}
+
+enum NavigationContext: Equatable {
+    case root
+    case child(parent: POSParentProduct, parentItem: POSItem)
 }

WooCommerce/Classes/POS/Models/PointOfSaleAggregateModel.swift

@@ -7,6 +7,7 @@ import struct Yosemite.Order
 import struct Yosemite.OrderItem
 import struct Yosemite.POSCartItem
 import enum Yosemite.SystemStatusAction
+import struct Yosemite.POSParentProduct
 
 protocol PointOfSaleAggregateModelProtocol {
     var orderStage: PointOfSaleOrderStage { get }
@@ -25,6 +26,7 @@ protocol PointOfSaleAggregateModelProtocol {
     func loadInitialItems() async
     func loadNextItems() async
     func reload() async
+    func showChildren(for: POSParentProduct)
 
     var cart: [CartItem] { get }
     func addToCart(_ item: POSOrderableItem)
@@ -108,6 +110,16 @@ extension PointOfSaleAggregateModel {
     func reload() async {
         await itemsController.reload()
     }
+
+    func showChildren(for parentProduct: POSParentProduct) {
+        Task { @MainActor in
+            await itemsController.loadChildItems(for: parentProduct)
+        }
+    }
+
+    func goBack() {
+        itemsController.goBack()
+    }
 }
 
 // MARK: - Cart

WooCommerce/Classes/POS/Presentation/CardReaderConnection/UI States/PointOfSaleItemListFullscreenView.swift

@@ -6,7 +6,7 @@ struct PointOfSaleItemListFullscreenView<Content: View>: View {
     var body: some View {
         ZStack {
             VStack(alignment: .center, spacing: PointOfSaleItemListErrorLayout.headerSpacing) {
-                POSHeaderTitleView(foregroundColor: .posSecondaryText)
+                POSHeaderTitleView(foregroundColor: .posSecondaryText, context: .root, backAction: {})
                 Spacer()
             }
 

WooCommerce/Classes/POS/Presentation/ItemListView.swift

@@ -1,6 +1,7 @@
 import SwiftUI
-import protocol Yosemite.POSDisplayableItem
+import enum Yosemite.POSItem
 import protocol Yosemite.POSOrderableItem
+import struct Yosemite.POSParentProduct
 
 struct ItemListView: View {
     @Environment(\.floatingControlAreaSize) var floatingControlAreaSize: CGSize
@@ -16,14 +17,16 @@ struct ItemListView: View {
 
     var body: some View {
         VStack {
-            headerView
             switch posModel.itemListState {
             case .initialLoading, .empty, .error:
                 // These cases are handled directly in the dashboard, we do not render
                 // a specific view within the ItemListView to handle them
+                headerView()
                 EmptyView()
-            case .loading(let items), .loaded(let items):
-                listView(items)
+            case .loading(let items, let context, _),
+                    .loaded(let items, let context, _):
+                headerView(context: context).transition(.slide)
+                listView(items).transition(.slide)
             }
         }
         .refreshable {
@@ -41,10 +44,14 @@ struct ItemListView: View {
 ///
 private extension ItemListView {
     @ViewBuilder
-    var headerView: some View {
+    func headerView(context: NavigationContext = .root) -> some View {
         VStack {
             HStack {
-                POSHeaderTitleView()
+                POSHeaderTitleView(context: context) {
+                    withAnimation {
+                        posModel.goBack()
+                    }
+                }
                 if !shouldShowHeaderBanner {
                     Spacer()
                     Button(action: {
@@ -124,13 +131,13 @@ private extension ItemListView {
     }
 
     @ViewBuilder
-    func listView(_ items: [POSDisplayableItem]) -> some View {
+    func listView(_ items: [POSItem]) -> some View {
         ScrollView {
             VStack {
                 if dynamicTypeSize.isAccessibilitySize, shouldShowHeaderBanner {
                     bannerCardView
                 }
-                ForEach(items, id: \.id) { item in
+                ForEach(items) { item in
                     listRow(item: item)
                 }
                 GhostItemCardView()
@@ -158,15 +165,28 @@ private extension ItemListView {
     }
 
     @ViewBuilder
-    func listRow(item: POSDisplayableItem) -> some View {
-        if let item = item as? POSOrderableItem {
+    func listRow(item: POSItem) -> some View {
+        switch item {
+        case .product(let product):
+            Button(action: {
+                posModel.addToCart(product)
+            }, label: {
+                ProductCardView(product: product)
+            })
+        case .parentProduct(let parentProduct):
+            Button(action: {
+                withAnimation {
+                    posModel.showChildren(for: parentProduct)
+                }
+            }, label: {
+                ParentProductCardView(parentProduct: parentProduct)
+            })
+        case .variation(let variation):
             Button(action: {
-                posModel.addToCart(item)
+                posModel.addToCart(variation)
             }, label: {
-                ItemCardView(item: item)
+                VariationCardView(variation: variation)
             })
-        } else {
-            ItemCardView(item: item)
         }
     }
 }

WooCommerce/Classes/POS/Presentation/ItemRowView.swift

@@ -115,9 +115,11 @@ private extension ItemRowView {
 }
 
 #if DEBUG
+import struct Yosemite.POSProduct
 #Preview {
+    let orderableItem = POSProduct(id: UUID(), name: "Product 3", formattedPrice: "$3.00", productID: 3, price: "3.00")
     ItemRowView(cartItem: CartItem(id: UUID(),
-                                   item: PointOfSalePreviewItemService().providePointOfSaleItem(),
+                                   item: orderableItem,
                                    quantity: 2),
                 onItemRemoveTapped: { })
 }