Grundlegende Authentifizierung mit Alamofire

Question

Ein Problem beim Authentifizieren mit Basic Auth. Ich verwende ein Standard-Enum, das dem Protokoll URLRequestConvertible entspricht, um meine Anfragen zu erstellen. Das Problem ist, dass, wenn ich manuell die Berechtigungsüberschriften in der ENUM-Set wie so:

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

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

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

ich immer eine 401 nicht autorisierte Antwort. jedoch wenn stelle ich das Passwort des authenticate Rückruf wie so mit:

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

Es richtig authentifiziert. Ich möchte es in der enum entsprechend URLRequestConvertible manuell setzen können, anstatt die Berechtigungsnachweise in authenticate zu übergeben.

Ich weiß, es ist mit einem NSURLCredential unter der Haube für Auth Herausforderungen, aber ich möchte in der Lage sein, es manuell einzustellen.

Hier ist meine URLRequestConvertible Umsetzung:

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

letztlich herausgefunden, was das Problem war. Es wurde ein fehlender Schrägstrich in der URL gefunden. Es scheint, dass Alamofire es nicht so behandelt wie AFNetworking. Ich konnte es herausfinden, indem ich die Anfragen protokollierte und sah, dass wir einige Bytes in der tatsächlichen Anfrage verloren hatten.

Answer 2

Sie diesen Code versuchen:

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

In swift 3,0

Verwenden Sie folgende Code -

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 bietet einen noch einfacheren Ansatz als die eigenen Header manuell zu erstellen.

Das entsprechende Stück Code von "Grund Auth" Abschnitt 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 

GERADE