कैसे तेजी से बॉडी के साथ एक पोस्ट अनुरोध भेजने के लिए

Question

मैं Alamofire का उपयोग करते हुए तेजी से एक निकाय के साथ पोस्ट अनुरोध करने की कोशिश कर रहा हूं।

मेरा शरीर कैसा दिखता है:

{
    "IdQuiz" : 102,
    "IdUser" : "iosclient",
    "User" : "iosclient",
    "List":[
        {
        "IdQuestion" : 5,
        "IdProposition": 2,
        "Time" : 32
        },
        {
        "IdQuestion" : 4,
        "IdProposition": 3,
        "Time" : 9
        }
    ]
}

मैं let listNSDictionnary के साथ बनाने की कोशिश कर रहा हूँ, जो इस तरह दिखता है:

[[Time: 30, IdQuestion: 6510, idProposition: 10], [Time: 30, IdQuestion: 8284, idProposition: 10]]

और अल्मोफायर का उपयोग करने का मेरा अनुरोध इस तरह दिखता है:

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)
        }

अनुरोध में त्रुटि है और मेरा मानना ​​है कि समस्या शब्दकोश सूची के साथ है, यदि मैं सूची के बिना अनुरोध करता हूं तो यह ठीक काम करता है, इसलिए कोई विचार?

---

मैंने सुझाए गए समाधान की कोशिश की है लेकिन मैं उसी समस्या का सामना कर रहा हूं:

 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)
    }

Comments

Alamofire के साथ शरीर में एक साधारण स्ट्रिंग के साथ POST अनुरोध के

— EI Captain v2.0

आपकी टिप्पणी के लिए धन्यवाद, लेकिन आपके द्वारा प्रदान की गई पोस्ट मदद नहीं करती है, और मैं शरीर के रूप में एक स्ट्रिंग को पारित करने की कोशिश नहीं कर रहा हूं, तो क्या आप कृपया पोस्ट को ध्यान से पढ़ सकते हैं

— अजनबी बी।

@YasserB। अपने JSON को NSString में परिवर्तित करें (उस के लिए विधि है), और फिर @Bhavin के लिंक का उपयोग करें?

— लारमे अगे

@ यदि आप एक उदाहरण प्रदान करते हैं तो यह वास्तव में उपयोगी होगा

— अजनबी बी।

@Larme मैंने सुझाए गए समाधान की कोशिश की है, लेकिन मेरे पास एक ही समस्या है अनुरोध अनुरोध काम नहीं करता है जब तक कि मैं बेटे के शरीर से सूची को नहीं हटाता हूं

— अजनबी बी।

Answer 1

तुम पास हो। पैरामीटर शब्दकोश स्वरूपण सही नहीं लगता है। आपको निम्नलिखित प्रयास करना चाहिए:

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)
    }

उम्मीद है कि अपने मुद्दे को तय किया। यदि ऐसा नहीं होता है, तो कृपया उत्तर दें और मैं अपने उत्तर को तदनुसार समायोजित करूंगा।

Comments

मैं कैसे, के बाद से मैं नहीं सौंप सकते अशक्त करने के लिए अपने JSON के कुछ गुण सेट करते हैं nilकरने के लिए AnyObject?

— आमप तनावत

@ जसेमअब्बास आलमोफायर के अपने संस्करण की जाँच करें, यदि आप v4.0 पर हैं + तो नीचे दिए गए मेरे उत्तर की जाँच करें

— Gianni Carlo

केस एन्कोडिंग में इस प्रकार के पैरामीटर को कैसे भेजा जाए .urlEncoding

— प्रमोद शुक्ला

अपेक्षित शब्दकोश मान 'AnyObject' में 'Int' प्रकार के मान को परिवर्तित नहीं कर सकते हैं

— myatmins

कैसे करें यदि मान लें कि "सूची" के पैरामीटर्स का मूल्य 1000 सूची तत्वों की तरह है?

— निषाद अरोरा

Answer 2

यदि आप Alamofire v4.0 + का उपयोग कर रहे हैं, तो स्वीकृत उत्तर इस तरह दिखेगा:

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)
    }

Comments

महान! कृपया इसे स्वीकार किए गए उत्तर को बदल दें! :) या दोनों Alamofire 3 और 4 समाधान के लिए वर्तमान एक के साथ गठबंधन।

— टॉम वैन ज़ुमेरन 12

सहमत - यह स्पष्ट JSONEncodingप्रकार है कि यह मेरे लिए किया था की तरह नापसंद है।

— थॉमस वर्बीक

@ गियानी कार्लो मैं आपके उत्तर के रूप में एक ही इस्तेमाल करता था लेकिन मेरी सफलता की प्रतिक्रिया में मुझे त्रुटियां मिल रही हैं।

— रामकृष्ण

@ रामकृष्ण जो आपके द्वारा उपयोग किए जा रहे एपीआई से संबंधित हो सकते हैं। प्रतिक्रिया को पार्स करने के लिए मैं आमतौर पर SwiftyJSON लाइब्रेरी का उपयोग करता हूं, मुझे बताएं कि आपको किस तरह की त्रुटियां मिल रही हैं

— Gianni Carlo

आपके जवाब के लिए धन्यवाद। मुझे हल मिल गया।

— रामकृष्ण

Answer 3

मैं अब तक किसी भी अन्य उत्तर को पसंद नहीं करता हूं (शायद स्विफ्टड्यूपर द्वारा एक को छोड़कर), क्योंकि उन्हें या तो आपको अपने JSON को डीरिशियल करना होगा, केवल इसके लिए फिर से क्रमबद्ध होना होगा, या खुद JSON की संरचना की परवाह करना होगा।

सही उत्तर को दूसरे प्रश्न में afrodev द्वारा पोस्ट किया गया है। आपको इसे बढ़ा-चढ़ाकर पेश करना चाहिए।

नीचे कुछ मामूली बदलाव (मुख्य रूप से स्पष्ट UTF-8 चारसेट) के साथ सिर्फ मेरा अनुकूलन है।

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)
}

Comments

मैं इस बात से सहमत हूं कि @ SwiftDeveloper का उत्तर बेहतर है और (मेरे विचार से) आपके द्वारा उल्लेखित 'सही' की तुलना में अधिक पूर्ण। लेकिन मैं दो बिंदुओं पर बहस करूंगा। एक, कि आपके द्वारा उल्लेखित 'सही उत्तर' में वह दोष है जो toJSONStringएक देशी विधि नहीं है, इसलिए यह मूल रूप से एक ब्लैक बॉक्स है जिसे आपको लागू करना है। दो, आप जो उत्तर देते हैं, वह एक संस्करण प्रदान करता है, jsonजो एक जस स्ट्रिंग के रूप में शुरू होता है, वास्तविक रूप से किसी के पास इस तरह के पैरामीटर नहीं होते हैं, जब तक कि आप उन्हें स्थानीय रूप से परिवर्तित और संग्रहीत नहीं कर रहे हैं।

— गियान्नी कार्लो

@GianniCarlo 1) toJSONStringमेरे उत्तर में कोई नहीं है, 2) "वास्तविक रूप से किसी के पास इस तरह के पैरामीटर नहीं हैं" - जो बहुत सारी धारणाएं बना रहा है; JSON ऐप के बिल्कुल अलग हिस्सों से आ सकता है, जो अनुरोध करने से संबंधित नहीं है, और जिसमें से नेटवर्किंग कोड कुछ भी नहीं जानता है।

— तिब्बत का समुद्री तट

मेरे जीवन को आसान बनाने के लिए धन्यवाद !!! 1 I मैं फ्लास्क बैकएंड के साथ अल्मोफायर का उपयोग कर रहा हूं। पोस्टमैन से सब कुछ अच्छा हुआ। लेकिन अलमॉफायर से यह काम नहीं करता है। HTTP बॉडी और URL पैरामीटर और उन्हें कैसे सेट करें। एक बार फिर धन्यवाद।

— विनील

Answer 4

Xcode 8.X, स्विफ्ट 3.X

आसान उपयोग;

    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)

            }

Answer 5

यदि आप उपयोग कर रहे हैं swift4और Alamofire v4.0फिर स्वीकृत कोड इस तरह दिखेगा:

            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: 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)
                }
            }

Answer 6

Xcode 11 में स्वीकृत उत्तर - स्विफ्ट 5 - एलामोफायर 5.0

func postRequest() {
    let parameters: [String: Any] = [
        "IdQuiz" : 102,
        "IdUser" : "iosclient",
        "User" : "iosclient",
        "List": [
            [
                "IdQuestion" : 5,
                "IdProposition": 2,
                "Time" : 32
            ],
            [
                "IdQuestion" : 4,
                "IdProposition": 3,
                "Time" : 9
            ]
        ]
    ]
    AF.request("http://myserver.com", method:.post, parameters: parameters,encoding: JSONEncoding.default) .responseJSON { (response) in
        print(response)
    }
}

Answer 7

मैंने SwiftDeveloper के उत्तर को थोड़ा संपादित किया है , क्योंकि यह मेरे लिए काम नहीं कर रहा था। मैंने आलमोफायर सत्यापन को भी जोड़ा।

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):
            ...
    }
}

Comments

अभी भी Alamofire 4.9.1 और Swift 5.1 में काम करता है। बहुत सराहना की

— अबे

Answer 8

कुछ बदलाव हैं जिन्हें मैं सूचित करना चाहूंगा। आप अनुरोध ऑब्जेक्ट, JSON, अब से प्रतिक्रिया ऑब्जेक्ट से त्रुटि तक पहुँच सकते हैं।

        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
        }

Answer 9

POST, Parameter और Headers के साथ Alamofire Fetch data

func feedbackApi(){
    DispatchQueue.main.async {
        let headers = [
            "Content-Type": "application/x-www-form-urlencoded",
            "Authorization": "------"
        ]
        let url = URL(string: "---------")
        var parameters = [String:AnyObject]()
        parameters =  [
            "device_id":"-----" as AnyObject,
            "user_id":"----" as AnyObject,
            "cinema_id":"-----" as AnyObject,
            "session_id":"-----" as AnyObject,
        ]
       Alamofire.request(url!, method: .post, parameters: parameters,headers:headers).responseJSON { response in
                switch response.result{
                case.success(let data):
                    self.myResponse = JSON(data)
                    print(self.myResponse as Any)
                    let slide = self.myResponse!["sliders"]
                    print(slide)
                    print(slide.count)
                    for i in 0..<slide.count{
                        let single = Sliders(sliderJson: slide[i])
                        self.slidersArray.append(single)
                    }
                    DispatchQueue.main.async {
                        self.getSliderCollection.reloadData()
                    }
                case .failure(let error):
                    print("dddd",error)
                }

        }
    }

}

Answer 10

यहां बताया गया है कि मैंने कैसे स्विफ्ट के साथ Http POST अनुरोध बनाया है जिसमें Json एन्कोडिंग और हेडर के साथ मापदंडों की आवश्यकता होती है।

एक साझा उदाहरण के रूप में बनाया गया API क्लाइंट BKCAPICient जिसमें सभी प्रकार के अनुरोध जैसे POST, GET, PUT, DELETE आदि शामिल होंगे।

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)
    }
}

बनाया गया ऑपरेशन क्लास जिसमें विशेष अनुरोध के लिए आवश्यक सभी डेटा होते हैं और पूर्ण ब्लॉक के अंदर पार्सिंग लॉजिक भी होता है।

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 को किसी भी व्‍यवस्‍थापक में कॉल करें जहां हमें इस डेटा की आवश्‍यकता है

func callToAPIOperation(){
let accOperation: AccountRequestOperation = AccountRequestOperation()
accOperation.requestAccountOperation{(result, error) in

}}

Answer 11

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
}

Answer 12

यदि कोई सोच रहा है कि मॉडल और सामान के साथ कैसे आगे बढ़ना है, तो नीचे देखें

        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
                }
        }

Answer 13

अल्मोफायर ~ 5.2 और स्विफ्ट 5

आप अपने पैरामीटर डेटा को संरचित कर सकते हैं

नकली जोंस आपी के साथ काम करें

struct Parameter: Encodable {
     let token: String = "xxxxxxxxxx"
     let data: Dictionary = [
        "id": "personNickname",
        "email": "internetEmail",
        "gender": "personGender",
     ]
}

 let parameters = Parameter()

 AF.request("https://app.fakejson.com/q", method: .post, parameters: parameters).responseJSON { response in
            print(response)
        }