Ottieni informazioni sull'utente tramite l'API di Google

È possibile ottenere informazioni dal profilo dell'utente tramite l'API di Google? Se è possibile, quale API dovrei usare?

Sono interessante in tali informazioni:

• Url al profilo utente (es. Https://profiles.google.com/115063121183536852887 );
• Genere (sesso);
• Foto profilo.

Inoltre sarebbe bello ottenere altre informazioni dal profilo dell'utente.

Aggiungilo all'ambito: https://www.googleapis.com/auth/userinfo.profile

E dopo l'autorizzazione, ottieni le informazioni da: https://www.googleapis.com/oauth2/v1/userinfo?alt=json

Ha un sacco di cose - inclusi nome, URL del profilo pubblico, sesso, foto ecc.

ambito: https://www.googleapis.com/auth/userinfo.profile

return youraccess_token = access_token

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

otterrai json:

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

A Tahir Yasin:

Questo è un esempio di php.
È possibile utilizzare la funzione json_decode per ottenere l'array 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'];

Questo ambito https://www.googleapis.com/auth/userinfo.profile è stato ora ritirato. Consulta https://developers.google.com/+/api/auth-migration#timetable .

Il nuovo ambito che utilizzerai per ottenere le informazioni sul profilo è: profilo o https://www.googleapis.com/auth/plus.login

e l'endpoint è - https://www.googleapis.com/plus/v1/people/ {userId} - userId può essere solo "me" per l'utente attualmente connesso.

Sto usando PHPe ho risolto questo problema usando la versione 1.1.4 di google-api-php-client

Supponendo che il codice seguente venga utilizzato per reindirizzare un utente alla pagina di autenticazione di 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();

Supponendo che venga restituito un codice di autenticazione valido redirect_url, quanto segue genererà un token dal codice di autenticazione e fornirà informazioni di base sul profilo:

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

Tuttavia, la posizione non viene restituita. I nuovi account YouTube non hanno nomi utente specifici per YouTube

Sto usando l'API di Google per .Net, ma senza dubbio puoi trovare lo stesso modo per ottenere queste informazioni utilizzando un'altra versione dell'API. Come menzionato da user872858 , l'ambito userinfo.profile è stato deprecato ( articolo di Google ).

Per ottenere le informazioni sul profilo utente utilizzo il seguente codice (parte riscritta dall'esempio di 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();
                    }

Quindi, puoi accedere a quasi tutto utilizzando userProfile.

AGGIORNAMENTO: Per far funzionare questo codice devi utilizzare gli ambiti appropriati sul pulsante di accesso di Google. Ad esempio il mio pulsante:

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

Ci sono 3 passaggi che devono essere eseguiti.

1. Registra l'ID client della tua app dalla console API di Google
2. Chiedi al tuo utente finale di dare il consenso utilizzando questa API https://developers.google.com/identity/protocols/OpenIDConnect#sendauthrequest
3. Utilizza l'API oauth2 di Google come descritto su https://any-api.com/googleapis_com/oauth2/docs/userinfo/oauth2_userinfo_v2_me_get utilizzando il token ottenuto al passaggio 2. (Anche se ancora non sono riuscito a trovare come riempire correttamente il parametro "fields") .

È molto interessante che questo utilizzo più semplice non sia chiaramente descritto da nessuna parte. E credo che ci sia un pericolo, dovresti prestare attenzione al verified_emailparametro che viene nella risposta. Perché se non sbaglio , potrebbe generare false email per registrare la tua domanda. (Questa è solo la mia interpretazione, ho una buona possibilità che possa sbagliarmi!)

Trovo che la meccanica OAuth di Facebook sia descritta molto chiaramente.

Se ti trovi in ​​un ambiente web lato client, la nuova API javascript auth2 contiene una funzione molto necessaria getBasicProfile(), che restituisce il nome, l'email e l'URL dell'immagine dell'utente.

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

Se desideri solo recuperare l'ID utente, il nome e l'immagine di Google per un visitatore della tua app web, ecco la mia soluzione lato servizio PHP puro per l'anno 2020 senza librerie esterne utilizzate -

Se leggi la guida Using OAuth 2.0 for Web Server Applications di Google (e fai attenzione, a Google piace modificare i link alla propria documentazione), devi eseguire solo 2 passaggi:

1. Presenta al visitatore una pagina web che chiede il consenso per condividere il suo nome con la tua app web
2. Quindi prendi il "codice" passato dalla pagina web sopra alla tua app web e recupera un token (in realtà 2) da Google.

Uno dei token restituiti si chiama "id_token" e contiene l'ID utente, il nome e la foto del visitatore.

Ecco il codice PHP di un mio gioco web . Inizialmente stavo usando Javascript SDK, ma poi ho notato che i dati utente falsi potevano essere passati al mio gioco web, quando si utilizzava solo l'SDK lato client (in particolare l'id utente, che è importante per il mio gioco), quindi sono passato all'utilizzo PHP lato server:

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

?>

È possibile utilizzare una libreria PHP per aggiungere ulteriore sicurezza verificando la firma JWT. Per i miei scopi non era necessario, perché confido che Google non tradirà il mio piccolo gioco web inviando falsi dati sui visitatori.

Inoltre, se desideri ottenere più dati personali del visitatore, è necessario un terzo passaggio:

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

Oppure potresti ottenere più autorizzazioni per conto dell'utente: consulta l'elenco lungo nel documento OAuth 2.0 Scopes for Google APIs .

Infine, le costanti APP_ID e APP_SECRET utilizzate nel mio codice, le ottieni dalla console dell'API di Google :