Merge branch 'trunk' into issue/8589-ipp-banner-dismiss

Author: iamgabrielma

Experiments/Experiments/DefaultFeatureFlagService.swift

@@ -60,8 +60,6 @@ public struct DefaultFeatureFlagService: FeatureFlagService {
         case .applicationPasswordAuthenticationForSiteCredentialLogin:
             // Enable this to test application password authentication (WIP)
             return false
-        case .productsBulkEditing:
-            return buildConfig == .localDeveloper || buildConfig == .alpha
         case .domainSettings:
             return buildConfig == .localDeveloper || buildConfig == .alpha
         default:

Experiments/Experiments/FeatureFlag.swift

@@ -142,10 +142,6 @@ public enum FeatureFlag: Int {
     ///
     case applicationPasswordAuthenticationForSiteCredentialLogin
 
-    /// Bulk editing of status and price in products list
-    ///
-    case productsBulkEditing
-
     /// Whether to enable domain updates from the settings for a WPCOM site.
     ///
     case domainSettings

Networking/Networking.xcodeproj/project.pbxproj

@@ -15,10 +15,11 @@ struct ApplicationPasswordStorage {
     ///
     var applicationPassword: ApplicationPassword? {
         guard let password = keychain.password,
-              let username = keychain.username else {
+              let username = keychain.username,
+              let uuid = keychain.uuid else {
             return nil
         }
-        return ApplicationPassword(wpOrgUsername: username, password: Secret(password))
+        return ApplicationPassword(wpOrgUsername: username, password: Secret(password), uuid: uuid)
     }
 
     /// Saves application password into keychain
@@ -28,6 +29,7 @@ struct ApplicationPasswordStorage {
     func saveApplicationPassword(_ password: ApplicationPassword) {
         keychain.username = password.wpOrgUsername
         keychain.password = password.password.secretValue
+        keychain.uuid = password.uuid
     }
 
     /// Removes the currently saved password from storage
@@ -36,6 +38,7 @@ struct ApplicationPasswordStorage {
         // Delete password from keychain
         keychain.username = nil
         keychain.password = nil
+        keychain.uuid = nil
     }
 }
 
@@ -44,6 +47,7 @@ struct ApplicationPasswordStorage {
 private extension Keychain {
     private static let keychainApplicationPassword = "ApplicationPassword"
     private static let keychainApplicationPasswordUsername = "ApplicationPasswordUsername"
+    private static let keychainApplicationPasswordUUID = "ApplicationPasswordUUID"
 
     var password: String? {
         get { self[Keychain.keychainApplicationPassword] }
@@ -54,4 +58,9 @@ private extension Keychain {
         get { self[Keychain.keychainApplicationPasswordUsername] }
         set { self[Keychain.keychainApplicationPasswordUsername] = newValue }
     }
+
+    var uuid: String? {
+        get { self[Keychain.keychainApplicationPasswordUUID] }
+        set { self[Keychain.keychainApplicationPasswordUUID] = newValue }
+    }
 }

Networking/Networking/ApplicationPassword/ApplicationPasswordStorage.swift

@@ -9,16 +9,7 @@ public enum ApplicationPasswordUseCaseError: Error {
     case applicationPasswordsDisabled
     case failedToConstructLoginOrAdminURLUsingSiteAddress
     case unauthorizedRequest
-}
-
-public struct ApplicationPassword {
-    /// WordPress org username that the application password belongs to
-    ///
-    let wpOrgUsername: String
-
-    /// Application password
-    ///
-    let password: Secret<String>
+    case unableToFindPasswordUUID
 }
 
 public protocol ApplicationPasswordUseCase {
@@ -105,16 +96,20 @@ final public class DefaultApplicationPasswordUseCase: ApplicationPasswordUseCase
     /// - Returns: Generated `ApplicationPassword` instance
     ///
     public func generateNewPassword() async throws -> ApplicationPassword {
-        async let password = try {
+        let applicationPassword = try await {
             do {
                 return try await createApplicationPassword()
             } catch ApplicationPasswordUseCaseError.duplicateName {
-                try await deletePassword()
+                do {
+                    try await deletePassword()
+                } catch ApplicationPasswordUseCaseError.unableToFindPasswordUUID {
+                    // No password found with the `applicationPasswordName`
+                    // We can proceed to the creation step
+                }
                 return try await createApplicationPassword()
             }
         }()
 
-        let applicationPassword = try await ApplicationPassword(wpOrgUsername: username, password: Secret(password))
         storage.saveApplicationPassword(applicationPassword)
         return applicationPassword
     }
@@ -124,26 +119,40 @@ final public class DefaultApplicationPasswordUseCase: ApplicationPasswordUseCase
     ///  Deletes locally and also sends an API request to delete it from the site
     ///
     public func deletePassword() async throws {
-        try await deleteApplicationPassword()
+        // Get the uuid before removing the password from storage
+        let uuidFromLocalPassword = applicationPassword?.uuid
+
+        // Remove password from storage
+        storage.removeApplicationPassword()
+
+        let uuidToBeDeleted = try await {
+            if let uuidFromLocalPassword {
+                return uuidFromLocalPassword
+            } else {
+                return try await self.fetchUUIDForApplicationPassword(await applicationPasswordName)
+            }
+        }()
+        try await deleteApplicationPassword(uuidToBeDeleted)
     }
 }
 
 private extension DefaultApplicationPasswordUseCase {
     /// Creates application password using WordPress.com authentication token
     ///
-    /// - Returns: Application password as `String`
+    /// - Returns: Generated `ApplicationPassword`
     ///
-    func createApplicationPassword() async throws -> String {
+    func createApplicationPassword() async throws -> ApplicationPassword {
         let passwordName = await applicationPasswordName
 
         let parameters = [ParameterKey.name: passwordName]
         let request = RESTRequest(siteURL: siteAddress, method: .post, path: Path.applicationPasswords, parameters: parameters)
         return try await withCheckedThrowingContinuation { continuation in
-            network.responseData(for: request) { result in
+            network.responseData(for: request) { [weak self] result in
+                guard let self else { return }
                 switch result {
                 case .success(let data):
                     do {
-                        let mapper = ApplicationPasswordMapper()
+                        let mapper = ApplicationPasswordMapper(wpOrgUsername: self.username)
                         let password = try mapper.map(response: data)
                         continuation.resume(returning: password)
                     } catch {
@@ -172,15 +181,37 @@ private extension DefaultApplicationPasswordUseCase {
         }
     }
 
-    /// Deletes application password using WordPress.com authentication token
+    /// Get the UUID of the application password
     ///
-    func deleteApplicationPassword() async throws {
-        // Remove password from storage
-        storage.removeApplicationPassword()
+    func fetchUUIDForApplicationPassword(_ passwordName: String) async throws -> String {
+        let request = RESTRequest(siteURL: siteAddress, method: .get, path: Path.applicationPasswords)
 
-        let passwordName = await applicationPasswordName
-        let parameters = [ParameterKey.name: passwordName]
-        let request = RESTRequest(siteURL: siteAddress, method: .delete, path: Path.applicationPasswords, parameters: parameters)
+        return try await withCheckedThrowingContinuation { continuation in
+            network.responseData(for: request) { result in
+                switch result {
+                case .success(let data):
+                    do {
+                        let mapper = ApplicationPasswordNameAndUUIDMapper()
+                        let list = try mapper.map(response: data)
+                        if let item = list.first(where: { $0.name == passwordName }) {
+                            continuation.resume(returning: item.uuid)
+                        } else {
+                            continuation.resume(throwing: ApplicationPasswordUseCaseError.unableToFindPasswordUUID)
+                        }
+                    } catch {
+                        continuation.resume(throwing: error)
+                    }
+                case .failure(let error):
+                    continuation.resume(throwing: error)
+                }
+            }
+        }
+    }
+
+    /// Deletes application password using UUID
+    ///
+    func deleteApplicationPassword(_ uuid: String) async throws {
+        let request = RESTRequest(siteURL: siteAddress, method: .delete, path: Path.applicationPasswords + "/" + uuid)
 
         try await withCheckedThrowingContinuation { continuation in
             network.responseData(for: request) { result in

Networking/Networking/ApplicationPassword/ApplicationPasswordUseCase.swift

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

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

@@ -6,9 +6,9 @@ struct RequestConverter {
     let credentials: Credentials?
 
     func convert(_ request: URLRequestConvertible) -> URLRequestConvertible {
-        guard let jetpackRequest = request as? JetpackRequest,
+        guard let convertibleRequest = request as? RESTRequestConvertible,
               case let .wporg(_, _, siteAddress) = credentials,
-              let restRequest = jetpackRequest.asRESTRequest(with: siteAddress) else {
+              let restRequest = convertibleRequest.asRESTRequest(with: siteAddress) else {
             return request
         }
 

Networking/Networking/ApplicationPassword/RequestConverter.swift

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

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

@@ -28,4 +28,8 @@ extension CodingUserInfoKey {
     /// Used to store the Granularity within a Coder/Decoder's userInfo dictionary.
     ///
     public static let granularity = CodingUserInfoKey(rawValue: "granularity")!
+
+    /// Used to store the WordPress org username within a Coder/Decoder's userInfo dictionary.
+    ///
+    public static let wpOrgUsername = CodingUserInfoKey(rawValue: "wpOrgUsername")!
 }

Networking/Networking/Extensions/CodingUserInfoKey+Woo.swift

@@ -11,7 +11,11 @@ struct AddOnGroupMapper: Mapper {
     func map(response: Data) throws -> [AddOnGroup] {
         let decoder = JSONDecoder()
         decoder.userInfo = [.siteID: siteID]
-        return try decoder.decode(AddOnGroupEnvelope.self, from: response).data
+        do {
+            return try decoder.decode(AddOnGroupEnvelope.self, from: response).data
+        } catch {
+            return try decoder.decode([AddOnGroup].self, from: response)
+        }
     }
 }