JSON Service With Basic Authentication

gistfile1.swift

//
//  JSONService.swift
//  SwiftPlaces
//
//  Created by Joshua Smith on 7/25/14.
//  Copyright (c) 2014 iJoshSmith. All rights reserved.
//

import Foundation

/** A simple HTTP client for fetching JSON data. */
class JSONService
{
    /** Prepares a GET request for the specified URL. */
    class func GET(url: NSURL, user: String, password: String) -> SuccessHandler
    {
        let service = JSONService("GET", url, user, password)
        service.successHandler = SuccessHandler(service: service)
        return service.successHandler!
    }
    
    private init(_ name: String, _ url: NSURL, _ user: String, _ password: String)
    {
        self.name = name
        self.url  = url
        self.usuario = user
        self.senha = password
    }
    
    class SuccessHandler
    {
        func success(
            closure: (json: AnyObject) -> (), // Array or dictionary
            queue:   NSOperationQueue? ) // Background queue by default
            -> ErrorHandler
        {
            self.closure = closure
            self.queue = queue
            service.errorHandler = ErrorHandler(service: service)
            return service.errorHandler!
        }
        
        private init(service: JSONService)
        {
            self.service = service
            closure = { (_) in return }
        }
        
        private var
        closure: (json: AnyObject) -> (),
        queue:   NSOperationQueue?,
        service: JSONService
    }
    
    class ErrorHandler
    {
        func failure(
            closure: (statusCode: Int, error: NSError?) -> (),
            queue:   NSOperationQueue? ) // Background queue by default
        {
            self.closure = closure
            self.queue = queue
            service.execute()
        }
        
        private init(service: JSONService)
        {
            self.service = service
            closure = { (_,_) in return }
        }
        
        private var
        closure: (statusCode: Int, error: NSError?) -> (),
        queue:   NSOperationQueue?,
        service: JSONService
    }
    
    private func execute()
    {
        let request = NSMutableURLRequest(URL: url)
        request.HTTPMethod = name
        let loginString = NSString(format: "%@:%@", usuario, senha)
        let loginData: NSData = loginString.dataUsingEncoding(NSUTF8StringEncoding)!
        let base64LoginString = loginData.base64EncodedDataWithOptions(nil)
        request.setValue("Basic \(base64LoginString)", forHTTPHeaderField: "Authorization")
        NSURLSession.sharedSession().dataTaskWithRequest(request)
        {
            [weak self]
            data, response, error in
            
            // Reference self strongly via `this`
            if let this = self
            {
                var statusCode = 0
                if let httpResponse = response as? NSHTTPURLResponse
                {
                    statusCode = httpResponse.statusCode
                }
                
                var json: AnyObject?, jsonError: NSError?
                switch JSONObjectWithData(data)
                {
                    case .Success(let res): json = res
                    case .Failure(let err): jsonError = err
                }
                this.handleResult(json, error ?? jsonError, statusCode)
            }
        }.resume()
    }
    
    private func handleResult(json: AnyObject?, _ error: NSError?, _ statusCode: Int)
    {
        if json != nil
        {
            let handler  = successHandler!
            let success  = { handler.closure(json: json!) }
            if let queue = handler.queue { queue.addOperationWithBlock(success) }
            else                         { success() }
        }
        else
        {
            let handler  = errorHandler!
            let failure  = { handler.closure(statusCode: statusCode, error: error) }
            if let queue = handler.queue { queue.addOperationWithBlock(failure) }
            else                         { failure() }
        }
        
        // Break the retain cycles keeping this object graph alive.
        errorHandler = nil
        successHandler = nil
    }
    
    private var
    errorHandler:   ErrorHandler?,
    successHandler: SuccessHandler?
    
    private let
    name: String,
    url:  NSURL,
    usuario: String,
    senha: String
}

func buscaUsuario(){
        let loginString = NSString(format: "%@:%@", user, senha)
        let loginData: NSData = loginString.dataUsingEncoding(NSUTF8StringEncoding)!
        let base64LoginString = loginData.base64EncodedStringWithOptions(nil)

        let url = NSURL(string: "https://api.github.com/search/users?q=\(search)")

        JSONService.GET(url!).success(self.teste, queue: nil) .failure(testeError, queue: NSOperationQueue.mainQueue())
    }

    func teste(json:AnyObject){
        self.data = json as! NSDictionary
        println(data)
    }

    func testeError(statusCode: Int, error: NSError?){

    }

Para autenticação síncrona eu montei esse aqui, funcionou bem comigo:

func getData (url: String) -> NSData? {
        // set up the base64-encoded credentials
        let username = "user"
        let password = "pass"
        let loginString = NSString(format: "%@:%@", username, password)
        let loginData: NSData = loginString.dataUsingEncoding(NSUTF8StringEncoding)!
        let base64LoginString = loginData.base64EncodedStringWithOptions(nil)

        // create the request
        let url2 = NSURL(string: url)
        let request = NSMutableURLRequest(URL: url2!)
        request.HTTPMethod = "GET"
        request.setValue("Basic \(base64LoginString)", forHTTPHeaderField: "Authorization")

        var response: NSURLResponse?; var error: NSError?
        let data: NSData? = NSURLConnection.sendSynchronousRequest(request, returningResponse: &response, error: &error)
        return data
}