Autenticazione di base con Alamofire

Question

Vivere un problema durante l'autenticazione con l'autenticazione di base. Sto usando un enum standard conforme al protocollo URLRequestConvertible per costruire le mie richieste. Il problema è che quando ho impostato manualmente le intestazioni di autorizzazione nel enum in questo modo:

let user = *** 
    let password = *** 

    let credentialData = "\(user):\(password)".dataUsingEncoding(NSUTF8StringEncoding)! 
    let base64Credentials = credentialData.base64EncodedStringWithOptions([]) 

    mutableURLRequest.setValue("Basic \(base64Credentials)", forHTTPHeaderField: "Authorization") 

Ho sempre trovato una risposta non autorizzati 401. Tuttavia se impostare la password utilizzando il authenticate richiamata in questo modo:

Alamofire.request(request) 
     .authenticate(user: "USERNAME_HERE", password: "PASSWORD_HERE") 
     .responseJSON { (response) -> Void in 
      print("JSON response \(response)") 
      completion(success: true, error: nil) 
    } 

Autentica correttamente. Vorrei essere in grado di impostarlo manualmente nell'enum conforme a URLRequestConvertible anziché passare le credenziali in authenticate.

So che sta usando un NSURLCredential sotto il cofano per sfide autentiche, ma mi piacerebbe poterlo impostare manualmente.

Ecco il mio URLRequestConvertible implementazione:

enum CheckedUpAPI: URLRequestConvertible { 
    static let baseURLString = "https://***" 
    static let APIKey = "***" 
    static let APIClientName = "iPad" 


    case UpdatePatient(String, [String: AnyObject]) 


    var method: Alamofire.Method { 
     switch self { 
     case .UpdatePatient: 
      return .PATCH 
     } 
    } 

    var path: String { 
     switch self { 
     case .UpdatePatient(let patientID, _): 
      return "patients/\(patientID)" 
     } 
    } 

    // MARK: URLRequestConvertible 

    var URLRequest: NSMutableURLRequest { 
     let URL = NSURL(string: CheckedUpAPI.baseURLString)! 
     let mutableURLRequest = NSMutableURLRequest(URL: URL.URLByAppendingPathComponent(path)) 
     mutableURLRequest.HTTPMethod = method.rawValue 


/** 
     We are not setting any authorization headers since they requests return 401 
     the `authenticate` function on Alamofire.request does the trick 

     let user = "easy@test.com" 
     let password = "test" 

     let credentialData = "\(user):\(password)".dataUsingEncoding(NSUTF8StringEncoding)! 
     let base64Credentials = credentialData.base64EncodedStringWithOptions([]) 

     mutableURLRequest.setValue("Basic \(base64Credentials)", forHTTPHeaderField: "Authorization") 
*/ 
     mutableURLRequest.setValue(CheckedUpAPI.APIKey, forHTTPHeaderField: "API-Key") 

     switch self { 
     case .UpdatePatient(_, let parameters): 
      return Alamofire.ParameterEncoding.JSON.encode(mutableURLRequest, parameters: parameters).0 
     } 
    } 
} 

Answer 1

definitiva capito cosa il problema era. Finì per essere una mancanza di una barra in discesa nell'URL. Sembra che Alamofire non la gestisca allo stesso modo di AFNetworking. Sono stato in grado di capire come registrare le richieste e vedere che stavamo perdendo alcuni byte nella richiesta effettiva.

Answer 2

Si può provare questo codice:

let user = *** 
    let password = *** 
    let credentialData = "\(user):\(password)".dataUsingEncoding(NSUTF8StringEncoding)! 
    let base64Credentials = credentialData.base64EncodedStringWithOptions([]) 
    let headers = ["Authorization": "Basic \(base64Credentials)"] 

Alamofire.manager.request(.GET, stringURL,headers: headers, parameters: params as? [String : AnyObject]) 
     .responseJSON { response in 
      if (response.result.error == nil){ 
       success(data: response.result.value) 
      }else{ 
       fail(error: response.result.error) 
      } 
    } 

Answer 3

a Swift 3,0

Usa seguente codice -

let user = *** 
    let password = *** 
    let credentialData = "\(user):\(password)".data(using: String.Encoding.utf8)! 
    let base64Credentials = credentialData.base64EncodedString(options: []) 
    let headers = ["Authorization": "Basic \(base64Credentials)"] 

    Alamofire.request(customerURL, 
         method: .get, 
         parameters: nil, 
         encoding: URLEncoding.default, 
         headers:headers) 
     .validate() 
     .responseJSON { response in 
      if response.result.value != nil{      
       print(response) 
      }else{ 

      } 
    } 

Answer 4

Alamofire fornisce un approccio ancora più facile che creare manualmente i propri intestazioni.

Il pezzo rilevante di codice da "Basic Auth" sezione here:

manager.request(.GET, "https://api.parse.com/1/classes/Spot/") 
    .authenticate(user: username, password: password) 
    .responseSpotsArray { response in 
     completionHandler(response.result) 
    } 

Answer 5

Alamofire.request(urlString, method: .get).authenticate(user: "username", password: "pwd").responseJSON 

limita a autenticare