Merge remote-tracking branch 'origin/master' into release

Author: dynabic-billing-team

AsposeWordsCloud.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
   s.name             = 'AsposeWordsCloud'
-  s.version          = '20.9'
+  s.version          = '20.10'
   s.summary          = 'Aspose Words for Cloud.'
   s.homepage         = 'https://github.com/aspose-words-cloud/aspose-words-cloud-swift.git'
   s.license          = { :type => 'MIT', :file => 'LICENSE' }

README.md

@@ -94,7 +94,7 @@ Add link to this repository as dependency to your Package.swift:
 
 dependencies: [
     // Dependencies declare other packages that this package depends on.
-    .package(url: "https://github.com/aspose-words-cloud/aspose-words-cloud-swift", from: "20.9"),
+    .package(url: "https://github.com/aspose-words-cloud/aspose-words-cloud-swift", from: "20.10"),
 ],
 targets: [
     // Targets are the basic building blocks of a package. A target can define a module or a test suite.
@@ -112,7 +112,7 @@ targets: [
 Add link to git repository as dependency to your Podfile:
 
 ```ruby
-pod 'AsposeWordsCloud', :git => 'https://github.com/aspose-words-cloud/aspose-words-cloud-swift.git', :tag => '20.9'
+pod 'AsposeWordsCloud', :git => 'https://github.com/aspose-words-cloud/aspose-words-cloud-swift.git', :tag => '20.10'
 ```
 
 ## Getting Started

Sources/AsposeWordsCloud/Api/ApiInvoker.swift

@@ -71,59 +71,20 @@ public class ApiInvoker {
     }
 
     // Invoke request to the API with the specified set of arguments and execute callback after the request is completed
-    public func invoke(
-        url: URL,
-        method: String,
-        body: Data?,
-        headers: Dictionary<String, String>?,
-        formParams: [RequestFormParam]?,
-        contentType: String = "application/json",
-        callback: @escaping (_ response: Data?, _ error: Error?) -> ()
+    public func invoke(apiRequestData : WordsApiRequestData, callback: @escaping (_ response: Data?, _ error: Error?) -> ()
     ) {
         // Create URL request object
-        var request = URLRequest(url: url);
-        request.httpMethod = method;
+        var request = URLRequest(url: apiRequestData.getURL());
+        request.httpMethod = apiRequestData.getMethod();
 
         // Fill headers
-        if (headers != nil) {
-            for (key, value) in headers! {
-                request.setValue(value, forHTTPHeaderField: key);
-            }
+        for (key, value) in apiRequestData.getHeaders() {
+            request.setValue(value, forHTTPHeaderField: key);
         }
 
         // Process the request body
-        if (body != nil) {
-            request.httpBody = body;
-            request.setValue(contentType, forHTTPHeaderField: "Content-Type");
-        }
-        else if (formParams != nil && formParams!.count > 0) {
-            if (formParams?.count == 1) {
-                request.httpBody = (formParams!)[0].getBody();
-            }
-            else {
-                // Generate body for multiform requests
-                var needsClrf = false;
-                var formBody = Data();
-                let boundaryPrefix = "Somthing";
-                for formParam in formParams! {
-                    if (needsClrf) {
-                        formBody.append("\r\n".data(using: .utf8)!);
-                    }
-                    needsClrf = true;
-
-                    formBody.append("--\(boundaryPrefix)\r\nContent-Disposition: form-data; name=\"\(formParam.getName())\"\r\n\r\n".data(using: .utf8)!);
-                    formBody.append(formParam.getBody());
-                }
-                formBody.append("\r\n--\(boundaryPrefix)--\r\n".data(using: .utf8)!);
-
-                request.httpBody = formBody;
-                request.setValue("multipart/form-data; boundary=\(boundaryPrefix)", forHTTPHeaderField: "Content-Type");
-            }
-        }
-
-        // Set content length header
-        if (request.httpBody != nil) {
-            request.setValue(String(request.httpBody!.count), forHTTPHeaderField: "Content-Length");
+        if (apiRequestData.getBody() != nil) {
+            request.httpBody = apiRequestData.getBody();
         }
 
         // Request or get from cache authorization token

Sources/AsposeWordsCloud/Api/Configuration.swift

@@ -91,6 +91,6 @@ public class Configuration : Codable {
 
     // Returns SDK version for using in statistics headers
     public func getSdkVersion() -> String {
-        return "20.9";
+        return "20.10";
     }
 }

Sources/AsposeWordsCloud/Api/ObjectSerializer.swift

@@ -130,6 +130,107 @@ class ObjectSerializer {
         return try customDecoder.decode(type, from: data);
     }
 
+    // Deserialize an multipart response
+    public static func parseMultipart(data: Data) throws -> [ResponseFormParam] {
+        var result = [ResponseFormParam]();
+        if (!data.starts(with: "--".data(using: .utf8)!)) {
+           throw WordsApiError.invalidMultipartResponse(message: "Boundary not found");
+        }
+
+        let newLineData = "\r\n".data(using: .utf8)!;
+        let boundaryEndIndex = data.range(of: newLineData);
+        if (boundaryEndIndex == nil || boundaryEndIndex!.isEmpty) {
+            throw WordsApiError.invalidMultipartResponse(message: "Boundary not found");
+        }
+
+        let boundary = data.subdata(in: data.startIndex..<boundaryEndIndex!.lowerBound);
+        let parts = ObjectSerializer.splitData(data: data, separator: boundary);
+        let dispositionSeparator = "\r\n\r\n".data(using: .utf8)!;
+
+        for part in parts {
+            let partDataBounds = part.range(of: dispositionSeparator);
+            if (partDataBounds == nil || partDataBounds!.isEmpty) {
+                throw WordsApiError.invalidMultipartResponse(message: "Part content not found");
+            }
+
+            let headData = part.subdata(in: part.startIndex..<partDataBounds!.lowerBound);
+            let headContent = String(decoding: headData, as: UTF8.self);
+            var headers = [String : String]();
+
+            for headerRawData in headContent.components(separatedBy: "\r\n") {
+                let headerData = headerRawData.trimmingCharacters(in: .whitespacesAndNewlines);
+                if (!headerData.isEmpty) {
+                    let headerParts = headerData.split(separator: ":");
+                    if (headerParts.count == 2) {
+                        let headerKey = headerParts[0].trimmingCharacters(in: .whitespaces);
+                        let headerValue = headerParts[1].trimmingCharacters(in: .whitespaces);
+                        headers[headerKey] = headerValue;
+                    }
+                }
+            }
+
+            let bodyData = part.subdata(in: partDataBounds!.upperBound..<part.endIndex);
+            result.append(ResponseFormParam(body: bodyData, headers: headers));
+        }
+
+        return result;
+    }
+
+    // Split data into parts
+    public static func splitData(data: Data, separator: Data) -> [Data] {
+        let endIndex = separator.count;
+        var chunks: [Data] = [];
+        var pos = 0;
+        while let r = data[pos...].range(of: separator) {
+            if (r.lowerBound > pos) {
+                chunks.append(data[pos..<r.lowerBound]);
+            }
+
+            pos = r.upperBound;
+        }
+
+        if (pos < endIndex) {
+            chunks.append(data[pos..<endIndex]);
+        }
+
+        return chunks;
+    }
+
+    // Create an instance of T, from batch part data
+    public static func deserializeBatchPart(request: WordsApiRequest, partData: ResponseFormParam) throws -> Any? {
+        let separator = "\r\n\r\n".data(using: .utf8)!;
+        let data = partData.getBody();
+        let partDataBounds = data.range(of: separator);
+        if (partDataBounds == nil || partDataBounds!.isEmpty) {
+            throw WordsApiError.invalidMultipartResponse(message: "Body content not found");
+        }
+
+        let headData = data.subdata(in: data.startIndex..<partDataBounds!.lowerBound);
+        let headContent = String(decoding: headData, as: UTF8.self);
+        let headParts = headContent.components(separatedBy: "\r\n");
+        if (headParts.count == 0) {
+            throw WordsApiError.invalidMultipartResponse(message: "Head content not found");
+        }
+
+        let codeContent = headParts[0].split(separator: " ", maxSplits: 1, omittingEmptySubsequences: true);
+        if (codeContent.count != 2) {
+            throw WordsApiError.invalidMultipartResponse(message: "Head content not found");
+        }
+
+        let codeStatus = Int(codeContent[0]);
+        if (codeStatus == nil) {
+            throw WordsApiError.invalidMultipartResponse(message: "Failed to parse head content");
+        }
+
+        let bodyData = data.subdata(in: partDataBounds!.upperBound..<data.endIndex);
+        if (codeStatus != 200) {
+            let errorMessage = String(decoding: bodyData, as: UTF8.self);
+            return WordsApiError.requestError(errorCode: codeStatus!, message: errorMessage);
+        }
+
+        return try request.deserializeResponse(data: bodyData);
+    }
+
     // Configuration for DateTime serialization/deserialization
     public static let customIso8601: DateFormatter = {
         let formatter = DateFormatter()

Sources/AsposeWordsCloud/Api/RequestFormParam.swift

@@ -29,19 +29,25 @@ import Foundation
 
 // Represent struct for using as form param in request
 public struct RequestFormParam {
-    private let name : String;
+    private let name : String?;
     private let body : Data;
+    private let contentType : String;
 
-    public init(name : String, body : Data) {
+    public init(name : String?, body : Data, contentType : String) {
         self.name = name;
         self.body = body;
+        self.contentType = contentType;
     }
 
-    public func getName() -> String {
+    public func getName() -> String? {
         return self.name;
     }
 
     public func getBody() -> Data {
         return self.body;
     }
+
+    public func getContentType() -> String {
+        return self.contentType;
+    }
 }

Sources/AsposeWordsCloud/Api/ResponseFormParam.swift

@@ -0,0 +1,47 @@
+/*
+ * --------------------------------------------------------------------------------
+ * <copyright company="Aspose" file="ResponseFormParam.swift">
+ *   Copyright (c) 2020 Aspose.Words for Cloud
+ * </copyright>
+ * <summary>
+ *   Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ * 
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ * 
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ * </summary>
+ * --------------------------------------------------------------------------------
+ */
+
+import Foundation
+
+// Represent struct for using as form param in request
+public struct ResponseFormParam {
+    private let body : Data;
+    private let headers : [String : String];
+
+    public init(body : Data, headers : [String : String]) {
+        self.body = body;
+        self.headers = headers;
+    }
+
+    public func getBody() -> Data {
+        return self.body;
+    }
+
+    public func getHeaders() -> [String : String] {
+        return self.headers;
+    }
+}