step 1

iOSClient/Menu/NCContextMenu.swift

@@ -153,7 +153,8 @@ class NCContextMenu: NSObject {
                                          image: UIImage(systemName: "trash"), attributes: .destructive) { _ in
             let alertController = UIAlertController(title: nil, message: nil, preferredStyle: .actionSheet)
             alertController.addAction(UIAlertAction(title: NSLocalizedString("_delete_file_", comment: ""), style: .destructive) { _ in
-                NCNetworking.shared.deleteMetadata(metadata, onlyLocalCache: false) { error in
+                Task {
+                    let error = await NCNetworking.shared.deleteMetadata(metadata, onlyLocalCache: false)
                     if error != .success {
                         NCContentPresenter.shared.showError(error: error)
                     }
@@ -165,7 +166,9 @@ class NCContextMenu: NSObject {
 
         let deleteConfirmLocal = UIAction(title: NSLocalizedString("_remove_local_file_", comment: ""),
                                           image: UIImage(systemName: "trash"), attributes: .destructive) { _ in
-            NCNetworking.shared.deleteMetadata(metadata, onlyLocalCache: true) { _ in }
+            Task {
+                await NCNetworking.shared.deleteMetadata(metadata, onlyLocalCache: true)
+            }
         }
 
         let deleteSubMenu = UIMenu(title: NSLocalizedString("_delete_file_", comment: ""),

iOSClient/Menu/NCMenuAction.swift

@@ -136,7 +136,11 @@ extension NCMenuAction {
                     preferredStyle: .alert)
                 if canDeleteServer {
                     alertController.addAction(UIAlertAction(title: NSLocalizedString("_yes_delete_", comment: ""), style: .default) { (_: UIAlertAction) in
-                        selectedMetadatas.forEach({ NCOperationQueue.shared.delete(metadata: $0, onlyLocalCache: false) })
+                        Task {
+                            for metadata in selectedMetadatas {
+                                let error = await NCNetworking.shared.deleteMetadata(metadata, onlyLocalCache: false)
+                            }
+                        }
                         completion?()
                     })
                 }
@@ -144,7 +148,11 @@ extension NCMenuAction {
                 // NCMedia removes image from collection view if removed from cache
                 if !(viewController is NCMedia) {
                     alertController.addAction(UIAlertAction(title: NSLocalizedString("_remove_local_file_", comment: ""), style: .default) { (_: UIAlertAction) in
-                        selectedMetadatas.forEach({ NCOperationQueue.shared.delete(metadata: $0, onlyLocalCache: true) })
+                        Task {
+                            for metadata in selectedMetadatas {
+                                let error = await NCNetworking.shared.deleteMetadata(metadata, onlyLocalCache: true)
+                            }
+                        }
                         completion?()
                     })
                 }

iOSClient/Networking/NCNetworking.swift

@@ -1159,7 +1159,7 @@ class NCNetworking: NSObject, NKCommonDelegate {
 
     // MARK: - WebDav Delete
 
-    func deleteMetadata(_ metadata: tableMetadata, onlyLocalCache: Bool, completion: @escaping (_ error: NKError) -> Void) {
+    func deleteMetadata(_ metadata: tableMetadata, onlyLocalCache: Bool) async -> (NKError) {
 
         if onlyLocalCache {
 
@@ -1180,10 +1180,8 @@ class NCNetworking: NSObject, NKCommonDelegate {
                     NCManageDatabase.shared.deleteLocalFile(predicate: NSPredicate(format: "ocId == %@", metadataLivePhoto.ocId))
                     NCUtilityFileSystem.shared.deleteFile(filePath: CCUtility.getDirectoryProviderStorageOcId(metadataLivePhoto.ocId))
                 }
-
-                NotificationCenter.default.postOnMainThread(name: NCGlobal.shared.notificationCenterDeleteFile, userInfo: ["ocId": metadata.ocId, "fileNameView": metadata.fileNameView, "serverUrl": metadata.serverUrl, "account": metadata.account, "classFile": metadata.classFile, "onlyLocalCache": true])
             }
-            return completion(NKError())
+            return NKError()
         }
 
         let metadataLive = NCManageDatabase.shared.getMetadataLivePhoto(metadata: metadata)
@@ -1194,73 +1192,61 @@ class NCNetworking: NSObject, NKCommonDelegate {
                 if let metadataLive = metadataLive {
                     let error = await NCNetworkingE2EEDelete.shared.delete(metadata: metadataLive)
                     if error == .success {
-                        let error = await NCNetworkingE2EEDelete.shared.delete(metadata: metadata)
-                        completion(error)
+                        return await NCNetworkingE2EEDelete.shared.delete(metadata: metadata)
                     } else {
-                        completion(error)
+                        return error
                     }
                 } else {
-                    let error = await NCNetworkingE2EEDelete.shared.delete(metadata: metadata)
-                    completion(error)
+                    return await NCNetworkingE2EEDelete.shared.delete(metadata: metadata)
                 }
             }
 #endif
         } else {
-            if metadataLive == nil {
-                self.deleteMetadataPlain(metadata, customHeader: nil, completion: completion)
-            } else {
-                self.deleteMetadataPlain(metadataLive!, customHeader: nil) { error in
-                    if error == .success {
-                        self.deleteMetadataPlain(metadata, customHeader: nil, completion: completion)
-                    } else {
-                        completion(error)
-                    }
+            if let metadataLive = metadataLive {
+                let error = await deleteMetadataPlain(metadataLive)
+                if error == .success {
+                    return await deleteMetadataPlain(metadata)
+                } else {
+                    return error
                 }
+            } else {
+                return await deleteMetadataPlain(metadata)
             }
         }
+        return NKError()
     }
 
-    func deleteMetadataPlain(_ metadata: tableMetadata, customHeader: [String: String]?, completion: @escaping (_ error: NKError) -> Void) {
+    func deleteMetadataPlain(_ metadata: tableMetadata, customHeader: [String: String]? = nil) async -> (NKError) {
 
         // verify permission
         let permission = NCUtility.shared.permissionsContainsString(metadata.permissions, permissions: NCGlobal.shared.permissionCanDelete)
         if metadata.permissions != "" && permission == false {
-            return completion(NKError(errorCode: NCGlobal.shared.errorInternalError, errorDescription: "_no_permission_delete_file_"))
+            return NKError(errorCode: NCGlobal.shared.errorInternalError, errorDescription: "_no_permission_delete_file_")
         }
 
         let serverUrlFileName = metadata.serverUrl + "/" + metadata.fileName
         let options = NKRequestOptions(customHeader: customHeader)
-        
-        NextcloudKit.shared.deleteFileOrFolder(serverUrlFileName: serverUrlFileName, options: options) { account, error in
 
-            if error == .success || error.errorCode == NCGlobal.shared.errorResourceNotFound {
+        let result = await NextcloudKit.shared.deleteFileOrFolder(serverUrlFileName: serverUrlFileName, options: options)
 
-                do {
-                    try FileManager.default.removeItem(atPath: CCUtility.getDirectoryProviderStorageOcId(metadata.ocId))
-                } catch { }
+        if result.error == .success || result.error.errorCode == NCGlobal.shared.errorResourceNotFound {
 
-                NCManageDatabase.shared.deleteVideo(metadata: metadata)
-                NCManageDatabase.shared.deleteMetadata(predicate: NSPredicate(format: "ocId == %@", metadata.ocId))
-                NCManageDatabase.shared.deleteLocalFile(predicate: NSPredicate(format: "ocId == %@", metadata.ocId))
+            do {
+                try FileManager.default.removeItem(atPath: CCUtility.getDirectoryProviderStorageOcId(metadata.ocId))
+            } catch { }
 
-                if metadata.directory {
-                    NCManageDatabase.shared.deleteDirectoryAndSubDirectory(serverUrl: CCUtility.stringAppendServerUrl(metadata.serverUrl, addFileName: metadata.fileName), account: metadata.account)
-                }
+            NCManageDatabase.shared.deleteVideo(metadata: metadata)
+            NCManageDatabase.shared.deleteMetadata(predicate: NSPredicate(format: "ocId == %@", metadata.ocId))
+            NCManageDatabase.shared.deleteLocalFile(predicate: NSPredicate(format: "ocId == %@", metadata.ocId))
 
-                NotificationCenter.default.postOnMainThread(name: NCGlobal.shared.notificationCenterDeleteFile, userInfo: ["ocId": metadata.ocId, "fileNameView": metadata.fileNameView, "serverUrl": metadata.serverUrl, "account": metadata.account, "classFile": metadata.classFile, "onlyLocalCache": false])
+            if metadata.directory {
+                NCManageDatabase.shared.deleteDirectoryAndSubDirectory(serverUrl: CCUtility.stringAppendServerUrl(metadata.serverUrl, addFileName: metadata.fileName), account: metadata.account)
             }
-
-            completion(error)
+        } else {
+            NotificationCenter.default.postOnMainThread(name: NCGlobal.shared.notificationCenterReloadDataSourceNetworkForced)
         }
-    }
 
-    func deleteMetadataPlain(_ metadata: tableMetadata, customHeader: [String: String]?) async -> (NKError) {
-
-        await withUnsafeContinuation({ continuation in
-            self.deleteMetadataPlain(metadata, customHeader: customHeader) { error in
-                continuation.resume(returning: error)
-            }
-        })
+        return result.error
     }
 
     // MARK: - WebDav Favorite

iOSClient/Networking/NCOperationQueue.swift

@@ -32,8 +32,6 @@ import NextcloudKit
     }()
 
     private var downloadQueue = Queuer(name: "downloadQueue", maxConcurrentOperationCount: 5, qualityOfService: .default)
-    private let deleteQueue = Queuer(name: "deleteQueue", maxConcurrentOperationCount: 10, qualityOfService: .default)
-    private let deleteQueueE2EE = Queuer(name: "deleteQueue", maxConcurrentOperationCount: 1, qualityOfService: .default)
     private let copyMoveQueue = Queuer(name: "copyMoveQueue", maxConcurrentOperationCount: 1, qualityOfService: .default)
     private let synchronizationQueue = Queuer(name: "synchronizationQueue", maxConcurrentOperationCount: 1, qualityOfService: .default)
     private let downloadThumbnailQueue = Queuer(name: "downloadThumbnailQueue", maxConcurrentOperationCount: 10, qualityOfService: .default)
@@ -44,7 +42,6 @@ import NextcloudKit
 
     @objc func cancelAllQueue() {
         downloadCancelAll()
-        deleteCancelAll()
         copyMoveCancelAll()
         synchronizationCancelAll()
         downloadThumbnailCancelAll()
@@ -78,27 +75,6 @@ import NextcloudKit
         return false
     }
 
-    // MARK: - Delete file
-
-    func delete(metadata: tableMetadata, onlyLocalCache: Bool) {
-
-        if metadata.isDirectoryE2EE {
-            for case let operation as NCOperationDelete in deleteQueueE2EE.operations where operation.metadata.ocId == metadata.ocId {
-                return
-            }
-            deleteQueueE2EE.addOperation(NCOperationDelete(metadata: metadata, onlyLocalCache: onlyLocalCache))
-        } else {
-            for case let operation as NCOperationDelete in deleteQueue.operations where operation.metadata.ocId == metadata.ocId {
-                return
-            }
-            deleteQueue.addOperation(NCOperationDelete(metadata: metadata, onlyLocalCache: onlyLocalCache))
-        }
-    }
-
-    func deleteCancelAll() {
-        deleteQueue.cancelAll()
-    }
-
     // MARK: - Copy Move file
 
     func copyMove(metadata: tableMetadata, serverUrl: String, overwrite: Bool, move: Bool) {
@@ -268,32 +244,6 @@ class NCOperationDownload: ConcurrentOperation {
 
 // MARK: -
 
-class NCOperationDelete: ConcurrentOperation {
-
-    var metadata: tableMetadata
-    var onlyLocalCache: Bool
-
-    init(metadata: tableMetadata, onlyLocalCache: Bool) {
-        self.metadata = tableMetadata.init(value: metadata)
-        self.onlyLocalCache = onlyLocalCache
-    }
-
-    override func start() {
-        if isCancelled {
-            self.finish()
-        } else {
-            NCNetworking.shared.deleteMetadata(metadata, onlyLocalCache: onlyLocalCache) { error in
-                if error != .success {
-                    NCContentPresenter.shared.showError(error: error)
-                }
-                self.finish()
-            }
-        }
-    }
-}
-
-// MARK: -
-
 class NCOperationCopyMove: ConcurrentOperation {
 
     var metadata: tableMetadata