Sending json array through Alamofire

Question

I wonder if it is possible to directly send an array (not wrapped in a dictionary) to a POST request. Apparently, the parameters parameters should get a map: [String: AnyObject]? But I want to be able to send the following json example:

 [ "06786984572365", "06644857247565", "06649998782227" ] 

Answer 1

You can simply encode JSON with NSJSONSerialization and then create NSURLRequest yourself. For example, in Swift 3:

 var request = URLRequest(url: url) request.httpMethod = "POST" request.setValue("application/json", forHTTPHeaderField: "Content-Type") let values = ["06786984572365", "06644857247565", "06649998782227"] request.httpBody = try! JSONSerialization.data(withJSONObject: values) Alamofire.request(request) .responseJSON { response in // do whatever you want here switch response.result { case .failure(let error): print(error) if let data = response.data, let responseString = String(data: data, encoding: .utf8) { print(responseString) } case .success(let responseObject): print(responseObject) } } 

For Swift 2, see the previous version of this answer.

Answer 2

For fast 3 and Alamofire 4, I use the following extensions ParametersEncoding and Array :

 import Foundation import Alamofire private let arrayParametersKey = "arrayParametersKey" /// Extenstion that allows an array be sent as a request parameters extension Array { /// Convert the receiver array to a `Parameters` object. func asParameters() -> Parameters { return [arrayParametersKey: self] } } /// Convert the parameters into a json array, and it is added as the request body. /// The array must be sent as parameters using its `asParameters` method. public struct ArrayEncoding: ParameterEncoding { /// The options for writing the parameters as JSON data. public let options: JSONSerialization.WritingOptions /// Creates a new instance of the encoding using the given options /// /// - parameter options: The options used to encode the json. Default is `[]` /// /// - returns: The new instance public init(options: JSONSerialization.WritingOptions = []) { self.options = options } public func encode(_ urlRequest: URLRequestConvertible, with parameters: Parameters?) throws -> URLRequest { var urlRequest = try urlRequest.asURLRequest() guard let parameters = parameters, let array = parameters[arrayParametersKey] else { return urlRequest } do { let data = try JSONSerialization.data(withJSONObject: array, options: options) if urlRequest.value(forHTTPHeaderField: "Content-Type") == nil { urlRequest.setValue("application/json", forHTTPHeaderField: "Content-Type") } urlRequest.httpBody = data } catch { throw AFError.parameterEncodingFailed(reason: .jsonEncodingFailed(error: error)) } return urlRequest } } 

Basically, it converts an array to a Dictionary to accept it as an Parameters argument, and then it returns an array from a dictionary, converts it to JSON Data and adds it as the request body.

After that, you can create a query this way:

 let values = ["06786984572365", "06644857247565", "06649998782227"] Alamofire.request(url, method: .post, parameters: values.asParameters(), encoding: ArrayEncoding()) 

Answer 3

Here is an example of encoding an array of type Thing for JSON using a router and Ogra for encoding JSON:

 import Foundation import Alamofire import Orga class Thing { ... } enum Router: URLRequestConvertible { static let baseURLString = "http://www.example.com" case UploadThings([Thing]) private var method: Alamofire.Method { switch self { case .UploadThings: return .POST } } private var path: String { switch self { case .UploadThings: return "upload/things" } } var URLRequest: NSMutableURLRequest { let r = NSMutableURLRequest(URL: NSURL(string: Router.baseURLString)!.URLByAppendingPathComponent(path)) r.HTTPMethod = method.rawValue switch self { case .UploadThings(let things): let custom: (URLRequestConvertible, [String:AnyObject]?) -> (NSMutableURLRequest, NSError?) = { (convertible, parameters) in var mutableRequest = convertible.URLRequest.copy() as! NSMutableURLRequest do { let jsonObject = things.encode().JSONObject() let data = try NSJSONSerialization.dataWithJSONObject(jsonObject, options: NSJSONWritingOptions.PrettyPrinted) mutableRequest.setValue("application/json", forHTTPHeaderField: "Content-Type") mutableRequest.HTTPBody = data return (mutableRequest, nil) } catch let error as NSError { return (mutableRequest, error) } } return ParameterEncoding.Custom(custom).encode(r, parameters: nil).0 default: return r } } } 

Answer 4

Swift 2.0
This code is below the post object array. This code is tested on swift 2.0

 func POST(RequestURL: String,postData:[AnyObject]?,successHandler: (String) -> (),failureHandler: (String) -> ()) -> () { print("POST : \(RequestURL)") let request = NSMutableURLRequest(URL: NSURL(string:RequestURL)!) request.HTTPMethod = "POST" request.setValue("application/json", forHTTPHeaderField: "Content-Type") var error: NSError? do { request.HTTPBody = try NSJSONSerialization.dataWithJSONObject(postData!, options:[]) } catch { print("JSON serialization failed: \(error)") } Alamofire.request(request) .responseString{ response in switch response.result { case .Success: print(response.response?.statusCode) print(response.description) if response.response?.statusCode == 200 { successHandler(response.result.value!) }else{ failureHandler("\(response.description)") } case .Failure(let error): failureHandler("\(error)") } } } 

Answer 5

@manueGE the answer is correct. I have a similar approach according to the alamofire github instruction: `

 struct JSONDocumentArrayEncoding: ParameterEncoding { private let array: [Any] init(array:[Any]) { self.array = array } func encode(_ urlRequest: URLRequestConvertible, with parameters: Parameters?) throws -> URLRequest { var urlRequest = urlRequest.urlRequest let data = try JSONSerialization.data(withJSONObject: array, options: []) if urlRequest!.value(forHTTPHeaderField: "Content-Type") == nil { urlRequest!.setValue("application/json", forHTTPHeaderField: "Content-Type") } urlRequest!.httpBody = data return urlRequest! } } 

`Then call this by tuning the query instead of using the default parameter with the parameter. In principle, discard the parameter, since this is a dictionary.

 let headers = getHeaders() var urlRequest = URLRequest(url: URL(string: (ServerURL + Api))!) urlRequest.httpMethod = "post" urlRequest.allHTTPHeaderFields = headers let jsonArrayencoding = JSONDocumentArrayEncoding(array: documents) let jsonAryEncodedRequest = try? jsonArrayencoding.encode(urlRequest, with: nil) request = customAlamofireManager.request(jsonAryEncodedRequest!) request?.validate{request, response, data in return .success } .responseJSON { /*[unowned self] */(response) -> Void in ... } 

Also a very useful way to handle data errors.

Answer 6

There are two approaches for sending JSON content as a parameter.

• You can send json as a string and your web service will parse it on the server.

    d["completionDetail"] = "[{"YearOfCompletion":"14/03/2017","Completed":true}]" 

• You can pass each value to json ( YearOfCompletion and Completed ) as a sequential array. And your web service will insert this data in the same sequence. The syntax for this will look like

   d["YearOfCompletion[0]"] = "1998" d["YearOfCompletion[1]"] = "1997" d["YearOfCompletion[2]"] = "1996" d["Completed[0]"] = "true" d["Completed[1]"] = "false" d["Completed[2]"] = "true" 

I used the following dictionary web services call function to invoke the Alamofire request to Alamofire .

 func wsDataRequest(url:String, parameters:Dictionary<String, Any>) { debugPrint("Request:", url, parameters as NSDictionary, separator: "\n") //check for internete collection, if not availabale, don;t move forword if Rechability.connectedToNetwork() == false {SVProgressHUD.showError(withStatus: NSLocalizedString("No Network available! Please check your connection and try again later.", comment: "")); return} // self.request = Alamofire.request(url, method: .post, parameters: parameters) if let request = self.request as? DataRequest { request.responseString { response in var serializedData : Any? = nil var message = NSLocalizedString("Success!", comment: "")//MUST BE CHANGED TO RELEVANT RESPONSES //check content availability and produce serializable response if response.result.isSuccess == true { do { serializedData = try JSONSerialization.jsonObject(with: response.data!, options: JSONSerialization.ReadingOptions.allowFragments) //print(serializedData as! NSDictionary) //debugPrint(message, "Response Dictionary:", serializedData ?? "Data could not be serialized", separator: "\n") }catch{ message = NSLocalizedString("Webservice Response error!", comment: "") var string = String.init(data: response.data!, encoding: .utf8) as String! //TO check when html coms as prefix of JSON, this is hack mush be fixed on web end. do { if let index = string?.characters.index(of: "{") { if let s = string?.substring(from: index) { if let data = s.data(using: String.Encoding.utf8) { serializedData = try JSONSerialization.jsonObject(with: data, options: JSONSerialization.ReadingOptions.allowFragments) debugPrint(message, "Courtesy SUME:", serializedData ?? "Data could not be serialized", separator: "\n") } } } }catch{debugPrint(message, error.localizedDescription, "Respone String:", string ?? "No respone value.", separator: "\n")} //let index: Int = text.distance(from: text.startIndex, to: range.lowerBound) debugPrint(message, error.localizedDescription, "Respone String:", string ?? "No respone value.", separator: "\n") } //call finised response in all cases self.delegate?.finished(succes: response.result.isSuccess, and: serializedData, message: message) }else{ if self.retryCounter < 1 {//this happens really frequntly so in that case this fn being called again as a retry self.wsDataRequest(url: url, parameters: parameters) }else{ message = response.error?.localizedDescription ?? (NSLocalizedString("No network", comment: "")+"!") SVProgressHUD.showError(withStatus: message);//this will show errror and hide Hud debugPrint(message) //call finised response in all cases self.delay(2.0, closure: {self.delegate?.finished(succes: response.result.isSuccess, and: serializedData, message:message)}) } self.retryCounter += 1 } } } } 

Answer 7

I think based on the Alamofire documentation you can write code like this:

 let values = ["06786984572365", "06644857247565", "06649998782227"] Alamofire.request(.POST, url, parameters: values, encoding:.JSON) .authenticate(user: userid, password: password) .responseJSON { (request, response, responseObject, error) in // do whatever you want here if responseObject == nil { println(error) } else { println(responseObject) } }