Introduction Le but de ce tutoriel et ce que vous allez apprendre.
Qui ne connait pas Twitter aujourd'hui ? Ce réseau social tend à devenir aussi populaire que Facebook et c'est une aubaine pour les développeurs. En effet, grâce aux API que mettent à disposition ces réseaux sociaux, les développeurs sont capables de développer des applications pouvant communiquer avec le compte d'un utilisateur inscrit sur un de ces réseaux.
Les API sont de façon générale assez bien documentées et complètes. Elles nous permettent de faire à peu près tout avec le compte d'un utilisateur. Du point de vue de l'utilisateur, on est en droit de se poser une question : Si l'application sur laquelle je me connecte peut tout faire avec mon compte, ais-je intérêt à m'y connecter, à lui fournir mes identifiants de connexion ?
Ces inquiétudes sont parfaitement fondées et c'est pour cette raison que OAuth a été inventé. OAuth est un protocol permettant une authentification à une API sécurisée. L'intérêt d'OAuth vient du fait que l'utilisateur n'a plus besoin de fournir ses identifiants de connexion à l'application tierce car la connexion se passe sur le site de l'API, site auquel l'utilisateur fait confiance à priori.
C'est pas le tout de causer, il faut coder un peu aussi !
Notre projet Fil rouge de ce tutoriel
Notre projet pour ce tutoriel sera un petit système de commentaire utilisant Twitter pour identifier les personnes postant un commentaire. Nous aurons donc une page avec quelque chose à commenter, une photo de Edward Burtynsky en l'occurence. Voici à quoi ressemblera notre projet une fois terminé.
Je vous donne tout de suite le code HTML et CSS de la page (hors balises
).<link rel="stylesheet" type="text/css" href="<?= $asset ?>css/design.css" media="screen" />
<div style="text-align:center">
<img src="<?= $asset ?>img/photo.jpg" alt="" width="700" /><br />
<i>“Jet Engines Tucson, Arizona, USA”, 2006. © <a href="http://edwardburtynsky.com/">Edward Burtynsky</a></i>
</div>
<br /><br /><br />
<div id="comments">
</div>
<div id="comment_form">
<?php
if ($this->session->flashdata('error_message')) {
echo '<div class="error">' . $this->session->flashdata('error_message') . '</div>';
}
elseif ($this->session->flashdata('success_message')) {
echo '<div class="success">' . $this->session->flashdata('success_message') . '</div>';
}
?>
<div class="clear"> </div>
<?php if ($this->session->userdata('twitter_screen_name')) : ?>
<div id="user_box">
<div id="user_image">
<img src="<?= $this->session->userdata('twitter_profile_image') ?>" alt="#" />
</div>
<div id="user_infos">
<strong><a href="http://twitter.com/<?= $this->session->userdata('twitter_screen_name') ?>"><?= $this->session->userdata('twitter_name') ?> (<?= $this->session->userdata('twitter_screen_name') ?>)</a></strong><br />
<a href="<?= base_url(); ?>twitter_oauth/logout">Déconnexion</a>
</div>
<div class="clear"></div>
</div>
<form method="post" action="<?= base_url(); ?>twitter_oauth/add_comment">
<p>
<label for="new_comment">Votre commentaire</label>
<textarea id="new_comment" name="new_comment"></textarea>
</p>
<input type="hidden" name="user_id" value="<?= $this->session->userdata('twitter_id') ?>" />
<?php $this->load->helper('cookie'); ?>
<input type="hidden" name="ci_csrf_token" value="<?= get_cookie('ci_csrf_token') ?>" />
<p id="button">
<input type="checkbox" name="update_status" id="update_status" /> Signaler mon commentaire sur Twitter
<input type="submit" value="Envoyer" />
</p>
</form>
<?php else: ?>
<div style="text-align:center"><a href="<?= base_url(); ?>twitter_oauth/login"><img src="<?= $asset ?>img/twitter.png" alt="" /></a></div>
<?php endif; ?>
</div>
<div id="users_list">
<p><strong>Ces utilisateurs se sont connectés à Syrinxoon :</strong></p>
<?php foreach($users as $user) : ?>
<a href="http://twitter.com/<?= $user['user_screen_name'] ?>">@<?= $user['user_screen_name'] ?></a>,
<?php endforeach; ?>
</div>
Les balises <?= ?> sont des short tags, elles sont équivalentes à <?php echo ''; ?>. Vous trouverez le code CSS utilisé ci-dessous.
#user_box { width: 882px; padding: 10px; margin: auto; border: 1px solid #d2d2d2; border-radius: 4px; -moz-border-radius: 4px; -webkit-border-radius: 4px; background: #efefef; }
#user_image { width: 50px; height: 50px; float: left; margin-left: 20px; }
#user_infos { float: left; margin-left: 10px; }
#user_infos a { text-decoration: none; }
#button { width: 910px; margin: auto; text-align: right; }
#comments { width: 902px; margin: auto; }
.success, .error { float: none; display: block; width: 880px; margin: 20px auto; }
#users_list { width: 900px; margin: auto; }
#users_list a { text-decoration: none; }
label, textarea { width: 900px; margin: auto; }
Création de l'application Enregistrement sur Twitter
Pour pouvoir utiliser l'API de Twitter, nous avons besoin de deux clés, comme un nom d'utilisateur (Consumer Key) et un mot de passe (Consumer Secret) si vous préférez. Pour obtenir ces clés, vous devez créer une application sur dev.twitter.com. Rendez-vous sur cette page pour créer votre application. Un formulaire apparaît, vous n'avez qu'à le remplir avec vos propres informations.
Une fois votre application créée, une page devrait s'afficher avec des informations sur votre application dont nos deux clés.
Gardez cette page ouverte, vous en aurez besoin dans quelques minutes.
Configuration de l'application En PHP
A présent, nous allons télécharger une bibliothèque PHP nous permettant de nous connecter via OAuth à Twitter. Vous pouvez voir la liste complète des bibliothèques à cette adresse. Dans ce tutoriel, j'utilise la bibliothèque PHP twitteroauth de @abraham. Vous pouvez la télécharger sur cette page, cliquez sur le bouton Download Source en haut à droite de la page.
Une fois téléchargée, dézipez la bibliothèque. Le dossier contient plusieurs fichiers. Seuls ceux contenu dans le dossier twitteroauth nous intéressent, à savoir : OAuth.php et twitteroauth.php.
Dans la suite de ce tutoriel, j'utilise le framework CodeIgniter qui repose sur le modèle MVC.
Si vous ne l'utilisez pas, ce n'est pas grave, je donnerai des explications pour les personnes qui n'utilisent pas de framework à côté mais sachez tout de même que la bibliothèque twitteroauth est écrite en orienté objet donc si vous avez l'habitude de programmer en procédural, ça vous fera un peu de changement ! (Mais rien de très compliqué rassurez vous).
Copiez les deux fichiers quelque part dans l'arborescence de votre application. Pour CodeIgniter, il y a deux choses à faire avant de pouvoir utiliser cette bibliothèque.
Premièrement, ouvrez le fichier /application/config/config.php et effectuez le remplacement suivant :
<?php
// Trouvez cette ligne
$config['permitted_uri_chars'] = 'a-z 0-9~%.:_\-';
// Et remplacez là par celle-ci :
$config['permitted_uri_chars'] = 'a-z 0-9~%.:_\-=&';
?>
Pourquoi cet remplacement ? Parce que CodeIgniter n'autorise pas par défaut le passage de paramètres dans l'url et la connexion par OAuth utilise les paramètres dans l'url, nous devons donc les autoriser.
Deuxièmement, vous allez placer les 2 fichiers PHP dans le repertoire /application/libraries/. Une fois que vous avez copié les fichiers, ouvrez twitteroauth.php. Vous trouverez en haut du fichier le constructeur de la classe.
<?php
/**
* construct TwitterOAuth object
*/
function __construct($consumer_key, $consumer_secret, $oauth_token = NULL, $oauth_token_secret = NULL) {
$this->sha1_method = new OAuthSignatureMethod_HMAC_SHA1();
$this->consumer = new OAuthConsumer($consumer_key, $consumer_secret);
if (!empty($oauth_token) && !empty($oauth_token_secret)) {
$this->token = new OAuthConsumer($oauth_token, $oauth_token_secret);
} else {
$this->token = NULL;
}
}
?>
Remplacez ce constructeur par celui-ci :
<?php
/**
* construct TwitterOAuth object for CodeIgniter
*/
function __construct($params) {
$consumer_key = $params['consumer_key'];
$consumer_secret = $params['consumer_secret'];
$oauth_token = $params['oauth_token'];
$oauth_token_secret = $params['oauth_token_secret'];
$this->sha1_method = new OAuthSignatureMethod_HMAC_SHA1();
$this->consumer = new OAuthConsumer($consumer_key, $consumer_secret);
if (!empty($oauth_token) && !empty($oauth_token_secret)) {
$this->token = new OAuthConsumer($oauth_token, $oauth_token_secret);
} else {
$this->token = NULL;
}
}
?>
J'ai effectué ce changement de constructeur afin de pouvoir charger la classe et lui passer des paramètres comme pour une bibliothèque de CodeIgniter. Les personnes n'utilisants pas CodeIgniter appellerons la classe de cette manière :
<?php
$twitteroauth = new TwitterOAuth($param1, $param2, $param3, $param4);
$twitteroauth->some_function();
?>
Tandis qu'avec CodeIgniter, l'appel se fera de cette façon :
<?php
$params = array($param1, $param2, $param3, $param4);
$this->load->library('twitteroauth', $params);
$this->twitteroauth->some_function();
?>
Nous sommes maintenant prêt à utiliser la bibliothèque twitteroauth.
Authentification des utilisateurs Avec twitteroauth
Nous avons donc notre page d'accueil, index, qui contient la photo ainsi que le bouton de connexion à Twitter. En haut du formulaire, vous pouvez voir 2 conditions, la première sert à vérifier si il y a des flashdatas en session. Les flashdatas sont des messages qui restent en mémoire pour une seule requête, elles servent par exemple à afficher des messages d'erreur ou de confirmation. C'est à cette fin que je m'en sert dans le tutoriel.
<?php
if ($this->session->flashdata('error_message')) {
echo '<div class="error">' . $this->session->flashdata('error_message') . '</div>';
}
elseif ($this->session->flashdata('success_message')) {
echo '<div class="success">' . $this->session->flashdata('success_message') . '</div>';
}
?>
La deuxième condition sert à vérifier si l'utilisateur est connecté à Twitter. Si ce n'est pas le cas, on affiche le bouton de connexion sinon on affiche le formulaire pour envoyer un commentaire ainsi que quelques informations sur l'utilisateur.
<?php if ($this->session->userdata('twitter_screen_name')) : ?>
<!-- Notre formulaire -->
<?php else: ?>
<div style="text-align:center"><a href="<?= base_url(); ?>twitter_oauth/login"><img src="<?= $asset ?>img/twitter.png" alt="" /></a></div>
<?php endif; ?>
Lorsque l'utilisateur clique sur le bouton de connexion, il est redirigé vers la fonction login() de mon controleur Twitter_oauth. Si vous n'utilisez pas de framework, redirigez le vers une autre page PHP, login.php par exemple.
<?php
class Twitter_oauth extends Controller {
function __construct() {
parent::Controller();
// On charge le modèle qui gèrera toutes les opérations avec la base de données
$this->load->model('twitter_oauth_model', 'the_model');
}
function index() {
// Cette fonction gere la page index, je la détaillerai plus tard
}
function login() {
// Notre fonction de connexion
}
}
?>
La première chose que nous devons faire est d'initialiser la bibliothèque avec les paramètres nécessaires. Twitteroauth prend 4 paramètres dont 2 nécessaires.
- Consumer Key : la première clé que vous pouvez récupérer sur dev.twitter.com (obligatoire)
- Consumer Secret : la seconde clé que vous pouvez récupérer sur dev.twitter.com (obligatoire)
- OAuth Token : clé renvoyée par Twitter pour la connexion via OAuth
- OAuth Token Secret : clé renvoyée par Twitter pour la connexion via OAuth
<?php
function login() {
$params = array(
'consumer_key' => 'VOTRE_CONSUMER_KEY',
'consumer_secret' => 'VOTRE_CONSUMER_SECRET',
'oauth_token' => NULL,
'oauth_token_secret' => NULL
);
$this->load->library('twitteroauth', $params);
}
?>
Une fois notre bibliothèque initialisée, nous allons demander des jetons de connexion. En fait, se connecter avec OAuth, c'est un peu comme un match de tennis entre notre application et Twitter, on demande des jetons à Twitter, on les renvoi, etc.
<?php
function login() {
$params = array(
'consumer_key' => 'VOTRE_CONSUMER_KEY',
'consumer_secret' => 'VOTRE_CONSUMER_SECRET',
'oauth_token' => NULL,
'oauth_token_secret' => NULL
);
$this->load->library('twitteroauth', $params);
// On demande les jetons de connexion, le paramètre est l'url vers laquelle l'utilisateur sera redirigé
$request_token = $this->twitteroauth->getRequestToken(base_url() . 'twitter_oauth/oauth');
// Si Twitter nous a envoyé les jetons temporaires
if ($this->twitteroauth->http_code == 200) {
// On met les jetons en session pour plus tard
$this->session->set_userdata('twitter_oauth_token', $request_token['oauth_token']);
$this->session->set_userdata('twitter_oauth_token_secret', $request_token['oauth_token_secret']);
// On génère l'url et on redirige
$url = $this->twitteroauth->getAuthorizeURL($request_token['oauth_token']);
redirect($url);
}
else {
// Sinon on met une erreur en flashdata et on redirige vers l'index
$this->session->set_flashdata('error_message', 'Une erreur est survenue lors de votre authentification.');
redirect(base_url() . 'twitter_oauth/');
}
}
?>
Que c'est-il passé lors de cette première étape ? Premièrement, nous avons demandé des jetons (token) temporaires à Twitter. On verifie ensuite que la requête à aboutie (Code HTTP 200). Si c'est le cas, on sauvegarde les jetons en session car on en aura besoin par la suite. Si ce n'est pas le cas, on redirige vers la page index. Ensuite, la fonction getAuthorizeURL() va construire une URL qui conduit sur le site de Twitter et vers laquelle on va rediriger l'utilisateur.
Si l'utilisateur se connecte et autorise l'accès à l'application, il sera redirigé vers la page passée en paramètre à la fonction getRequestToken() un peu plus tôt. Dans mon cas, l'utilisateur sera redirigé vers la fonction oauth(). Si la page que vous avez passé en paramètre plus tôt est http://monsite.com/oauth, Twitter redirigera l'utilisateur vers http://monsite.com/oauth?oauth_token=XXXXXXX&oauth_verifier=XXXXXXX. CodeIgniter refusant tout paramètre passé par l'url, nous allons devoir ruser un peu pour récupérer les nouveaux paramètres.
<?php
function oauth() {
// On va récupérer la chaine contenant les paramètres grâce à la superglobale $_SERVER['QUERY_STRING']
// Qui nous retourne oauth_token=XXXXXXX&oauth_verifier=XXXXXXX
$part1 = explode('=', $_SERVER['QUERY_STRING']);
$part2 = explode('&', $part1[1]);
$oauth_token = $part2[0];
$oauth_verifier = $part1[2];
}
?>
On récupère donc deux nouvelles variables. Vous pouvez jeter $oauth_token car elle ne nous servira pas. En revanche, $oauth_verifier va nous servir pour demander des jetons permanents. En effet, nous avons toujours des jetons temporaires pour le moment, servant seulement à établir la connexion avec le profil de l'utilisateur. Nous allons ensuite vérifier que nous avons tous les paramètres nécessaires et demander à Twitter les jetons permanents. Ajoutez le code ci-dessous dans la fonction oauth().
<?php
if ($oauth_verifier != '' && $this->session->userdata('twitter_oauth_token') != '' && $this->session->userdata('twitter_oauth_token_secret') != '') {
$params = array(
'consumer_key' => 'VOTRE_CONSUMER_KEY',
'consumer_secret' => 'VOTRE_CONSUMER_SECRET',
'oauth_token' => $this->session->userdata('twitter_oauth_token'),
'oauth_token_secret' => $this->session->userdata('twitter_oauth_token_secret')
);
$this->load->library('twitteroauth', $params);
// On demande les jetons d'accès permanent
$access_token = $this->twitteroauth->getAccessToken($oauth_verifier);
// On les sauvegarde en session
$this->session->set_userdata('twitter_access_token', $access_token);
// La condition n'est pas terminée, il y aura encore du code à ajouter dedans
?>
Nous verifions donc que le nouveau paramètre que nous venons d'acquerir n'est pas vide puis que les jetons temporaires ne sont pas vides non plus. Nous initialisons à nouveau notre bibliothèque avec les jetons temporaires cette fois. Puis le moment tant attendu : on demande les jetons d'accès permanents puis on les sauvegarde en session.
<?php
// Toujours dans la condition
// On récupère les informations de l'utilisateur
$user_infos = $this->twitteroauth->get('account/verify_credentials');
// On sauvegarde le tout dans un tableau
$data = array(
'user_oauth_uid' => $user_infos->id,
'user_name' => $user_infos->name,
'user_screen_name' => $user_infos->screen_name,
'user_profile_image' => $user_infos->profile_image_url,
'user_oauth_provider' => 'Twitter',
'user_oauth_token' => $access_token['oauth_token'],
'user_oauth_token_secret' => $access_token['oauth_token_secret']
);
?>
Il ne nous reste plus qu'à récupérer les informations de l'utilisateur et à les stocker. La fonction get() se charge de récupérer les informations, il suffit de lui passer comme premier paramètre l'adresse de l'API, vous trouverez toutes les adresses disponibles sur le site de la documentation. Cette fonction peut prendre un deuxième paramètre sous forme de tableau contenant les paramètres que vous souhaitez envoyer à l'API. Nous allons ensuite enregistrer les informations de l'utilisateur dans une base de données. Voici le code de SQL de la table contenant les utilisateurs :
--
-- Table structure for table `sxn_oauth_users`
--
CREATE TABLE IF NOT EXISTS `sxn_oauth_users` (
`user_id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`user_oauth_provider` varchar(10) DEFAULT NULL,
`user_oauth_uid` bigint(20) DEFAULT NULL,
`user_oauth_token` text,
`user_oauth_token_secret` text,
`user_name` varchar(255) NOT NULL,
`user_screen_name` text,
`user_profile_image` text NOT NULL,
`user_date` bigint(20) NOT NULL,
`user_ip_address` varchar(255) NOT NULL,
PRIMARY KEY (`user_id`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8 AUTO_INCREMENT=1 ;
Avant d'enregistrer l'utilisateur, nous allons vérifier si il existe déjà dans notre base de données, auquel cas, nous allons mettre à jour son profil. Je vous donne tel quel la suite de la fonction oauth(), le code parle de lui même.
<?php
if ($this->the_model->user_exists($data)) {
// L'utilisateur existe, on met à jour son profil
if ($this->the_model->update_user($data)) {
$user_id = $this->the_model->get_user_id($data);
$session = array(
'twitter_id' => $user_id,
'twitter_name' => $data['user_name'],
'twitter_screen_name' => $data['user_screen_name'],
'twitter_profile_image' => $data['user_profile_image'],
'twitter_oauth_token' => $data['user_oauth_token'],
'twitter_oauth_token_secret' => $data['user_oauth_token_secret']
);
$this->session->set_userdata($session);
$this->session->set_flashdata('success_message', 'Vous êtes maintenant connecté et votre profil a été mis à jour.');
}
else {
$this->session->set_flashdata('error_message', 'Une erreur est survenue lors de la mise à jour de votre profil.');
}
}
else {
// L'utilisateur n'existe pas chez nous, on l'enregistre
if ($this->the_model->add_user($data)) {
$user_id = $this->the_model->get_user_id($data);
$session = array(
'twitter_id' => $user_id,
'twitter_name' => $data['user_name'],
'twitter_screen_name' => $data['user_screen_name'],
'twitter_profile_image' => $data['user_profile_image'],
'twitter_oauth_token' => $data['user_oauth_token'],
'twitter_oauth_token_secret' => $data['user_oauth_token_secret']
);
$this->session->set_userdata($session);
$this->session->set_flashdata('success_message', 'Vous êtes maintenant connecté et votre profil a été créé.');
}
else {
$this->session->set_flashdata('error_message', 'Une erreur est survenue lors de la création de votre profil.');
}
}
redirect(base_url() . 'twitter_oauth/');
} // Fin de la première condition
else {
$this->session->set_flashdata('error_message', 'Echec de l\'authentification via OAuth.');
redirect(base_url() . 'twitter_oauth/');
}
} // Fin de la fonction oauth()
?>
Notre fonction oauth() est maintenant achevée, notre utilisateur est authentifié avec son compte Twitter, nous le redirigeons vers la page d'index.
Voici le code du modèle gérant toutes les interactions avec la base de données. J'utilise Active Record, c'est pour cette raison qu'il n'y a aucun code SQL dans les fonctions.
<?php
class Twitter_oauth_model extends CI_Model {
function user_exists($data) {
$where = array('user_oauth_provider' => $data['user_oauth_provider'], 'user_oauth_uid' => $data['user_oauth_uid']);
// Selectionne tous les utilisateurs dont le champ user_oauth_provider = Twitter et dont le champ user_oauth_uid = l'uid fourni par twitter
$q = $this->db->get_where('oauth_users', $where);
if ($q->num_rows() > 0) {
return TRUE;
}
else {
return FALSE;
}
}
function get_user_id($data) {
$where = array('user_oauth_provider' => $data['user_oauth_provider'], 'user_oauth_uid' => $data['user_oauth_uid']);
// Retourne le champ user_id d'un utilisateur en fonction de son uid
$q = $this->db->where($where)->select('user_id')->get('oauth_users');
if ($q->num_rows() > 0) {
$data = $q->row();
return $data->user_id;
}
else {
return FALSE;
}
}
function add_user($data) {
$data['user_date'] = time();
$data['user_ip_address'] = $this->input->ip_address();
// On ajoute un utilisateur
if ($this->db->insert('oauth_users', $data)) {
return TRUE;
}
else {
return FALSE;
}
}
function update_user($data) {
$where = array('user_oauth_provider' => $data['user_oauth_provider'], 'user_oauth_uid' => $data['user_oauth_uid']);
$data['user_ip_address'] = $this->input->ip_address();
// Met à jour tous les utilisateurs dont le champ user_oauth_provider = Twitter et dont le champ user_oauth_uid = l'UID fourni par twitter
if ($this->db->where($where)->update('oauth_users', $data)) {
return TRUE;
}
else {
return FALSE;
}
}
}
?>
Ajout de commentaires Avec votre compte Twitter
Notre utilisateur étant connecté, la page d'index affiche le formulaire permettant d'ajouter un commentaire. Pour la suite, il n'y a rien d'extraordinaire, on a juste à insérer des données dans la table contenant les commentaires dont voici le code SQL :
--
-- Table structure for table `sxn_oauth_comments`
--
CREATE TABLE IF NOT EXISTS `sxn_oauth_comments` (
`com_id` bigint(20) NOT NULL AUTO_INCREMENT,
`com_user_oauth_provider` varchar(255) NOT NULL,
`com_user_id` bigint(20) NOT NULL,
`com_message` text NOT NULL,
`com_date` bigint(20) NOT NULL,
`com_ip_address` varchar(255) NOT NULL,
PRIMARY KEY (`com_id`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8;
Lorsque l'utilisateur clique sur le bouton Envoyer, il est redirigé vers la fonction add_comment() qui va récupérer les données et les enregistrer. Voici la fonction du modèle pour enregistrer les données :
<?php
function add_comment() {
$data = array(
'com_user_oauth_provider' => 'Twitter',
'com_user_id' => $this->input->post('user_id'),
'com_message' => $this->input->post('new_comment'),
'com_date' => time(),
'com_ip_address' => $this->input->ip_address()
);
if ($this->db->insert('oauth_comments', $data)) {
return TRUE;
}
else {
return FALSE;
}
}
?>
Ici, $this->input->post('user_id') correspond à $_POST['user_id']. La fonction du controleur, celle sur laquelle arrive l'utilisateur, contient le code suivant :
<?php
function add_comment() {
$params = array(
'consumer_key' => 'VOTRE_CONSUMER_KEY',
'consumer_secret' => 'VOTRE_CONSUMER_SECRET',
'oauth_token' => $this->session->userdata('twitter_oauth_token'),
'oauth_token_secret' => $this->session->userdata('twitter_oauth_token_secret')
);
$this->load->library('twitteroauth', $params);
if ($this->the_model->add_comment()) {
// Si l'utilisateur a coché la case Signaler mon commentaire sur Twitter
if ($this->input->post('update_status') == TRUE) {
$update = array('status' => 'J\'ai publié un commentaire sur Syrinxoon Tuts http://bit.ly/aW4UCL @Syrinxoon');
$this->twitteroauth->post('statuses/update', $update);
$this->session->set_flashdata('success_message', 'Votre commentaire a été enregistré et signalé sur votre compte Twitter.');
}
else {
$this->session->set_flashdata('success_message', 'Votre commentaire a été enregistré.');
}
}
else {
$this->session->set_flashdata('error_message', 'Une erreur est survenue lors de l\'enregistrement de votre commentaire.');
}
redirect(base_url() . 'twitter_oauth/');
}
?>
Si l'utilisateur à coché la case Signaler mon commentaire sur Twitter, on envoi un tweet sur son compte. Le tweet est contenu dans le tableau $update. Tout comme la fonction get(), la fonction post() prend comme premier paramètre l'adresse de l'API et comme second paramètre les paramètres que souhaitez envoyer à l'API.
Affichage des commentaires Juste sous l'image
Il est maintenant le moment de vous donner le code de la fonction index du controleur :
<?php
function index() {
$comments = $this->the_model->get_comments();
$users = $this->the_model->get_users_for_comments();
$demo_content = array('comments' => $comments, 'users' => $users);
$data = array(
'page_data' => array(
'demo_content' => $demo_content
),
'view' => 'twitter_oauth_index'
);
$this->load->view('template', $data);
}
?>
Cette fonction va récupérer les commentaires et la liste des utilisateurs s'étant connectés. Pour cela, elle fait appel au modèle et aux fonctions get_comments() et get_users_for_comments() que voici :
<?php
function get_comments() {
$q = $this->db->where('com_user_oauth_provider', 'Twitter')->order_by('com_id', 'asc')->get('oauth_comments');
if ($q->num_rows() > 0) {
return $q->result();
}
else {
return FALSE;
}
}
function get_users_for_comments() {
$q = $this->db->where('user_oauth_provider', 'Twitter')->get('oauth_users');
if ($q->num_rows() > 0) {
$users_raw = $q->result();
$users = array();
foreach ($users_raw as $user) {
$users[$user->user_id] = array('user_screen_name' => $user->user_screen_name, 'user_profile_image' => $user->user_profile_image);
}
return $users;
}
else {
return FALSE;
}
}
?>
Pour afficher les commentaires sur la page index, insérez le code suivant dans la balise
Plus d'informations sur l'API Pour étendre votre application
Je ne vous ai montré seulement que quelques fonctions parmis toutes celles qu'offre l'API de Twitter, en voici d'autre. N'oubliez pas d'initialiser la bibliothèque avant d'utiliser ces fonctions.
<?php
$params = array(
'consumer_key' => 'VOTRE_CONSUMER_KEY',
'consumer_secret' => 'VOTRE_CONSUMER_SECRET',
'oauth_token' => $this->session->userdata('twitter_oauth_token'),
'oauth_token_secret' => $this->session->userdata('twitter_oauth_token_secret')
);
$this->load->library('twitteroauth', $params);
?>
Pour récupérer les 50 derniers tweets de la timeline de l'utilisateur connecté :
<?php
$data = array('count' => 50);
$timeline = $this->twitteroauth->get('statuses/timeline', $data);
?>
Vous pouvez également voir les tweets de quelqu'un d'autre si son compte n'est pas protégé
<?php
$data = array('screen_name' => 'OyoKooN');
$timeline = $this->twitteroauth->get('statuses/user_timeline', $data);
?>
Il y a tellement de fonctions que je pourrais faire un tutoriel 2 fois plus long que celui-ci rien que pour vous les montrer de cette manère (Oui, celui-ci est déjà très long...).
Conclusion Ce que vous avez appris et ce que vous pouvez faire maintenant.
Vous avez donc appris dans ce tutoriel à authentifier vos utilisateurs via Twitter OAuth et découvert CodeIgniter si vous ne connaissiez pas le framework. C'est pas trop mal non ?
Je ne peux m'empêcher de vous livrer quelques conseils avant de vous laisser partir. Comme je l'ai dis dans l'introduction, une fois que vous avez l'autorisation de l'utilisateur, vous pouvez faire ce que vous voulez (ou presque) avec son compte Twitter. On dit que de grands pouvoirs impliquent de grandes responsabilités. C'est le cas ici. Ne faites rien que l'utilisateur n'ait approuvé explicitement auquel cas, il ne reviendra plus sur votre site. Par exemple, le fait que j'ai mis une case à cocher (décochée par défaut) pour envoyer automatiquement un tweet ou non lors du commentaire ne dérange pas l'utilisateur s'il ne souhaite pas qu'un tweet soit envoyé sur son compte. De même, il est agréable pour l'utilisateur de pouvoir se déconnecter du site une fois qu'il a terminé ce qu'il avait à faire, proposez un lien de déconnexion. Ce n'est pas difficile, il suffit de vider la session.
Quelques liens utiles :
- Documentation de l'API de Twitter
- Règles de l'API de Twitter
- Statut de l'API de twitter
- Définition du modèle MVC sur Wikipedia
- Définition d'OAuth sur Wikipedia
- Définition d'une API sur Wikipedia
Ce tutoriel vous a plu ? Partagez le ou laissez un commentaire :)
Abonnez vous au flux RSS des tutoriels pour rester informé.
Sinon, n'hésitez pas à laisser un commentaire ou à partage ce tutoriel sur les réseaux sociaux, ça me fait toujours plaisir et m'encourage à continuer mon oeuvre pour un monde meilleur.
Il ne nous manque plus que la fonction de déconnexion à mettre dans le controleur :