II. Réception des données : le principe▲
II-A. Principe général▲
L'API Google Analytics est relativement simple : vous demandez une information en GET (en accédant à une URL), vous recevez un flux XML en réponse.
II-B. Authentification▲
L'échange des données se fait après une authentification préalable par Google. En réponse de l'authentification, vous recevez un jeton d'identification "token", valable pour une seule requête (nous verrons comment le rendre permanent) :
Il existe deux types d'authentification :
- Authentification client :
L'utilisateur est redirigé vers Google Account et doit saisir son mot de passe. le compte utilisé est celui de l'utilisateur. - Authentification serveur :
L'identifiant et le mot de passe sont enregistrés dans l'application, et transmis de façon transparente pour l'utilisateur. Le compte utilisé est celui du propriétaire de l'application.
| Authentification client | Authentification serveur |
|---|---|
| Redirection vers Google Account | Identification directe par compte unique et obtention d'un jeton |
| L'utilisateur accepte (ou non) que l'application ait accès à ses données | Utilisation par l'application de ce jeton pour effectuer une requête |
| Redirection vers l'application et livraison d'un jeton | |
| Utilisation par l'application de ce jeton pour effectuer une requête |
Nous allons dans un premier temps n'examiner que le premier cas d'authentification (Authentification client). Pour un exemple d'Authentification serveur, vous pouvez vous rendre dans la section IV de ce tutoriel (Zend Framework).
Voyons maintenant ce qui se passe lors d'une Authentification client. Concrètement, il suffit d'appeler la page https://www.google.com/accounts/AuthSubRequest, en précisant deux paramètres :
- scope : le service (ici pour Google Analytics : https://www.google.com/analytics/feeds/)
- next : la page de redirection une fois l'authentification effectuée
/**
* appeler la page de connexion
* l'utilisateur sera redirigé vers le site Google, puis redirigé vers la page indiquée
* @param string url de retour
*/
function google_login($urlRetour) {
$url = 'https://www.google.com/accounts/AuthSubRequest?'
. '&next='.$urlRetour
. '&scope=https://www.google.com/analytics/feeds/'
. '&secure=0'
. '&session=1';
header("Location: $url");
exit;
}II-C. Réception de données : cURL▲
Une fois authentifié, Google redirige l'utilisateur vers votre page (url passée dans "next"), et ajoute un argument ?token=xxxxxxx. C'est votre jeton d'identification, valable une fois.
/**
* récupérer le token de l'url en GET
* @return string token
*/
function google_get_token() {
if( !isset($_GET['token']) ) return false;
if( empty($_GET['token']) ) return false;
return strip_tags( $_GET['token'] );
}Vous aurez besoin de ce jeton à chaque requête envoyée à Google. Ce jeton s'envoie en en-tête de votre requête :
Authorization: AuthSub token="xxxxx"C'est ici que ça se corse un peu. Pour envoyer cet en-tête, vous aurez besoin de cURL :
/**
* effectuer une requete cUrl chez google
* @param string requete
* @return xml / génère une erreur
*/
function google_call($url, $token) {
//
// entête à envoyer
$headers = array( 'Authorization: AuthSub token="$token"' );
//
// Requete cUrl
$ch = curl_init($url);
$options = array(
CURLOPT_RETURNTRANSFER => true, // renvoie une page web
CURLOPT_HEADER => false, // ne renvoie pas d'en-tête
CURLOPT_HTTPHEADER => $headers, // en-têtes à envoyer
CURLOPT_FOLLOWLOCATION => true, // suivre les redirections
CURLOPT_ENCODING => "", // tout encodage possible
CURLOPT_USERAGENT => "spider", // nom de l'agent
CURLOPT_AUTOREFERER => true, // set referer on redirect
CURLOPT_CONNECTTIMEOUT => 120, // timeout on connect
CURLOPT_TIMEOUT => 120, // timeout on response
CURLOPT_MAXREDIRS => 10, // stop after 10 redirects
CURLOPT_SSL_VERIFYHOST => 0, // ne pas vérifier le SSL
CURLOPT_SSL_VERIFYPEER => false, // ne pas vérifier le SSL
CURLOPT_VERBOSE => 1
);
curl_setopt_array($ch,$options);
//
// Reponse cUrl
$content = curl_exec($ch);
$err = curl_errno($ch);
$errmsg = curl_error($ch) ;
$resp = curl_getinfo($ch);
curl_close($ch);
//
// Erreur : le code 200 n'est pas envoyé
if($resp['http_code'] != '200') {
echo "<strong>Impossible d'effectuer la requete : $content</strong><p><pre>";
print_r($resp);
echo '</pre></p>';
exit;
}
//
// renvoyer le contenu
return $content;
}Si tout est bon, Google renvoie le code "200".
II-D. Réception de données : Stream▲
Vous pouvez tout autant passer par des fonctions de flux (stream), et éviter ainsi l'utilisation de cURL :
/**
* effectuer une requete chez google en utilisant les fonctions de flux
* @param string requete
* @return xml
*/
function google_call($url, $token) {
//
// entête à envoyer
$headers = array( 'Authorization: AuthSub token="$token"' );
$options = array(
'http' => array(
'method' => 'POST',
'header' => $this->headers)
);
//
// flux
$context = stream_context_create($options);
$content = file_get_contents($url, false, $context);
return $content;
}II-E. Exemple : lister tous les profils du compte▲
Maintenant, utilisons cette fonction pour effectuer la requête qui va nous fournir la liste de nos comptes :
//
// effectuer une requete : on va lister tous les comptes du profil
$accountxml = google_call("https://www.google.com/analytics/feeds/accounts/default");
echo $accountxml;Vous voilà avec un flux XML contenant la liste de vos comptes.