Merge branch 'trunk' into feat/WOOMOB-935-refactor-pos-entry-point

# Conflicts:
#	WooCommerce/Classes/POS/Models/POSIneligibleReason.swift
#	WooCommerce/Classes/POS/Presentation/Settings/PointOfSaleSettingsView.swift
#	WooCommerce/Classes/POS/TabBar/POSTabCoordinator.swift

Author: jaclync

.swiftlint.yml

@@ -1,6 +1,7 @@
 swiftlint_version: 0.58.2
 
 excluded:
+  - build
   - BuildTools/.build
   - DerivedData
   - fastlane

Modules/Sources/Experiments/DefaultFeatureFlagService.swift

@@ -84,8 +84,6 @@ public struct DefaultFeatureFlagService: FeatureFlagService {
             return false
         case .inventoryProductLabelsInPOS:
             return false
-        case .pointOfSaleReceipts:
-            return true
         case .productImageOptimizedHandling:
             return true
         case .pointOfSaleOrdersi1:

Modules/Sources/Experiments/FeatureFlag.swift

@@ -179,10 +179,6 @@ public enum FeatureFlag: Int {
     ///
     case inventoryProductLabelsInPOS
 
-    /// Enables sending POS specific email receipts for eligible stores
-    ///
-    case pointOfSaleReceipts
-
     /// Enables displaying Point Of Sale details in order list and order details
     ///
     case pointOfSaleOrdersi1

Modules/Sources/WooFoundation/Utilities/WaitingTimeTracker.swift

@@ -0,0 +1,86 @@
+import Foundation
+
+/// Tracks the waiting time for a given scenario, allowing to evaluate as analytics
+/// how much time in seconds it took between the init and `end` function call
+///
+public class WaitingTimeTracker {
+    private let trackScenario: WooAnalyticsEvent.WaitingTime.Scenario
+    private let currentTimestampSeconds: () -> TimeInterval
+    private let waitingStartedTimestamp: TimeInterval
+
+    public enum TrackingUnit {
+        case seconds
+        case milliseconds
+    }
+
+    public init(trackScenario: WooAnalyticsEvent.WaitingTime.Scenario,
+                currentTimestampSeconds: @escaping () -> TimeInterval = { Date().timeIntervalSince1970 }
+    ) {
+        self.trackScenario = trackScenario
+        self.currentTimestampSeconds = currentTimestampSeconds
+        waitingStartedTimestamp = currentTimestampSeconds()
+    }
+
+    /// Default `end()` method to preserve interface compatibility. By default, tracks in `.seconds`
+    /// - Returns: The analytics event to be tracked.
+    ///
+    public func end() -> WooAnalyticsEvent {
+        end(using: .seconds)
+    }
+
+    /// End the waiting time by evaluating the elapsed time from the init,
+    /// and returning an analytics event for tracking.
+    ///
+    /// - Parameter trackingUnit: Defines whether the elapsed time should be tracked in `.seconds` or `.milliseconds` (default is `.seconds`).
+    /// - Returns: The analytics event to be tracked.
+    ///
+    public func end(using trackingUnit: TrackingUnit = .seconds) -> WooAnalyticsEvent {
+        let elapsedTime = calculateElapsedTime(in: trackingUnit)
+        return .WaitingTime.waitingFinished(scenario: trackScenario, elapsedTime: elapsedTime)
+    }
+
+    /// Calculates elapsed time in the specified tracking unit.
+    ///
+    private func calculateElapsedTime(in trackingUnit: TrackingUnit) -> TimeInterval {
+        let elapsedTime = currentTimestampSeconds() - waitingStartedTimestamp
+        return trackingUnit == .milliseconds ? elapsedTime * 1000 : elapsedTime
+    }
+}
+
+// MARK: - Waiting Time measurement
+//
+public extension WooAnalyticsEvent {
+    enum WaitingTime {
+        /// Possible Waiting time scenarios
+        public enum Scenario {
+            case orderDetails
+            case dashboardTopPerformers
+            case dashboardMainStats
+            case analyticsHub
+            case appStartup
+            case pointOfSaleLoaded
+        }
+
+        private enum Keys {
+            static let waitingTime = "waiting_time"
+            static let millisecondsTimeElapsedInSplashScreen = "milliseconds_time_elapsed_in_splash_screen"
+        }
+
+        static func waitingFinished(scenario: Scenario, elapsedTime: TimeInterval) -> WooAnalyticsEvent {
+            switch scenario {
+            case .orderDetails:
+                return WooAnalyticsEvent(statName: .orderDetailWaitingTimeLoaded, properties: [Keys.waitingTime: elapsedTime])
+            case .dashboardTopPerformers:
+                return WooAnalyticsEvent(statName: .dashboardTopPerformersWaitingTimeLoaded, properties: [Keys.waitingTime: elapsedTime])
+            case .dashboardMainStats:
+                return WooAnalyticsEvent(statName: .dashboardMainStatsWaitingTimeLoaded, properties: [Keys.waitingTime: elapsedTime])
+            case .analyticsHub:
+                return WooAnalyticsEvent(statName: .analyticsHubWaitingTimeLoaded, properties: [Keys.waitingTime: elapsedTime])
+            case .appStartup:
+                return WooAnalyticsEvent(statName: .applicationOpenedWaitingTimeLoaded, properties: [Keys.waitingTime: elapsedTime])
+            case .pointOfSaleLoaded:
+                return WooAnalyticsEvent(statName: .pointOfSaleLoaded, properties: [Keys.millisecondsTimeElapsedInSplashScreen: elapsedTime])
+            }
+        }
+    }
+}

Modules/Sources/Yosemite/Actions/BookingAction.swift

@@ -14,4 +14,10 @@ public enum BookingAction: Action {
                              pageNumber: Int,
                              pageSize: Int = BookingsRemote.Default.pageSize,
                              onCompletion: (Result<Bool, Error>) -> Void)
+
+    /// Checks if the store already has any bookings.
+    /// Returns `false` if the store has no bookings.
+    ///
+    case checkIfStoreHasBookings(siteID: Int64,
+                                 onCompletion: (Result<Bool, Error>) -> Void)
 }

Modules/Sources/Yosemite/Stores/BookingStore.swift

@@ -37,6 +37,8 @@ public class BookingStore: Store {
         switch action {
         case let .synchronizeBookings(siteID, pageNumber, pageSize, onCompletion):
             synchronizeBookings(siteID: siteID, pageNumber: pageNumber, pageSize: pageSize, onCompletion: onCompletion)
+        case let .checkIfStoreHasBookings(siteID, onCompletion):
+            checkIfStoreHasBookings(siteID: siteID, onCompletion: onCompletion)
         }
     }
 }
@@ -65,6 +67,31 @@ private extension BookingStore {
             }
         }
     }
+
+    /// Checks if the store already has any bookings.
+    /// Returns `false` if the store has no bookings.
+    ///
+    func checkIfStoreHasBookings(siteID: Int64, onCompletion: @escaping (Result<Bool, Error>) -> Void) {
+        let derivedStorage = storageManager.viewStorage
+        let hasLocalBookings = derivedStorage.countObjects(ofType: StorageBooking.self, matching: NSPredicate(format: "siteID == %lld", siteID)) > 0
+
+        if hasLocalBookings {
+            onCompletion(.success(true))
+            return
+        }
+
+        Task { @MainActor in
+            do {
+                let bookings = try await remote.loadAllBookings(for: siteID,
+                                                                pageNumber: 1,
+                                                                pageSize: 1)
+                let hasRemoteBookings = !bookings.isEmpty
+                onCompletion(.success(hasRemoteBookings))
+            } catch {
+                onCompletion(.failure(error))
+            }
+        }
+    }
 }
 
 

Modules/Sources/Yosemite/Tools/POS/POSCatalogSettingsService.swift

@@ -0,0 +1,46 @@
+import Foundation
+import GRDB
+import protocol Storage.GRDBManagerProtocol
+
+public protocol POSCatalogSettingsServiceProtocol {
+    /// Gets catalog information for the specified site.
+    /// - Parameter siteID: The site ID to get catalog information for.
+    /// - Returns: Catalog information including statistics and sync dates.
+    func loadCatalogInfo(for siteID: Int64) async throws -> POSCatalogInfo
+}
+
+public struct POSCatalogInfo {
+    public let productCount: Int
+    public let variationCount: Int
+    public let lastFullSyncDate: Date?
+    public let lastIncrementalSyncDate: Date?
+
+    public init(productCount: Int, variationCount: Int, lastFullSyncDate: Date?, lastIncrementalSyncDate: Date?) {
+        self.productCount = productCount
+        self.variationCount = variationCount
+        self.lastFullSyncDate = lastFullSyncDate
+        self.lastIncrementalSyncDate = lastIncrementalSyncDate
+    }
+}
+
+public class POSCatalogSettingsService: POSCatalogSettingsServiceProtocol {
+    private let grdbManager: GRDBManagerProtocol
+
+    public init(grdbManager: GRDBManagerProtocol) {
+        self.grdbManager = grdbManager
+    }
+
+    public func loadCatalogInfo(for siteID: Int64) async throws -> POSCatalogInfo {
+        try await grdbManager.databaseConnection.read { db in
+            let productCount = try PersistedProduct.filter { $0.siteID == siteID }.fetchCount(db)
+            let variationCount = try PersistedProductVariation.filter { $0.siteID == siteID }.fetchCount(db)
+            let site = try PersistedSite.filter(key: siteID).fetchOne(db)
+            return POSCatalogInfo(
+                productCount: productCount,
+                variationCount: variationCount,
+                lastFullSyncDate: site?.lastCatalogFullSyncDate,
+                lastIncrementalSyncDate: site?.lastCatalogIncrementalSyncDate
+            )
+        }
+    }
+}

Modules/Tests/WooFoundationTests/Utilities/WaitingTimeTrackerTests.swift

@@ -0,0 +1,113 @@
+import XCTest
+@testable import WooFoundation
+
+/// WaitingTimeTracker Unit Tests
+///
+final class WaitingTimeTrackerTests: XCTestCase {
+    func testTimeElapsedEvaluationIsCorrect() {
+        var currentTimeCallCounter = 0.0
+
+        // Given
+        let waitingTracker = WaitingTimeTracker(trackScenario: .orderDetails) {
+            currentTimeCallCounter += 1
+            return currentTimeCallCounter * 10
+        }
+
+        // When
+        let event = waitingTracker.end()
+
+        // Then
+        XCTAssertEqual(event.properties["waiting_time"] as? TimeInterval, 10.0)
+    }
+
+    func testOrderDetailsTrackScenarioTriggersExpectedAnalyticsStat() {
+        // Given
+        let waitingTracker = WaitingTimeTracker(trackScenario: .orderDetails, currentTimestampSeconds: { 0 })
+
+        // When
+        let event = waitingTracker.end()
+
+        // Then
+        XCTAssertEqual(event.statName.rawValue, WooAnalyticsStat.orderDetailWaitingTimeLoaded.rawValue)
+    }
+
+    func testTopPerformersTrackScenarioTriggersExpectedAnalyticsStat() {
+        // Given
+        let waitingTracker = WaitingTimeTracker(trackScenario: .dashboardTopPerformers,
+                                                currentTimestampSeconds: { 0 }
+        )
+
+        // When
+        let event = waitingTracker.end()
+
+        // Then
+        XCTAssertEqual(event.statName.rawValue, WooAnalyticsStat.dashboardTopPerformersWaitingTimeLoaded.rawValue)
+    }
+
+    func testMainStatsTrackScenarioTriggersExpectedAnalyticsStat() {
+        // Given
+        let waitingTracker = WaitingTimeTracker(trackScenario: .dashboardMainStats,
+                                                currentTimestampSeconds: { 0 }
+        )
+
+        // When
+        let event = waitingTracker.end()
+
+        // Then
+        XCTAssertEqual(event.statName.rawValue, WooAnalyticsStat.dashboardMainStatsWaitingTimeLoaded.rawValue)
+    }
+
+    func test_analytics_hub_track_scenario_triggers_expected_analytics_stat() {
+        // Given
+        let waitingTracker = WaitingTimeTracker(trackScenario: .analyticsHub,
+                                                currentTimestampSeconds: { 0 }
+        )
+
+        // When
+        let event = waitingTracker.end()
+
+        // Then
+        XCTAssertEqual(event.statName.rawValue, WooAnalyticsStat.analyticsHubWaitingTimeLoaded.rawValue)
+    }
+
+    func test_appStartup_track_scenario_triggers_expected_analytics_stat() {
+        // Given
+        let waitingTracker = WaitingTimeTracker(trackScenario: .appStartup,
+                                                currentTimestampSeconds: { 0 }
+        )
+
+        // When
+        let event = waitingTracker.end()
+
+        // Then
+        XCTAssertEqual(event.statName.rawValue, WooAnalyticsStat.applicationOpenedWaitingTimeLoaded.rawValue)
+    }
+
+    func test_timeElapsed_evaluation_in_milliseconds_is_correct() {
+        // Given
+        var currentTimeCallCounter = 0.0
+        let expectedReceivedWaitingTime = 10_000.0 // 10s * 1000 ms
+        let waitingTracker = WaitingTimeTracker(trackScenario: .orderDetails) {
+            currentTimeCallCounter += 1
+            return currentTimeCallCounter * 10
+        }
+
+        // When
+        let event = waitingTracker.end(using: .milliseconds)
+
+        // Then
+        XCTAssertEqual(event.properties["waiting_time"] as? TimeInterval, expectedReceivedWaitingTime)
+    }
+
+    func test_track_scenario_triggers_expected_analytics_stat_in_milliseconds() {
+        // Given
+        let waitingTracker = WaitingTimeTracker(trackScenario: .pointOfSaleLoaded,
+                                                currentTimestampSeconds: { 0 })
+
+        // When
+        let event = waitingTracker.end(using: .milliseconds)
+
+        // Then
+        XCTAssertEqual(event.statName.rawValue, WooAnalyticsStat.pointOfSaleLoaded.rawValue)
+    }
+}