richiesta dati di Google Analytics da un server locale

Question

Voglio scrivere uno script PHP che importi i dati delle statistiche web da GA. Lo script è accessibile tramite un front-end Web (per l'attivazione dell'importazione) e risiede su un server locale (127.0.0.1).

Come ho capito dalla documentazione è che ci sono due opzioni per l'autenticazione e utilizzando l'API di base:

1. API chiave - concede solo l'accesso alle statistiche
2. OAuth2 - autorizzazione completa

Se comprendo correttamente i meccanismi di OAuth2, questa non è un'opzione nel mio scenario perché non è possibile specificare un URL di richiamata. Mi vengono in mente le soluzioni di Hacky - come stabilire un'autenticazione di un profilo web che si collega direttamente a GA dal browser e quindi recuperare i dati da JavaScript e alimentarli allo script di importazione - ma preferirei astenermi da tali soluzioni. Anche perché l'interazione del browser che ha attivato il processo di importazione potrebbe essere sostituita con un cron job in futuro.

La chiave API sembra essere esattamente ciò che voglio ma la richiesta GET dal browser non riesce.

richiesta GET:

https://www.googleapis.com/analytics/v3/data/ga 
    ?ids=ga:[profile ID] 
    &start-date=2013-01-01&end-date=2013-01-05 
    &metrics=ga:visits 
    &key=[the API key] 

Risposta:

{ 
    error: { 
    errors: [ 
    { 
     domain: "global", 
     reason: "required", 
     message: "Login Required", 
     locationType: "header", 
     location: "Authorization" 
    } 
    ], 
    code: 401, 
    message: "Login Required" 
    } 
} 

L'URL però dovrebbe andare bene. Tranne che per il parametro chiave, è uguale a quello generato con http://ga-dev-tools.appspot.com/explorer/ che funziona anche (in questo caso viene utilizzato AOuth2). La chiave API è fresca.

Quindi generare di nuovo una nuova chiave API mi mette di fronte al prossimo inconveniente che è apparentemente la chiave è valida solo per un giorno.

---

Così, alla fine della giornata la mia domanda è questa:

E 'possibile recuperare i dati dello scenario sopra descritto, senza dover autenticare manualmente o generare le chiavi API su una base quotidiana?

Answer 1

come già suggerito, usa questa libreria: https://code.google.com/p/google-api-php-client/ ma, invece di utilizzare OAuth, creare un account di servizio dalla console api (solo applicazione server di selezione). Ciò fornirà un ID cliente, una e-mail che identifica l'account del servizio e il file * .p12 contenente la chiave privata.

È quindi necessario aggiungere l'account di servizio (l'e-mail) all'analisi come utente amministratore per ottenere i dati necessari.

Per utilizzare il servizio:

$client = new Google_Client(); 
$client->setApplicationName('test'); 

$client->setAssertionCredentials(
    new Google_AssertionCredentials(
     EMAIL, 
     array('https://www.googleapis.com/auth/analytics.readonly'), 
     file_get_contents(PRIVATE_KEY_FILEPATH) 
    ) 
); 
$client->setClientId(CLIENT_ID); 
$client->setAccessType('offline_access'); 

$analytics = new Google_AnalyticsService($client); 

per ottenere alcuni dati:

$analytics->data_ga->get(PROFILE_ID, $date_from, $date_to, $metrics, $optParams) 

Per i dettagli Controllate la documentazione di api. Inoltre, fai attenzione, c'è un limite di query (a meno che non paghi)

Answer 2

Penso che per ottenere questo funzionamento, è necessario utilizzare OAuth ma con una leggera modifica per eseguirlo dal server. Google chiama questo metodo di autenticazione "Using OAuth 2.0 for Web Server Applications"

Come descritto in questa pagina, è possibile utilizzare una libreria client PHP per eseguire l'autenticazione. La libreria client si trova here.

Un esempio di esempio su come utilizzare questa libreria client si trova nello stesso progetto help pages. Nota che dovrai apportare alcune modifiche al codice mentre i commenti dicono di memorizzare il token in db e di aggiornarlo regolarmente.

<?php 
require_once 'google-api-php-client/src/Google_Client.php'; 
require_once 'google-api-php-client/src/contrib/Google_PlusService.php'; 

// Set your cached access token. Remember to replace $_SESSION with a 
// real database or memcached. 
session_start(); 

$client = new Google_Client(); 
$client->setApplicationName('Google+ PHP Starter Application'); 
// Visit https://code.google.com/apis/console?api=plus to generate your 
// client id, client secret, and to register your redirect uri. 
$client->setClientId('insert_your_oauth2_client_id'); 
$client->setClientSecret('insert_your_oauth2_client_secret'); 
$client->setRedirectUri('insert_your_oauth2_redirect_uri'); 
$client->setDeveloperKey('insert_your_simple_api_key'); 
$plus = new Google_PlusService($client); 

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

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

if ($client->getAccessToken()) { 
    $activities = $plus->activities->listActivities('me', 'public'); 
    print 'Your Activities: <pre>' . print_r($activities, true) . '</pre>'; 

    // We're not done yet. Remember to update the cached access token. 
    // Remember to replace $_SESSION with a real database or memcached. 
    $_SESSION['token'] = $client->getAccessToken(); 
} else { 
    $authUrl = $client->createAuthUrl(); 
    print "<a href='$authUrl'>Connect Me!</a>"; 
} 

Answer 3

Ho una configurazione simile.La cosa che non ti rendi conto è che puoi specificare un http://localhost o http://127.0.0.1 o qualsiasi altra cosa come origine e URL di richiamata. È necessario configurare alcune interfacce Web sul server locale che inizino una configurazione OAuth per l'utente con l'accesso GA. Si noti che questa è una volta. Il gestore di callback deve essere qualcosa del tipo:

Nota: le librerie utilizzate qui sono le stesse della risposta precedente, il codice dettagliato è nel wrapper.

$redirect = 'http://' . $_SERVER['HTTP_HOST'] . '/content/business-intelligence'; 
if (isset($_GET['code'])) { 
    require_once 'GAPI.php'; 
    $client = GAPI::init(); //create client instance of Google_Client 
    $client->authenticate(); //convert auth code to access token 
    $token = $client->getAccessToken(); 
    $retVal = CF_GAPI::persistToken($token); //save token 
    if($retVal) 
     $redirect .= "?new_token"; 
    else 
     $redirect .= "?bad_token"; 
} 
header('Location: ' . $redirect); //redirect to bi index 

Dopo aver salvato il token salvato, è necessario impostarlo nel client prima di fare richieste di GA per ottenere i dati di analisi. Come:

try { 
    $token = GAPI::readToken(); //read from persistent storage 
} catch (Exception $e) { 
    $token = FALSE; 
} 

if($token == FALSE) { 
    $logger->crit("Token not set before running cron!"); 
    echo "Error: Token not set before running cron!"; 
    exit; 
} 

$client = GAPI::init(); //instance of Google_Client 
$client->setAccessToken($token); 

Il GAPI::init() è implementato come segue:

$client = new Google_Client(); 
$client->setApplicationName(self::APP_NAME); 

$client->setClientId(self::CLIENT_ID); 
$client->setClientSecret(self::CLIENT_SECRET); 
$client->setRedirectUri(self::REDIRECT_URI); 
$client->setDeveloperKey(self::DEVELOPER_KEY); 

//to specify that the token is stored offline 
$client->setAccessType('offline'); 

//all results will be objects 
$client->setUseObjects(true); 

//tell that this app will RO from Analytics 
$client->setScopes('https://www.googleapis.com/auth/analytics.readonly'); 

return $client; 

Il mio tavolo mysql ha colonne come id, title, send_to_emails, frequency, dimensions, metrics, filters, profile_id che definiscono completamente ogni rapporto alla generato da GA. Puoi giocare con loro usando lo documentation, e lo sandbox tester che già conosci.