CSV Login Import UI (#162)

* Work on CSV import.

* Begin using the vault to import items.

* Continue fleshing out import.

* Add basic CSV parsing tests.

* Test some of the CSV importing functionality.

* More UI work for the CSV import feature.

* Add a login summary object.

* Fix an issue with merge conflict resolution.

* Show a summary view when completing the import.

* Import an array of summary objects.

* Show a count of the import summary stats.

* Use an enum to report the result of data import.

* Rework the file store to support full URLs.

* Update the login exporter to use FileStore.

* Add mocks for testing the export feature.

* Update BrowserServicesKit.

* Fix some issues with CSV parsing.

* Move strings to a localized text file.

* Fix another localized string.

* Parse an optional title when importing.

* Add the title to the summary if it's present.

* Export the title as the first column in each row.

* Remove BrowserImportViewController, that's for the next PR.

* Ignore header rows if they're found.

* Remove a local BSK reference.

* Move the Import/Export options to the File menu.

* Tweak import UI.

* Copy Brindy's approach for the @testable issue.

* Add pixels for import/export.

* Present an alert if password export fails.

* Infer the position of the columns.

* Normalize the header values when inferring positions.

* Allow exporting credentials with blank fields.

* Hide the cancel button in the success state.

* Fix an incorrect bool value.

* Update the CSV header text.

* Add titles to the exported CSV.

Author: samsymons

DuckDuckGo.xcodeproj/project.pbxproj

@@ -52,10 +52,10 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
 
         do {
             let encryptionKey = Self.isRunningTests ? nil : try keyStore.readKey()
-            fileStore = FileStore(encryptionKey: encryptionKey)
+            fileStore = EncryptedFileStore(encryptionKey: encryptionKey)
         } catch {
             os_log("App Encryption Key could not be read: %s", "\(error)")
-            fileStore = FileStore()
+            fileStore = EncryptedFileStore()
         }
         stateRestorationManager = AppStateRestorationManager(fileStore: fileStore)
 

DuckDuckGo/AppDelegate/AppDelegate.swift

@@ -31,4 +31,16 @@ extension NSOpenPanel {
 
         return panel
     }
+
+    static func filePanel(allowedExtension: String) -> NSOpenPanel {
+        let panel = NSOpenPanel()
+
+        panel.directoryURL = FileManager.default.homeDirectoryForCurrentUser.appendingPathComponent("Desktop")
+        panel.canChooseFiles = true
+        panel.allowedFileTypes = [allowedExtension]
+        panel.canChooseDirectories = false
+
+        return panel
+    }
+
 }

DuckDuckGo/Common/Extensions/NSOpenPanelExtensions.swift

@@ -29,6 +29,11 @@ extension URL {
         return libraryURL.appendingPathComponent(sandboxPathComponent)
     }
 
+    static func persistenceLocation(for fileName: String) -> URL {
+        let applicationSupportPath = URL.sandboxApplicationSupportURL
+        return applicationSupportPath.appendingPathComponent(fileName)
+    }
+
     // MARK: - Factory
 
     static func makeSearchUrl(from searchQuery: String) -> URL? {

DuckDuckGo/Common/Extensions/URLExtension.swift

@@ -19,22 +19,22 @@
 import Foundation
 import CryptoKit
 
-protocol FileStoring {
-    func persist(_ data: Data, fileName: String) -> Bool
-    func loadData(named fileName: String) -> Data?
-    func hasData(for fileName: String) -> Bool
-    func remove(_ fileName: String)
+protocol FileStore {
+    func persist(_ data: Data, url: URL) -> Bool
+    func loadData(at url: URL) -> Data?
+    func hasData(at url: URL) -> Bool
+    func remove(fileAtURL url: URL)
 }
 
-final class FileStore: FileStoring {
+final class EncryptedFileStore: FileStore {
 
     private let encryptionKey: SymmetricKey?
 
     init(encryptionKey: SymmetricKey? = nil) {
         self.encryptionKey = encryptionKey
     }
 
-    func persist(_ data: Data, fileName: String) -> Bool {
+    func persist(_ data: Data, url: URL) -> Bool {
         do {
             let dataToWrite: Data
 
@@ -44,18 +44,18 @@ final class FileStore: FileStoring {
                 dataToWrite = data
             }
 
-            try dataToWrite.write(to: persistenceLocation(for: fileName))
+            try dataToWrite.write(to: url)
 
             return true
         } catch {
             Pixel.fire(.debug(event: .fileStoreWriteFailed, error: error),
-                       withAdditionalParameters: ["config": fileName])
+                       withAdditionalParameters: ["config": url.lastPathComponent])
             return false
         }
     }
 
-    func loadData(named fileName: String) -> Data? {
-        guard let data = try? Data(contentsOf: persistenceLocation(for: fileName)) else {
+    func loadData(at url: URL) -> Data? {
+        guard let data = try? Data(contentsOf: url) else {
             return nil
         }
 
@@ -66,22 +66,40 @@ final class FileStore: FileStoring {
         }
     }
 
-    func hasData(for fileName: String) -> Bool {
-        let path = persistenceLocation(for: fileName).path
-        return FileManager.default.fileExists(atPath: path)
+    func hasData(at url: URL) -> Bool {
+        return FileManager.default.fileExists(atPath: url.path)
     }
 
-    func remove(_ fileName: String) {
-        let url = persistenceLocation(for: fileName)
+    func remove(fileAtURL url: URL) {
         var isDir: ObjCBool = false
         let fileManager = FileManager()
         guard fileManager.fileExists(atPath: url.path, isDirectory: &isDir) && !isDir.boolValue else { return }
         try? fileManager.removeItem(at: url)
     }
 
-    func persistenceLocation(for fileName: String) -> URL {
-        let applicationSupportPath = URL.sandboxApplicationSupportURL
-        return applicationSupportPath.appendingPathComponent(fileName)
+}
+
+extension FileManager: FileStore {
+
+    func persist(_ data: Data, url: URL) -> Bool {
+        do {
+            try data.write(to: url)
+            return true
+        } catch {
+            return false
+        }
+    }
+
+    func loadData(at url: URL) -> Data? {
+        try? Data(contentsOf: url)
+    }
+
+    func hasData(at url: URL) -> Bool {
+        return fileExists(atPath: url.path)
+    }
+
+    func remove(fileAtURL url: URL) {
+        try? removeItem(at: url)
     }
 
 }

DuckDuckGo/Common/FileSystem/FileStore.swift

@@ -147,4 +147,23 @@ struct UserText {
         return String(format: localized, version, build)
     }
 
+    // MARK: - Login Import & Export
+
+    static let importLoginsCSV = NSLocalizedString("import.logins.csv.title", value: "CSV Logins File", comment: "Title text for the CSV importer")
+
+    static let csvImportDescription = NSLocalizedString("import.logins.csv.description", value: "The CSV importer will try to match column headers to their position.\nIf there is no header, it supports two formats:\n\n1. URL, Username, Password\n2. Title, URL, Username, Password", comment: "Description text for the CSV importer")
+    static let importLoginsSelectCSVFile = NSLocalizedString("import.logins.select-csv-file", value: "Select CSV File", comment: "Button text for selecting a CSV file")
+    static let importLoginsSelectAnotherFile = NSLocalizedString("import.logins.select-another-file", value: "Select Another File", comment: "Button text for selecting another file")
+    static let importLoginsFailedToReadCSVFile = NSLocalizedString("import.logins.failed-to-read-file", value: "Failed to get CSV file URL", comment: "Error text when importing a CSV file")
+
+    static func importingFile(at filePath: String, validLogins: Int) -> String {
+        let localized = NSLocalizedString("import.logins.csv.file-description",
+                                          value: "Importing File: %@ (%@ valid logins)",
+                                          comment: "Displays the path of the file being imported")
+        return String(format: localized, filePath, String(validLogins))
+    }
+
+    static let initiateImport = NSLocalizedString("import.logins.initiate", value: "Import", comment: "Button text for importing data")
+    static let doneImporting = NSLocalizedString("import.logins.done", value: "Done", comment: "Button text for finishing the data import")
+
 }

DuckDuckGo/Common/Localizables/UserText.swift

@@ -0,0 +1,33 @@
+//
+//  DataExport.swift
+//
+//  Copyright © 2021 DuckDuckGo. All rights reserved.
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//  http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+
+import Foundation
+
+enum DataExport {
+
+    enum DataType {
+        case logins
+    }
+
+}
+
+enum DataExportError: Error {
+
+    case fileAlreadyExists
+
+}

DuckDuckGo/Data Export/DataExport.swift

@@ -0,0 +1,79 @@
+//
+//  CSVLoginExporter.swift
+//
+//  Copyright © 2021 DuckDuckGo. All rights reserved.
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//  http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+
+import Foundation
+import BrowserServicesKit
+
+final class CSVLoginExporter: LoginExporter {
+
+    enum CSVLoginExportError: Error {
+        case failedToEncodeLogins
+    }
+
+    private let secureVault: SecureVault
+    private let fileStore: FileStore
+
+    init(secureVault: SecureVault, fileStore: FileStore = FileManager.default) {
+        self.secureVault = secureVault
+        self.fileStore = fileStore
+    }
+
+    func exportVaultLogins(to url: URL) throws {
+        guard let accounts = try? secureVault.accounts() else {
+            return
+        }
+
+        var credentialsToExport: [SecureVaultModels.WebsiteCredentials] = []
+
+        for account in accounts {
+            guard let accountID = account.id else {
+                continue
+            }
+
+            if let credentials = try? secureVault.websiteCredentialsFor(accountId: accountID) {
+                credentialsToExport.append(credentials)
+            }
+        }
+
+        try save(credentials: credentialsToExport, to: url)
+    }
+
+    private func save(credentials: [SecureVaultModels.WebsiteCredentials], to url: URL) throws {
+        let credentialsAsCSVRows: [String] = credentials.compactMap { credential in
+            let title = credential.account.title ?? ""
+            let domain = credential.account.domain
+            let username = credential.account.username
+            let password = credential.password.utf8String() ?? ""
+
+            // Ensure that exported passwords escape any quotes they contain
+            let escapedPassword = password.replacingOccurrences(of: "\"", with: "\\\"")
+
+            return "\"\(title)\",\"\(domain)\",\"\(username)\",\"\(escapedPassword)\""
+        }
+
+        let headerRow = ["\"title\",\"url\",\"username\",\"password\""]
+        let csvString = (headerRow + credentialsAsCSVRows).joined(separator: "\n")
+
+        if let stringData = csvString.data(using: .utf8) {
+            _ = fileStore.persist(stringData, url: url)
+        } else {
+            throw CSVLoginExportError.failedToEncodeLogins
+        }
+    }
+
+}

DuckDuckGo/Data Export/Logins/CSV/CSVLoginExporter.swift

@@ -0,0 +1,25 @@
+//
+//  LoginExport.swift
+//
+//  Copyright © 2021 DuckDuckGo. All rights reserved.
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//  http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+
+import Foundation
+
+protocol LoginExporter {
+
+    func exportVaultLogins(to: URL) throws
+
+}

DuckDuckGo/Data Export/Logins/LoginExport.swift

@@ -0,0 +1,63 @@
+//
+//  DataImport.swift
+//
+//  Copyright © 2021 DuckDuckGo. All rights reserved.
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//  http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+
+import Foundation
+
+enum DataImport {
+
+    // Third-party browser support will be added later.
+    enum Source: CaseIterable {
+        case csv
+
+        var importSourceName: String {
+            switch self {
+            case .csv:
+                return UserText.importLoginsCSV
+            }
+        }
+    }
+
+    // Different data types (e.g. bookmarks) will be added later.
+    enum DataType {
+        case logins
+    }
+
+    enum Summary: Equatable {
+        case logins(successfulImports: [String], duplicateImports: [String], failedImports: [String])
+    }
+
+}
+
+enum DataImportError: Error {
+
+    case cannotReadFile
+    case cannotAccessSecureVault
+
+}
+
+/// Represents an object able to import data from an outside source. The outside source may be capable of importing multiple types of data.
+/// For instance, a browser data importer may be able to import logins and bookmarks.
+protocol DataImporter {
+
+    /// Performs a quick check to determine if the data is able to be imported. It does not guarantee that the import will succeed.
+    /// For example, a CSV importer will return true if the URL it has been created with is a CSV file, but does not check whether the CSV data matches the expected format.
+    func importableTypes() -> [DataImport.DataType]
+
+    func importData(types: [DataImport.DataType], completion: @escaping (Result<[DataImport.Summary], DataImportError>) -> Void)
+
+}