Come aggiornare il token con il client API di Google?

Ho giocato con l'API di Google Analytics (V3) e ho riscontrato alcuni errori. In primo luogo, tutto è impostato correttamente e ha funzionato con il mio account di prova. Ma quando desidero acquisire dati da un altro ID profilo (stesso account Google Accont / GA) ottengo un errore 403. La cosa strana è che i dati di alcuni account GA restituiranno dati mentre altri genereranno questo errore.

Ho revocato il token e mi sono autenticato ancora una volta, e ora sembra che io possa prendere i dati da tutti i miei account. Problema risolto? Non. Poiché la chiave di accesso scadrà, mi imbatterò di nuovo nello stesso problema.

Se ho capito bene le cose, si potrebbe usare resfreshToken per ottenere un nuovo authenticationTooken.

Il problema è che quando corro:

$client->refreshToken(refresh_token_key) 

viene restituito il seguente errore:

Error refreshing the OAuth2 token, message: '{ "error" : "invalid_grant" }'

Ho controllato il codice dietro il metodo refreshToken e ho rintracciato la richiesta nel file "apiOAuth2.php". Tutti i parametri vengono inviati correttamente. Grant_type è hardcoded in "refresh_token" all'interno del metodo, quindi è difficile per me capire cosa c'è che non va. L'array dei parametri ha questo aspetto:

Array ( [client_id] => *******-uqgau8uo1l96bd09eurdub26c9ftr2io.apps.googleusercontent.com [client_secret] => ******** [refresh_token] => 1\/lov250YQTMCC9LRQbE6yMv-FiX_Offo79UXimV8kvwY [grant_type] => refresh_token )

La procedura è la seguente.

$client = new apiClient();
$client->setClientId($config['oauth2_client_id']);
$client->setClientSecret($config['oauth2_client_secret']);
$client->setRedirectUri($config['oauth2_redirect_uri']);
$client->setScopes('https://www.googleapis.com/auth/analytics.readonly');
$client->setState('offline');

$client->setAccessToken($config['token']); // The access JSON object.

$client->refreshToken($config['refreshToken']); // Will return error here

È un bug o ho completamente frainteso qualcosa?

Quindi ho finalmente capito come farlo. L'idea di base è che hai il token che ricevi la prima volta che chiedi l'autenticazione. Questo primo token ha un token di aggiornamento. Il primo token originale scade dopo un'ora. Dopo un'ora è necessario utilizzare il token di aggiornamento del primo token per ottenere un nuovo token utilizzabile. Si utilizza $client->refreshToken($refreshToken)per recuperare un nuovo token. Lo chiamerò "token temporaneo". È necessario memorizzare anche questo token temporaneo perché dopo un'ora scade e nota che non è associato un token di aggiornamento. Per ottenere un nuovo token temporaneo è necessario utilizzare il metodo utilizzato in precedenza e utilizzare il refreshtoken del primo token. Ho allegato il codice di seguito, che è brutto, ma sono nuovo in questo ...

//pull token from database
$tokenquery="SELECT * FROM token WHERE type='original'";
$tokenresult = mysqli_query($cxn,$tokenquery);
if($tokenresult!=0)
{
    $tokenrow=mysqli_fetch_array($tokenresult);
    extract($tokenrow);
}
$time_created = json_decode($token)->created;
$t=time();
$timediff=$t-$time_created;
echo $timediff."<br>";
$refreshToken= json_decode($token)->refresh_token;


//start google client note:
$client = new Google_Client();
$client->setApplicationName('');
$client->setScopes(array());
$client->setClientId('');
$client->setClientSecret('');
$client->setRedirectUri('');
$client->setAccessType('offline');
$client->setDeveloperKey('');

//resets token if expired
if(($timediff>3600)&&($token!=''))
{
    echo $refreshToken."</br>";
    $refreshquery="SELECT * FROM token WHERE type='refresh'";
    $refreshresult = mysqli_query($cxn,$refreshquery);
    //if a refresh token is in there...
    if($refreshresult!=0)
    {
        $refreshrow=mysqli_fetch_array($refreshresult);
        extract($refreshrow);
        $refresh_created = json_decode($token)->created;
        $refreshtimediff=$t-$refresh_created;
        echo "Refresh Time Diff: ".$refreshtimediff."</br>";
        //if refresh token is expired
        if($refreshtimediff>3600)
        {
            $client->refreshToken($refreshToken);
        $newtoken=$client->getAccessToken();
        echo $newtoken."</br>";
        $tokenupdate="UPDATE token SET token='$newtoken' WHERE type='refresh'";
        mysqli_query($cxn,$tokenupdate);
        $token=$newtoken;
        echo "refreshed again";
        }
        //if the refresh token hasn't expired, set token as the refresh token
        else
        {
        $client->setAccessToken($token);
           echo "use refreshed token but not time yet";
        }
    }
    //if a refresh token isn't in there...
    else
    {
        $client->refreshToken($refreshToken);
        $newtoken=$client->getAccessToken();
        echo $newtoken."</br>";
        $tokenupdate="INSERT INTO token (type,token) VALUES ('refresh','$newtoken')";
        mysqli_query($cxn,$tokenupdate);
        $token=$newtoken;
        echo "refreshed for first time";
    }      
}

//if token is still good.
if(($timediff<3600)&&($token!=''))
{
    $client->setAccessToken($token);
}

$service = new Google_DfareportingService($client);

Il problema è nel token di aggiornamento:

[refresh_token] => 1\/lov250YQTMCC9LRQbE6yMv-FiX_Offo79UXimV8kvwY

Quando una stringa con a '/'ottiene json encoded, viene preceduto da una a '\', quindi è necessario rimuoverla.

Il token di aggiornamento nel tuo caso dovrebbe essere:

1/lov250YQTMCC9LRQbE6yMv-FiX_Offo79UXimV8kvwY

Quello che presumo tu abbia fatto è che tu abbia stampato la stringa json che Google ha inviato indietro e copiato e incollato il token nel tuo codice perché se lo fai json_decode, rimuoverà correttamente il '\'per te!

ecco lo snippet per impostare il token, prima assicurati che il tipo di accesso sia impostato su offline

if (isset($_GET['code'])) {
  $client->authenticate();
  $_SESSION['access_token'] = $client->getAccessToken();
}

Per aggiornare il token

$google_token= json_decode($_SESSION['access_token']);
$client->refreshToken($google_token->refresh_token);

questo aggiornerà il tuo token, devi aggiornarlo in sessione per quello che puoi fare

 $_SESSION['access_token']= $client->getAccessToken()

Il tipo di accesso dovrebbe essere impostato su offline. stateè una variabile che imposti per il tuo uso personale, non per l'uso dell'API.

Assicurati di avere l' ultima versione della libreria client e aggiungi:

$client->setAccessType('offline');

Vedere Formazione dell'URL per una spiegazione dei parametri.

La risposta pubblicata da @ uri-weg ha funzionato per me, ma poiché non ho trovato le sue spiegazioni molto chiare, lasciatemi riformulare un po '.

Durante la prima sequenza di autorizzazioni di accesso, nella richiamata, quando si arriva al punto in cui si riceve un codice di autenticazione, è necessario salvare anche il token di accesso e il token di aggiornamento .

Il motivo è che l'API di Google ti invia un token di accesso con un token di aggiornamento solo quando viene richiesta l'autorizzazione all'accesso. I successivi token di accesso verranno inviati senza alcun token di aggiornamento (a meno che non si utilizzi l' approval_prompt=forceopzione).

Il token di aggiornamento ricevuto la prima volta rimane valido fino a quando l'utente non revoca l'autorizzazione di accesso.

In semplicistico php, un esempio della sequenza di callback sarebbe:

// init client
// ...

$authCode = $_GET['code'];
$accessToken = $client->authenticate($authCode);
// $accessToken needs to be serialized as json
$this->saveAccessToken(json_encode($accessToken));
$this->saveRefreshToken($accessToken['refresh_token']);

E in seguito, in semplicistico php, la sequenza di connessione sarebbe:

// init client
// ...

$accessToken = $this->loadAccessToken();
// setAccessToken() expects json
$client->setAccessToken($accessToken);

if ($client->isAccessTokenExpired()) {
    // reuse the same refresh token
    $client->refreshToken($this->loadRefreshToken());
    // save the new access token (which comes without any refresh token)
    $this->saveAccessToken($client->getAccessToken());
}

Ecco il codice che sto usando nel mio progetto e funziona bene:

public function getClient(){
    $client = new Google_Client();
    $client->setApplicationName(APPNAME);       // app name
    $client->setClientId(CLIENTID);             // client id
    $client->setClientSecret(CLIENTSECRET);     // client secret 
    $client->setRedirectUri(REDIRECT_URI);      // redirect uri
    $client->setApprovalPrompt('auto');

    $client->setAccessType('offline');         // generates refresh token

    $token = $_COOKIE['ACCESSTOKEN'];          // fetch from cookie

    // if token is present in cookie
    if($token){
        // use the same token
        $client->setAccessToken($token);
    }

    // this line gets the new token if the cookie token was not present
    // otherwise, the same cookie token
    $token = $client->getAccessToken();

    if($client->isAccessTokenExpired()){  // if token expired
        $refreshToken = json_decode($token)->refresh_token;

        // refresh the token
        $client->refreshToken($refreshToken);
    }

    return $client;
}

Ha avuto lo stesso problema; il mio script che ha funzionato ieri, per qualche strana ragione non ha funzionato oggi. Nessun cambiamento.

Apparentemente questo era perché il mio orologio di sistema era spento di 2,5 (!!) secondi, la sincronizzazione con NTP lo ha risolto.

Vedi anche: https://code.google.com/p/google-api-php-client/wiki/OAuth2#Solving_invalid_grant_errors

FYI: l'API di Google Analytics 3.0 aggiornerà automaticamente il token di accesso se hai un token di aggiornamento quando scade, quindi il tuo script non avrà mai bisogno refreshToken.

(Vedi la Signfunzione in auth/apiOAuth2.php)

A volte il token di aggiornamento non viene generato utilizzando $client->setAccessType ("offline");.

Prova questo:

$client->setAccessType ("offline");
$client->setApprovalPrompt ("force"); 

Ho usato l'esempio di smartcode con la versione corrente dell'API di Google, ma quello non ha funzionato. Penso che la sua API sia troppo obsoleta.

Quindi, ho appena scritto la mia versione, basata su uno degli esempi API ... Emette token di accesso, token di richiesta, tipo di token, token ID, ora di scadenza e ora di creazione come stringhe

Se le credenziali del cliente e la chiave sviluppatore sono corrette, questo codice dovrebbe funzionare immediatamente.

<?php
// Call set_include_path() as needed to point to your client library.
require_once 'google-api-php-client/src/Google_Client.php';
require_once 'google-api-php-client/src/contrib/Google_Oauth2Service.php';
session_start();

$client = new Google_Client();
$client->setApplicationName("Get Token");
// Visit https://code.google.com/apis/console?api=plus to generate your
// oauth2_client_id, oauth2_client_secret, and to register your oauth2_redirect_uri.
$oauth2 = new Google_Oauth2Service($client);

if (isset($_GET['code'])) {
    $client->authenticate($_GET['code']);
    $_SESSION['token'] = $client->getAccessToken();
    $redirect = 'http://' . $_SERVER['HTTP_HOST'] . $_SERVER['PHP_SELF'];
    header('Location: ' . filter_var($redirect, FILTER_SANITIZE_URL));
    return;
}

if (isset($_SESSION['token'])) {
    $client->setAccessToken($_SESSION['token']);
}

if (isset($_REQUEST['logout'])) {
    unset($_SESSION['token']);
    $client->revokeToken();
}
?>
<!doctype html>
<html>
    <head><meta charset="utf-8"></head>
    <body>
        <header><h1>Get Token</h1></header>
        <?php
        if ($client->getAccessToken()) {
            $_SESSION['token'] = $client->getAccessToken();
            $token = json_decode($_SESSION['token']);
            echo "Access Token = " . $token->access_token . '<br/>';
            echo "Refresh Token = " . $token->refresh_token . '<br/>';
            echo "Token type = " . $token->token_type . '<br/>';
            echo "Expires in = " . $token->expires_in . '<br/>';
            echo "ID Token = " . $token->id_token . '<br/>';
            echo "Created = " . $token->created . '<br/>';
            echo "<a class='logout' href='?logout'>Logout</a>";
        } else {
            $authUrl = $client->createAuthUrl();
            print "<a class='login' href='$authUrl'>Connect Me!</a>";
        }
        ?>
    </body>
</html>

Ho lo stesso problema con google / google-api-php-client v2.0.0-RC7 e dopo aver cercato per 1 ora, ho risolto questo problema usando json_encode in questo modo:

    if ($client->isAccessTokenExpired()) {
        $newToken = json_decode(json_encode($client->getAccessToken()));
        $client->refreshToken($newToken->refresh_token);
        file_put_contents(storage_path('app/client_id.txt'), json_encode($client->getAccessToken()));
    }

Questo qui funziona molto bene, forse potrebbe aiutare chiunque:

index.php

session_start();

require_once __DIR__.'/client.php';

if(!isset($obj->error) && isset($_SESSION['access_token']) && $_SESSION['access_token'] && isset($obj->expires_in)) {
?>
<!DOCTYPE html>
<html>
<head>
<title>Google API Token Test</title>
<meta charset='utf-8' />
<script src="https://code.jquery.com/jquery-1.12.4.js"></script>
<script>
search('Music Mix 2010');
function search(q) {
    $.ajax({
        type: 'GET',
        url: 'action.php?q='+q,
        success: function(data) {
            if(data == 'refresh') location.reload();
            else $('#response').html(JSON.stringify(JSON.parse(data)));
        }
    });
}
</script>
</head>
<body>
<div id="response"></div>
</body>
</html>
<?php
}
else header('Location: '.filter_var('https://'.$_SERVER['HTTP_HOST'].dirname($_SERVER['PHP_SELF']).'/oauth2callback.php', FILTER_SANITIZE_URL));
?>

oauth2callback.php

require_once __DIR__.'/vendor/autoload.php';

session_start();

$client = new Google_Client();
$client->setAuthConfigFile('auth.json');
$client->setAccessType('offline');
$client->setApprovalPrompt('force');
$client->setRedirectUri('https://'.filter_var($_SERVER['HTTP_HOST'].$_SERVER['PHP_SELF'], FILTER_SANITIZE_URL));
$client->addScope(Google_Service_YouTube::YOUTUBE_FORCE_SSL);

if(isset($_GET['code']) && $_GET['code']) {
    $client->authenticate(filter_var($_GET['code'], FILTER_SANITIZE_STRING));
    $_SESSION['access_token'] = $client->getAccessToken();
    $_SESSION['refresh_token'] = $_SESSION['access_token']['refresh_token'];
    setcookie('refresh_token', $_SESSION['refresh_token'], time()+60*60*24*180, '/', filter_var($_SERVER['HTTP_HOST'], FILTER_SANITIZE_URL), true, true);
    header('Location: '.filter_var('https://'.$_SERVER['HTTP_HOST'].dirname($_SERVER['PHP_SELF']), FILTER_SANITIZE_URL));
    exit();
}
else header('Location: '.filter_var($client->createAuthUrl(), FILTER_SANITIZE_URL));
exit();

?>

client.php

// https://developers.google.com/api-client-library/php/start/installation
require_once __DIR__.'/vendor/autoload.php';

$client = new Google_Client();
$client->setAuthConfig('auth.json');
$client->setAccessType('offline');
$client->setApprovalPrompt('force');
$client->addScope(Google_Service_YouTube::YOUTUBE_FORCE_SSL);

// Delete Cookie Token
#setcookie('refresh_token', @$_SESSION['refresh_token'], time()-1, '/', filter_var($_SERVER['HTTP_HOST'], FILTER_SANITIZE_URL), true, true);

// Delete Session Token
#unset($_SESSION['refresh_token']);

if(isset($_SESSION['refresh_token']) && $_SESSION['refresh_token']) {
    $client->refreshToken($_SESSION['refresh_token']);
    $_SESSION['access_token'] = $client->getAccessToken();
}
elseif(isset($_COOKIE['refresh_token']) && $_COOKIE['refresh_token']) {
    $client->refreshToken($_COOKIE['refresh_token']);
    $_SESSION['access_token'] = $client->getAccessToken();
}

$url = 'https://www.googleapis.com/oauth2/v1/tokeninfo?access_token='.urlencode(@$_SESSION['access_token']['access_token']);
$curl_handle = curl_init();
curl_setopt($curl_handle, CURLOPT_URL, $url);
curl_setopt($curl_handle, CURLOPT_CONNECTTIMEOUT, 2);
curl_setopt($curl_handle, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($curl_handle, CURLOPT_USERAGENT, 'Google API Token Test');
$json = curl_exec($curl_handle);
curl_close($curl_handle);

$obj = json_decode($json);

?>

action.php

session_start();

require_once __DIR__.'/client.php';

if(isset($obj->error)) {
    echo 'refresh';
    exit();
}
elseif(isset($_SESSION['access_token']) && $_SESSION['access_token'] && isset($obj->expires_in) && isset($_GET['q']) && !empty($_GET['q'])) {
    $client->setAccessToken($_SESSION['access_token']);
    $service = new Google_Service_YouTube($client);
    $response = $service->search->listSearch('snippet', array('q' => filter_input(INPUT_GET, 'q', FILTER_SANITIZE_SPECIAL_CHARS), 'maxResults' => '1', 'type' => 'video'));
    echo json_encode($response['modelData']);
    exit();
}
?>

Google ha apportato alcune modifiche da quando questa domanda è stata originariamente pubblicata.

Ecco il mio esempio attualmente funzionante.

    public function update_token($token){

    try {

        $client = new Google_Client();
        $client->setAccessType("offline"); 
        $client->setAuthConfig(APPPATH . 'vendor' . DIRECTORY_SEPARATOR . 'google' . DIRECTORY_SEPARATOR . 'client_secrets.json');  
        $client->setIncludeGrantedScopes(true); 
        $client->addScope(Google_Service_Calendar::CALENDAR); 
        $client->setAccessToken($token);

        if ($client->isAccessTokenExpired()) {
            $refresh_token = $client->getRefreshToken();
            if(!empty($refresh_token)){
                $client->fetchAccessTokenWithRefreshToken($refresh_token);      
                $token = $client->getAccessToken();
                $token['refresh_token'] = json_decode($refresh_token);
                $token = json_encode($token);
            }
        }

        return $token;

    } catch (Exception $e) { 
        $error = json_decode($e->getMessage());
        if(isset($error->error->message)){
            log_message('error', $error->error->message);
        }
    }


}

Uso google-api-php-client v2.2.2 Ottengo un nuovo token con la fetchAccessTokenWithRefreshToken();chiamata alla funzione if senza parametri, restituisce un token di accesso aggiornato e il token aggiornato non viene perso.

if ($client->getAccessToken() && $client->isAccessTokenExpired()) {
    $new_token=$client->fetchAccessTokenWithRefreshToken();
    $token_data = $client->verifyIdToken();
}    

È necessario salvare il token di accesso su file o database come stringa json durante la richiesta di autorizzazione iniziale e impostare il tipo di accesso su offline $client->setAccessType("offline")

Quindi, durante le richieste API successive, prendi il token di accesso dal tuo file o db e passalo al client:

$accessToken = json_decode($row['token'], true);
$client->setAccessToken($accessToken);

Ora devi controllare se il token è scaduto:

if ($client->isAccessTokenExpired()) {
    // access token has expired, use the refresh token to obtain a new one
    $client->fetchAccessTokenWithRefreshToken($client->getRefreshToken());
    // save the new token to file or db
    // ...json_encode($client->getAccessToken())

La fetchAccessTokenWithRefreshToken()funzione farà il lavoro per te e fornirà un nuovo token di accesso, salvandolo nuovamente nel tuo file o database.

Secondo l' autenticazione su Google: OAuth2 continua a restituire "invalid_grant"

"Dovresti riutilizzare il token di accesso che ottieni dopo la prima autenticazione riuscita. Riceverai un errore invalid_grant se il tuo token precedente non è ancora scaduto. Mettilo nella cache da qualche parte in modo da poterlo riutilizzare."

spero che sia d'aiuto

usa il seguente frammento di codice per ottenere il token di aggiornamento

    <?php

    require_once 'src/apiClient.php';
    require_once 'src/contrib/apiTasksService.php';

    $client = new apiClient();
    $client->setAccessType('offline');
    $tasksService = new apiTasksService($client);

    $auth = $client->authenticate();
    $token = $client->getAccessToken();
    // the refresh token
    $refresh_token = $token['refresh_token'];
    ?>