coding

Signed-off-by: marinofaggiana <ios@nextcloud.com>

iOSClient/Networking/NCNetworkingChunkedUpload.swift

@@ -37,11 +37,10 @@ extension NCNetworking {
 
         var uploadErrorCode: Int = 0
         var uploadErrorDescription: String = ""
+        
         var filesNames = NCManageDatabase.shared.getChunks(account: metadata.account, ocId: metadata.ocId)
         if filesNames.count == 0 {
-
             filesNames = NCCommunicationCommon.shared.chunkedFile(inputDirectory: directoryProviderStorageOcId, outputDirectory: directoryProviderStorageOcId, fileName: metadata.fileName, chunkSizeMB: chunkSize)
-
             if filesNames.count > 0 {
                 NCManageDatabase.shared.addChunks(account: metadata.account, ocId: metadata.ocId, chunkFolder: chunkFolder, fileNames: filesNames)
             } else {
@@ -49,149 +48,140 @@ extension NCNetworking {
                 NCManageDatabase.shared.deleteMetadata(predicate: NSPredicate(format: "ocId == %@", metadata.ocId))
                 return completion(uploadErrorCode, uploadErrorDescription)
             }
-
         } else {
-
             NotificationCenter.default.postOnMainThread(name: NCGlobal.shared.notificationCenterReloadDataSource, userInfo: ["serverUrl": metadata.serverUrl])
         }
-
         NCContentPresenter.shared.noteTop(text: NSLocalizedString("_upload_chunk_", comment: ""), image: nil, type: NCContentPresenter.messageType.info, delay: NCGlobal.shared.dismissAfterSecond, priority: .max)
 
         createChunkedFolder(chunkFolderPath: chunkFolderPath, account: metadata.account) { errorCode, errorDescription in
 
             start()
 
-            if errorCode == 0 {
-
-                NotificationCenter.default.postOnMainThread(name: NCGlobal.shared.notificationCenterUploadStartFile, userInfo: ["ocId": metadata.ocId])
-
-                for fileName in filesNames {
+            guard errorCode == 0 else {
+                self.uploadChunkFileError(metadata: metadata, chunkFolderPath: chunkFolderPath, directoryProviderStorageOcId: directoryProviderStorageOcId, errorCode: errorCode, errorDescription: errorDescription)
+                completion(errorCode, errorDescription)
+                return
+            }
 
-                    let serverUrlFileName = chunkFolderPath + "/" + fileName
-                    let fileNameChunkLocalPath = CCUtility.getDirectoryProviderStorageOcId(metadata.ocId, fileNameView: fileName)!
+            NotificationCenter.default.postOnMainThread(name: NCGlobal.shared.notificationCenterUploadStartFile, userInfo: ["ocId": metadata.ocId])
 
-                    var size: Int64?
-                    if let tableChunk = NCManageDatabase.shared.getChunk(account: metadata.account, fileName: fileName) {
-                        size = tableChunk.size - NCUtilityFileSystem.shared.getFileSize(filePath: fileNameChunkLocalPath)
-                    }
+            for fileName in filesNames {
 
-                    let semaphore = Semaphore()
+                let serverUrlFileName = chunkFolderPath + "/" + fileName
+                let fileNameChunkLocalPath = CCUtility.getDirectoryProviderStorageOcId(metadata.ocId, fileNameView: fileName)!
 
-                    NCCommunication.shared.upload(serverUrlFileName: serverUrlFileName, fileNameLocalPath: fileNameChunkLocalPath, requestHandler: { request in
+                var size: Int64?
+                if let tableChunk = NCManageDatabase.shared.getChunk(account: metadata.account, fileName: fileName) {
+                    size = tableChunk.size - NCUtilityFileSystem.shared.getFileSize(filePath: fileNameChunkLocalPath)
+                }
 
-                        self.uploadRequest[fileNameLocalPath] = request
+                let semaphore = Semaphore()
 
-                    }, taskHandler: { task in
+                NCCommunication.shared.upload(serverUrlFileName: serverUrlFileName, fileNameLocalPath: fileNameChunkLocalPath, requestHandler: { request in
 
-                        NCManageDatabase.shared.setMetadataSession(ocId: metadata.ocId, sessionError: "", sessionTaskIdentifier: task.taskIdentifier, status: NCGlobal.shared.metadataStatusUploading)
+                    self.uploadRequest[fileNameLocalPath] = request
 
-                        NotificationCenter.default.postOnMainThread(name: NCGlobal.shared.notificationCenterUploadStartFile, userInfo: ["ocId": metadata.ocId])
+                }, taskHandler: { task in
 
-                        NCCommunicationCommon.shared.writeLog("Upload chunk: " + fileName)
+                    NCManageDatabase.shared.setMetadataSession(ocId: metadata.ocId, sessionError: "", sessionTaskIdentifier: task.taskIdentifier, status: NCGlobal.shared.metadataStatusUploading)
 
-                    }, progressHandler: { progress in
+                    NotificationCenter.default.postOnMainThread(name: NCGlobal.shared.notificationCenterUploadStartFile, userInfo: ["ocId": metadata.ocId])
 
-                        if let size = size {
+                    NCCommunicationCommon.shared.writeLog("Upload chunk: " + fileName)
 
-                            let totalBytesExpected = size + progress.completedUnitCount
-                            let totalBytes = metadata.size
-                            let fractionCompleted = Float(totalBytesExpected) / Float(totalBytes)
+                }, progressHandler: { progress in
 
-                            NotificationCenter.default.postOnMainThread(
-                                name: NCGlobal.shared.notificationCenterProgressTask,
-                                object: nil,
-                                userInfo: [
-                                    "account": metadata.account,
-                                    "ocId": metadata.ocId,
-                                    "fileName": metadata.fileName,
-                                    "serverUrl": metadata.serverUrl,
-                                    "status": NSNumber(value: NCGlobal.shared.metadataStatusInUpload),
-                                    "progress": NSNumber(value: fractionCompleted),
-                                    "totalBytes": NSNumber(value: totalBytes),
-                                    "totalBytesExpected": NSNumber(value: totalBytesExpected)])
-                        }
+                    if let size = size {
 
-                    }) { _, _, _, _, _, _, _, errorCode, errorDescription in
+                        let totalBytesExpected = size + progress.completedUnitCount
+                        let totalBytes = metadata.size
+                        let fractionCompleted = Float(totalBytesExpected) / Float(totalBytes)
 
-                        self.uploadRequest[fileNameLocalPath] = nil
-                        uploadErrorCode = errorCode
-                        uploadErrorDescription = errorDescription
-                        semaphore.continue()
+                        NotificationCenter.default.postOnMainThread(
+                            name: NCGlobal.shared.notificationCenterProgressTask,
+                            object: nil,
+                            userInfo: [
+                                "account": metadata.account,
+                                "ocId": metadata.ocId,
+                                "fileName": metadata.fileName,
+                                "serverUrl": metadata.serverUrl,
+                                "status": NSNumber(value: NCGlobal.shared.metadataStatusInUpload),
+                                "progress": NSNumber(value: fractionCompleted),
+                                "totalBytes": NSNumber(value: totalBytes),
+                                "totalBytesExpected": NSNumber(value: totalBytesExpected)])
                     }
 
-                    semaphore.wait()
+                }) { _, _, _, _, _, _, _, errorCode, errorDescription in
 
-                    if uploadErrorCode == 0 {
-                        NCManageDatabase.shared.deleteChunk(account: metadata.account, ocId: metadata.ocId, fileName: fileName)
-                    } else {
-                        break
-                    }
+                    self.uploadRequest[fileNameLocalPath] = nil
+                    uploadErrorCode = errorCode
+                    uploadErrorDescription = errorDescription
+                    semaphore.continue()
                 }
 
-                if uploadErrorCode == 0 {
-
-                    // Assembling the chunks
-                    let serverUrlFileNameSource = chunkFolderPath + "/.file"
-                    let pathServerUrl = CCUtility.returnPathfromServerUrl(metadata.serverUrl, urlBase: metadata.urlBase, account: metadata.account)!
-                    let serverUrlFileNameDestination = metadata.urlBase + "/" + NCUtilityFileSystem.shared.getWebDAV(account: metadata.account) + "/files/" + metadata.userId + pathServerUrl + "/" + metadata.fileName
+                semaphore.wait()
 
-                    var addCustomHeaders: [String: String] = [:]
-                    let creationDate = "\(metadata.creationDate.timeIntervalSince1970)"
-                    let modificationDate = "\(metadata.date.timeIntervalSince1970)"
+                if uploadErrorCode == 0 {
+                    NCManageDatabase.shared.deleteChunk(account: metadata.account, ocId: metadata.ocId, fileName: fileName)
+                } else {
+                    break
+                }
+            }
 
-                    addCustomHeaders["X-OC-CTime"] = creationDate
-                    addCustomHeaders["X-OC-MTime"] = modificationDate
+            guard uploadErrorCode == 0 else {
+                self.uploadChunkFileError(metadata: metadata, chunkFolderPath: chunkFolderPath, directoryProviderStorageOcId: directoryProviderStorageOcId, errorCode: uploadErrorCode, errorDescription: uploadErrorDescription)
+                completion(errorCode, errorDescription)
+                return
+            }
 
-                    NCCommunication.shared.moveFileOrFolder(serverUrlFileNameSource: serverUrlFileNameSource, serverUrlFileNameDestination: serverUrlFileNameDestination, overwrite: true, addCustomHeaders: addCustomHeaders) { _, errorCode, errorDescription in
+            // Assembling the chunks
+            let serverUrlFileNameSource = chunkFolderPath + "/.file"
+            let pathServerUrl = CCUtility.returnPathfromServerUrl(metadata.serverUrl, urlBase: metadata.urlBase, account: metadata.account)!
+            let serverUrlFileNameDestination = metadata.urlBase + "/" + NCUtilityFileSystem.shared.getWebDAV(account: metadata.account) + "/files/" + metadata.userId + pathServerUrl + "/" + metadata.fileName
 
-                        NCCommunicationCommon.shared.writeLog("Assembling chunk with error code: \(errorCode)")
+            var addCustomHeaders: [String: String] = [:]
+            let creationDate = "\(metadata.creationDate.timeIntervalSince1970)"
+            let modificationDate = "\(metadata.date.timeIntervalSince1970)"
 
-                        if errorCode == 0 {
+            addCustomHeaders["X-OC-CTime"] = creationDate
+            addCustomHeaders["X-OC-MTime"] = modificationDate
 
-                            let serverUrl = metadata.serverUrl
-                            let assetLocalIdentifier = metadata.assetLocalIdentifier
+            NCCommunication.shared.moveFileOrFolder(serverUrlFileNameSource: serverUrlFileNameSource, serverUrlFileNameDestination: serverUrlFileNameDestination, overwrite: true, addCustomHeaders: addCustomHeaders) { _, errorCode, errorDescription in
 
-                            NCManageDatabase.shared.deleteMetadata(predicate: NSPredicate(format: "ocId == %@", metadata.ocId))
-                            NCManageDatabase.shared.deleteChunks(account: metadata.account, ocId: metadata.ocId)
-                            NCUtilityFileSystem.shared.deleteFile(filePath: directoryProviderStorageOcId)
+                NCCommunicationCommon.shared.writeLog("Assembling chunk with error code: \(errorCode)")
 
-                            self.readFile(serverUrlFileName: serverUrlFileNameDestination) { (_, metadata, _, _) in
+                guard uploadErrorCode == 0 else {
+                    self.uploadChunkFileError(metadata: metadata, chunkFolderPath: chunkFolderPath, directoryProviderStorageOcId: directoryProviderStorageOcId, errorCode: errorCode, errorDescription: errorDescription)
+                    completion(errorCode, errorDescription)
+                    return
+                }
 
-                                if errorCode == 0, let metadata = metadata {
+                let serverUrl = metadata.serverUrl
+                let assetLocalIdentifier = metadata.assetLocalIdentifier
 
-                                    metadata.assetLocalIdentifier = assetLocalIdentifier
-                                    // Delete Asset on Photos album
-                                    if CCUtility.getRemovePhotoCameraRoll() && !metadata.assetLocalIdentifier.isEmpty {
-                                        metadata.deleteAssetLocalIdentifier = true
-                                    }
-                                    NCManageDatabase.shared.addMetadata(metadata)
-                                    NotificationCenter.default.postOnMainThread(name: NCGlobal.shared.notificationCenterReloadDataSource, userInfo: ["serverUrl": serverUrl])
+                NCManageDatabase.shared.deleteMetadata(predicate: NSPredicate(format: "ocId == %@", metadata.ocId))
+                NCManageDatabase.shared.deleteChunks(account: metadata.account, ocId: metadata.ocId)
+                NCUtilityFileSystem.shared.deleteFile(filePath: directoryProviderStorageOcId)
 
-                                } else {
+                self.readFile(serverUrlFileName: serverUrlFileNameDestination) { (_, metadata, _, _) in
 
-                                    NotificationCenter.default.postOnMainThread(name: NCGlobal.shared.notificationCenterReloadDataSourceNetworkForced, userInfo: ["serverUrl": serverUrl])
-                                }
+                    if errorCode == 0, let metadata = metadata {
 
-                                completion(errorCode, errorDescription)
-                            }
+                        metadata.assetLocalIdentifier = assetLocalIdentifier
+                        // Delete Asset on Photos album
+                        if CCUtility.getRemovePhotoCameraRoll() && !metadata.assetLocalIdentifier.isEmpty {
+                            metadata.deleteAssetLocalIdentifier = true
+                        }
+                        NCManageDatabase.shared.addMetadata(metadata)
+                        NotificationCenter.default.postOnMainThread(name: NCGlobal.shared.notificationCenterReloadDataSource, userInfo: ["serverUrl": serverUrl])
 
-                        } else {
+                    } else {
 
-                            self.uploadChunkFileError(metadata: metadata, chunkFolderPath: chunkFolderPath, directoryProviderStorageOcId: directoryProviderStorageOcId, errorCode: errorCode, errorDescription: errorDescription)
-                            completion(errorCode, errorDescription)
-                        }
+                        NotificationCenter.default.postOnMainThread(name: NCGlobal.shared.notificationCenterReloadDataSourceNetworkForced, userInfo: ["serverUrl": serverUrl])
                     }
 
-                } else {
-
-                    self.uploadChunkFileError(metadata: metadata, chunkFolderPath: chunkFolderPath, directoryProviderStorageOcId: directoryProviderStorageOcId, errorCode: uploadErrorCode, errorDescription: uploadErrorDescription)
                     completion(errorCode, errorDescription)
                 }
-
-            } else {
-
-                self.uploadChunkFileError(metadata: metadata, chunkFolderPath: chunkFolderPath, directoryProviderStorageOcId: directoryProviderStorageOcId, errorCode: errorCode, errorDescription: errorDescription)
-                completion(errorCode, errorDescription)
             }
         }
     }