[Woo POS] Coupons: Sync from remote (#15423)

Author: iamgabrielma

Networking/Networking/Remote/CouponsRemote.swift

@@ -372,6 +372,23 @@ public final class CouponsRemote: Remote, CouponsRemoteProtocol {
     }
 }
 
+extension CouponsRemote {
+    public func loadAllCoupons(for siteID: Int64,
+                               pageNumber: Int = CouponsRemote.Default.pageNumber,
+                               pageSize: Int = CouponsRemote.Default.pageSize) async throws -> [Coupon] {
+        try await withCheckedThrowingContinuation { continuation in
+            loadAllCoupons(for: siteID, pageNumber: pageNumber, pageSize: pageSize) { result in
+                switch result {
+                case .success(let coupons):
+                    continuation.resume(returning: coupons)
+                case .failure(let error):
+                    continuation.resume(throwing: error)
+                }
+            }
+        }
+    }
+}
+
 // MARK: - Constants
 //
 public extension CouponsRemote {

WooCommerce/Classes/POS/Controllers/PointOfSaleCouponsController.swift

@@ -1,5 +1,6 @@
 import Observation
 import enum Yosemite.POSItem
+import enum Yosemite.CouponAction
 import protocol Yosemite.PointOfSaleItemServiceProtocol
 
 @available(iOS 17.0, *)

WooCommerce/Classes/ViewRelated/Hub Menu/HubMenuViewModel.swift

@@ -108,10 +108,12 @@ final class HubMenuViewModel: ObservableObject {
     private(set) lazy var posCouponProvider: PointOfSaleItemServiceProtocol = {
         let storage = ServiceLocator.storageManager
         let currencySettings = ServiceLocator.currencySettings
+        let stores = ServiceLocator.stores
 
         return PointOfSaleCouponService(siteID: siteID,
                                         currencySettings: currencySettings,
                                         credentials: credentials,
+                                        stores: stores,
                                         storage: storage)
     }()
 

Yosemite/Yosemite/PointOfSale/PointOfSaleCouponService.swift

@@ -1,7 +1,6 @@
 import protocol Networking.Network
 import protocol Networking.ProductVariationsRemoteProtocol
-import class Networking.ProductsRemote
-import class Networking.ProductVariationsRemote
+import class Networking.CouponsRemote
 import class Networking.AlamofireNetwork
 import class WooFoundation.CurrencyFormatter
 import class WooFoundation.CurrencySettings
@@ -10,52 +9,56 @@ import Storage
 public final class PointOfSaleCouponService: PointOfSaleItemServiceProtocol {
     private var siteID: Int64
     private let currencyFormatter: CurrencyFormatter
-    private let productsRemote: ProductsRemote
-    private let variationRemote: ProductVariationsRemoteProtocol
+    private let couponsRemote: CouponsRemote
+    private let stores: StoresManager?
     private let storage: StorageManagerType?
 
     public init(siteID: Int64,
                 currencySettings: CurrencySettings,
                 network: Network,
+                stores: StoresManager? = nil,
                 storage: StorageManagerType? = nil) {
         self.siteID = siteID
         self.currencyFormatter = CurrencyFormatter(currencySettings: currencySettings)
-        self.productsRemote = ProductsRemote(network: network)
-        self.variationRemote = ProductVariationsRemote(network: network)
+        self.couponsRemote = CouponsRemote(network: network)
+        self.stores = stores
         self.storage = storage
     }
 
     public convenience init(siteID: Int64,
                             currencySettings: CurrencySettings,
                             credentials: Credentials?,
+                            stores: StoresManager,
                             storage: StorageManagerType) {
         self.init(siteID: siteID,
                   currencySettings: currencySettings,
                   network: AlamofireNetwork(credentials: credentials),
+                  stores: stores,
                   storage: storage)
     }
 
     // TODO:
     // gh-15326 - Return PagedItems<POSItem> instead.
     @MainActor
-    public func providePointOfSaleCoupons() -> [POSItem] {
+    public func providePointOfSaleCoupons() async -> [POSItem] {
         guard let storage = storage else {
             return []
         }
+
         let predicate = NSPredicate(format: "siteID == %lld", siteID)
         let descriptor = NSSortDescriptor(keyPath: \StorageCoupon.dateCreated,
                                           ascending: false)
 
         let resultsController = ResultsController<StorageCoupon>(storageManager: storage,
-                                                                matching: predicate,
-                                                                sortedBy: [descriptor])
+                                                                 matching: predicate,
+                                                                 sortedBy: [descriptor])
 
         do {
             try resultsController.performFetch()
-            let storeCoupons = resultsController.fetchedObjects
-            return mapCouponsToPOSItems(coupons: storeCoupons)
+            let storageCoupons = resultsController.fetchedObjects
+            return mapCouponsToPOSItems(coupons: storageCoupons)
         } catch {
-            debugPrint(error)
+            debugPrint("Failed to load coupons from storage:", error)
             return []
         }
     }
@@ -73,7 +76,39 @@ public final class PointOfSaleCouponService: PointOfSaleItemServiceProtocol {
 
     @MainActor
     public func providePointOfSaleItems(pageNumber: Int) async throws -> PagedItems<POSItem> {
-        let coupons = providePointOfSaleCoupons()
-        return .init(items: coupons, hasMorePages: false)
+        let coupons = await providePointOfSaleCoupons()
+
+        if !coupons.isEmpty {
+            // Fire-and-forget sync
+            Task.detached {
+                await self.syncCouponsFromRemote(pageNumber: pageNumber)
+            }
+            return .init(items: coupons, hasMorePages: false)
+        } else {
+            // Wait for the sync to complete
+            await syncCouponsFromRemote(pageNumber: pageNumber)
+            let refreshedCoupons = await providePointOfSaleCoupons()
+            return .init(items: refreshedCoupons, hasMorePages: false)
+        }
+    }
+
+    private func syncCouponsFromRemote(pageNumber: Int) async {
+        guard let stores = stores else {
+            return
+        }
+
+        await withCheckedContinuation { continuation in
+            let action = CouponAction.synchronizeCoupons(
+                siteID: siteID,
+                pageNumber: pageNumber,
+                pageSize: 25,
+                onCompletion: { _ in
+                    continuation.resume()
+                }
+            )
+            Task { @MainActor in
+                stores.dispatch(action)
+            }
+        }
     }
 }