J'essaie de faire une demande de publication avec un corps à Swift en utilisant Alamofire.
mon corps json ressemble à:
{
"IdQuiz" : 102,
"IdUser" : "iosclient",
"User" : "iosclient",
"List":[
{
"IdQuestion" : 5,
"IdProposition": 2,
"Time" : 32
},
{
"IdQuestion" : 4,
"IdProposition": 3,
"Time" : 9
}
]
}
J'essaie de faire let
list
avec NSDictionnary qui ressemble à:
[[Time: 30, IdQuestion: 6510, idProposition: 10], [Time: 30, IdQuestion: 8284, idProposition: 10]]
et ma demande utilisant Alamofire ressemble à:
Alamofire.request(.POST, "http://myserver.com", parameters: ["IdQuiz":"102","IdUser":"iOSclient","User":"iOSClient","List":list ], encoding: .JSON)
.response { request, response, data, error in
let dataString = NSString(data: data!, encoding:NSUTF8StringEncoding)
println(dataString)
}
La demande a une erreur et je crois que le problème vient de la liste des dictionnaires, car si je fais une demande sans la liste, cela fonctionne bien, alors vous avez une idée?
J'ai essayé la solution suggérée mais je suis confronté au même problème:
let json = ["List":list,"IdQuiz":"102","IdUser":"iOSclient","UserInformation":"iOSClient"]
let data = NSJSONSerialization.dataWithJSONObject(json, options: NSJSONWritingOptions.PrettyPrinted,error:nil)
let jsons = NSString(data: data!, encoding: NSUTF8StringEncoding)
Alamofire.request(.POST, "http://myserver.com", parameters: [:], encoding: .Custom({
(convertible, params) in
var mutableRequest = convertible.URLRequest.copy() as! NSMutableURLRequest
mutableRequest.HTTPBody = jsons!.dataUsingEncoding(NSUTF8StringEncoding, allowLossyConversion: false)
return (mutableRequest, nil)
}))
.response { request, response, data, error in
let dataString = NSString(data: data!, encoding:NSUTF8StringEncoding)
println(dataString)
}
Tu es proche. La mise en forme du dictionnaire de paramètres ne semble pas correcte. Vous devriez essayer ce qui suit:
let parameters: [String: AnyObject] = [
"IdQuiz" : 102,
"IdUser" : "iosclient",
"User" : "iosclient",
"List": [
[
"IdQuestion" : 5,
"IdProposition": 2,
"Time" : 32
],
[
"IdQuestion" : 4,
"IdProposition": 3,
"Time" : 9
]
]
]
Alamofire.request(.POST, "http://myserver.com", parameters: parameters, encoding: .JSON)
.responseJSON { request, response, JSON, error in
print(response)
print(JSON)
print(error)
}
Espérons que cela corrige votre problème. Si ce n'est pas le cas, répondez et je modifierai ma réponse en conséquence.
Si vous utilisez Alamofire v4.0 +, la réponse acceptée ressemblera à ceci:
let parameters: [String: Any] = [
"IdQuiz" : 102,
"IdUser" : "iosclient",
"User" : "iosclient",
"List": [
[
"IdQuestion" : 5,
"IdProposition": 2,
"Time" : 32
],
[
"IdQuestion" : 4,
"IdProposition": 3,
"Time" : 9
]
]
]
Alamofire.request("http://myserver.com", method: .post, parameters: parameters, encoding: JSONEncoding.default)
.responseJSON { response in
print(response)
}
Je n’aime pas d’autres réponses jusqu’à présent (sauf peut-être la one de SwiftDeveloper), car elles nécessitent soit de désérialiser votre JSON, mais uniquement de le rediffuser, ou de s’occuper de la structure du JSON lui-même.
La bonne réponse a été publiée par afrodev dans une autre question. Tu devrais y aller.
Ci-dessous est juste mon adaptation, avec quelques changements mineurs (principalement un jeu de caractères UTF-8 explicite).
let urlString = "https://example.org/some/api"
let json = "{\"What\":\"Ever\"}"
let url = URL(string: urlString)!
let jsonData = json.data(using: .utf8, allowLossyConversion: false)!
var request = URLRequest(url: url)
request.httpMethod = HTTPMethod.post.rawValue
request.setValue("application/json; charset=UTF-8", forHTTPHeaderField: "Content-Type")
request.httpBody = jsonData
Alamofire.request(request).responseJSON {
(response) in
print(response)
}
Xcode 8.X, Swift 3.X
Utilisation facile;
let params:NSMutableDictionary? = [
"IdQuiz" : 102,
"IdUser" : "iosclient",
"User" : "iosclient",
"List": [
[
"IdQuestion" : 5,
"IdProposition": 2,
"Time" : 32
],
[
"IdQuestion" : 4,
"IdProposition": 3,
"Time" : 9
]
]
];
let ulr = NSURL(string:"http://myserver.com" as String)
let request = NSMutableURLRequest(url: ulr! as URL)
request.httpMethod = "POST"
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
let data = try! JSONSerialization.data(withJSONObject: params!, options: JSONSerialization.WritingOptions.prettyPrinted)
let json = NSString(data: data, encoding: String.Encoding.utf8.rawValue)
if let json = json {
print(json)
}
request.httpBody = json!.data(using: String.Encoding.utf8.rawValue);
Alamofire.request(request as! URLRequestConvertible)
.responseJSON { response in
// do whatever you want here
print(response.request)
print(response.response)
print(response.data)
print(response.result)
}
J'ai légèrement modifié la réponse de SwiftDeveloper , parce que cela ne fonctionnait pas pour moi. J'ai également ajouté la validation Alamofire.
let body: NSMutableDictionary? = [
"name": "\(nameLabel.text!)",
"phone": "\(phoneLabel.text!))"]
let url = NSURL(string: "http://server.com" as String)
var request = URLRequest(url: url! as URL)
request.httpMethod = "POST"
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
let data = try! JSONSerialization.data(withJSONObject: body!, options: JSONSerialization.WritingOptions.prettyPrinted)
let json = NSString(data: data, encoding: String.Encoding.utf8.rawValue)
if let json = json {
print(json)
}
request.httpBody = json!.data(using: String.Encoding.utf8.rawValue)
let alamoRequest = Alamofire.request(request as URLRequestConvertible)
alamoRequest.validate(statusCode: 200..<300)
alamoRequest.responseString { response in
switch response.result {
case .success:
...
case .failure(let error):
...
}
}
Si vous utilisez Swift4
et Alamofire v4.0
, le code accepté devrait ressembler à ceci:
let parameters: Parameters = [ "username" : email.text!, "password" : password.text! ]
let urlString = "https://api.harridev.com/api/v1/login"
let url = URL.init(string: urlString)
Alamofire.request(url!, method: .put, parameters: , encoding: JSONEncoding.default, headers: nil).responseJSON { response in
switch response.result
{
case .success(let json):
let jsonData = json as! Any
print(jsonData)
case .failure(let error):
self.errorFailer(error: error)
}
}
Il y a peu de changements que je voudrais signaler. Vous pouvez désormais accéder à la requête, JSON, erreur de l'objet réponse.
let urlstring = "Add URL String here"
let parameters: [String: AnyObject] = [
"IdQuiz" : 102,
"IdUser" : "iosclient",
"User" : "iosclient",
"List": [
[
"IdQuestion" : 5,
"IdProposition": 2,
"Time" : 32
],
[
"IdQuestion" : 4,
"IdProposition": 3,
"Time" : 9
]
]
]
Alamofire.request(.POST, urlstring, parameters: parameters, encoding: .JSON).responseJSON { response in
print(response.request) // original URL request
print(response.response) // URL response
print(response.data) // server data
print(response.result) // result of response serialization
if let JSON = response.result.value {
print("JSON: \(JSON)")
}
response.result.error
}
Voici comment j'ai créé une requête Http POST avec Swift qui nécessite des paramètres avec codage Json et des en-têtes.
API client créée BKCAPIClient en tant qu’instance partagée qui inclura tous les types de demandes telles que POST, GET, PUT, DELETE, etc.
func postRequest(url:String, params:Parameters?, headers:HTTPHeaders?, completion:@escaping (_ responseData:Result<Any>?, _ error:Error?)->Void){
Alamofire.request(url, method: .post, parameters: params, encoding: JSONEncoding.default, headers: headers).responseJSON {
response in
guard response.result.isSuccess,
(response.result.value != nil) else {
debugPrint("Error while fetching data: \(String(describing: response.result.error))")
completion(nil,response.result.error)
return
}
completion(response.result,nil)
}
}
Classe d'opération créée qui contient toutes les données nécessaires à une requête particulière et contient également une logique d'analyse à l'intérieur du bloc d'achèvement.
func requestAccountOperation(completion: @escaping ( (_ result:Any?, _ error:Error?) -> Void)){
BKCApiClient.shared.postRequest(url: BKCConstants().bkcUrl, params: self.parametrs(), headers: self.headers()) { (result, error) in
if(error != nil){
//Parse and save to DB/Singletons.
}
completion(result, error)
}
}
func parametrs()->Parameters{
return ["userid”:”xnmtyrdx”,”bcode":"HDF"] as Parameters
}
func headers()->HTTPHeaders{
return ["Authorization": "Basic bXl1c2VyOm15cGFzcw",
"Content-Type": "application/json"] as HTTPHeaders
}
API d'appel dans n'importe quel contrôleur de vue où nous avons besoin de ces données
func callToAPIOperation(){
let accOperation: AccountRequestOperation = AccountRequestOperation()
accOperation.requestAccountOperation{(result, error) in
}}
func get_Contact_list()
{
ApiUtillity.sharedInstance.showSVProgressHUD(text: "Loading..")
let cont_nunber = contact_array as NSArray
print(cont_nunber)
let token = UserDefaults.standard.string(forKey: "vAuthToken")!
let apiToken = "Bearer \(token)"
let headers = [
"Vauthtoken": apiToken,
"content-type": "application/json"
]
let myArray: [Any] = cont_nunber as! [Any]
let jsonData: Data? = try? JSONSerialization.data(withJSONObject: myArray, options: .prettyPrinted)
// var jsonString: String = nil
var jsonString = String()
if let aData = jsonData {
jsonString = String(data: aData, encoding: .utf8)!
}
let url1 = "URL"
var request = URLRequest(url: URL(string: url1)!)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = jsonData as! Data
// let session = URLSession.shared
let task = URLSession.shared.dataTask(with: request) { data, response, error in
guard let data = data, error == nil else {
print("error=\(String(describing: error))")
ApiUtillity.sharedInstance.dismissSVProgressHUD()
return
}
print("response = \(String(describing: response))")
let responseString = String(data: data, encoding: .utf8)
print("responseString = \(String(describing: responseString))")
let json = self.convertStringToDictionary(text: responseString!)! as NSDictionary
print(json)
let status = json.value(forKey: "status") as! Int
if status == 200
{
let array = (json.value(forKey: "data") as! NSArray).mutableCopy() as! NSMutableArray
}
else if status == 401
{
ApiUtillity.sharedInstance.dismissSVProgressHUD()
}
else
{
ApiUtillity.sharedInstance.dismissSVProgressHUD()
}
}
task.resume()
}
func convertStringToDictionary(text: String) -> [String:AnyObject]? {
if let data = text.data(using: String.Encoding.utf8) {
do {
let json = try JSONSerialization.jsonObject(with: data, options: .mutableContainers) as? [String:AnyObject]
return json
} catch {
print("Something went wrong")
}
}
return nil
}
Si quelqu'un se demande comment procéder avec des modèles et d'autres choses, voir ci-dessous
var itemArr: [Dictionary<String, String>] = []
for model in models {
let object = ["param1": model.param1,
"param2": model.param2]
itemArr.append(object as! [String : String])
}
let param = ["field1": someValue,
"field2": someValue,
"field3": itemArr] as [String : Any]
let url: URLConvertible = "http://------"
Alamofire.request(url, method: .post, parameters: param, encoding: JSONEncoding.default)
.responseJSON { response in
self.isLoading = false
switch response.result {
case .success:
break
case .failure:
break
}
}