Merge branch 'trunk' into woomob-980-mark-manually-saved-addresses-as-unverified

Author: itsmeichigo

Modules/Package.swift

@@ -6,7 +6,7 @@ let package = Package(
     name: "Modules",
     platforms: [
         // Keep in sync with Common.xcconfig
-        .iOS(.v16),
+        .iOS(.v17),
         .macOS(.v10_14),
         .watchOS(.v9),
     ],

Modules/Sources/Experiments/DefaultFeatureFlagService.swift

@@ -103,6 +103,8 @@ public struct DefaultFeatureFlagService: FeatureFlagService {
             return true
         case .pointOfSaleBarcodeScanningi2:
             return true
+        case .pointOfSaleSettingsi1:
+            return false
         case .orderAddressMapSearch:
             return true
         default:

Modules/Sources/Experiments/FeatureFlag.swift

@@ -211,6 +211,10 @@ public enum FeatureFlag: Int {
     ///
     case pointOfSaleBarcodeScanningi2
 
+    /// Enables the entry point for Point of Sale Settings
+    ///
+    case pointOfSaleSettingsi1
+
     /// Enables the CTA to search for an address in the map in order details > shipping address.
     ///
     case orderAddressMapSearch

Modules/Sources/Networking/Remote/JetpackConnectionRemote.swift

@@ -4,11 +4,12 @@ import Foundation
 ///
 public final class JetpackConnectionRemote: Remote {
     private let siteURL: String
-
+    private let network: Network
     private var accountConnectionURL: URL?
 
     public init(siteURL: String, network: Network) {
         self.siteURL = siteURL
+        self.network = network
         super.init(network: network)
     }
 
@@ -49,6 +50,41 @@ public final class JetpackConnectionRemote: Remote {
         enqueue(request, mapper: mapper, completion: completion)
     }
 
+    /// Registers Jetpack site connection by requesting the input URL while disabling automatic redirection,
+    /// and returns the URL in the requested redirection.
+    /// To simplify redirection manipulation, we'll use a `URLSession` here instead of `Network`.
+    ///
+    public func registerJetpackSiteConnection(with url: URL, completion: @escaping (Result<URL, Error>) -> Void) {
+
+        let configuration = URLSessionConfiguration.default
+        for cookie in network.session.configuration.httpCookieStorage?.cookies ?? [] {
+            configuration.httpCookieStorage?.setCookie(cookie)
+        }
+
+        let session = URLSession(configuration: configuration, delegate: self, delegateQueue: nil)
+        do {
+            let request = try URLRequest(url: url, method: .get)
+            let task = session.dataTask(with: request) { [weak self] data, response, error in
+                if let result = self?.accountConnectionURL {
+                    DispatchQueue.main.async {
+                        completion(.success(result))
+                    }
+                    return
+                }
+                // We don't expect any response here since we'll cancel the task as soon as a redirect request is received.
+                // So always complete with a failure here.
+                let returnedError = error ?? JetpackConnectionError.accountConnectionURLNotFound
+                DispatchQueue.main.async {
+                    completion(.failure(returnedError))
+                }
+                return
+            }
+            task.resume()
+        } catch {
+            completion(.failure(error))
+        }
+    }
+
     /// Fetches the connection state with the site's Jetpack for the authenticated user.
     ///
     public func fetchJetpackConnectionData(completion: @escaping (Result<JetpackConnectionData, Error>) -> Void) {
@@ -84,6 +120,24 @@ public final class JetpackConnectionRemote: Remote {
     }
 }
 
+// MARK: - URLSessionDataDelegate conformance
+//
+extension JetpackConnectionRemote: URLSessionDataDelegate {
+    public func urlSession(_ session: URLSession,
+                           task: URLSessionTask,
+                           willPerformHTTPRedirection response: HTTPURLResponse,
+                           newRequest request: URLRequest) async -> URLRequest? {
+        // Disables redirection if the request is to load the Jetpack account connection URL
+        if let url = request.url,
+            url.absoluteString.hasPrefix(Constants.jetpackAccountConnectionURL) {
+            accountConnectionURL = url
+            task.cancel()
+            return nil
+        }
+        return request
+    }
+}
+
 /// periphery: ignore - used in test module and on the UI layer
 public enum JetpackConnectionError: Error, Equatable {
     case malformedURL

Modules/Sources/NetworkingCore/ApplicationPassword/ApplicationPasswordUseCase.swift

@@ -2,6 +2,10 @@ import Foundation
 import enum Alamofire.AFError
 import KeychainAccess
 
+#if canImport(UIKit)
+import UIKit
+#endif
+
 public enum ApplicationPasswordUseCaseError: Error {
     case duplicateName
     case applicationPasswordsDisabled
@@ -29,25 +33,6 @@ public protocol ApplicationPasswordUseCase {
     func deletePassword() async throws
 }
 
-/// A wrapper for the `UIDevice` `model` and `identifierForVendor` properties.
-///
-/// This is necessary because `UIDevice` is part of UIKit which we cannot use when targeting watchOS.
-/// So, to keep this package compatible with watchOS, we need to abstract UIKit away and delegate it to the consumers to provide us
-/// with the device information.
-///
-/// This approach is feasible because only the `applicationPasswordName` method in
-/// `DefaultApplicationPasswordUseCase` needs access to the information and watchOS does not need to create application
-/// passwords. We can therefore pass a `nil` value to it to satisfy the compilation without issues for the user experience.
-public struct DeviceModelIdentifierInfo {
-    let model: String
-    let identifierForVendor: String
-
-    public init(model: String, identifierForVendor: String) {
-        self.model = model
-        self.identifierForVendor = identifierForVendor
-    }
-}
-
 final public class DefaultApplicationPasswordUseCase: ApplicationPasswordUseCase {
     /// Site Address
     ///
@@ -65,31 +50,27 @@ final public class DefaultApplicationPasswordUseCase: ApplicationPasswordUseCase
     ///
     private let storage: ApplicationPasswordStorage
 
-    private let deviceModelIdentifierInfo: DeviceModelIdentifierInfo?
-
     /// Used to name the password in wpadmin.
     ///
     private var applicationPasswordName: String {
-        get {
-            guard let deviceModelIdentifierInfo else {
-                return "" // This is not needed on watchOS as the watch does not create application passwords.
-            }
-
-            let bundleIdentifier = Bundle.main.bundleIdentifier ?? "Unknown"
-            return "\(bundleIdentifier).ios-app-client.\(deviceModelIdentifierInfo.model).\(deviceModelIdentifierInfo.identifierForVendor)"
-        }
+#if !os(watchOS)
+        let bundleIdentifier = Bundle.main.bundleIdentifier ?? "Unknown"
+        let model = UIDevice.current.model
+        let identifierForVendor = UIDevice.current.identifierForVendor?.uuidString ?? ""
+        return "\(bundleIdentifier).ios-app-client.\(model).\(identifierForVendor)"
+#else
+        fatalError("Unexpected error: Application password should not be generated through watch app")
+#endif
     }
 
     public init(username: String,
                 password: String,
                 siteAddress: String,
-                deviceModelIdentifierInfo: DeviceModelIdentifierInfo? = nil,
                 network: Network? = nil,
                 keychain: Keychain = Keychain(service: WooConstants.keychainServiceName)) throws {
         self.siteAddress = siteAddress
         self.username = username
         self.storage = ApplicationPasswordStorage(keychain: keychain)
-        self.deviceModelIdentifierInfo = deviceModelIdentifierInfo
 
         if let network {
             self.network = network
@@ -154,7 +135,7 @@ final public class DefaultApplicationPasswordUseCase: ApplicationPasswordUseCase
             if let uuidFromLocalPassword {
                 return uuidFromLocalPassword
             } else {
-                return try await self.fetchUUIDForApplicationPassword(await applicationPasswordName)
+                return try await self.fetchUUIDForApplicationPassword(applicationPasswordName)
             }
         }()
         try await deleteApplicationPassword(uuidToBeDeleted)
@@ -167,7 +148,7 @@ private extension DefaultApplicationPasswordUseCase {
     /// - Returns: Generated `ApplicationPassword`
     ///
     func createApplicationPassword() async throws -> ApplicationPassword {
-        let passwordName = await applicationPasswordName
+        let passwordName = applicationPasswordName
 
         let parameters = [ParameterKey.name: passwordName]
         let request = RESTRequest(siteURL: siteAddress, method: .post, path: Path.applicationPasswords, parameters: parameters)

Modules/Sources/Yosemite/Actions/JetpackConnectionAction.swift

@@ -13,7 +13,8 @@ public enum JetpackConnectionAction: Action {
     /// Updates Jetpack the plugin for the current site.
     case activateJetpackPlugin(completion: (Result<Void, Error>) -> Void)
     /// Fetches the URL used for setting up Jetpack connection.
-    case fetchJetpackConnectionURL(completion: (Result<URL, Error>) -> Void)
+    case fetchJetpackConnectionURL(authenticatedWithWPCom: Bool,
+                                   completion: (Result<URL, Error>) -> Void)
     /// Fetches connection state with the given site's Jetpack.
     case fetchJetpackConnectionData(completion: (Result<JetpackConnectionData, Error>) -> Void)
     /// Establishes site-level connection and returns WordPress.com blog ID.

Modules/Sources/Yosemite/Stores/JetpackConnectionStore.swift

@@ -41,8 +41,9 @@ public final class JetpackConnectionStore: DeauthenticatedStore {
             installJetpackPlugin(completion: completion)
         case .activateJetpackPlugin(let completion):
             activateJetpackPlugin(completion: completion)
-        case .fetchJetpackConnectionURL(let completion):
-            fetchJetpackConnectionURL(completion: completion)
+        case let .fetchJetpackConnectionURL(authenticatedWithWPCom, completion):
+            fetchJetpackConnectionURL(authenticatedWithWPCom: authenticatedWithWPCom,
+                                      completion: completion)
         case .fetchJetpackConnectionData(let completion):
             fetchJetpackConnectionData(completion: completion)
         case .registerSite(let completion):
@@ -88,8 +89,26 @@ private extension JetpackConnectionStore {
         })
     }
 
-    func fetchJetpackConnectionURL(completion: @escaping (Result<URL, Error>) -> Void) {
-        jetpackConnectionRemote?.fetchJetpackConnectionURL(completion: completion)
+    func fetchJetpackConnectionURL(authenticatedWithWPCom: Bool,
+                                   completion: @escaping (Result<URL, Error>) -> Void) {
+        guard authenticatedWithWPCom else {
+            jetpackConnectionRemote?.fetchJetpackConnectionURL(completion: completion)
+            return
+        }
+        jetpackConnectionRemote?.fetchJetpackConnectionURL { [weak self] result in
+            guard let self else { return }
+            switch result {
+            case .success(let url):
+                // If we get the account connection URL, return it immediately.
+                if url.absoluteString.hasPrefix(Constants.jetpackAccountConnectionURL) {
+                    return completion(.success(url))
+                }
+                // Otherwise, request the url with redirection disabled and retrieve the URL in LOCATION header
+                self.jetpackConnectionRemote?.registerJetpackSiteConnection(with: url, completion: completion)
+            case .failure(let error):
+                completion(.failure(error))
+            }
+        }
     }
 
     func fetchJetpackConnectionData(completion: @escaping (Result<JetpackConnectionData, Error>) -> Void) {
@@ -152,3 +171,9 @@ private extension JetpackConnectionStore {
         self.accountRemote = remote
     }
 }
+
+private extension JetpackConnectionStore {
+    enum Constants {
+        static let jetpackAccountConnectionURL = "https://jetpack.wordpress.com/jetpack.authorize"
+    }
+}

Modules/Tests/YosemiteTests/Stores/JetpackConnectionStoreTests.swift

@@ -167,7 +167,7 @@ final class JetpackConnectionStoreTests: XCTestCase {
 
         // When
         let result: Result<URL, Error> = waitFor { promise in
-            let action = JetpackConnectionAction.fetchJetpackConnectionURL { result in
+            let action = JetpackConnectionAction.fetchJetpackConnectionURL(authenticatedWithWPCom: true) { result in
                 promise(result)
             }
             store.onAction(action)
@@ -192,7 +192,7 @@ final class JetpackConnectionStoreTests: XCTestCase {
 
         // When
         let result: Result<URL, Error> = waitFor { promise in
-            let action = JetpackConnectionAction.fetchJetpackConnectionURL { result in
+            let action = JetpackConnectionAction.fetchJetpackConnectionURL(authenticatedWithWPCom: false) { result in
                 promise(result)
             }
             store.onAction(action)

RELEASE-NOTES.txt

@@ -4,11 +4,14 @@
 23.1
 -----
 - [internal] Remove oldest (<30) core data models [https://github.com/woocommerce/woocommerce-ios/pull/15987]
+- [***] Increased app's minimum deployment target to iOS17 [https://github.com/woocommerce/woocommerce-ios/pull/16003]
 - [*] Jetpack setup: Native experience for the connection step [https://github.com/woocommerce/woocommerce-ios/pull/15983]
 - [*] Payments: Updated the In-Person Payments `Learn More` redirection to display the correct page based on the selected payment provider [https://github.com/woocommerce/woocommerce-ios/pull/15998]
+- [*] Add "POS" label in Most recent orders in My store dashboard [https://github.com/woocommerce/woocommerce-ios/pull/16006]
 - [*] Order details: Always show shipping labels section if order is eligible for label creation. [https://github.com/woocommerce/woocommerce-ios/pull/16010]
 - [*] Order details: Remove print buttons from shipment details [https://github.com/woocommerce/woocommerce-ios/pull/16012]
 - [*] Shipping labels: Mark manually saved addresses as unverified [https://github.com/woocommerce/woocommerce-ios/pull/16013]
+- [*] Shipping Labels: Updated incorrect HS Tariff info page. [https://github.com/woocommerce/woocommerce-ios/pull/16016]
 
 23.0
 -----

WooCommerce/Classes/Analytics/WooAnalyticsEvent+BackgroudUpdates.swift

@@ -1,14 +1,51 @@
 import Foundation
+import WooFoundation
 
 extension WooAnalyticsEvent {
     enum BackgroundUpdates {
 
         private enum Keys {
             static let timeTaken = "time_taken"
+            static let backgroundTimeGranted = "background_time_granted"
+            static let networkType = "network_type"
+            static let isExpensiveConnection = "is_expensive_connection"
+            static let isLowDataMode = "is_low_data_mode"
+            static let isPowered = "is_powered"
+            static let batteryLevel = "battery_level"
+            static let isLowPowerMode = "is_low_power_mode"
+            static let timeSinceLastRun = "time_since_last_run"
         }
 
-        static func dataSynced(timeTaken: TimeInterval) -> WooAnalyticsEvent {
-            WooAnalyticsEvent(statName: .backgroundDataSynced, properties: [Keys.timeTaken: timeTaken])
+        static func dataSynced(
+            timeTaken: TimeInterval,
+            backgroundTimeGranted: TimeInterval?,
+            networkType: String,
+            isExpensiveConnection: Bool,
+            isLowDataMode: Bool,
+            isPowered: Bool,
+            batteryLevel: Float,
+            isLowPowerMode: Bool,
+            timeSinceLastRun: TimeInterval?
+        ) -> WooAnalyticsEvent {
+            var properties: [String: WooAnalyticsEventPropertyType] = [
+                Keys.timeTaken: Int64(timeTaken),
+                Keys.networkType: networkType,
+                Keys.isExpensiveConnection: isExpensiveConnection,
+                Keys.isLowDataMode: isLowDataMode,
+                Keys.isPowered: isPowered,
+                Keys.batteryLevel: Float64(batteryLevel),
+                Keys.isLowPowerMode: isLowPowerMode
+            ]
+
+            if let backgroundTimeGranted = backgroundTimeGranted {
+                properties[Keys.backgroundTimeGranted] = Int64(backgroundTimeGranted)
+            }
+
+            if let timeSinceLastRun = timeSinceLastRun {
+                properties[Keys.timeSinceLastRun] = Int64(timeSinceLastRun)
+            }
+
+            return WooAnalyticsEvent(statName: .backgroundDataSynced, properties: properties)
         }
 
         static func dataSyncError(_ error: Error) -> WooAnalyticsEvent {