Shipping Labels: Load shipments from storage on purchase form (#15919)

Author: itsmeichigo

RELEASE-NOTES.txt

@@ -10,6 +10,7 @@
 - [*] POS: a POS tab in the tab bar is now available in the app for stores in countries eligible for Point of Sale, instead of the tab is only shown when the store is eligible for POS. [https://github.com/woocommerce/woocommerce-ios/pull/15918]
 - [*] Shipping Labels: Display base rate on selected shipping service cards [https://github.com/woocommerce/woocommerce-ios/pull/15916]
 - [*] Shipping Labels: Update mark order completed toggle on purchase form [https://github.com/woocommerce/woocommerce-ios/pull/15917]
+- [*] Shipping Labels: Optimize data loading on purchase form [https://github.com/woocommerce/woocommerce-ios/pull/15919]
 - [internal] Optimized assets for app size reduction [https://github.com/woocommerce/woocommerce-ios/pull/15881]
 
 22.8

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

@@ -217,7 +217,7 @@ private extension OrderDetailsResultsControllers {
         do {
             try shipmentResultsController.performFetch()
         } catch {
-            DDLogError("⛔️ Unable to fetch Order Statuses: \(error)")
+            DDLogError("⛔️ Unable to fetch shipments: \(error)")
         }
     }
 

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

@@ -117,6 +117,12 @@ final class OrderDetailsViewModel {
     ///
     let dataSource: OrderDetailsDataSource
 
+    /// The eligibility check for Woo Shipping can be updated late due to being async
+    /// So the additional check for shipments determines if the new form should be displayed.
+    var shouldNavigateToNewShippingLabelFlow: Bool {
+        dataSource.isEligibleForWooShipping || dataSource.shipments.isNotEmpty
+    }
+
     private(set) lazy var editNoteViewModel: EditCustomerNoteViewModel = {
         return EditCustomerNoteViewModel(order: order)
     }()

WooCommerce/Classes/ViewRelated/Orders/Order Details/OrderDetailsViewController.swift

@@ -427,7 +427,7 @@ private extension OrderDetailsViewController {
     }
 
     func navigateToCreateShippingLabelForm(preSelection: WooShippingCreateLabelSelection? = nil) {
-        guard viewModel.dataSource.isEligibleForWooShipping else {
+        guard viewModel.shouldNavigateToNewShippingLabelFlow else {
             // Navigate to legacy shipping label creation form if Woo Shipping extension is not supported.
             let shippingLabelFormVC = ShippingLabelFormViewController(order: viewModel.order)
             shippingLabelFormVC.onLabelPurchase = { [weak self] isOrderComplete in

WooCommerce/Classes/ViewRelated/Orders/Order Details/Shipping Labels/WooShipping Create Shipping Labels/WooShipping Split Shipments/WooShippingSplitShipmentsView.swift

@@ -517,19 +517,21 @@ fileprivate extension WooShippingSplitShipmentsView {
 
 #if DEBUG
 #Preview {
-    WooShippingSplitShipmentsView(viewModel: WooShippingSplitShipmentsViewModel(order: ShippingLabelSampleData.sampleOrder(),
-                                                                                      config: ShippingLabelSampleData.sampleWooShippingConfig(),
-                                                                                      items: [ShippingLabelPackageItem(productOrVariationID: 1,
-                                                                                                                       orderItemID: 12,
-                                                                                                                       name: "Shirt",
-                                                                                                                       weight: 0.5,
-                                                                                                                       quantity: 2,
-                                                                                                                       value: 9.99,
-                                                                                                                       dimensions: ProductDimensions(length: "",
-                                                                                                                                                     width: "",
-                                                                                                                                                     height: ""),
-                                                                                                                       attributes: [],
-                                                                                                                       imageURL: nil)]),
-                                  onShipmentUpdate: { _ in })
+    WooShippingSplitShipmentsView(viewModel: WooShippingSplitShipmentsViewModel(
+        order: ShippingLabelSampleData.sampleOrder(),
+        remoteShipments: [],
+        items: [ShippingLabelPackageItem(productOrVariationID: 1,
+                                         orderItemID: 12,
+                                         name: "Shirt",
+                                         weight: 0.5,
+                                         quantity: 2,
+                                         value: 9.99,
+                                         dimensions: ProductDimensions(length: "",
+                                                                       width: "",
+                                                                       height: ""),
+                                         attributes: [],
+                                         imageURL: nil)]),
+                                  onShipmentUpdate: { _ in }
+    )
 }
 #endif

WooCommerce/Classes/ViewRelated/Orders/Order Details/Shipping Labels/WooShipping Create Shipping Labels/WooShipping Split Shipments/WooShippingSplitShipmentsViewModel.swift

@@ -112,7 +112,7 @@ final class WooShippingSplitShipmentsViewModel: ObservableObject {
     }
 
     init(order: Order,
-         config: WooShippingConfig?,
+         remoteShipments: [WooShippingShipment],
          items: [ShippingLabelPackageItem],
          stores: StoresManager = ServiceLocator.stores,
          currencySettings: CurrencySettings = ServiceLocator.currencySettings,
@@ -122,7 +122,7 @@ final class WooShippingSplitShipmentsViewModel: ObservableObject {
         self.currencySettings = currencySettings
         self.shippingSettingsService = shippingSettingsService
 
-        let shipments = Self.createShipments(with: config,
+        let shipments = Self.createShipments(with: remoteShipments,
                                              packageItems: items,
                                              currency: order.currency,
                                              currencySettings: currencySettings,
@@ -528,12 +528,12 @@ private extension WooShippingSplitShipmentsViewModel {
 
 extension WooShippingSplitShipmentsViewModel {
 
-    private static func createShipments(with config: WooShippingConfig?,
+    private static func createShipments(with remoteShipments: [WooShippingShipment],
                                         packageItems: [ShippingLabelPackageItem],
                                         currency: String,
                                         currencySettings: CurrencySettings,
                                         shippingSettingsService: ShippingSettingsService) -> [Shipment] {
-        guard let config, config.shipments.isEmpty == false else {
+        guard remoteShipments.isEmpty == false else {
             let contents = packageItems.map { item in
                 CollapsibleShipmentItemCardViewModel(item: item, currency: currency)
             }
@@ -544,7 +544,7 @@ extension WooShippingSplitShipmentsViewModel {
             return [shipment]
         }
 
-        let shipments = config.shipments
+        let shipments = remoteShipments
             .sorted(by: { $0.index.localizedStandardCompare($1.index) == .orderedAscending })
             .map { shipment in
                 var shipmentContents = ShipmentContents()

WooCommerce/Classes/ViewRelated/Orders/Order Details/Shipping Labels/WooShipping Create Shipping Labels/WooShippingCreateLabelsViewModel.swift

@@ -4,6 +4,7 @@ import WooFoundation
 import Combine
 import struct Networking.WooShippingAccountSettings
 import enum Networking.DotcomError
+import protocol Storage.StorageManagerType
 
 enum WooShippingCreateLabelSelection {
     case shipment(index: Int)
@@ -31,6 +32,7 @@ final class WooShippingCreateLabelsViewModel: ObservableObject {
     private let itemsDataSource: WooShippingItemsDataSource
     private var destinationEmail: String?
     private let stores: StoresManager
+    private let storageManager: StorageManagerType
     private let currencySettings: CurrencySettings
     private var subscriptions: Set<AnyCancellable> = []
     private let initialNoticeDelay: RunLoop.SchedulerTimeType.Stride
@@ -207,12 +209,24 @@ final class WooShippingCreateLabelsViewModel: ObservableObject {
 
     let isOrderCompleted: Bool
 
+    /// Shipments Results Controller.
+    ///
+    private lazy var shipmentResultsController: ResultsController<StorageWooShippingShipment> = {
+        let predicate = NSPredicate(format: "siteID = %ld AND orderID = %ld",
+                                    self.order.siteID,
+                                    self.order.orderID)
+        let descriptor = NSSortDescriptor(keyPath: \StorageWooShippingShipment.index, ascending: true)
+
+        return ResultsController<StorageWooShippingShipment>(storageManager: storageManager, matching: predicate, sortedBy: [descriptor])
+    }()
+
     /// Initialize the view model with or without an existing shipping label.
     init(order: Order,
          preselection: WooShippingCreateLabelSelection? = nil,
          currencySettings: CurrencySettings = ServiceLocator.currencySettings,
          shippingSettingsService: ShippingSettingsService = ServiceLocator.shippingSettingsService,
          stores: StoresManager = ServiceLocator.stores,
+         storageManager: StorageManagerType = ServiceLocator.storageManager,
          analytics: Analytics = ServiceLocator.analytics,
          initialNoticeDelay: RunLoop.SchedulerTimeType.Stride = .seconds(2),
          onLabelPurchase: ((Bool) -> Void)? = nil) {
@@ -224,13 +238,14 @@ final class WooShippingCreateLabelsViewModel: ObservableObject {
         self.destinationEmail = order.shippingAddress?.email ?? order.billingAddress?.email
         self.shippingLines = order.shippingLines.map({ WooShipping_ShippingLineViewModel(shippingLine: $0, currency: order.currency) })
         self.stores = stores
+        self.storageManager = storageManager
         self.analytics = analytics
         self.shippingSettingsService = shippingSettingsService
         self.initialNoticeDelay = initialNoticeDelay
         self.isOrderCompleted = order.status == .completed
 
         let splitShipmentsViewModel = WooShippingSplitShipmentsViewModel(order: order,
-                                                                         config: nil,
+                                                                         remoteShipments: [],
                                                                          items: itemsDataSource.items,
                                                                          stores: stores)
         self.splitShipmentsViewModel = splitShipmentsViewModel
@@ -251,6 +266,7 @@ final class WooShippingCreateLabelsViewModel: ObservableObject {
         observeDestinationAddress()
         observeViewStates()
         observePaymentMethod()
+        configureShipmentResultsController()
 
         Task { @MainActor in
             await loadRequiredData()
@@ -281,19 +297,15 @@ final class WooShippingCreateLabelsViewModel: ObservableObject {
                 }
             }
 
-            if shipments.contains(where: { $0.purchasedLabel == nil }) {
+            if hasUnfulfilledShipments {
                 group.addTask {
                     await self.loadOriginAddresses()
                 }
             }
-
-            group.addTask {
-                await self.loadShipmentsInfo()
-            }
         }
 
         if isMissingStoreSettings ||
-            originAddress.isEmpty {
+            (originAddress.isEmpty && hasUnfulfilledShipments) {
             state = .missingRequiredData
         } else {
             state = .ready
@@ -438,33 +450,6 @@ private extension WooShippingCreateLabelsViewModel {
         }
     }
 
-    /// Loads shipment info from remote and creates view model for split shipments.
-    ///
-    @MainActor
-    func loadShipmentsInfo() async {
-        let config: WooShippingConfig? = await withCheckedContinuation { continuation in
-            let action = WooShippingAction.loadConfig(siteID: order.siteID,
-                                                      orderID: order.orderID) { result in
-                switch result {
-                case .success(let shipmentResponse):
-                    continuation.resume(returning: shipmentResponse)
-                case .failure(let error):
-                    DDLogError("⛔️ Error loading config for Woo Shipping labels: \(error)")
-                    continuation.resume(returning: nil)
-                }
-            }
-            stores.dispatch(action)
-        }
-
-        if let config {
-            splitShipmentsViewModel = WooShippingSplitShipmentsViewModel(order: order,
-                                                                         config: config,
-                                                                         items: itemsDataSource.items,
-                                                                         stores: stores)
-            shipments = splitShipmentsViewModel.shipments
-        }
-    }
-
     /// Loads destination address of the order from remote.
     ///
     func loadDestinationAddress() {
@@ -661,6 +646,33 @@ private extension WooShippingCreateLabelsViewModel {
             return $0.paymentMethodID == accountSettings?.selectedPaymentMethodID
         }
     }
+
+    func configureShipmentResultsController() {
+        let reloadShipments = { [weak self] in
+            guard let self else { return }
+            let fetchedShipments = shipmentResultsController.fetchedObjects
+            splitShipmentsViewModel = WooShippingSplitShipmentsViewModel(order: order,
+                                                                         remoteShipments: fetchedShipments,
+                                                                         items: itemsDataSource.items,
+                                                                         stores: stores)
+            shipments = splitShipmentsViewModel.shipments
+        }
+
+        shipmentResultsController.onDidChangeContent = {
+            reloadShipments()
+        }
+
+        shipmentResultsController.onDidResetContent = {
+            reloadShipments()
+        }
+
+        do {
+            try shipmentResultsController.performFetch()
+            reloadShipments()
+        } catch {
+            DDLogError("⛔️ Unable to fetch shipments: \(error)")
+        }
+    }
 }
 
 private extension WooShippingCreateLabelsViewModel {