Version 5.0.4

Sources/NextcloudKit/Models/NKFile.swift

@@ -21,7 +21,7 @@ public class NKFile: NSObject {
     /// Download limits for shares of this file.
     ///
     public var downloadLimits = [NKDownloadLimit]()
-    
+
     public var e2eEncrypted: Bool = false
     public var etag = ""
     public var favorite: Bool = false

Sources/NextcloudKit/NKSession.swift

@@ -14,6 +14,9 @@ public class NKSession {
     public var userAgent: String
     public var nextcloudVersion: Int
     public let groupIdentifier: String
+    public let httpMaximumConnectionsPerHost: Int
+    public let httpMaximumConnectionsPerHostInDownload: Int
+    public let httpMaximumConnectionsPerHostInUpload: Int
     public let requestCachePolicy: URLRequest.CachePolicy
     public let dav: String = "remote.php/dav"
     public var internalTypeIdentifiers: [NKCommon.UTTypeConformsToServer] = []
@@ -31,6 +34,9 @@ public class NKSession {
          userAgent: String,
          nextcloudVersion: Int,
          groupIdentifier: String,
+         httpMaximumConnectionsPerHost: Int,
+         httpMaximumConnectionsPerHostInDownload: Int,
+         httpMaximumConnectionsPerHostInUpload: Int,
          requestCachePolicy: URLRequest.CachePolicy = .useProtocolCachePolicy) {
         self.urlBase = urlBase
         self.user = user
@@ -40,6 +46,9 @@ public class NKSession {
         self.userAgent = userAgent
         self.nextcloudVersion = nextcloudVersion
         self.groupIdentifier = groupIdentifier
+        self.httpMaximumConnectionsPerHost = httpMaximumConnectionsPerHost
+        self.httpMaximumConnectionsPerHostInDownload = httpMaximumConnectionsPerHostInDownload
+        self.httpMaximumConnectionsPerHostInUpload = httpMaximumConnectionsPerHostInUpload
         self.requestCachePolicy = requestCachePolicy
 
         let backgroundSessionDelegate = NKBackground(nkCommonInstance: NextcloudKit.shared.nkCommonInstance)
@@ -49,6 +58,7 @@ public class NKSession {
         /// Session Alamofire
         let configuration = URLSessionConfiguration.af.default
         configuration.requestCachePolicy = requestCachePolicy
+        configuration.httpMaximumConnectionsPerHost = httpMaximumConnectionsPerHost
 
         #if os(iOS) || targetEnvironment(macCatalyst)
             configuration.multipathServiceType = .handover
@@ -71,7 +81,7 @@ public class NKSession {
         }
 
         configurationDownloadBackground.isDiscretionary = false
-        configurationDownloadBackground.httpMaximumConnectionsPerHost = 5
+        configurationDownloadBackground.httpMaximumConnectionsPerHost = self.httpMaximumConnectionsPerHostInDownload
         configurationDownloadBackground.requestCachePolicy = requestCachePolicy
 
         #if os(iOS) || targetEnvironment(macCatalyst)
@@ -90,7 +100,7 @@ public class NKSession {
         }
 
         configurationUploadBackground.isDiscretionary = false
-        configurationUploadBackground.httpMaximumConnectionsPerHost = 5
+        configurationUploadBackground.httpMaximumConnectionsPerHost = self.httpMaximumConnectionsPerHostInUpload
         configurationUploadBackground.requestCachePolicy = requestCachePolicy
 
         #if os(iOS) || targetEnvironment(macCatalyst)
@@ -109,7 +119,7 @@ public class NKSession {
         }
 
         configurationUploadBackgroundWWan.isDiscretionary = false
-        configurationUploadBackgroundWWan.httpMaximumConnectionsPerHost = 5
+        configurationUploadBackgroundWWan.httpMaximumConnectionsPerHost = self.httpMaximumConnectionsPerHostInUpload
         configurationUploadBackgroundWWan.requestCachePolicy = requestCachePolicy
         configurationUploadBackgroundWWan.httpCookieStorage = HTTPCookieStorage.sharedCookieStorage(forGroupContainerIdentifier: sharedCookieStorage)
         sessionUploadBackgroundWWan = URLSession(configuration: configurationUploadBackgroundWWan, delegate: backgroundSessionDelegate, delegateQueue: OperationQueue.main)
@@ -123,14 +133,14 @@ public class NKSession {
         }
 
         configurationUploadBackgroundExt.isDiscretionary = false
-        configurationUploadBackgroundExt.httpMaximumConnectionsPerHost = 5
+        configurationUploadBackgroundExt.httpMaximumConnectionsPerHost = self.httpMaximumConnectionsPerHostInUpload
         configurationUploadBackgroundExt.requestCachePolicy = requestCachePolicy
         configurationUploadBackgroundExt.sharedContainerIdentifier = groupIdentifier
 
         #if os(iOS) || targetEnvironment(macCatalyst)
             configurationUploadBackgroundExt.multipathServiceType = .handover
         #endif
-        
+
         configurationUploadBackgroundExt.httpCookieStorage = HTTPCookieStorage.sharedCookieStorage(forGroupContainerIdentifier: sharedCookieStorage)
         sessionUploadBackgroundExt = URLSession(configuration: configurationUploadBackgroundExt, delegate: backgroundSessionDelegate, delegateQueue: OperationQueue.main)
     }

Sources/NextcloudKit/NextcloudKit+ShareDownloadLimit.swift

@@ -4,12 +4,82 @@
 
 import Alamofire
 import Foundation
+import SwiftyJSON
 
 public extension NextcloudKit {
     private func makeEndpoint(with token: String) -> String {
         "ocs/v2.php/apps/files_downloadlimit/api/v1/\(token)/limit"
     }
 
+    func getDownloadLimit(account: String, token: String, completion: @escaping (NKDownloadLimit?, NKError) -> Void) {
+        let endpoint = makeEndpoint(with: token)
+        let options = NKRequestOptions()
+
+        guard let nkSession = nkCommonInstance.getSession(account: account),
+              let url = nkCommonInstance.createStandardUrl(serverUrl: nkSession.urlBase, endpoint: endpoint, options: options),
+              let headers = nkCommonInstance.getStandardHeaders(account: account, options: options) else {
+            return options.queue.async {
+                completion(nil, .urlError)
+            }
+        }
+
+        nkSession
+            .sessionData
+            .request(url, method: .get, parameters: nil, encoding: URLEncoding.default, headers: headers, interceptor: nil)
+            .validate(statusCode: 200..<300)
+            .responseData(queue: self.nkCommonInstance.backgroundQueue) { response in
+                if self.nkCommonInstance.levelLog > 0 {
+                    debugPrint(response)
+                }
+
+                switch response.result {
+                case .failure(let error):
+                    let error = NKError(error: error, afResponse: response, responseData: response.data)
+
+                    options.queue.async {
+                        completion(nil, error)
+                    }
+                case .success(let jsonData):
+                    let json = JSON(jsonData)
+
+                    guard json["ocs"]["meta"]["statuscode"].int == 200 else {
+                        let error = NKError(rootJson: json, fallbackStatusCode: response.response?.statusCode)
+
+                        options.queue.async {
+                            completion(nil, error)
+                        }
+
+                        return
+                    }
+
+                    let count = json["ocs"]["data"]["count"]
+                    let limit = json["ocs"]["data"]["limit"]
+
+                    guard count.type != .null else {
+                        options.queue.async {
+                            completion(nil, .success)
+                        }
+
+                        return
+                    }
+
+                    guard limit.type != .null else {
+                        options.queue.async {
+                            completion(nil, .success)
+                        }
+
+                        return
+                    }
+
+                    let downloadLimit = NKDownloadLimit(count: count.intValue, limit: limit.intValue, token: token)
+
+                    options.queue.async {
+                        completion(downloadLimit, .success)
+                    }
+                }
+            }
+    }
+
     func removeShareDownloadLimit(account: String, token: String, completion: @escaping (_ error: NKError) -> Void) {
         let endpoint = makeEndpoint(with: token)
         let options = NKRequestOptions()

Sources/NextcloudKit/NextcloudKit.swift

@@ -61,11 +61,27 @@
                               password: String,
                               userAgent: String,
                               nextcloudVersion: Int,
+                              httpMaximumConnectionsPerHost: Int = 6,
+                              httpMaximumConnectionsPerHostInDownload: Int = 6,
+                              httpMaximumConnectionsPerHostInUpload: Int = 6,
                               groupIdentifier: String) {
         if nkCommonInstance.nksessions.filter({ $0.account == account }).first != nil {
             return updateSession(account: account, urlBase: urlBase, userId: userId, password: password, userAgent: userAgent, nextcloudVersion: nextcloudVersion)
         }
-        let nkSession = NKSession(urlBase: urlBase, user: user, userId: userId, password: password, account: account, userAgent: userAgent, nextcloudVersion: nextcloudVersion, groupIdentifier: groupIdentifier)
+
+        let nkSession = NKSession(
+            urlBase: urlBase,
+            user: user,
+            userId: userId,
+            password: password,
+            account: account,
+            userAgent: userAgent,
+            nextcloudVersion: nextcloudVersion,
+            groupIdentifier: groupIdentifier,
+            httpMaximumConnectionsPerHost: httpMaximumConnectionsPerHost,
+            httpMaximumConnectionsPerHostInDownload: httpMaximumConnectionsPerHostInDownload,
+            httpMaximumConnectionsPerHostInUpload: httpMaximumConnectionsPerHostInUpload
+        )
 
         nkCommonInstance.nksessions.append(nkSession)
     }

Sources/NextcloudKit/Utils/FileNameValidator.swift

@@ -39,7 +39,7 @@ public class FileNameValidator {
     }
 
     public var fileForbiddenFileExtensionError: NKError {
-        let errorMessageTemplate = NSLocalizedString("_file_name_validator_error_forbidden_file_extension_", value: ".\"%@\" is a forbidden file extension.", comment: "")
+        let errorMessageTemplate = NSLocalizedString("_file_name_validator_error_forbidden_file_extension_", value: "\".%@\" is a forbidden file extension.", comment: "")
         let errorMessage = String(format: errorMessageTemplate, templateString)
         return NKError(errorCode: NSURLErrorCannotCreateFile, errorDescription: errorMessage)
     }