NetNewsWire/Shared/Commands/DeleteCommand.swift

281 lines
5.6 KiB
Swift
Raw Normal View History

//
// DeleteFromSidebarCommand.swift
2018-08-29 07:18:24 +02:00
// NetNewsWire
//
// Created by Brent Simmons on 11/4/17.
// Copyright © 2017 Ranchero Software. All rights reserved.
//
import Foundation
import RSCore
import RSTree
import Account
import Articles
final class DeleteCommand: UndoableCommand {
2017-11-05 21:14:36 +01:00
let undoManager: UndoManager
let undoActionName: String
var redoActionName: String {
return undoActionName
}
let errorHandler: (Error) -> ()
2017-11-05 21:14:36 +01:00
private let itemSpecifiers: [SidebarItemSpecifier]
init?(nodesToDelete: [Node], undoManager: UndoManager, errorHandler: @escaping (Error) -> ()) {
guard DeleteCommand.canDelete(nodesToDelete) else {
2017-11-05 21:14:36 +01:00
return nil
}
guard let actionName = DeleteActionName.name(for: nodesToDelete) else {
return nil
}
self.undoActionName = actionName
self.undoManager = undoManager
self.errorHandler = errorHandler
2017-11-05 21:14:36 +01:00
let itemSpecifiers = nodesToDelete.compactMap{ SidebarItemSpecifier(node: $0, errorHandler: errorHandler) }
2017-11-05 21:14:36 +01:00
guard !itemSpecifiers.isEmpty else {
return nil
}
self.itemSpecifiers = itemSpecifiers
}
func perform() {
itemSpecifiers.forEach { $0.delete() {} }
registerUndo()
}
func undo() {
itemSpecifiers.forEach { $0.restore() }
registerRedo()
}
static func canDelete(_ nodes: [Node]) -> Bool {
// Return true if all nodes are feeds and folders.
// Any other type: return false.
if nodes.isEmpty {
return false
}
for node in nodes {
if let _ = node.representedObject as? Feed {
continue
}
if let _ = node.representedObject as? Folder {
continue
}
return false
}
return true
}
}
// Remember as much as we can now about the items being deleted,
// so they can be restored to the correct place.
private struct SidebarItemSpecifier {
private weak var account: Account?
2017-11-05 21:14:36 +01:00
private let parentFolder: Folder?
private let folder: Folder?
private let feed: Feed?
private let path: ContainerPath
private let errorHandler: (Error) -> ()
2017-11-05 21:14:36 +01:00
private var container: Container? {
if let parentFolder = parentFolder {
return parentFolder
}
if let account = account {
return account
2017-11-05 21:14:36 +01:00
}
return nil
2017-11-05 21:14:36 +01:00
}
init?(node: Node, errorHandler: @escaping (Error) -> ()) {
var account: Account?
2017-11-05 21:14:36 +01:00
self.parentFolder = node.parentFolder()
if let feed = node.representedObject as? Feed {
self.feed = feed
2017-11-05 21:14:36 +01:00
self.folder = nil
account = feed.account
}
else if let folder = node.representedObject as? Folder {
2017-11-05 21:14:36 +01:00
self.feed = nil
self.folder = folder
account = folder.account
}
2017-11-05 21:14:36 +01:00
else {
return nil
}
if account == nil {
return nil
}
2017-11-05 03:29:43 +01:00
self.account = account!
2017-11-05 21:14:36 +01:00
self.path = ContainerPath(account: account!, folders: node.containingFolders())
self.errorHandler = errorHandler
2017-11-05 21:14:36 +01:00
}
func delete(completion: @escaping () -> Void) {
2017-11-05 21:14:36 +01:00
if let feed = feed {
guard let container = path.resolveContainer() else {
completion()
return
}
BatchUpdate.shared.start()
account?.removeFeed(feed, from: container) { result in
BatchUpdate.shared.end()
completion()
2019-05-09 23:09:21 +02:00
self.checkResult(result)
2019-05-09 14:25:45 +02:00
}
2019-05-09 14:25:45 +02:00
} else if let folder = folder {
BatchUpdate.shared.start()
account?.removeFolder(folder) { result in
BatchUpdate.shared.end()
completion()
2019-05-09 23:09:21 +02:00
self.checkResult(result)
2019-05-07 00:34:41 +02:00
}
2017-11-05 21:14:36 +01:00
}
}
func restore() {
if let _ = feed {
2017-11-05 21:14:36 +01:00
restoreFeed()
}
else if let _ = folder {
2017-11-05 21:14:36 +01:00
restoreFolder()
}
}
private func restoreFeed() {
guard let account = account, let feed = feed, let container = path.resolveContainer() else {
2017-11-05 21:14:36 +01:00
return
}
2019-05-09 23:09:21 +02:00
BatchUpdate.shared.start()
account.restoreFeed(feed, container: container) { result in
BatchUpdate.shared.end()
2019-05-09 23:09:21 +02:00
self.checkResult(result)
}
2017-11-05 21:14:36 +01:00
}
private func restoreFolder() {
guard let account = account, let folder = folder else {
return
}
2019-05-09 23:09:21 +02:00
BatchUpdate.shared.start()
2019-05-09 23:09:21 +02:00
account.restoreFolder(folder) { result in
BatchUpdate.shared.end()
2019-05-09 23:09:21 +02:00
self.checkResult(result)
}
2017-11-05 21:14:36 +01:00
}
2019-05-09 23:09:21 +02:00
private func checkResult(_ result: Result<Void, Error>) {
switch result {
case .success:
break
case .failure(let error):
errorHandler(error)
2019-05-09 23:09:21 +02:00
}
}
}
2017-11-05 03:29:43 +01:00
private extension Node {
2019-05-09 23:09:21 +02:00
2017-11-05 21:14:36 +01:00
func parentFolder() -> Folder? {
guard let parentNode = self.parent else {
return nil
}
if parentNode.isRoot {
return nil
}
if let folder = parentNode.representedObject as? Folder {
return folder
2017-11-05 21:14:36 +01:00
}
return nil
}
func containingFolders() -> [Folder] {
var nomad = self.parent
var folders = [Folder]()
while nomad != nil {
if let folder = nomad!.representedObject as? Folder {
folders += [folder]
}
else {
break
}
nomad = nomad!.parent
}
return folders.reversed()
}
2017-11-05 03:29:43 +01:00
}
private struct DeleteActionName {
2017-11-05 21:14:36 +01:00
private static let deleteFeed = NSLocalizedString("Delete Feed", comment: "command")
private static let deleteFeeds = NSLocalizedString("Delete Feeds", comment: "command")
private static let deleteFolder = NSLocalizedString("Delete Folder", comment: "command")
private static let deleteFolders = NSLocalizedString("Delete Folders", comment: "command")
private static let deleteFeedsAndFolders = NSLocalizedString("Delete Feeds and Folders", comment: "command")
static func name(for nodes: [Node]) -> String? {
var numberOfFeeds = 0
var numberOfFolders = 0
for node in nodes {
if let _ = node.representedObject as? Feed {
numberOfFeeds += 1
}
else if let _ = node.representedObject as? Folder {
numberOfFolders += 1
}
else {
return nil // Delete only Feeds and Folders.
}
}
if numberOfFolders < 1 {
return numberOfFeeds == 1 ? deleteFeed : deleteFeeds
}
if numberOfFeeds < 1 {
return numberOfFolders == 1 ? deleteFolder : deleteFolders
}
return deleteFeedsAndFolders
}
}