Return shipments when syncing labels for woo shipping

Author: itsmeichigo

Modules/Sources/Yosemite/Actions/WooShippingAction.swift

@@ -111,7 +111,7 @@ public enum WooShippingAction: Action {
     ///
     case syncShippingLabels(siteID: Int64,
                             orderID: Int64,
-                            completion: (Result<[ShippingLabel], Error>) -> Void)
+                            completion: (Result<ShippingLabelSyncResult, Error>) -> Void)
 
     /// Updates shipments for given order
     ///

Modules/Sources/Yosemite/Stores/WooShippingStore.swift

@@ -2,6 +2,18 @@ import Foundation
 import Networking
 import Storage
 
+public struct ShippingLabelSyncResult {
+    public let labels: [ShippingLabel]
+    public let shipments: WooShippingShipments
+
+    public init(labels: [ShippingLabel], shipments: WooShippingShipments) {
+        self.labels = labels
+        self.shipments = shipments
+    }
+
+    public static let none = ShippingLabelSyncResult(labels: [], shipments: [:])
+}
+
 /// Implements `WooShippingAction` actions
 ///
 public final class WooShippingStore: Store {
@@ -292,21 +304,22 @@ private extension WooShippingStore {
 
     func syncShippingLabels(siteID: Int64,
                             orderID: Int64,
-                            completion: @escaping (Result<[ShippingLabel], Error>) -> Void) {
+                            completion: @escaping (Result<ShippingLabelSyncResult, Error>) -> Void) {
         remote.loadConfig(siteID: siteID, orderID: orderID, completion: { [weak self] result in
             guard let self else { return }
 
             switch result {
             case .failure(let error):
                 completion(.failure(error))
             case .success(let config):
+                let shipments = config.shipments
                 guard let labels = config.shippingLabelData?.currentOrderLabels else {
-                    return completion(.success([]))
+                    return completion(.success(ShippingLabelSyncResult(labels: [], shipments: shipments)))
                 }
                 upsertShippingLabelsInBackground(siteID: siteID,
                                                  orderID: orderID,
                                                  shippingLabels: labels) {
-                    completion(.success(labels))
+                    completion(.success(ShippingLabelSyncResult(labels: labels, shipments: shipments)))
                 }
             }
         })

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

@@ -61,6 +61,10 @@ final class OrderDetailsDataSource: NSObject {
         return true
     }
 
+    /// Shipments created for the order
+    ///
+    private var wooShippingShipments: [Shipment] = []
+
     /// Whether the button to create shipping labels should be visible.
     ///
     var shouldShowShippingLabelCreation: Bool {
@@ -1696,6 +1700,36 @@ extension OrderDetailsDataSource {
     }
 }
 
+// MARK: - Woo Shipping Shipments
+extension OrderDetailsDataSource {
+    struct Shipment {
+        let index: String
+        let shippingLabel: ShippingLabel?
+    }
+
+    func populateShipments(labels: [ShippingLabel], shipments: WooShippingShipments) {
+        var contents = [Shipment]()
+
+        for key in shipments.keys.sorted(by: { $0.localizedStandardCompare($1) == .orderedAscending }) {
+
+            let label: ShippingLabel? = {
+                let purchasedLabels = labels.filter {
+                    $0.shipmentID == key && $0.status == .purchased
+                }
+                let sortedLabels = purchasedLabels.sorted { $0.dateCreated > $1.dateCreated }
+                if let completedLabel = sortedLabels.first(where: { $0.refund == nil }) {
+                    return completedLabel
+                } else {
+                    return sortedLabels.first
+                }
+            }()
+
+            let shipment = Shipment(index: key, shippingLabel: label)
+            contents.append(shipment)
+        }
+        self.wooShippingShipments = contents
+    }
+}
 
 // MARK: - Constants
 extension OrderDetailsDataSource {

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

@@ -283,9 +283,12 @@ extension OrderDetailsViewModel {
                     taskGroup.addTask { [weak self] in
                         guard let self else { return }
                         // Sync shipping labels and update order with the result if available
-                        let shippingLabels = await syncShippingLabels()
+                        let syncResult = await syncShippingLabels()
+                        dataSource.populateShipments(labels: syncResult.labels,
+                                                     shipments: syncResult.shipments)
+
                         // Update the order with the newly synced shipping labels
-                        let updatedOrder = order.copy(shippingLabels: shippingLabels)
+                        let updatedOrder = order.copy(shippingLabels: syncResult.labels)
                         update(order: updatedOrder)
                     }
                 }
@@ -703,26 +706,26 @@ extension OrderDetailsViewModel {
     }
 
     @discardableResult
-    @MainActor func syncShippingLabels() async -> [ShippingLabel] {
+    @MainActor func syncShippingLabels() async -> ShippingLabelSyncResult {
         let isRevampedFlow = featureFlagService.isFeatureFlagEnabled(.revampedShippingLabelCreation)
         guard isRevampedFlow else {
             /// old logic for syncing labels
             if await localRequirementsForShippingLabelsAreFulfilled() {
                 return await syncShippingLabelsForLegacyPlugin(isRevampedFlow: isRevampedFlow)
             }
-            return []
+            return .none
         }
 
         guard !orderContainsOnlyVirtualProducts else {
-            return []
+            return .none
         }
 
         if await isPluginActive(pluginPath: SitePlugin.SupportedPluginPath.WooShipping) {
             return await syncShippingLabelsForWooShipping()
         } else if await isPluginActive(pluginPath: SitePlugin.SupportedPluginPath.LegacyWCShip) {
             return await syncShippingLabelsForLegacyPlugin(isRevampedFlow: isRevampedFlow)
         } else {
-            return []
+            return .none
         }
     }
 
@@ -990,33 +993,45 @@ private extension OrderDetailsViewModel {
         }
     }
 
-    @MainActor func syncShippingLabelsForWooShipping() async -> [ShippingLabel] {
+    @MainActor func syncShippingLabelsForWooShipping() async -> ShippingLabelSyncResult {
         await withCheckedContinuation { continuation in
             stores.dispatch(WooShippingAction.syncShippingLabels(siteID: order.siteID, orderID: order.orderID) { [weak self] result in
-                let labels = self?.handleShippingLabelSyncingResult(result: result, isRevampedFlow: true) ?? []
-                continuation.resume(returning: labels)
+                switch result {
+                case let .success(result):
+                    self?.trackShippingLabelSyncingResult(result: .success, isRevampedFlow: true)
+                    continuation.resume(returning: result)
+                case let .failure(error):
+                    self?.trackShippingLabelSyncingResult(result: .failed(error: error), isRevampedFlow: true)
+                    continuation.resume(returning: .none)
+                }
             })
         }
     }
 
-    @MainActor func syncShippingLabelsForLegacyPlugin(isRevampedFlow: Bool) async -> [ShippingLabel] {
+    @MainActor func syncShippingLabelsForLegacyPlugin(isRevampedFlow: Bool) async -> ShippingLabelSyncResult {
         await withCheckedContinuation { continuation in
             stores.dispatch(ShippingLabelAction.synchronizeShippingLabels(siteID: order.siteID, orderID: order.orderID) { [weak self] result in
-                let labels = self?.handleShippingLabelSyncingResult(result: result, isRevampedFlow: isRevampedFlow) ?? []
-                continuation.resume(returning: labels)
+                switch result {
+                case .success(let labels):
+                    self?.trackShippingLabelSyncingResult(result: .success, isRevampedFlow: isRevampedFlow)
+                    continuation.resume(returning: ShippingLabelSyncResult(labels: labels, shipments: [:]))
+                case .failure(let error):
+                    self?.trackShippingLabelSyncingResult(result: .failed(error: error), isRevampedFlow: isRevampedFlow)
+                    continuation.resume(returning: .none)
+                }
             })
         }
     }
 
-    func handleShippingLabelSyncingResult(result: Result<[ShippingLabel], Error>, isRevampedFlow: Bool) -> [ShippingLabel] {
+    func trackShippingLabelSyncingResult(result: WooAnalyticsEvent.ShippingLabelsAPIRequestResult,
+                                         isRevampedFlow: Bool) {
         switch result {
-        case .success(let shippingLabels):
+        case .success:
             ServiceLocator.analytics.track(event: .shippingLabelsAPIRequest(
                 result: .success,
                 isRevampedFlow: isRevampedFlow
             ))
-            return shippingLabels
-        case .failure(let error):
+        case .failed(let error):
             ServiceLocator.analytics.track(event: .shippingLabelsAPIRequest(
                 result: .failed(error: error),
                 isRevampedFlow: isRevampedFlow
@@ -1026,7 +1041,6 @@ private extension OrderDetailsViewModel {
             } else {
                 DDLogError("⛔️ Error synchronizing shipping labels: \(error)")
             }
-            return []
         }
     }