[POS Settings] Store section and PointOfSaleSettingsService

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

@@ -0,0 +1,31 @@
+import Foundation
+import Networking
+import Storage
+
+public protocol PointOfSaleSettingsServiceProtocol {
+    var siteID: Int64 { get }
+    func retrievePointOfSaleSettings() async throws -> [SiteSetting]
+}
+
+public final class PointOfSaleSettingsService: PointOfSaleSettingsServiceProtocol {
+    public let siteID: Int64
+    private let settingStoreMethods: SettingStoreMethodsProtocol
+
+    init(siteID: Int64,
+         settingStoreMethods: SettingStoreMethodsProtocol) {
+        self.siteID = siteID
+        self.settingStoreMethods = settingStoreMethods
+    }
+
+    public convenience init(siteID: Int64,
+                            credentials: Credentials?,
+                            storage: StorageManagerType) {
+        let network = AlamofireNetwork(credentials: credentials)
+        self.init(siteID: siteID, settingStoreMethods: SettingStoreMethods(storageManager: storage,
+                                                                           network: network))
+    }
+
+    public func retrievePointOfSaleSettings() async throws -> [SiteSetting] {
+        return try await settingStoreMethods.retrievePointOfSaleSettings(siteID: siteID)
+    }
+}

Modules/Tests/YosemiteTests/Mocks/MockSettingStoreMethods.swift

@@ -9,9 +9,12 @@ final class MockSettingStoreMethods: SettingStoreMethodsProtocol {
     var retrieveAnalyticsSettingCalled = false
     var enableAnalyticsSettingCalled = false
     var retrieveTaxBasedOnSettingCalled = false
+    var retrievePointOfSaleSettingsCalled = false
 
     var couponsEnabled: Bool = true
     var featureEnabled: Result<Bool, Error> = .success(true)
+    var retrievePointOfSaleSettingsResult: Result<[SiteSetting], Error> = .success([])
+    var retrievePointOfSaleSettingsSiteID: Int64?
 
     func synchronizeGeneralSiteSettings(siteID: Int64,
                                       onCompletion: @escaping (Error?) -> Void) {
@@ -74,6 +77,13 @@ final class MockSettingStoreMethods: SettingStoreMethodsProtocol {
     }
 
     func retrievePointOfSaleSettings(siteID: Int64) async throws -> [SiteSetting] {
-        []
+        retrievePointOfSaleSettingsCalled = true
+        retrievePointOfSaleSettingsSiteID = siteID
+        switch retrievePointOfSaleSettingsResult {
+        case .success(let settings):
+            return settings
+        case .failure(let error):
+            throw error
+        }
     }
 }

Modules/Tests/YosemiteTests/PointOfSale/PointOfSaleSettingsServiceTests.swift

@@ -0,0 +1,135 @@
+import Foundation
+import Testing
+@testable import Yosemite
+
+struct PointOfSaleSettingsServiceTests {
+    private let sut: PointOfSaleSettingsService
+    private let settingStoreMethods: MockSettingStoreMethods
+    private let storage: MockStorageManager
+    private let sampleSiteID: Int64 = 123
+
+    init() {
+        self.settingStoreMethods = MockSettingStoreMethods()
+        self.storage = MockStorageManager()
+        self.sut = PointOfSaleSettingsService(siteID: sampleSiteID,
+                                              settingStoreMethods: settingStoreMethods)
+    }
+
+    @Test func retrievePointOfSaleSettings_when_empty_settings_then_returns_empty_array() async throws {
+        // Given
+        settingStoreMethods.retrievePointOfSaleSettingsResult = .success([])
+
+        // When
+        let settings = try await sut.retrievePointOfSaleSettings()
+
+        // Then
+        #expect(settingStoreMethods.retrievePointOfSaleSettingsCalled)
+        #expect(settingStoreMethods.retrievePointOfSaleSettingsSiteID == sampleSiteID)
+        #expect(settings.isEmpty)
+    }
+
+    @Test func retrievePointOfSaleSettings_when_network_error_then_throws_error() async throws {
+        // Given
+        let expectedError = NSError(domain: "NetworkError", code: 500, userInfo: [NSLocalizedDescriptionKey: "Network request failed"])
+        settingStoreMethods.retrievePointOfSaleSettingsResult = .failure(expectedError)
+
+        // When
+        do {
+            _ = try await sut.retrievePointOfSaleSettings()
+            #expect(Bool(false), "Expected error to be thrown")
+        } catch {
+            // Then
+            #expect(settingStoreMethods.retrievePointOfSaleSettingsCalled)
+            #expect(settingStoreMethods.retrievePointOfSaleSettingsSiteID == sampleSiteID)
+            let nsError = error as NSError
+            #expect(nsError.domain == expectedError.domain)
+            #expect(nsError.code == expectedError.code)
+        }
+    }
+
+    @Test func retrievePointOfSaleSettings_when_settingStoreMethods_throws_then_propagates_error() async throws {
+        // Given
+        let expectedError = TestError.customError
+        settingStoreMethods.retrievePointOfSaleSettingsResult = .failure(expectedError)
+
+        // When
+        do {
+            _ = try await sut.retrievePointOfSaleSettings()
+            #expect(Bool(false), "Expected error to be thrown")
+        } catch {
+            // Then
+            #expect(settingStoreMethods.retrievePointOfSaleSettingsCalled)
+            #expect(settingStoreMethods.retrievePointOfSaleSettingsSiteID == sampleSiteID)
+            #expect(error as? TestError == expectedError)
+        }
+    }
+
+    @Test func retrievePointOfSaleSettings_with_expected_pos_settings_then_returns_all_settings() async throws {
+        // Given
+        let expectedSettings = makeSiteSettings()
+        settingStoreMethods.retrievePointOfSaleSettingsResult = .success(expectedSettings)
+
+        // When
+        let settings = try await sut.retrievePointOfSaleSettings()
+
+        // Then
+        #expect(settingStoreMethods.retrievePointOfSaleSettingsCalled)
+        #expect(settingStoreMethods.retrievePointOfSaleSettingsSiteID == sampleSiteID)
+        #expect(settings.count == 5)
+        #expect(settings == expectedSettings)
+
+        let storeNameSetting = settings.first { $0.settingID == "woocommerce_pos_store_name" }
+        #expect(storeNameSetting?.value == "WooCommerce Store")
+
+        let addressSetting = settings.first { $0.settingID == "woocommerce_pos_store_address" }
+        #expect(addressSetting?.value == "123 Commerce Street\nBusiness District")
+
+        let phoneSetting = settings.first { $0.settingID == "woocommerce_pos_store_phone" }
+        #expect(phoneSetting?.value == "+1 (555) 123-4567")
+
+        let emailSetting = settings.first { $0.settingID == "woocommerce_pos_store_email" }
+        #expect(emailSetting?.value == "[email protected]")
+
+        let policySetting = settings.first { $0.settingID == "woocommerce_pos_refund_returns_policy" }
+        #expect(policySetting?.value == "30-day return policy with receipt")
+    }
+
+    private func makeSiteSettings() -> [SiteSetting] {
+        return [
+            SiteSetting(siteID: sampleSiteID,
+                        settingID: "woocommerce_pos_store_name",
+                        label: "Store Name",
+                        settingDescription: "Name of the store for POS receipts",
+                        value: "WooCommerce Store",
+                        settingGroupKey: "pos"),
+            SiteSetting(siteID: sampleSiteID,
+                        settingID: "woocommerce_pos_store_address",
+                        label: "Store Address",
+                        settingDescription: "Physical address for receipts",
+                        value: "123 Commerce Street\nBusiness District",
+                        settingGroupKey: "pos"),
+            SiteSetting(siteID: sampleSiteID,
+                        settingID: "woocommerce_pos_store_phone",
+                        label: "Store Phone",
+                        settingDescription: "Contact phone number",
+                        value: "+1 (555) 123-4567",
+                        settingGroupKey: "pos"),
+            SiteSetting(siteID: sampleSiteID,
+                        settingID: "woocommerce_pos_store_email",
+                        label: "Store Email",
+                        settingDescription: "Contact email address",
+                        value: "[email protected]",
+                        settingGroupKey: "pos"),
+            SiteSetting(siteID: sampleSiteID,
+                        settingID: "woocommerce_pos_refund_returns_policy",
+                        label: "Refund & Returns Policy",
+                        settingDescription: "Store policy for refunds and returns",
+                        value: "30-day return policy with receipt",
+                        settingGroupKey: "pos")
+        ]
+    }
+}
+
+private enum TestError: Error, Equatable {
+    case customError
+}

WooCommerce/Classes/POS/Models/PointOfSaleAggregateModel.swift

@@ -70,6 +70,7 @@ protocol PointOfSaleAggregateModelProtocol {
     let popularPurchasableItemsController: PointOfSaleItemsControllerProtocol
     let couponsController: PointOfSaleCouponsControllerProtocol
     let couponsSearchController: PointOfSaleSearchingItemsControllerProtocol
+    let settingsController: PointOfSaleSettingsControllerProtocol
 
     private let cardPresentPaymentService: CardPresentPaymentFacade
     private let orderController: PointOfSaleOrderControllerProtocol
@@ -105,6 +106,7 @@ protocol PointOfSaleAggregateModelProtocol {
          couponsSearchController: PointOfSaleSearchingItemsControllerProtocol,
          cardPresentPaymentService: CardPresentPaymentFacade,
          orderController: PointOfSaleOrderControllerProtocol,
+         settingsController: PointOfSaleSettingsControllerProtocol,
          analytics: Analytics = ServiceLocator.analytics,
          collectOrderPaymentAnalyticsTracker: POSCollectOrderPaymentAnalyticsTracking,
          searchHistoryService: POSSearchHistoryProviding,
@@ -119,6 +121,7 @@ protocol PointOfSaleAggregateModelProtocol {
         self.couponsSearchController = couponsSearchController
         self.cardPresentPaymentService = cardPresentPaymentService
         self.orderController = orderController
+        self.settingsController = settingsController
         self.analytics = analytics
         self.collectOrderPaymentAnalyticsTracker = collectOrderPaymentAnalyticsTracker
         self.searchHistoryService = searchHistoryService

WooCommerce/Classes/POS/Models/PointOfSaleSettingsController.swift

@@ -0,0 +1,139 @@
+import Foundation
+import struct Yosemite.SiteSetting
+import enum Yosemite.Plugin
+import class Yosemite.PluginsService
+import Observation
+
+import protocol Yosemite.PointOfSaleSettingsServiceProtocol
+import class Yosemite.PointOfSaleSettingsService
+import Storage
+
+protocol PointOfSaleSettingsControllerProtocol {
+    var receiptStoreName: String? { get }
+    var receiptStoreAddress: String? { get }
+    var receiptStorePhone: String? { get }
+    var receiptStoreEmail: String? { get }
+    var receiptRefundReturnsPolicy: String? { get }
+    var isLoading: Bool { get }
+    var shouldShowReceiptInformation: Bool { get }
+    var storeName: String { get }
+    var storeAddress: String { get }
+
+    func retrievePOSReceiptSettings() async
+}
+
+@Observable final class PointOfSaleSettingsController: PointOfSaleSettingsControllerProtocol {
+    private(set) var receiptStoreName: String?
+    private(set) var receiptStoreAddress: String?
+    private(set) var receiptStorePhone: String?
+    private(set) var receiptStoreEmail: String?
+    private(set) var receiptRefundReturnsPolicy: String?
+    private(set) var isLoading: Bool = false
+    private(set) var shouldShowReceiptInformation: Bool = false
+
+    private let defaultSiteName: String?
+    private let settingsService: PointOfSaleSettingsServiceProtocol
+    private let siteSettings: [SiteSetting]
+
+    init(settingsService: PointOfSaleSettingsServiceProtocol,
+         defaultSiteName: String? = ServiceLocator.stores.sessionManager.defaultSite?.name,
+         siteSettings: [SiteSetting] = ServiceLocator.selectedSiteSettings.siteSettings) {
+        self.settingsService = settingsService
+        self.defaultSiteName = defaultSiteName
+        self.siteSettings = siteSettings
+    }
+
+    var storeName: String {
+        if let defaultSiteName {
+            return defaultSiteName
+        } else {
+            return Localization.storeNameNotSet
+        }
+    }
+
+    var storeAddress: String {
+        SiteAddress(siteSettings: siteSettings).address
+    }
+
+    @MainActor
+    func retrievePOSReceiptSettings() async {
+        isLoading = true
+
+        shouldShowReceiptInformation = await isPluginSupported(.wooCommerce, minimumVersion: Constants.minimumWooCommerceVersion)
+
+        guard shouldShowReceiptInformation else {
+            isLoading = false
+            return
+        }
+
+        do {
+            let siteSettings = try await settingsService.retrievePointOfSaleSettings()
+            updateReceiptSettings(from: siteSettings)
+        } catch {
+            DDLogError("Failed to load POS settings: \(error)")
+        }
+        isLoading = false
+    }
+
+    @MainActor
+    private func isPluginSupported(_ plugin: Plugin,
+                                   storageManager: StorageManagerType = ServiceLocator.storageManager,
+                                   minimumVersion: String) async -> Bool {
+        let pluginsService = PluginsService(storageManager: storageManager)
+        guard let systemPlugin = pluginsService.loadPluginInStorage(siteID: settingsService.siteID, plugin: plugin, isActive: true), systemPlugin.active else {
+            return false
+        }
+
+        let isSupported = VersionHelpers.isVersionSupported(version: systemPlugin.version,
+                                                            minimumRequired: minimumVersion)
+        return isSupported
+    }
+
+    private func updateReceiptSettings(from siteSettings: [SiteSetting]) {
+        receiptStoreName = settingValue(from: siteSettings, settingID: "woocommerce_pos_store_name")
+        receiptStoreAddress = settingValue(from: siteSettings, settingID: "woocommerce_pos_store_address")
+        receiptStorePhone = settingValue(from: siteSettings, settingID: "woocommerce_pos_store_phone")
+        receiptStoreEmail = settingValue(from: siteSettings, settingID: "woocommerce_pos_store_email")
+        receiptRefundReturnsPolicy = settingValue(from: siteSettings, settingID: "woocommerce_pos_refund_returns_policy")
+    }
+
+    private func settingValue(from siteSettings: [SiteSetting], settingID: String) -> String? {
+        let value = siteSettings.first { $0.settingID == settingID }?.value
+        return value?.isEmpty == true ? nil : value
+    }
+}
+
+private extension PointOfSaleSettingsController {
+    enum Constants {
+        static let minimumWooCommerceVersion: String = "10.0"
+    }
+
+    enum Localization {
+        static let storeNameNotSet = NSLocalizedString(
+            "pointOfSaleSettingsService.storeNameNotSet",
+            value: "Not set",
+            comment: "Text displayed on Point of Sale settings when store has not been provided."
+        )
+    }
+}
+
+#if DEBUG
+final class PointOfSaleSettingsPreviewController: PointOfSaleSettingsControllerProtocol {
+    var receiptStoreName: String? = "Sample Store"
+    var receiptStoreAddress: String? = "123 Main Street\nAnytown, ST 12345"
+    var receiptStorePhone: String? = "+1 (555) 123-4567"
+    var receiptStoreEmail: String? = "[email protected]"
+    var receiptRefundReturnsPolicy: String? = "30-day return policy"
+    var isLoading: Bool = false
+    var shouldShowReceiptInformation: Bool = true
+    var storeName: String = "Sample Store"
+
+    var storeAddress: String {
+        "123 Main Street\nAnytown, ST 12345"
+    }
+
+    func retrievePOSReceiptSettings() async {
+        // no-op
+    }
+}
+#endif

WooCommerce/Classes/POS/Presentation/PointOfSaleDashboardView.swift

@@ -132,7 +132,7 @@ struct PointOfSaleDashboardView: View {
             documentationView
         }
         .posFullScreenCover(isPresented: $showSettings) {
-            PointOfSaleSettingsView()
+            PointOfSaleSettingsView(settingsController: posModel.settingsController)
         }
         .onChange(of: posModel.entryPointController.eligibilityState) { oldValue, newValue in
             guard newValue == .eligible else { return }