Obtenez des informations sur l'utilisateur via l'API Google

Est-il possible d'obtenir des informations du profil de l'utilisateur via l'API Google? Si c'est possible, quelle API dois-je utiliser?

Je suis intéressé par de telles informations:

• URL du profil utilisateur (par exemple https://profiles.google.com/115063121183536852887 );
• Sexe (sexe);
• Photo de profil.

De plus, ce serait cool d'obtenir d'autres informations du profil de l'utilisateur.

Ajoutez ceci à la portée - https://www.googleapis.com/auth/userinfo.profile

Et une fois l'autorisation terminée, obtenez les informations sur - https://www.googleapis.com/oauth2/v1/userinfo?alt=json

Il contient beaucoup de choses - y compris le nom, l'URL du profil public, le sexe, la photo, etc.

portée - https://www.googleapis.com/auth/userinfo.profile

return youraccess_token = access_token

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

vous obtiendrez json:

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

À Tahir Yasin:

Ceci est un exemple php.
Vous pouvez utiliser la fonction json_decode pour obtenir le tableau userInfo.

$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'];

Cette portée https://www.googleapis.com/auth/userinfo.profile est désormais obsolète. Veuillez consulter https://developers.google.com/+/api/auth-migration#timetable .

La nouvelle portée que vous utiliserez pour obtenir des informations de profil est: profile ou https://www.googleapis.com/auth/plus.login

et le point final est - https://www.googleapis.com/plus/v1/people/ {userId} - userId peut être simplement «moi» pour l'utilisateur actuellement connecté.

J'utilise PHPet j'ai résolu ce problème en utilisant la version 1.1.4 de google-api-php-client

En supposant que le code suivant est utilisé pour rediriger un utilisateur vers la page d'authentification Google:

 $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();

En supposant qu'un code d'authentification valide est renvoyé au redirect_url, ce qui suit va générer un jeton à partir du code d'authentification et fournir des informations de profil de base:

 //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

Cependant, l'emplacement n'est pas retourné. Les nouveaux comptes YouTube n'ont pas de nom d'utilisateur spécifique à YouTube

J'utilise Google API pour .Net, mais vous pouvez sans aucun doute trouver la même manière d'obtenir ces informations en utilisant une autre version de l'API. Comme user872858 l'a mentionné, scope userinfo.profile est obsolète ( article google ).

Pour obtenir des informations sur le profil utilisateur, j'utilise le code suivant (partie réécrite de l'exemple de Google ):

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();
                    }

Ensuite, vous pouvez accéder à presque tout en utilisant userProfile.

MISE À JOUR: Pour que ce code fonctionne, vous devez utiliser les portées appropriées sur le bouton de connexion Google. Par exemple mon bouton:

     <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>

Il y a 3 étapes qui doivent être exécutées.

1. Enregistrez l'identifiant client de votre application à partir de la console API Google
2. Demandez à votre utilisateur final de donner son consentement en utilisant cette API https://developers.google.com/identity/protocols/OpenIDConnect#sendauthrequest
3. Utilisez l'API oauth2 de Google comme décrit à l' adresse https://any-api.com/googleapis_com/oauth2/docs/userinfo/oauth2_userinfo_v2_me_get en utilisant le jeton obtenu à l'étape 2. (Bien que je ne trouve toujours pas comment remplir correctement le paramètre "fields") .

Il est très intéressant que cette utilisation la plus simple ne soit clairement décrite nulle part. Et je crois qu'il y a un danger, vous devez faire attention au verified_emailparamètre entrant dans la réponse. Parce que si je ne me trompe pas, cela peut générer de faux e-mails pour enregistrer votre application. (Ce n'est que mon interprétation, j'ai de bonnes chances que je me trompe!)

Je trouve que la mécanique OAuth de Facebook est bien décrite.

Si vous êtes dans un environnement Web côté client, la nouvelle API javascript auth2 contient une getBasicProfile()fonction indispensable , qui renvoie le nom, l'adresse e-mail et l'URL de l'image de l'utilisateur.

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

Si vous souhaitez uniquement récupérer l'identifiant d'utilisateur Google, le nom et l'image d'un visiteur de votre application Web - voici ma solution côté service PHP pure pour l'année 2020 sans bibliothèques externes utilisées -

Si vous lisez le guide Utiliser OAuth 2.0 pour les applications serveur Web de Google (et attention, Google aime modifier les liens vers sa propre documentation), alors vous devez effectuer seulement 2 étapes:

1. Présentez au visiteur une page Web demandant le consentement pour partager son nom avec votre application Web
2. Ensuite, prenez le "code" transmis par la page Web ci-dessus à votre application Web et récupérez un jeton (en fait 2) de Google.

L'un des jetons retournés s'appelle "id_token" et contient l'ID utilisateur, le nom et la photo du visiteur.

Voici le code PHP d' un jeu Web par moi. Au départ, j'utilisais le SDK Javascript, mais j'ai ensuite remarqué que de fausses données utilisateur pouvaient être transmises à mon jeu Web, lorsque j'utilisais uniquement le SDK côté client (en particulier l'ID utilisateur, qui est important pour mon jeu), j'ai donc opté pour PHP côté serveur:

<?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));

?>

Vous pouvez utiliser une bibliothèque PHP pour ajouter une sécurité supplémentaire en vérifiant la signature JWT. Pour mes besoins, ce n'était pas nécessaire, car je suis convaincu que Google ne trahira pas mon petit jeu Web en envoyant de fausses données de visiteurs.

De plus, si vous souhaitez obtenir plus de données personnelles du visiteur, vous avez besoin d'une troisième étape:

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);

Ou vous pouvez obtenir plus d'autorisations au nom de l'utilisateur - voir la longue liste dans le document OAuth 2.0 Scopes for Google APIs .

Enfin, les constantes app_id et APP_SECRET utilisées dans mon code - vous l' obtenez à partir de la console API Google :