Uzyskaj informacje o użytkowniku za pośrednictwem Google API

Czy można uzyskać informacje z profilu użytkownika za pośrednictwem Google API? Jeśli to możliwe, którego interfejsu API powinienem użyć?

Interesują mnie takie informacje:

• Adres URL profilu użytkownika (np. Https://profiles.google.com/115063121183536852887 );
• Płeć (płeć);
• Zdjęcie profilowe.

Fajnie byłoby też uzyskać inne informacje z profilu użytkownika.

Dodaj to do zakresu - https://www.googleapis.com/auth/userinfo.profile

Po dokonaniu autoryzacji uzyskaj informacje z - https://www.googleapis.com/oauth2/v1/userinfo?alt=json

Ma mnóstwo rzeczy - w tym imię i nazwisko, adres URL profilu publicznego, płeć, zdjęcie itp.

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

return youraccess_token = access_token

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

otrzymasz json:

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

Do Tahira Yasina:

To jest przykład php.
Możesz użyć funkcji json_decode, aby uzyskać tablicę 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'];

Ten zakres https://www.googleapis.com/auth/userinfo.profile został wycofany. Zajrzyj na https://developers.google.com/+/api/auth-migration#timetable .

Nowy zakres, którego będziesz używać do uzyskiwania informacji o profilu, to: profile lub https://www.googleapis.com/auth/plus.login

a punkt końcowy to - https://www.googleapis.com/plus/v1/people/ {userId} - userId może być po prostu „ja” dla aktualnie zalogowanego użytkownika.

Używam PHPi rozwiązałem ten problem, używając wersji 1.1.4 google-api-php-client

Zakładając, że następujący kod służy do przekierowania użytkownika na stronę uwierzytelniającą 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();

Zakładając, że poprawny kod uwierzytelniający zostanie zwrócony do redirect_url, poniższe wygeneruje token z kodu uwierzytelniającego, a także poda podstawowe informacje o profilu:

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

Jednak lokalizacja nie jest zwracana. Nowe konta YouTube nie mają nazw użytkownika specyficznych dla YouTube

Używam Google API dla .Net, ale bez wątpienia możesz znaleźć ten sam sposób na uzyskanie tych informacji za pomocą innej wersji API. Jako user872858 wspomniano, zakres userinfo.profile została zastąpiona ( google artykułu ).

Aby uzyskać informacje o profilu użytkownika, używam następującego kodu (przepisanego fragmentu z przykładu 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();
                    }

Dzięki temu możesz uzyskać dostęp do prawie wszystkiego za pomocą userProfile.

AKTUALIZACJA: Aby ten kod działał, musisz użyć odpowiednich zakresów na przycisku logowania Google. Na przykład mój przycisk:

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

Należy wykonać 3 kroki.

1. Zarejestruj identyfikator klienta swojej aplikacji w konsoli Google API
2. Poproś użytkownika końcowego o wyrażenie zgody za pomocą tego interfejsu API https://developers.google.com/identity/protocols/OpenIDConnect#sendauthrequest
3. Użyj google oauth2 api zgodnie z opisem na https://any-api.com/googleapis_com/oauth2/docs/userinfo/oauth2_userinfo_v2_me_get, używając tokena uzyskanego w kroku 2. (Chociaż nadal nie mogłem znaleźć sposobu prawidłowego wypełnienia parametru „pola”) .

To bardzo interesujące, że to najprostsze zastosowanie nie jest nigdzie jasno opisane. I wierzę, istnieje niebezpieczeństwo, należy zwrócić uwagę na verified_emailparametr nadchodzącym w odpowiedzi. Ponieważ jeśli się nie mylę , rejestracja aplikacji może zawierać fałszywe e-maile. (To tylko moja interpretacja, istnieje duże prawdopodobieństwo, że się mylę!)

Uważam, że mechanika OAuth na Facebooku jest znacznie wyraźnie opisana.

Jeśli pracujesz w środowisku internetowym po stronie klienta, nowy interfejs API javascript auth2 zawiera bardzo potrzebną getBasicProfile()funkcję, która zwraca nazwę użytkownika, adres e-mail i adres URL obrazu.

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

Jeśli chcesz pobrać tylko identyfikator użytkownika Google, nazwę i zdjęcie odwiedzającego Twoją aplikację internetową - oto moje rozwiązanie po stronie usługi PHP na rok 2020 bez użycia zewnętrznych bibliotek -

Jeśli przeczytałeś przewodnik Google Using OAuth 2.0 for Web Server Applications (i uważaj, Google lubi zmieniać linki do własnej dokumentacji), musisz wykonać tylko 2 kroki:

1. Zaprezentuj odwiedzającemu stronę internetową z prośbą o zgodę na udostępnienie jej imienia i nazwiska Twojej aplikacji internetowej
2. Następnie przenieś „kod” przekazany przez powyższą stronę internetową do swojej aplikacji internetowej i pobierz token (a właściwie 2) z Google.

Jeden ze zwróconych tokenów nosi nazwę „id_token” i zawiera identyfikator użytkownika, imię i nazwisko oraz zdjęcie odwiedzającego.

Oto kod PHP mojej gry internetowej . Początkowo korzystałem z Javascript SDK, ale potem zauważyłem, że fałszywe dane użytkownika mogą być przekazywane do mojej gry internetowej, gdy używam tylko SDK po stronie klienta (szczególnie identyfikator użytkownika, który jest ważny dla mojej gry), więc przełączyłem się na używanie PHP po stronie serwera:

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

?>

Możesz użyć biblioteki PHP, aby zwiększyć bezpieczeństwo, weryfikując podpis JWT. Dla moich celów było to niepotrzebne, ponieważ ufam, że Google nie zdradzi mojej małej gry internetowej, wysyłając fałszywe dane odwiedzających.

Ponadto, jeśli chcesz uzyskać więcej danych osobowych odwiedzającego, potrzebujesz trzeciego kroku:

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

Możesz też uzyskać więcej uprawnień w imieniu użytkownika - zobacz długą listę w dokumencie OAuth 2.0 Scopes for Google APIs .

Na koniec stałe APP_ID i APP_SECRET użyte w moim kodzie - otrzymujesz to z konsoli Google API :