Merge branch 'trunk' into feat/8648-ipp-migration

Author: itsmeichigo

CHANGELOG.md

@@ -1,6 +1,9 @@
 <!--
 Contains editorialized release notes. Raw release notes should go into `RELEASE-NOTES.txt`.
 -->
+## 11.9
+Exciting news! It's possible to generate every variation combinations from your attributes. Please try it out and share your feedback!
+
 ## 11.8
 You’ll notice some nice visual changes to the look of the app! Take a look and please share your feedback – more updates to come in the next few weeks!
 

Hardware/Hardware/CardReader/UnderlyingError.swift

@@ -450,7 +450,7 @@ extension UnderlyingError: LocalizedError {
                                      "the device does not meet minimum requirements.")
         case .commandNotAllowedDuringCall:
             return NSLocalizedString("The built-in reader cannot be used during a phone call. Please try again after " +
-                                     "you finish your call",
+                                     "you finish your call.",
                                      comment: "Error message shown when the built-in reader cannot be used because " +
                                      "there is a call in progress")
         case .invalidAmount:

Networking/Networking.xcodeproj/project.pbxproj

@@ -1,9 +1,9 @@
-enum RequestAuthenticatorError: Error {
+enum ApplicationPasswordAuthenticatorError: Error {
     case applicationPasswordUseCaseNotAvailable
     case applicationPasswordNotAvailable
 }
 
-protocol RequestAuthenticator {
+protocol ApplicationPasswordAuthenticator {
     /// Credentials to authenticate the URLRequest
     ///
     var credentials: Credentials? { get }
@@ -26,7 +26,7 @@ protocol RequestAuthenticator {
 
 /// Authenticates request
 ///
-public struct DefaultRequestAuthenticator: RequestAuthenticator {
+public struct DefaultApplicationPasswordAuthenticator: ApplicationPasswordAuthenticator {
     /// Credentials to authenticate the URLRequest
     ///
     let credentials: Credentials?
@@ -71,7 +71,7 @@ public struct DefaultRequestAuthenticator: RequestAuthenticator {
     ///
     func generateApplicationPassword() async throws {
         guard let applicationPasswordUseCase else {
-            throw RequestAuthenticatorError.applicationPasswordUseCaseNotAvailable
+            throw ApplicationPasswordAuthenticatorError.applicationPasswordUseCaseNotAvailable
         }
         let _ = try await applicationPasswordUseCase.generateNewPassword()
         return
@@ -84,7 +84,7 @@ public struct DefaultRequestAuthenticator: RequestAuthenticator {
     }
 }
 
-private extension DefaultRequestAuthenticator {
+private extension DefaultApplicationPasswordAuthenticator {
     /// To check whether the given URLRequest is a REST API request
     /// 
     func isRestAPIRequest(_ urlRequest: URLRequest) -> Bool {
@@ -110,7 +110,7 @@ private extension DefaultRequestAuthenticator {
     ///
     func authenticateUsingApplicationPasswordIfPossible(_ urlRequest: URLRequest) throws -> URLRequest {
         guard let applicationPassword = applicationPasswordUseCase?.applicationPassword else {
-            throw RequestAuthenticatorError.applicationPasswordNotAvailable
+            throw ApplicationPasswordAuthenticatorError.applicationPasswordNotAvailable
         }
 
         return AuthenticatedRESTRequest(applicationPassword: applicationPassword, request: urlRequest).asURLRequest()

Networking/Networking/ApplicationPassword/RequestAuthenticator.swift renamed to Networking/Networking/ApplicationPassword/ApplicationPasswordAuthenticator.swift

@@ -3,29 +3,29 @@ import Foundation
 
 /// Authenticates and retries requests
 ///
-final class RequestProcessor {
+final class ApplicationPasswordRequestProcessor {
     private var requestsToRetry = [RequestRetryCompletion]()
 
     private var isAuthenticating = false
 
-    private let requestAuthenticator: RequestAuthenticator
+    private let requestAuthenticator: ApplicationPasswordAuthenticator
 
-    init(requestAuthenticator: RequestAuthenticator) {
+    init(requestAuthenticator: ApplicationPasswordAuthenticator) {
         self.requestAuthenticator = requestAuthenticator
     }
 }
 
 // MARK: Request Authentication
 //
-extension RequestProcessor: RequestAdapter {
+extension ApplicationPasswordRequestProcessor: RequestAdapter {
     func adapt(_ urlRequest: URLRequest) throws -> URLRequest {
         return try requestAuthenticator.authenticate(urlRequest)
     }
 }
 
 // MARK: Retrying Request
 //
-extension RequestProcessor: RequestRetrier {
+extension ApplicationPasswordRequestProcessor: RequestRetrier {
     func should(_ manager: Alamofire.SessionManager,
                 retry request: Alamofire.Request,
                 with error: Error,
@@ -48,7 +48,7 @@ extension RequestProcessor: RequestRetrier {
 
 // MARK: Helpers
 //
-private extension RequestProcessor {
+private extension ApplicationPasswordRequestProcessor {
     func generateApplicationPassword() {
         Task(priority: .medium) {
             isAuthenticating = true
@@ -66,7 +66,7 @@ private extension RequestProcessor {
 
     func shouldRetry(_ error: Error) -> Bool {
         // Need to generate application password
-        if .applicationPasswordNotAvailable == error as? RequestAuthenticatorError {
+        if .applicationPasswordNotAvailable == error as? ApplicationPasswordAuthenticatorError {
             return true
         }
 

Networking/Networking/ApplicationPassword/RequestProcessor.swift renamed to Networking/Networking/ApplicationPassword/ApplicationPasswordRequestProcessor.swift

@@ -84,13 +84,11 @@ final public class DefaultApplicationPasswordUseCase: ApplicationPasswordUseCase
                 throw ApplicationPasswordUseCaseError.failedToConstructLoginOrAdminURLUsingSiteAddress
             }
             // Prepares the authenticator with username and password
-            let authenticator = CookieNonceAuthenticator(username: username,
-                                                         password: password,
-                                                         loginURL: loginURL,
-                                                         adminURL: adminURL,
-                                                         version: Constants.defaultWPVersion,
-                                                         nonce: nil)
-            self.network = WordPressOrgNetwork(authenticator: authenticator)
+            let config = CookieNonceAuthenticatorConfiguration(username: username,
+                                                               password: password,
+                                                               loginURL: loginURL,
+                                                               adminURL: adminURL)
+            self.network = WordPressOrgNetwork(configuration: config)
         }
     }
 
@@ -218,6 +216,5 @@ private extension DefaultApplicationPasswordUseCase {
     enum Constants {
         static let loginPath = "/wp-login.php"
         static let adminPath = "/wp-admin/"
-        static let defaultWPVersion = "5.6.0" // a default version that supports Ajax nonce retrieval
     }
 }

Networking/Networking/ApplicationPassword/ApplicationPasswordUseCase.swift

@@ -0,0 +1,172 @@
+import Alamofire
+import Foundation
+
+/// An authenticator to handle cookie-nonce authentication.
+/// This differs from WordPressKit's version by handling the nonce retrieval as a separate request
+/// instead of a redirect from the login request - to fix issues with Pressable sites.
+///
+/// This authenticator uses Ajax nonce retrieval method by default
+/// since we are not supporting sites with WP versions earlier than 5.6.0.
+///
+final class CookieNonceAuthenticator: RequestRetrier & RequestAdapter {
+    private let username: String
+    private let password: String
+    private let loginURL: URL
+    private let adminURL: URL
+    private var nonce: String?
+
+    private var canRetry = true
+    private var isAuthenticating = false
+    private var requestsToRetry = [RequestRetryCompletion]()
+
+    init(configuration: CookieNonceAuthenticatorConfiguration) {
+        self.username = configuration.username
+        self.password = configuration.password
+        self.loginURL = configuration.loginURL
+        self.adminURL = configuration.adminURL
+    }
+
+    // MARK: Request Adapter
+
+    func adapt(_ urlRequest: URLRequest) throws -> URLRequest {
+        guard let nonce else {
+            return urlRequest
+        }
+        var adaptedRequest = urlRequest
+        adaptedRequest.addValue(nonce, forHTTPHeaderField: "X-WP-Nonce")
+        return adaptedRequest
+    }
+
+    // MARK: Retrier
+    func should(_ manager: SessionManager, retry request: Alamofire.Request, with error: Swift.Error, completion: @escaping RequestRetryCompletion) {
+        guard
+            canRetry,
+            // Only retry once
+            request.retryCount == 0,
+            // And don't retry the login request
+            request.request?.url != loginURL,
+            // Only retry because of failed authorization
+            case .responseValidationFailed(reason: .unacceptableStatusCode(code: 401)) = error as? AFError
+        else {
+            return completion(false, 0.0)
+        }
+
+        requestsToRetry.append(completion)
+        if !isAuthenticating {
+            startLoginSequence(manager: manager)
+        }
+    }
+
+    enum Error: Swift.Error {
+        case invalidNewPostURL
+        case postLoginFailed(Swift.Error)
+        case missingNonce
+        case unknown(Swift.Error)
+    }
+}
+
+// MARK: Private helpers
+private extension CookieNonceAuthenticator {
+
+    func startLoginSequence(manager: SessionManager) {
+        DDLogInfo("Starting Cookie+Nonce login sequence for \(loginURL)")
+        guard let nonceRetrievalURL = buildNonceRequestURL(base: adminURL),
+              let nonceRequest = try? URLRequest(url: nonceRetrievalURL, method: .get) else {
+            return invalidateLoginSequence(error: .invalidNewPostURL)
+        }
+        Task(priority: .medium) {
+            do {
+                try await handleSiteCredentialLogin(manager: manager)
+                let page = try await handleNonceRetrieval(request: nonceRequest, manager: manager)
+                guard let nonce = readNonceFromAjaxAction(html: page) else {
+                    throw CookieNonceAuthenticator.Error.missingNonce
+                }
+                self.nonce = nonce
+                successfulLoginSequence()
+            } catch let error as CookieNonceAuthenticator.Error {
+                invalidateLoginSequence(error: error)
+            } catch {
+                DDLogError("⛔️ Cookie nonce authenticator failed with uncaught error: \(error)")
+            }
+        }
+    }
+
+    func handleSiteCredentialLogin(manager: SessionManager) async throws {
+        let request = authenticatedRequest()
+        return try await withCheckedThrowingContinuation { continuation in
+            manager.request(request)
+                .validate()
+                .response { response in
+                    if let error = response.error {
+                        continuation.resume(throwing: error)
+                    } else {
+                        continuation.resume(returning: ())
+                    }
+                }
+        }
+    }
+
+    func handleNonceRetrieval(request: URLRequest, manager: SessionManager) async throws -> String {
+        try await withCheckedThrowingContinuation { continuation -> Void in
+            manager.request(request)
+                .validate()
+                .responseString { response in
+                    switch response.result {
+                    case .failure(let error):
+                        continuation.resume(throwing: error)
+                    case .success(let page):
+                        continuation.resume(returning: page)
+                    }
+                }
+        }
+    }
+
+    func successfulLoginSequence() {
+        DDLogInfo("Completed Cookie+Nonce login sequence for \(loginURL)")
+        completeRequests(true)
+    }
+
+    func invalidateLoginSequence(error: Error) {
+        canRetry = false
+        if case .postLoginFailed(let originalError) = error {
+            let nsError = originalError as NSError
+            if nsError.domain == NSURLErrorDomain, nsError.code == NSURLErrorNotConnectedToInternet {
+                canRetry = true
+            }
+        }
+        DDLogInfo("Aborting Cookie+Nonce login sequence for \(loginURL)")
+        completeRequests(false)
+        isAuthenticating = false
+    }
+
+    func completeRequests(_ shouldRetry: Bool) {
+        requestsToRetry.forEach { (completion) in
+            completion(shouldRetry, 0.0)
+        }
+        requestsToRetry.removeAll()
+    }
+
+    func authenticatedRequest() -> URLRequest {
+        var request = URLRequest(url: loginURL)
+
+        request.httpMethod = "POST"
+        request.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
+
+        var parameters = [URLQueryItem]()
+        parameters.append(URLQueryItem(name: "log", value: username))
+        parameters.append(URLQueryItem(name: "pwd", value: password))
+        parameters.append(URLQueryItem(name: "rememberme", value: "true"))
+        var components = URLComponents()
+        components.queryItems = parameters
+        request.httpBody = components.percentEncodedQuery?.data(using: .utf8)
+        return request
+    }
+
+    func readNonceFromAjaxAction(html: String) -> String? {
+        html.isEmpty ? nil : html
+    }
+
+    func buildNonceRequestURL(base: URL) -> URL? {
+        URL(string: "admin-ajax.php?action=rest-nonce", relativeTo: base)
+    }
+}

Networking/Networking/CookieNonce/CookieNonceAuthenticator.swift

@@ -465,6 +465,8 @@ public struct Product: Codable, GeneratedCopiable, Equatable, GeneratedFakeable
     public func encode(to encoder: Encoder) throws {
         var container = encoder.container(keyedBy: CodingKeys.self)
 
+        try container.encode(productID, forKey: .productID)
+
         try container.encode(images, forKey: .images)
 
         try container.encode(name, forKey: .name)

Networking/Networking/Model/Product/Product.swift

@@ -28,15 +28,15 @@ public class AlamofireNetwork: Network {
 
     /// Authenticator to update requests authorization header if possible.
     ///
-    private let requestAuthenticator: RequestProcessor
+    private let requestAuthenticator: ApplicationPasswordRequestProcessor
 
     public var session: URLSession { SessionManager.default.session }
 
     /// Public Initializer
     ///
     public required init(credentials: Credentials?) {
         self.requestConverter = RequestConverter(credentials: credentials)
-        self.requestAuthenticator = RequestProcessor(requestAuthenticator: DefaultRequestAuthenticator(credentials: credentials))
+        self.requestAuthenticator = ApplicationPasswordRequestProcessor(requestAuthenticator: DefaultApplicationPasswordAuthenticator(credentials: credentials))
     }
 
     /// Executes the specified Network Request. Upon completion, the payload will be sent back to the caller as a Data instance.

Networking/Networking/Network/AlamofireNetwork.swift

@@ -1,13 +1,28 @@
 import Alamofire
 import Combine
 import Foundation
-import WordPressKit
+
+/// Configuration for handling cookie nonce authentication.
+///
+public struct CookieNonceAuthenticatorConfiguration {
+    let username: String
+    let password: String
+    let loginURL: URL
+    let adminURL: URL
+
+    public init(username: String, password: String, loginURL: URL, adminURL: URL) {
+        self.username = username
+        self.password = password
+        self.loginURL = loginURL
+        self.adminURL = adminURL
+    }
+}
 
 /// Class to handle WP.org REST API requests.
 ///
 public final class WordPressOrgNetwork: Network {
 
-    private let authenticator: Authenticator?
+    private let authenticator: CookieNonceAuthenticator
     private let userAgent: String?
 
     private lazy var sessionManager: Alamofire.SessionManager = {
@@ -27,8 +42,8 @@ public final class WordPressOrgNetwork: Network {
 
     public var session: URLSession { sessionManager.session }
 
-    public init(authenticator: Authenticator? = nil, userAgent: String = UserAgent.defaultUserAgent) {
-        self.authenticator = authenticator
+    public init(configuration: CookieNonceAuthenticatorConfiguration, userAgent: String = UserAgent.defaultUserAgent) {
+        self.authenticator = CookieNonceAuthenticator(configuration: configuration)
         self.userAgent = userAgent
     }