Making a POST request in Swift

 
You should now have a web server up and running that accepts a POST call to /login. The server by default runs on port 4567, so now let’s create a Swift project to interact with it. A simple single-view project is fine for this example.

In your application didFinishLaunchingWithOptions method add the following:

func application(application: UIApplication!, didFinishLaunchingWithOptions launchOptions: NSDictionary!) -> Bool {
    var request = NSMutableURLRequest(URL: NSURL(string: "http://localhost:4567/login"))
    var session = NSURLSession.sharedSession()
    request.HTTPMethod = "POST"
    
    var params = ["username":"jameson", "password":"password"] as Dictionary<String, String>
    
    var err: NSError?
    request.HTTPBody = NSJSONSerialization.dataWithJSONObject(params, options: nil, error: &err)
    request.addValue("application/json", forHTTPHeaderField: "Content-Type")
    request.addValue("application/json", forHTTPHeaderField: "Accept")
    
    var task = session.dataTaskWithRequest(request, completionHandler: {data, response, error -> Void in
        println("Response: \(response)")
        var strData = NSString(data: data, encoding: NSUTF8StringEncoding)
        println("Body: \(strData)")
        var err: NSError?
        var json = NSJSONSerialization.JSONObjectWithData(data, options: .MutableLeaves, error: &err) as? NSDictionary
        
        // Did the JSONObjectWithData constructor return an error? If so, log the error to the console
        if(err != nil) {
            println(err!.localizedDescription)
            let jsonStr = NSString(data: data, encoding: NSUTF8StringEncoding)
            println("Error could not parse JSON: '\(jsonStr)'")
        }
        else {
            // The JSONObjectWithData constructor didn't return an error. But, we should still
            // check and make sure that json has a value using optional binding.
            if let parseJSON = json {
                // Okay, the parsedJSON is here, let's get the value for 'success' out of it
                var success = parseJSON["success"] as? Int
                println("Succes: \(success)")
            }
            else {
                // Woa, okay the json object was nil, something went worng. Maybe the server isn't running?
                let jsonStr = NSString(data: data, encoding: NSUTF8StringEncoding)
                println("Error could not parse JSON: \(jsonStr)")
            }
        }
    })
    
    task.resume()
    return true
}

First we create a request and a session to operate on.
Next, we set some params in a Swift dictionary, these values will be passed to the server.

Using dataWithJSONObject() we can encode our parameters as NSData, and set the HTTPBody of the request to this NSData object.

Next we add our headers stating we’re working with JSON using addValue()

Finally we instantiate a NSTask from the NSURLSession object with dataTaskWithRequest()

The last parameter of dataTaskWithRequest is a closure that contains values for the response, data, or error from our server.

After deserializing the response with JSONObjectWithData(), we can check json[“success”] for the 0 or 1 coming back from our server to see if the request succeeded, and process the results.

Most of this is just boilerplate, so it’s useless to move this all out in to a new function, we’ll call it post().

Move all the post logic out to this method, taking params and url as arguments.

func post(params : Dictionary<String, String>, url : String) {
    var request = NSMutableURLRequest(URL: NSURL(string: url))
    var session = NSURLSession.sharedSession()
    request.HTTPMethod = "POST"
    
    var err: NSError?
    request.HTTPBody = NSJSONSerialization.dataWithJSONObject(params, options: nil, error: &err)
    request.addValue("application/json", forHTTPHeaderField: "Content-Type")
    request.addValue("application/json", forHTTPHeaderField: "Accept")
    
    var task = session.dataTaskWithRequest(request, completionHandler: {data, response, error -> Void in
        println("Response: \(response)")
        var strData = NSString(data: data, encoding: NSUTF8StringEncoding)
        println("Body: \(strData)")
        var err: NSError?
        var json = NSJSONSerialization.JSONObjectWithData(data, options: .MutableLeaves, error: &err) as? NSDictionary
        
        // Did the JSONObjectWithData constructor return an error? If so, log the error to the console
        if(err != nil) {
            println(err!.localizedDescription)
            let jsonStr = NSString(data: data, encoding: NSUTF8StringEncoding)
            println("Error could not parse JSON: '\(jsonStr)'")
        }
        else {
            // The JSONObjectWithData constructor didn't return an error. But, we should still
            // check and make sure that json has a value using optional binding.
            if let parseJSON = json {
                // Okay, the parsedJSON is here, let's get the value for 'success' out of it
                var success = parseJSON["success"] as? Int
                println("Succes: \(success)")
            }
            else {
                // Woa, okay the json object was nil, something went worng. Maybe the server isn't running?
                let jsonStr = NSString(data: data, encoding: NSUTF8StringEncoding)
                println("Error could not parse JSON: \(jsonStr)")
            }
        }
    })
    
    task.resume()
}

Now our main logic can be greatly simplified for making any POST request. Let’s make a couple in the didFinishLaunching method.

func application(application: UIApplication!, didFinishLaunchingWithOptions launchOptions: NSDictionary!) -> Bool {
    
    // Correct url and username/password
    self.post(["username":"jameson", "password":"password"], url: "http://localhost:4567/login")
    
    // Correct url, incorrect password
    self.post(["username":"jameson", "password":"wrong_password"], url: "http://localhost:4567/login")
    
    // Incorrect url
    self.post(["username":"jameson", "password":"password"], url: "http://badurl.com/nonexistent")

    return true
}

In your console you should be able to see three login attempts, with only one of them succeeding. This is all great, but we should probably implement a way for the post request to notify our caller of a success or failure. Let’s add a Swift closure as a third method parameter to our post() function, so we can call it upon success or completion.

func post(params : Dictionary<String, String>, url : String, postCompleted : (succeeded: Bool, msg: String) -> ()) {

Now we have our new postCompleted closure, we can pass back to the caller whether or not the post request “succeeded”, and a string message to display to the user.

func post(params : Dictionary<String, String>, url : String, postCompleted : (succeeded: Bool, msg: String) -> ()) {
    var request = NSMutableURLRequest(URL: NSURL(string: url))
    var session = NSURLSession.sharedSession()
    request.HTTPMethod = "POST"
    
    var err: NSError?
    request.HTTPBody = NSJSONSerialization.dataWithJSONObject(params, options: nil, error: &err)
    request.addValue("application/json", forHTTPHeaderField: "Content-Type")
    request.addValue("application/json", forHTTPHeaderField: "Accept")
    
    var task = session.dataTaskWithRequest(request, completionHandler: {data, response, error -> Void in
        println("Response: \(response)")
        var strData = NSString(data: data, encoding: NSUTF8StringEncoding)
        println("Body: \(strData)")
        var err: NSError?
        var json = NSJSONSerialization.JSONObjectWithData(data, options: .MutableLeaves, error: &err) as? NSDictionary
        
        var msg = "No message"
        
        // Did the JSONObjectWithData constructor return an error? If so, log the error to the console
        if(err != nil) {
            println(err!.localizedDescription)
            let jsonStr = NSString(data: data, encoding: NSUTF8StringEncoding)
            println("Error could not parse JSON: '\(jsonStr)'")
            postCompleted(succeeded: false, msg: "Error")
        }
        else {
            // The JSONObjectWithData constructor didn't return an error. But, we should still
            // check and make sure that json has a value using optional binding.
            if let parseJSON = json {
                // Okay, the parsedJSON is here, let's get the value for 'success' out of it
                if let success = parseJSON["success"] as? Bool {
                    println("Succes: \(success)")
                    postCompleted(succeeded: success, msg: "Logged in.")
                }
                return
            }
            else {
                // Woa, okay the json object was nil, something went worng. Maybe the server isn't running?
                let jsonStr = NSString(data: data, encoding: NSUTF8StringEncoding)
                println("Error could not parse JSON: \(jsonStr)")
                postCompleted(succeeded: false, msg: "Error")
            }
        }
    })
    
    task.resume()
}

We’ll also need to modify how we call the method in our applicationDidFinishLaunching function.
The last parameter will now be a closure. Using Swift’s trailing closure syntax we can just end the post call with the block { }
Inside of this closure we create an UIAlertView control and populate it based on the succeeded and msg variables.
Then, we move back to a foreground thread and show the alert view.

func application(application: UIApplication!, didFinishLaunchingWithOptions launchOptions: NSDictionary!) -> Bool {
    
    // Correct url and username/password
    self.post(["username":"jameson", "password":"password"], url: "http://localhost:4567/login") { (succeeded: Bool, msg: String) -> () in
        var alert = UIAlertView(title: "Success!", message: msg, delegate: nil, cancelButtonTitle: "Okay.")
        if(succeeded) {
            alert.title = "Success!"
            alert.message = msg
        }
        else {
            alert.title = "Failed : ("
            alert.message = msg
        }
        
        // Move to the UI thread
        dispatch_async(dispatch_get_main_queue(), { () -> Void in
            // Show the alert
            alert.show()
        })
    }

    return true
}

Give it a whirl, and can now see a server logging in a user (or failing to) with some UI feedback. Cool right?

Try changing the login information and see what you get.

This is an overly simplistic server but I just wanted to demonstrate how you would go about making a POST request in Swift. I hope it was helpful!

The full source code to this project can be downloaded from Github here.

In my book I go in to much more detail, showing how to work with form data and chain API requests together.