Merge branch 'trunk' into task/WOOMOB-1640-post-app-listings-meta

Author: iamgabrielma

CHANGELOG.md

@@ -1,6 +1,9 @@
 <!--
 Contains editorialized release notes. Raw release notes should go into `RELEASE-NOTES.txt`.
 -->
+## 23.7
+This update brings Tap to Pay on iPhone to UK stores using Stripe, and automatic SSO sign-ins for web admin tasks. We made card payment onboarding error tips clearer, and fixed an intermittent bug with adding variations to an order. Lastly, iPad users can share quick feedback about Point of Sale.
+
 ## 23.6
 This update improves app stability and usability. We’ve enhanced compatibility for stores using HTTP site addresses, optimized how tabs load based on saved states, and fixed an issue that prevented dismissing the keyboard when editing product titles.
 

Modules/Sources/Fakes/Networking.generated.swift

@@ -814,6 +814,7 @@ extension Networking.POSProduct {
             manageStock: .fake(),
             stockQuantity: .fake(),
             stockStatusKey: .fake(),
+            statusKey: .fake(),
             variationIDs: .fake()
         )
     }

Modules/Sources/Networking/Model/Copiable/Models+Copiable.generated.swift

@@ -1371,6 +1371,7 @@ extension Networking.POSProduct {
         manageStock: CopiableProp<Bool> = .copy,
         stockQuantity: NullableCopiableProp<Decimal> = .copy,
         stockStatusKey: CopiableProp<String> = .copy,
+        statusKey: CopiableProp<String> = .copy,
         variationIDs: CopiableProp<[Int64]> = .copy
     ) -> Networking.POSProduct {
         let siteID = siteID ?? self.siteID
@@ -1389,6 +1390,7 @@ extension Networking.POSProduct {
         let manageStock = manageStock ?? self.manageStock
         let stockQuantity = stockQuantity ?? self.stockQuantity
         let stockStatusKey = stockStatusKey ?? self.stockStatusKey
+        let statusKey = statusKey ?? self.statusKey
         let variationIDs = variationIDs ?? self.variationIDs
 
         return Networking.POSProduct(
@@ -1408,6 +1410,7 @@ extension Networking.POSProduct {
             manageStock: manageStock,
             stockQuantity: stockQuantity,
             stockStatusKey: stockStatusKey,
+            statusKey: statusKey,
             variationIDs: variationIDs
         )
     }

Modules/Sources/Networking/Model/POSProduct.swift

@@ -43,6 +43,12 @@ public struct POSProduct: Codable, Equatable, GeneratedCopiable, GeneratedFakeab
     public let stockQuantity: Decimal?
     public let stockStatusKey: String
 
+    public let statusKey: String
+
+    public var productStatus: ProductStatus {
+        return ProductStatus(rawValue: statusKey)
+    }
+
     public let variationIDs: [Int64]
 
     public init(siteID: Int64,
@@ -61,6 +67,7 @@ public struct POSProduct: Codable, Equatable, GeneratedCopiable, GeneratedFakeab
                 manageStock: Bool,
                 stockQuantity: Decimal?,
                 stockStatusKey: String,
+                statusKey: String,
                 variationIDs: [Int64]) {
         self.siteID = siteID
         self.productID = productID
@@ -85,6 +92,8 @@ public struct POSProduct: Codable, Equatable, GeneratedCopiable, GeneratedFakeab
         self.stockQuantity = stockQuantity
         self.stockStatusKey = stockStatusKey
 
+        self.statusKey = statusKey
+
         self.variationIDs = variationIDs
     }
 
@@ -129,6 +138,8 @@ public struct POSProduct: Codable, Equatable, GeneratedCopiable, GeneratedFakeab
         let stockQuantity = container.failsafeDecodeIfPresent(decimalForKey: .stockQuantity)
         let stockStatusKey = try container.decode(String.self, forKey: .stockStatusKey)
 
+        let statusKey = try container.decode(String.self, forKey: .statusKey)
+
         let variationIDs = try container.decodeIfPresent([Int64].self, forKey: .variationIDs) ?? []
 
         self.init(siteID: siteID,
@@ -147,6 +158,7 @@ public struct POSProduct: Codable, Equatable, GeneratedCopiable, GeneratedFakeab
                   manageStock: manageStock,
                   stockQuantity: stockQuantity,
                   stockStatusKey: stockStatusKey,
+                  statusKey: statusKey,
                   variationIDs: variationIDs)
     }
 
@@ -180,6 +192,7 @@ private extension POSProduct {
         case manageStock = "manage_stock"
         case stockQuantity = "stock_quantity"
         case stockStatusKey = "stock_status"
+        case statusKey = "status"
         case variationIDs = "variations"
     }
 }

Modules/Sources/Networking/Model/Product/ProductStatus.swift

@@ -10,6 +10,7 @@ public enum ProductStatus: Codable, Hashable, GeneratedFakeable {
     case privateStatus  // `private` is a reserved keyword
     case autoDraft
     case importing      // used for placeholder products from a product import or template
+    case trash
     case custom(String) // in case there are extensions modifying product statuses
 }
 
@@ -34,6 +35,8 @@ extension ProductStatus: RawRepresentable {
             self = .autoDraft
         case Keys.importing:
             self = .importing
+        case Keys.trash:
+            self = .trash
         default:
             self = .custom(rawValue)
         }
@@ -49,6 +52,7 @@ extension ProductStatus: RawRepresentable {
         case .privateStatus:        return Keys.privateStatus
         case .autoDraft:            return Keys.autoDraft
         case .importing:            return Keys.importing
+        case .trash:                return Keys.trash
         case .custom(let payload):  return payload
         }
     }
@@ -69,6 +73,8 @@ extension ProductStatus: RawRepresentable {
             return "Auto Draft" // We don't need to localize this now.
         case .importing:
             return "Importing" // We don't need to localize this now.
+        case .trash:
+            return "Trash" // We don't need to localize this now.
         case .custom(let payload):
             return payload // unable to localize at runtime.
         }
@@ -85,4 +91,5 @@ private enum Keys {
     static let privateStatus = "private"
     static let autoDraft     = "auto-draft"
     static let importing     = "importing"
+    static let trash         = "trash"
 }

Modules/Sources/Networking/Model/Product/ProductType.swift

@@ -105,5 +105,5 @@ private enum Keys {
     static let variableSubscription = "variable-subscription"
     static let bundle               = "bundle"
     static let composite            = "composite"
-    static let booking              = "booking"
+    static let booking              = "bookable-service"
 }

Modules/Sources/Networking/Network/BackgroundCatalogDownloadCoordinator.swift

@@ -0,0 +1,55 @@
+import Foundation
+import CocoaLumberjackSwift
+
+/// Coordinates background catalog downloads, including handling app wake events.
+public class BackgroundCatalogDownloadCoordinator {
+    private let backgroundDownloader: BackgroundDownloadProtocol
+
+    public init(backgroundDownloader: BackgroundDownloadProtocol = BackgroundDownloadService()) {
+        self.backgroundDownloader = backgroundDownloader
+    }
+
+    /// Handles a background URLSession wake event.
+    /// Called from AppDelegate when iOS wakes the app for a completed download.
+    /// - Parameters:
+    ///   - sessionIdentifier: The session identifier from the callback
+    ///   - completionHandler: Completion handler to call when processing is done
+    ///   - parseHandler: Closure to parse and persist the downloaded file
+    public func handleBackgroundSessionEvent(
+        sessionIdentifier: String,
+        completionHandler: @escaping () -> Void,
+        parseHandler: @escaping (URL, Int64) async throws -> Void
+    ) async {
+        DDLogInfo("🟣 Handling background session event for: \(sessionIdentifier)")
+
+        // Load the saved download state to know which site this is for
+        guard let state = BackgroundDownloadState.load(for: sessionIdentifier) else {
+            DDLogError("⛔️ No saved state found for background download session: \(sessionIdentifier)")
+            completionHandler()
+            return
+        }
+
+        // Reconnect to the background session and get the downloaded file
+        guard let fileURL = await backgroundDownloader.reconnectToSession(identifier: sessionIdentifier,
+                                                                          allowCellular: true,
+                                                                          completionHandler: completionHandler) else {
+            DDLogError("⛔️ Failed to reconnect to background download session")
+            BackgroundDownloadState.clear()
+            return
+        }
+
+        DDLogInfo("🟣 Background download file ready at: \(fileURL.path)")
+
+        // Parse the catalog file in this background window (~30 seconds)
+        // TODO: WOOMOB-1677 - For very large catalogs, consider hybrid approach: try immediate parse, defer if timeout.
+        do {
+            try await parseHandler(fileURL, state.siteID)
+            DDLogInfo("✅ Background catalog processing completed successfully")
+        } catch {
+            DDLogError("⛔️ Failed to process catalog in background: \(error)")
+        }
+
+        // Clean up state
+        BackgroundDownloadState.clear()
+    }
+}

Modules/Sources/Networking/Network/BackgroundDownloadProtocol.swift

@@ -0,0 +1,86 @@
+// periphery:ignore:all
+import Foundation
+
+/// Protocol for handling background downloads with app suspension support.
+public protocol BackgroundDownloadProtocol {
+    /// Downloads a file from the specified URL in the background.
+    /// - Parameters:
+    ///   - url: The URL to download from.
+    ///   - sessionIdentifier: Unique identifier for the background session.
+    ///   - allowCellular: Whether cellular data should be allowed for this download.
+    /// - Returns: Local file URL where the downloaded content is stored.
+    func downloadFile(from url: URL, sessionIdentifier: String, allowCellular: Bool) async throws -> URL
+
+    /// Sets up background app suspension handling.
+    /// - Parameter completionHandler: Handler to call when background download completes.
+    func setBackgroundCompletionHandler(_ completionHandler: @escaping () -> Void)
+
+    /// Reconnects to an existing background session after app wake.
+    /// Call this from AppDelegate when iOS wakes the app for background URLSession events.
+    /// - Parameters:
+    ///   - sessionIdentifier: The session identifier from the callback
+    ///   - allowCellular: Whether cellular data should be allowed
+    ///   - completionHandler: Completion handler to call when all events are processed
+    /// - Returns: Downloaded file URL if download completed, nil if still in progress
+    func reconnectToSession(identifier sessionIdentifier: String,
+                           allowCellular: Bool,
+                           completionHandler: @escaping () -> Void) async -> URL?
+
+    /// Cancels all active downloads for the session.
+    /// - Parameter sessionIdentifier: The session identifier to cancel.
+    func cancelDownloads(for sessionIdentifier: String) async
+}
+
+/// Progress and status information for background downloads.
+public struct BackgroundDownloadProgress {
+    public let bytesDownloaded: Int64
+    public let totalBytes: Int64
+    public let progress: Double
+
+    public init(bytesDownloaded: Int64, totalBytes: Int64) {
+        self.bytesDownloaded = bytesDownloaded
+        self.totalBytes = totalBytes
+        self.progress = totalBytes > 0 ? Double(bytesDownloaded) / Double(totalBytes) : 0.0
+    }
+}
+
+/// Errors that can occur during background downloads.
+public enum BackgroundDownloadError: Error, LocalizedError, Equatable {
+    case invalidURL
+    case sessionCreationFailed
+    case downloadFailed(Error)
+    case fileNotFound
+    case cancelled
+
+    public var errorDescription: String? {
+        switch self {
+        case .invalidURL:
+            return "The provided URL is invalid"
+        case .sessionCreationFailed:
+            return "Failed to create background download session"
+        case .downloadFailed(let error):
+            return "Download failed: \(error.localizedDescription)"
+        case .fileNotFound:
+            return "Downloaded file not found"
+        case .cancelled:
+            return "Download was cancelled"
+        }
+    }
+
+    public static func == (lhs: BackgroundDownloadError, rhs: BackgroundDownloadError) -> Bool {
+        switch (lhs, rhs) {
+        case (.invalidURL, .invalidURL):
+            return true
+        case (.sessionCreationFailed, .sessionCreationFailed):
+            return true
+        case (.downloadFailed(let lhsError), .downloadFailed(let rhsError)):
+            return lhsError.localizedDescription == rhsError.localizedDescription
+        case (.fileNotFound, .fileNotFound):
+            return true
+        case (.cancelled, .cancelled):
+            return true
+        default:
+            return false
+        }
+    }
+}