Erhalten Sie Benutzerinformationen über die Google API

Ist es möglich, Informationen aus dem Nutzerprofil über die Google-API abzurufen? Wenn es möglich ist, welche API soll ich verwenden?

Ich bin an solchen Informationen interessiert:

• URL zum Benutzerprofil (z. B. https://profiles.google.com/115063121183536852887 );
• Geschlecht (Geschlecht);
• Profilfoto.

Es wäre auch cool, andere Informationen aus dem Benutzerprofil zu erhalten.

Fügen Sie dies dem Bereich hinzu - https://www.googleapis.com/auth/userinfo.profile

Nach Abschluss der Autorisierung erhalten Sie die Informationen unter - https://www.googleapis.com/oauth2/v1/userinfo?alt=json

Es hat eine Menge Dinge - einschließlich Name, URL des öffentlichen Profils, Geschlecht, Foto usw.

Umfang - https://www.googleapis.com/auth/userinfo.profile

return youraccess_token = access_token

Holen Sie sich https://www.googleapis.com/oauth2/v1/userinfo?alt=json&access_token=youraccess_token

Sie werden json bekommen:

{
 "id": "xx",
 "name": "xx",
 "given_name": "xx",
 "family_name": "xx",
 "link": "xx",
 "picture": "xx",
 "gender": "xx",
 "locale": "xx"
}

Zu Tahir Yasin:

Dies ist ein PHP-Beispiel.
Sie können die Funktion json_decode verwenden, um das userInfo-Array abzurufen.

$q = 'https://www.googleapis.com/oauth2/v1/userinfo?access_token=xxx';
$json = file_get_contents($q);
$userInfoArray = json_decode($json,true);
$googleEmail = $userInfoArray['email'];
$googleFirstName = $userInfoArray['given_name'];
$googleLastName = $userInfoArray['family_name'];

Dieser Bereich https://www.googleapis.com/auth/userinfo.profile ist jetzt veraltet. Bitte besuchen Sie https://developers.google.com/+/api/auth-migration#timetable .

Der neue Bereich, den Sie zum Abrufen von Profilinformationen verwenden, ist: profile oder https://www.googleapis.com/auth/plus.login

und der Endpunkt ist - https://www.googleapis.com/plus/v1/people/ {userId} - userId kann nur "ich" für den aktuell angemeldeten Benutzer sein.

Ich benutze PHPund löste dies mit der Version 1.1.4 von Google-API-PHP-Client

Angenommen, der folgende Code wird verwendet, um einen Nutzer zur Google-Authentifizierungsseite umzuleiten:

 $client = new Google_Client();
 $client->setAuthConfigFile('/path/to/config/file/here');
 $client->setRedirectUri('https://redirect/url/here');
 $client->setAccessType('offline'); //optional
 $client->setScopes(['profile']); //or email
 $auth_url = $client->createAuthUrl();
 header('Location: ' . filter_var($auth_url, FILTER_SANITIZE_URL));
 exit();

Angenommen, ein gültiger Authentifizierungscode wird an zurückgegeben, redirect_urlgeneriert das Folgende ein Token aus dem Authentifizierungscode und stellt grundlegende Profilinformationen bereit:

 //assuming a successful authentication code is return
 $authentication_code = 'code-returned-by-google';
 $client = new Google_Client();
 //.... configure $client object code goes here
 $client->authenticate($authentication_code);
 $token_data = $client->getAccessToken();

 //get user email address
 $google_oauth =new Google_Service_Oauth2($client);
 $google_account_email = $google_oauth->userinfo->get()->email;
 //$google_oauth->userinfo->get()->familyName;
 //$google_oauth->userinfo->get()->givenName;
 //$google_oauth->userinfo->get()->name;
 //$google_oauth->userinfo->get()->gender;
 //$google_oauth->userinfo->get()->picture; //profile picture

Der Standort wird jedoch nicht zurückgegeben. Neue YouTube-Konten haben keine YouTube-spezifischen Benutzernamen

Ich verwende die Google-API für .Net, aber ohne Zweifel können Sie den gleichen Weg finden, um diese Informationen mit einer anderen API-Version zu erhalten. Wie bereits erwähnt, ist der Bereich userinfo.profile veraltet ( Google-Artikel) ).

Um Benutzerprofilinformationen zu erhalten, verwende ich folgenden Code (neu geschriebener Teil aus Googles Beispiel ):

IAuthorizationCodeFlow flow = new GoogleAuthorizationCodeFlow(
                                  new GoogleAuthorizationCodeFlow.Initializer
                                      {
                                            ClientSecrets = Secrets,
                                            Scopes = new[] { PlusService.Scope.PlusLogin,"https://www.googleapis.com/auth/plus.profile.emails.read"  }
                                       });    
TokenResponse _token = flow.ExchangeCodeForTokenAsync("", code, "postmessage", 
                              CancellationToken.None).Result;

                    // Create an authorization state from the returned token.
                    context.Session["authState"] = _token;

                    // Get tokeninfo for the access token if you want to verify.
                    Oauth2Service service = new Oauth2Service(
                     new Google.Apis.Services.BaseClientService.Initializer());
                    Oauth2Service.TokeninfoRequest request = service.Tokeninfo();
                    request.AccessToken = _token.AccessToken;
                    Tokeninfo info = request.Execute();
                    if (info.VerifiedEmail.HasValue && info.VerifiedEmail.Value)
                    {
                        flow = new GoogleAuthorizationCodeFlow(
                                    new GoogleAuthorizationCodeFlow.Initializer
                                         {
                                             ClientSecrets = Secrets,
                                             Scopes = new[] { PlusService.Scope.PlusLogin }
                                          });

                        UserCredential credential = new UserCredential(flow, 
                                                              "me", _token);
                        _token = credential.Token;
                        _ps = new PlusService(
                              new Google.Apis.Services.BaseClientService.Initializer()
                               {
                                   ApplicationName = "Your app name",
                                   HttpClientInitializer = credential
                               });
                        Person userProfile = _ps.People.Get("me").Execute();
                    }

Dann können Sie mit userProfile auf fast alles zugreifen.

UPDATE: Damit dieser Code funktioniert, müssen Sie die entsprechenden Bereiche für die Google-Anmeldeschaltfläche verwenden. Zum Beispiel meine Schaltfläche:

     <button class="g-signin"
             data-scope="https://www.googleapis.com/auth/plus.login https://www.googleapis.com/auth/plus.profile.emails.read"
             data-clientid="646361778467-nb2uipj05c4adlk0vo66k96bv8inqles.apps.googleusercontent.com"
             data-accesstype="offline"
             data-redirecturi="postmessage"
             data-theme="dark"
             data-callback="onSignInCallback"
             data-cookiepolicy="single_host_origin"
             data-width="iconOnly">
     </button>

Es müssen 3 Schritte ausgeführt werden.

1. Registrieren Sie die Client-ID Ihrer App über die Google API-Konsole
2. Bitten Sie Ihren Endbenutzer, über diese API https://developers.google.com/identity/protocols/OpenIDConnect#sendauthrequest seine Zustimmung zu erteilen
3. Verwenden Sie die oauth2-API von Google wie unter https://any-api.com/googleapis_com/oauth2/docs/userinfo/oauth2_userinfo_v2_me_get beschrieben, indem Sie das in Schritt 2 erhaltene Token verwenden. .

Es ist sehr interessant, dass diese einfachste Verwendung nirgendwo klar beschrieben wird. Und ich glaube, es besteht die Gefahr, dass Sie auf den verified_emailParameter in der Antwort achten . Denn wenn ich mich nicht irre , kann es zu gefälschten E-Mails kommen, um Ihre Bewerbung zu registrieren. (Dies ist nur meine Interpretation, hat eine faire Chance, dass ich mich irre!)

Ich finde die OAuth-Mechanik von Facebook sehr klar beschrieben.

Wenn Sie sich in einer clientseitigen Webumgebung befinden, enthält die neue Javascript-API auth2 eine dringend benötigte getBasicProfile()Funktion, die den Namen, die E-Mail- Adresse und die Bild-URL des Benutzers zurückgibt.

https://developers.google.com/identity/sign-in/web/reference#googleusergetbasicprofile

Wenn Sie nur die Google-Benutzer-ID, den Namen und das Bild für einen Besucher Ihrer Web-App abrufen möchten, finden Sie hier meine reine PHP-Service-Side-Lösung für das Jahr 2020, ohne dass externe Bibliotheken verwendet werden.

Wenn Sie das Handbuch Verwenden von OAuth 2.0 für Webserver-Anwendungen von Google lesen (und beachten Sie, dass Google gerne Links zu seiner eigenen Dokumentation ändert), müssen Sie nur zwei Schritte ausführen:

1. Präsentieren Sie dem Besucher eine Webseite, auf der er um die Zustimmung gebeten wird, seinen Namen mit Ihrer Web-App zu teilen
2. Nehmen Sie dann den von der obigen Webseite übergebenen "Code" an Ihre Web-App und rufen Sie einen Token (tatsächlich 2) von Google ab.

Einer der zurückgegebenen Token heißt "id_token" und enthält die Benutzer-ID, den Namen und das Foto des Besuchers.

Hier ist der PHP-Code eines Web-Spiels von mir. Ursprünglich habe ich Javascript SDK verwendet, aber dann habe ich festgestellt, dass gefälschte Benutzerdaten an mein Webspiel übergeben werden können, wenn nur clientseitiges SDK verwendet wird (insbesondere die Benutzer-ID, die für mein Spiel wichtig ist). Daher habe ich auf Verwendung umgestellt PHP auf der Serverseite:

<?php

const APP_ID       = '1234567890-abcdefghijklmnop.apps.googleusercontent.com';
const APP_SECRET   = 'abcdefghijklmnopq';

const REDIRECT_URI = 'https://the/url/of/this/PHP/script/';
const LOCATION     = 'Location: https://accounts.google.com/o/oauth2/v2/auth?';
const TOKEN_URL    = 'https://oauth2.googleapis.com/token';
const ERROR        = 'error';
const CODE         = 'code';
const STATE        = 'state';
const ID_TOKEN     = 'id_token';

# use a "random" string based on the current date as protection against CSRF
$CSRF_PROTECTION   = md5(date('m.d.y'));

if (isset($_REQUEST[ERROR]) && $_REQUEST[ERROR]) {
    exit($_REQUEST[ERROR]);
}

if (isset($_REQUEST[CODE]) && $_REQUEST[CODE] && $CSRF_PROTECTION == $_REQUEST[STATE]) {
    $tokenRequest = [
        'code'          => $_REQUEST[CODE],
        'client_id'     => APP_ID,
        'client_secret' => APP_SECRET,
        'redirect_uri'  => REDIRECT_URI,
        'grant_type'    => 'authorization_code',
    ];

    $postContext = stream_context_create([
        'http' => [
            'header'  => "Content-type: application/x-www-form-urlencoded\r\n",
            'method'  => 'POST',
            'content' => http_build_query($tokenRequest)
        ]
    ]);

    # Step #2: send POST request to token URL and decode the returned JWT id_token
    $tokenResult = json_decode(file_get_contents(TOKEN_URL, false, $postContext), true);
    error_log(print_r($tokenResult, true));
    $id_token    = $tokenResult[ID_TOKEN];
    # Beware - the following code does not verify the JWT signature! 
    $userResult  = json_decode(base64_decode(str_replace('_', '/', str_replace('-', '+', explode('.', $id_token)[1]))), true);

    $user_id     = $userResult['sub'];
    $given_name  = $userResult['given_name'];
    $family_name = $userResult['family_name'];
    $photo       = $userResult['picture'];

    if ($user_id != NULL && $given_name != NULL) {
        # print your web app or game here, based on $user_id etc.
        exit();
    }
}

$userConsent = [
    'client_id'     => APP_ID,
    'redirect_uri'  => REDIRECT_URI,
    'response_type' => 'code',
    'scope'         => 'profile',
    'state'         => $CSRF_PROTECTION,
];

# Step #1: redirect user to a the Google page asking for user consent
header(LOCATION . http_build_query($userConsent));

?>

Sie können eine PHP-Bibliothek verwenden, um zusätzliche Sicherheit zu schaffen, indem Sie die JWT-Signatur überprüfen. Für meine Zwecke war dies unnötig, da ich darauf vertraue, dass Google mein kleines Web-Spiel nicht durch das Senden gefälschter Besucherdaten verrät.

Wenn Sie mehr persönliche Daten des Besuchers erhalten möchten, benötigen Sie einen dritten Schritt:

const USER_INFO    = 'https://www.googleapis.com/oauth2/v3/userinfo?access_token=';
const ACCESS_TOKEN = 'access_token'; 

# Step #3: send GET request to user info URL
$access_token = $tokenResult[ACCESS_TOKEN];
$userResult = json_decode(file_get_contents(USER_INFO . $access_token), true);

Oder Sie erhalten weitere Berechtigungen für den Benutzer. Weitere Informationen finden Sie in der langen Liste im Dokument OAuth 2.0 Scopes for Google APIs .

Schließlich die in meinem Code verwendeten Konstanten APP_ID und APP_SECRET - Sie erhalten sie von der Google API-Konsole :