Wie erneuern der access token mit der refresh-token?

Diese Frage ist nicht doppelte AN ALLE. Ich hoffe, dass dies anderen helfen, nicht zu verbringen Tage, die ich verbracht haben.

Nach fast 4 Tagen habe ich herausgefunden, wie man eine frische access token in die google-api mit OWIN.

Werde ich die Lösung posten, aber zuerst MUSS ich sagen, dass das, was mir geholfen hat, starten Sie bekommen eine Ahnung, mein Fehler war das einrichten der Debug-Symbole für das Katana-Projekt. Finden Sie unter diesem link:
http://www.symbolsource.org/Public/Home/VisualStudio

Diesem Bild veranschaulichen die Konfiguration von Debug-Symbolen-Server.

Und dieser zeigt den Katana-Debug-Symbole geladen.

Danach fand ich heraus, dass mein problem war, dass Google-API war die Rückkehr 403: Forbidden

"Zugriff Nicht Konfiguriert. Bitte verwenden Sie Google Entwickler-Konsole zur Aktivierung der API für Ihr Projekt"

Dann, gefunden auf stack overflow diesen Beitrag:
"Zugriff Nicht Konfiguriert. Bitte verwenden Sie Google Entwickler-Konsole zur Aktivierung der API für Ihr Projekt."

genauer gesagt diese Antwort: https://stackoverflow.com/a/24401189/833846

Danach ging ich zu Google Entwickler-Konsole und setup von Google+ API

Dann, voillá! Es arbeitete.

Nun der code, um einen frischen Zugang token mit der refresh-token (ich habe nicht gefunden, einen Weg, um zu erreichen, dass Sie mit der OWIN-API).

public static class TokenValidator
{
    ///<summary>
    ///Obtém um novo access token na API do google.
    ///</summary>
    ///<param name="clientId"></param>
    ///<param name="clientSecret"></param>
    ///<param name="refreshToken"></param>
    ///<returns></returns>
    public static GoogleRefreshTokenModel ValidateGoogleToken(string clientId, string clientSecret, string refreshToken)
    {
        const string url = "https://accounts.google.com/o/oauth2/token";

        var parameters = new List<KeyValuePair<string, string>>
        {
            new KeyValuePair<string, string>("client_id", clientId),
            new KeyValuePair<string, string>("client_secret", clientSecret),
            new KeyValuePair<string, string>("grant_type", "refresh_token"),
            new KeyValuePair<string, string>("refresh_token", refreshToken)
        };

        var content = GetContentAsync(url, "POST",  parameters);

        var token = JsonConvert.DeserializeObject<GoogleRefreshTokenModel>(content);

        return token;
    }

    private static string GetContentAsync(string url, 
        string method = "POST",
        IEnumerable<KeyValuePair<string, string>> parameters = null)
    {
        return method == "POST" ? PostAsync(url, parameters) : GetAsync(url, parameters);
    }

    private static string PostAsync(string url, IEnumerable<KeyValuePair<string, string>> parameters = null)
    {
        var uri = new Uri(url);

        var request = WebRequest.Create(uri) as HttpWebRequest;
        request.Method = "POST";
        request.KeepAlive = true;
        request.ContentType = "application/x-www-form-urlencoded";

        var postParameters = GetPostParameters(parameters);

        var bs = Encoding.UTF8.GetBytes(postParameters);
        using (var reqStream = request.GetRequestStream())
        {
            reqStream.Write(bs, 0, bs.Length);
        }

        using (var response = request.GetResponse())
        {
            var sr = new StreamReader(response.GetResponseStream());
            var jsonResponse = sr.ReadToEnd();
            sr.Close();

            return jsonResponse;
        }
    }

    private static string GetPostParameters(IEnumerable<KeyValuePair<string, string>> parameters = null)
    {
        var postParameters = string.Empty;
        foreach (var parameter in parameters)
        {
            postParameters += string.Format("&{0}={1}", parameter.Key,
                HttpUtility.HtmlEncode(parameter.Value));
        }
        postParameters = postParameters.Substring(1);

        return postParameters;
    }

    private static string GetAsync(string url, IEnumerable<KeyValuePair<string, string>> parameters = null)
    {
        url += "?" + GetQueryStringParameters(parameters);

        var forIdsWebRequest = WebRequest.Create(url);
        using (var response = (HttpWebResponse)forIdsWebRequest.GetResponse())
        {
            using (var data = response.GetResponseStream())
            using (var reader = new StreamReader(data))
            {
                var jsonResponse = reader.ReadToEnd();

                return jsonResponse;
            }
        }
    }

    private static string GetQueryStringParameters(IEnumerable<KeyValuePair<string, string>> parameters = null)
    {
        var queryStringParameters = string.Empty;
        foreach (var parameter in parameters)
        {
            queryStringParameters += string.Format("&{0}={1}", parameter.Key,
                HttpUtility.HtmlEncode(parameter.Value));
        }
        queryStringParameters = queryStringParameters.Substring(1);

        return queryStringParameters;
    }
}

WICHTIGEN 1: Um einen refresh-token müssen Sie die "access_type" zu "offline" in der "ExecuteResult" - Methode, auf diese Weise:

properties.Dictionary["access_type"] = "offline";

WICHTIGE 2: Sobald Sie Ihre refresh-token, müssen Sie es speichern, und in einigen sicheren Quelle. Google-API nicht Problem Sie ein neues refresh token, es sei denn, Sie "approval_prompt" zu "zwingen" rufen Sie vor der Zeile (in der gleichen Methode):

context.HttpContext.GetOwinContext().Authentication.Challenge(properties, LoginProvider);

Ich empfehle auch einen Blick auf:

Google-API, Offline-Zugriff

Google OAUTH 2.0 Playground

Google API-Discovery-Check

InformationsquelleAutor der Antwort Marco Alves