Shipping Labels: Migrate to the config endpoint for syncing shipping labels in Woo Shipping plugin (#15800)

Author: itsmeichigo

Modules/Sources/Yosemite/Actions/WooShippingAction.swift

@@ -99,6 +99,14 @@ public enum WooShippingAction: Action {
                     orderID: Int64,
                     completion: (Result<WooShippingConfig, Error>) -> Void)
 
+    /// Sync shipping labels for a given order.
+    /// This uses the same endpoint as `loadConfig` but also stores shipping labels to the storage
+    /// and returns them in the completion closure.
+    ///
+    case syncShippingLabels(siteID: Int64,
+                            orderID: Int64,
+                            completion: (Result<[ShippingLabel], Error>) -> Void)
+
     /// Updates shipments for given order
     ///
     case updateShipment(siteID: Int64,

Modules/Sources/Yosemite/Stores/WooShippingStore.swift

@@ -82,6 +82,8 @@ public final class WooShippingStore: Store {
             updateDestinationAddress(siteID: siteID, orderID: orderID, address: address, completion: completion)
         case let .loadConfig(siteID, orderID, completion):
             loadConfig(siteID: siteID, orderID: orderID, completion: completion)
+        case let .syncShippingLabels(siteID, orderID, completion):
+            syncShippingLabels(siteID: siteID, orderID: orderID, completion: completion)
         case let .updateShipment(siteID, orderID, shipmentToUpdate, completion):
             updateShipment(siteID: siteID,
                            orderID: orderID,
@@ -247,6 +249,28 @@ private extension WooShippingStore {
                                  completion: @escaping (Result<Bool, Error>) -> Void) {
         remote.acceptUPSTermsOfService(siteID: siteID, originAddress: originAddress, completion: completion)
     }
+
+    func syncShippingLabels(siteID: Int64,
+                            orderID: Int64,
+                            completion: @escaping (Result<[ShippingLabel], 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):
+                guard let labels = config.shippingLabelData?.currentOrderLabels else {
+                    return completion(.success([]))
+                }
+                upsertShippingLabelsInBackground(siteID: siteID,
+                                                 orderID: orderID,
+                                                 shippingLabels: labels) {
+                    completion(.success(labels))
+                }
+            }
+        })
+    }
 }
 
 // MARK: Helpers
@@ -602,7 +626,7 @@ private extension WooShippingStore {
 
     /// Updates order's `dateModified` locally
     /// Used as temp workaround to reflect that the order instance was updated
-    private func setLastModifiedDateForOrder(siteID: Int64, orderID: Int64) {
+    func setLastModifiedDateForOrder(siteID: Int64, orderID: Int64) {
         storageManager.performAndSave({ derivedStorage in
             guard let storedOrder = derivedStorage.loadOrder(
                 siteID: siteID,
@@ -614,6 +638,70 @@ private extension WooShippingStore {
             storedOrder.dateModified = Date()
         }, completion: nil, on: .main)
     }
+
+    /// Updates/inserts the specified readonly shipping label entities *in a background thread*.
+    /// `onCompletion` will be called on the main thread!
+    func upsertShippingLabelsInBackground(siteID: Int64,
+                                          orderID: Int64,
+                                          shippingLabels: [ShippingLabel],
+                                          onCompletion: @escaping () -> Void) {
+        if shippingLabels.isEmpty {
+            return onCompletion()
+        }
+
+        storageManager.performAndSave ({ [weak self] storage in
+            guard let self else { return }
+            guard let order = storage.loadOrder(siteID: siteID, orderID: orderID) else {
+                return
+            }
+            upsertShippingLabels(siteID: siteID, orderID: orderID, shippingLabels: shippingLabels, storageOrder: order, using: storage)
+        }, completion: onCompletion, on: .main)
+    }
+
+    /// Updates/inserts the specified readonly ShippingLabel entities in the current thread.
+    func upsertShippingLabels(siteID: Int64,
+                              orderID: Int64,
+                              shippingLabels: [ShippingLabel],
+                              storageOrder: StorageOrder,
+                              using storage: StorageType) {
+        let storedLabels = storage.loadAllShippingLabels(siteID: siteID, orderID: orderID)
+        for shippingLabel in shippingLabels {
+            let storageShippingLabel = storedLabels.first(where: { $0.shippingLabelID == shippingLabel.shippingLabelID }) ??
+            storage.insertNewObject(ofType: Storage.ShippingLabel.self)
+            storageShippingLabel.update(with: shippingLabel)
+            storageShippingLabel.order = storageOrder
+
+            update(storageShippingLabel: storageShippingLabel, refund: shippingLabel.refund, using: storage)
+
+            let originAddress = storageShippingLabel.originAddress ?? storage.insertNewObject(ofType: Storage.ShippingLabelAddress.self)
+            originAddress.update(with: shippingLabel.originAddress)
+            storageShippingLabel.originAddress = originAddress
+
+            let destinationAddress = storageShippingLabel.destinationAddress ?? storage.insertNewObject(ofType: Storage.ShippingLabelAddress.self)
+            destinationAddress.update(with: shippingLabel.destinationAddress)
+            storageShippingLabel.destinationAddress = destinationAddress
+        }
+
+        // Now, remove any objects that exist in storage but not in shippingLabels
+        let shippingLabelIDs = shippingLabels.map(\.shippingLabelID)
+        storedLabels.filter {
+            !shippingLabelIDs.contains($0.shippingLabelID)
+        }.forEach {
+            storage.deleteObject($0)
+        }
+    }
+
+    func update(storageShippingLabel: StorageShippingLabel,
+                refund: ShippingLabelRefund?,
+                using storage: StorageType) {
+        if let refund {
+            let storageRefund = storageShippingLabel.refund ?? storage.insertNewObject(ofType: Storage.ShippingLabelRefund.self)
+            storageRefund.update(with: refund)
+            storageShippingLabel.refund = storageRefund
+        } else {
+            storageShippingLabel.refund = nil
+        }
+    }
 }
 
 /// Represents errors that can be returned when purchasing a shipping label

RELEASE-NOTES.txt

@@ -9,6 +9,7 @@
 - [***] POS: Barcode scanning using Bluetooth scanners in Point of Sale (HID-based scanners are supported) [https://github.com/woocommerce/woocommerce-ios/pull/15776]
 - [*] POS: Support refreshing product list when it's empty [https://github.com/woocommerce/woocommerce-ios/pull/15782]
 - [*] Shipping Labels: Fixed issue displaying fulfilled shipment after purchasing a label and quickly navigating back to the purchase form. [https://github.com/woocommerce/woocommerce-ios/pull/15790]
+- [*] Shipping Labels: Fixed mismatched indices of purchased labels on the order details screen. [https://github.com/woocommerce/woocommerce-ios/pull/15800]
 - [*] POS: Prevent card reader connection success alert flashing when connecting during a payment [https://github.com/woocommerce/woocommerce-ios/pull/15784]
 
 22.6

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

@@ -1307,7 +1307,13 @@ extension OrderDetailsDataSource {
             }
 
             let sections = shippingLabels.enumerated().map { index, shippingLabel -> Section in
-                let title = String.localizedStringWithFormat(Title.shippingLabelPackageFormat, index + 1)
+                let title = {
+                    guard let shipmentID = shippingLabel.shipmentID,
+                          let intID = Int(shipmentID) else {
+                        return String.localizedStringWithFormat(Title.shippingLabelPackageFormat, index + 1)
+                    }
+                    return String.localizedStringWithFormat(Title.shippingLabelPackageFormat, intID + 1)
+                }()
                 let isRefunded = shippingLabel.refund != nil
                 let rows: [Row]
                 let headerStyle: Section.HeaderStyle

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

@@ -108,7 +108,13 @@ final class OrderDetailsResultsControllers {
     /// Shipping labels for an Order
     ///
     var shippingLabels: [ShippingLabel] {
-        return order.shippingLabels
+        order.shippingLabels.sorted(by: { label1, label2 in
+            if let shipmentID1 = label1.shipmentID,
+               let shipmentID2 = label2.shipmentID {
+                return shipmentID1.localizedStandardCompare(shipmentID2) == .orderedAscending
+            }
+            return label1.dateCreated < label2.dateCreated
+        })
     }
 
     /// Site's add-on groups.

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

@@ -696,32 +696,25 @@ extension OrderDetailsViewModel {
 
     @discardableResult
     @MainActor func syncShippingLabels() async -> [ShippingLabel] {
-        guard await localRequirementsForShippingLabelsAreFulfilled() else {
+        let isRevampedFlow = featureFlagService.isFeatureFlagEnabled(.revampedShippingLabelCreation)
+        guard isRevampedFlow else {
+            /// old logic for syncing labels
+            if await localRequirementsForShippingLabelsAreFulfilled() {
+                return await syncShippingLabelsForLegacyPlugin(isRevampedFlow: isRevampedFlow)
+            }
             return []
         }
-        let isRevampedFlow = featureFlagService.isFeatureFlagEnabled(.revampedShippingLabelCreation)
-        return await withCheckedContinuation { continuation in
-            stores.dispatch(ShippingLabelAction.synchronizeShippingLabels(siteID: order.siteID, orderID: order.orderID) { result in
-                switch result {
-                case .success(let shippingLabels):
-                    ServiceLocator.analytics.track(event: .shippingLabelsAPIRequest(
-                        result: .success,
-                        isRevampedFlow: isRevampedFlow
-                    ))
-                    continuation.resume(returning: shippingLabels)
-                case .failure(let error):
-                    ServiceLocator.analytics.track(event: .shippingLabelsAPIRequest(
-                        result: .failed(error: error),
-                        isRevampedFlow: isRevampedFlow
-                    ))
-                    if error as? DotcomError == .noRestRoute {
-                        DDLogError("⚠️ Endpoint for synchronizing shipping labels is unreachable. WC Shipping plugin may be missing.")
-                    } else {
-                        DDLogError("⛔️ Error synchronizing shipping labels: \(error)")
-                    }
-                    continuation.resume(returning: [])
-                }
-            })
+
+        guard !orderContainsOnlyVirtualProducts else {
+            return []
+        }
+
+        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 []
         }
     }
 
@@ -956,6 +949,47 @@ extension OrderDetailsViewModel {
 }
 
 private extension OrderDetailsViewModel {
+
+    @MainActor func syncShippingLabelsForWooShipping() async -> [ShippingLabel] {
+        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)
+            })
+        }
+    }
+
+    @MainActor func syncShippingLabelsForLegacyPlugin(isRevampedFlow: Bool) async -> [ShippingLabel] {
+        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)
+            })
+        }
+    }
+
+    func handleShippingLabelSyncingResult(result: Result<[ShippingLabel], Error>, isRevampedFlow: Bool) -> [ShippingLabel] {
+        switch result {
+        case .success(let shippingLabels):
+            ServiceLocator.analytics.track(event: .shippingLabelsAPIRequest(
+                result: .success,
+                isRevampedFlow: isRevampedFlow
+            ))
+            return shippingLabels
+        case .failure(let error):
+            ServiceLocator.analytics.track(event: .shippingLabelsAPIRequest(
+                result: .failed(error: error),
+                isRevampedFlow: isRevampedFlow
+            ))
+            if error as? DotcomError == .noRestRoute {
+                DDLogError("⚠️ Endpoint for synchronizing shipping labels is unreachable. WC Shipping plugin may be missing.")
+            } else {
+                DDLogError("⛔️ Error synchronizing shipping labels: \(error)")
+            }
+            return []
+        }
+    }
+
     @MainActor
     func isPluginActive(_ plugin: String) async -> Bool {
         return await isPluginActive([plugin])