it-swarm.com.de

Grundlegende Authentifizierung mit Alamofire

Bei der Authentifizierung mit Basic Auth tritt ein Problem auf. Ich verwende ein Standard-Enum, das dem URLRequestConvertible-Protokoll entspricht, um meine Anforderungen zu erstellen. Das Problem ist, dass, wenn ich die Berechtigungsheader wie folgt manuell in der Aufzählung setze:

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

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

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

Ich bekomme immer eine 401 nicht autorisierte Antwort. Allerdings wenn ich das Passwort mit dem authenticate Callback so setze:

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

Es authentifiziert sich richtig. Ich möchte es in der Lage haben, es manuell in der Aufzählung entsprechend URLRequestConvertible einzustellen, anstatt die Berechtigungsnachweise in authenticate zu übergeben.

Ich weiß, dass es eine NSURLCredential unter der Haube für auth-Herausforderungen verwendet, aber ich möchte es gerne manuell einstellen.

Hier ist meine URLRequestConvertible Implementierung:

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 = "[email protected]"
        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
        }
    }
}

Letztendlich herausgefunden, was das Problem war. Am Ende fehlte der nachgestellte Schrägstrich in der URL. Es scheint, dass Alamofire nicht so mit AFNetworking umgeht. Ich konnte herausfinden, wie ich die Anfragen protokollierte und sah, dass wir in der eigentlichen Anfrage einige Bytes verloren.

In Swift 3.0

Verwenden Sie folgenden 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{

            }
    }
19
be.with.veeresh

Sie können diesen Code ausprobieren:

    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)
            }
    }
11
Pheaktra Ty
Alamofire.request(urlString, method: .get).authenticate(user: "username", password: "pwd").responseJSON

NUR authentifizieren

9
Badre

Swift 4

private func getHeaders() -> [String: String] {
        let userName = "xxxx"
        let password = "xxxx"
        let credentialData = "\(userName):\(password)".data(using: .utf8)
        guard let cred = credentialData else { return ["" : ""] }
        let base64Credentials = cred.base64EncodedData(options: [])
        guard let base64Date = Data(base64Encoded: base64Credentials) else { return ["" : ""] }
        return ["Authorization": "Basic \(base64Date.base64EncodedString())"]
    }
1
Rajesh Panda

Alamofire bietet einen noch einfacheren Ansatz als das manuelle Erstellen eigener Header.

Der entsprechende Code aus dem Abschnitt "Basic Auth" hier :

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