Comment mettre à jour votre statut Twitter avec CodeIgniter

Bonjour, dans ce tutoriel, nous mettrons à jour notre statut Twitter via l'API Twitter à l'aide de CodeIgniter. Je recommande de suivre étape par étape plutôt que de passer sous silence le tutoriel. Creusons!

Détails du tutoriel

• Programme: Framework PHP CodeIgniter
• Version: 1.7.1
• Difficulté: avancée
• Temps d'exécution estimé: 30 minutes

1. Configuration de CodeIgniter

Au début, nous devons modifier certains paramètres par défaut dans la section Configuration de CI..

Ouvrez le système / application / config / autoload.php et éditez ce qui suit depuis:

$ autoload ['libraries'] = array (");

à:

$ autoload ['libraries'] = array ('base de données');

Cela chargera automatiquement la base de données. Ensuite, ouvrez database.php et éditez le paramètre de connexion à la base de données - le nom de
votre base de données, utilisateur et mot de passe. Comme nom nous allons utiliser ci_twitter_api.

Ouvert config.php et changer le base_url dans votre dossier CI. Mon dossier s'appelle twitter_api.
Dans ce dossier se trouve mon système dossier. Donc, mon base_url sera:

$ config ['base_url'] = "http: // localhost / ci / twitter_api";

2. Remplir la base de données

Parce que nous allons travailler avec une base de données, nous aurons besoin de certaines données pour jouer. Ouvrir phpmyadmin ou votre
outil de gestion de base de données préféré et créer une nouvelle base de données appelée ci_twitter_api. Maintenant, nous allons mettre en place un
nouvelle table en utilisant la requête SQL suivante, mais attention, utilisez VOS identifiants de nom d'utilisateur et de mot de passe twitter.

CREATE TABLE IF NOT PAS EXISTS 'accounts' ('id' int (11) NOT NULL AUTO_INCREMENT, 'nom d'utilisateur' varchar (120) NOT NULL, 'mot de passe' varchar (32) NOT NULL, 'actif' int (11) NOT NULL, 'last_message' varchar (140) NOT NULL, PRIMARY KEY ('id')) ENGINE = MyISAM DEFAULT CHARSET = latin1 AUTO_INCREMENT = 3; INSERT INTO 'comptes' ('' id ',' nom d'utilisateur ',' mot de passe ',' actif ',' last_message ') VALEURS (1,'TON NOM D'UTILISATEUR','VOTRE MOT DE PASSE', 1,' Aucun message envoyé. ');

Clique le D'accord sur le côté droit et la requête doit être traitée. Maintenant, votre structure pour la table
comptes devrait ressembler à l'image ci-dessous.

3. Construire le modèle

Aller à système / application / modèles et créez un nouveau fichier appelé twitter_model.php.

Tout d'abord, nous allons déclarer deux variables globales en haut.

var $ accounts_table = 'comptes'; var $ update_url = 'http://twitter.com/statuses/update.xml';

Alors $ accounts_table fait référence à la table que nous avons créée juste avant, et $ update_url est l'URL que nous utiliserons
pour mettre à jour notre statut. Si Twitter change d'URL de mise à jour, il vous suffit de l'éditer une fois ici au lieu de chaque fois qu'il est utilisé dans le code..

Maintenant, nous allons créer notre première méthode qui retournera simplement le compte d'utilisateur actif stocké dans la base de données,
basé sur la rangée actif et valeur 1. J'ai ajouté cela parce que certaines personnes ont deux ou plusieurs Twitter
comptes.

 class Twitter_model étend Model // récupère le compte twitter actif dans la base de données, par ligne active = 1 fonction getActiveAccount () return $ this-> db-> get_where ($ this-> accounts_table, array ('active' => ' 1 ')) -> rangée (); 

Nous utilisons simplement des enregistrements actifs
récupérer le compte actif et retourner la ligne affectée.

Prochaine étape, nous allons construire la méthode principale, la mettre à jour méthode. Cela utilisera notre
nom d'utilisateur, mot de passe et bien sûr le message que nous voulons envoyer et mettre à jour notre statut sur Twitter. Mis à part cela,
il va interpréter le HTTP_CODE qui est renvoyé par Twitter pour nous dire si le statut a été mis à jour
avec succès ou pas.

// met à jour le statut Twitter et le dernier message en cas de succès function update_status ($ nom d'utilisateur, $ mot de passe, $ message) $ ch = curl_init ($ this-> update_url); curl_setopt ($ ch, CURLOPT_POST, 1); curl_setopt ($ ch, CURLOPT_POSTFIELDS, 'status ='. urlencode ($ message)); curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt ($ ch, CURLOPT_USERPWD, $ username. ':'. $ mot de passe); curl_exec ($ ch); $ httpcode = curl_getinfo ($ ch, CURLINFO_HTTP_CODE); // si nous réussissons, nous devons mettre à jour notre last_message if ($ httpcode == '200') $ this-> db-> where ('active', '1'); $ this-> db-> update ($ this-> accounts_table, array ('last_message' => $ message)); renvoyer VRAI;  else return FALSE; 

À première vue, le code ci-dessus peut sembler un peu compliqué, mais ce n'est pas si difficile à comprendre. La partie la plus importante est
que nous utilisons cURL pour communiquer avec Twitter. C'est vraiment génial
bibliothèque qui nous permet d'envoyer et de recevoirPOST HTTP données de Twitter.

Maintenant curl_init initialise une session cURL et prend l'URL en tant que paramètre - dans notre cas, la mise à jour du statut
URL de la API Twitter.

Avec curl_setopt nous définissons quelques options nécessaires pour le transfert de cURL.

• CURLOPT_POST: Nous avons défini ceci sur '1' pour utiliser HTTP POST, identique à celui utilisé dans les formulaires HTML..
• CURLOPT_POSTFIELDS: Cette option aceepts le Données POST que nous voulons envoyer. Dans notre cas
  'status =' et notre message. Nous devons le faire code url le message pour pouvoir utiliser spéciale
  des personnages comme '% & / " .
• CURLOPT_RETURNTRANSFER: Il est important pour nous de définir ce paramètre sur "1", car le retour sera effectué
  comme une chaîne. Cette chaîne nous dira plus tard si le statut a été mis à jour avec succès ou non.
• CURLOPT_USERPWD: Cette option est pour l'authentification. Il suffit de notre nom d'utilisateur Twitter et mot de passe
  dans le format Identifiant Mot de passe.

curl_exec ($ ch); $ httpcode = curl_getinfo ($ ch, CURLINFO_HTTP_CODE); // si nous réussissons, nous devons mettre à jour notre last_message if ($ httpcode == '200') $ this-> db-> where ('active', '1'); $ this-> db-> update ($ this-> accounts_table, array ('last_message' => $ message)); renvoyer VRAI;  else return FALSE; 

Dans cette partie, nous exécutons le transfert avec curl_exec () et récupérer le retour HTTP_CODE
en utilisant curl_getinfo (CURLINFO_HTTP_CODE). Ce HTTP_CODE nous indique si la mise à jour de statut a été complétée ou non.
Le code «200» signifie que cela a fonctionné et que la mise à jour a été effectuée. Vous pouvez voir une liste complète des codes de statut HTTP
ici.

Si nous obtenons «200» renvoyés par Twitter, nous envoyons une requête à notre base de données qui met à jour notre ligne last_message, et enfin
nous retournons VRAI. Si 200 n'est pas retourné, nous retournons simplement FAUX.

Pour finir notre twitter_model nous allons créer une dernière méthode qui va obtenir le Dernier message nous avons envoyé. Nous avons besoin
cette méthode car nous allons afficher notre message le plus récent dans une vue.

// récupère le dernier message, par ligne active = 1 fonction getLastMessage () $ this-> db-> select ('last_message'); $ last_message = $ this-> db-> get_where ($ this-> accounts_table, array ('active' => '1')) -> row () -> last_message; return htmlspecialchars ($ last_message); 

Cette méthode est assez simple. Il sélectionne le Dernier message ligne de notre compte actif et le renvoie
converti avec htmlspecialchars en entités HTML.
Notre twitter_model.php ressemble maintenant à ceci:

 La classe Twitter_model étend Model var $ accounts_table = 'accounts'; var $ update_url = 'http://twitter.com/statuses/update.xml'; // récupère le compte twitter actif dans la base de données, par ligne active = 1 function getActiveAccount () return $ this-> db-> get_where ($ this-> accounts_table, array ('active' => '1')) - > row ();  // met à jour le statut Twitter et le dernier message en cas de succès de la fonction update_status ($ nom d'utilisateur, $ mot de passe, $ message) $ ch = curl_init ($ this-> update_url); curl_setopt ($ ch, CURLOPT_POST, 1); curl_setopt ($ ch, CURLOPT_POSTFIELDS, 'status ='. urlencode ($ message)); curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt ($ ch, CURLOPT_USERPWD, $ username. ':'. $ mot de passe); curl_exec ($ ch); $ httpcode = curl_getinfo ($ ch, CURLINFO_HTTP_CODE); // si nous réussissons, nous devons mettre à jour notre last_message if ($ httpcode == '200') $ this-> db-> where ('active', '1'); $ this-> db-> update ($ this-> accounts_table, array ('last_message' => $ message)); renvoyer VRAI;  else return FALSE;  // récupère le dernier message, par ligne active = 1 fonction getLastMessage () $ this-> db-> select ('last_message'); $ last_message = $ this-> db-> get_where ($ this-> accounts_table, array ('active' => '1')) -> row () -> last_message; return htmlspecialchars ($ last_message); 

4. Construire le contrôleur

Maintenant, allez à système / application / contrôleurs et créez un nouveau fichier appelé twitter.php.
Ajoutons quelques lignes:

la classe Twitter étend Controller function Twitter () parent :: Controller (); $ this-> load-> model ('twitter_model'); 

C’est un constructeur simple de CI qui charge notre twitter_model. Donc, il sera disponible pour nous dans l’ensemble du contrôleur.
Maintenant vient le indice() méthode.

function index () $ data ['rubrique'] = 'Bonjour, envoie un tweet!'; $ data ['last_message'] = $ this-> twitter_model-> getLastMessage (); $ data ['active_user'] = $ this-> twitter_model-> getActiveAccount () -> nom d'utilisateur; $ this-> load-> view ('en-tête', $ data); $ this-> load-> view ('index'); $ this-> load-> view ('footer'); 

Nous transmettons des informations telles que du texte, notre dernier message et le nom d’utilisateur actif à la $ data tableau.
Merci à notre twitter_model c'est un jeu d'enfant de saisir le dernier message et le nom d'utilisateur actif. Au moins nous chargeons
vues que nous allons créer après avoir fini notre contrôleur. Construisons le mettre à jour méthode.

// mise à jour de notre statut sur twitter (nouveau message) function update () if ($ this-> input-> post ('submit')) $ this-> load-> library ('form_validation'); $ this-> form_validation-> set_error_delimiters ('
','
'); $ this-> form_validation-> set_rules ('message', 'Message', 'trim | required | longueur_min [5] | longueur_max [140]'); if ($ this-> form_validation-> run () == FALSE) $ this-> index ();  else $ message = $ this-> input-> post ('message'); // récupère les données du compte utilisateur $ account = $ this-> twitter_model-> getActiveAccount (); $ nom d'utilisateur = $ compte-> nom d'utilisateur; $ password = $ compte-> mot de passe; // envoie un tweet if ($ this-> twitter_model-> update_status ($ username, $ password, $ message)) redirect ('twitter');  else $ data ['error'] = 'Une erreur est survenue lors de la mise à jour de votre statut'; $ this-> load-> view ('en-tête', $ data); $ this-> load-> view ('error'); $ this-> load-> view ('footer'); 

Cela peut encore être déroutant, mais nous allons le parcourir partie par partie.

if ($ this-> input-> post ('submit')) $ this-> load-> library ('form_validation'); $ this-> form_validation-> set_error_delimiters ('
','
'); $ this-> form_validation-> set_rules ('message', 'Message', 'trim | required | longueur_min [5] | longueur_max [140]'); if ($ this-> form_validation-> run () == FALSE) $ this-> index (); 

Avec $ this-> input-> post ('submit') nous vérifions si le formulaire a été soumis - que nous créerons plus tard dans notre vue principale
fichier. Après cela, nous chargeons le formulaire_validation bibliothèque parce que nous voulons nous assurer que certaines entrées nécessitent certaines règles,
comme une longueur minimale et maximale de 5 et 140 caractères. De plus, nous coupons les blancs avec réduire et
définir le champ comme Champs obligatoires parce que nous n'avons pas besoin d'un message vide. La fonction Définis les règles prend comme premier paramètre,
le nom du champ from, notre cas message (qui sera créé bientôt dans la vue) et en second paramètre un humain
le nom de ce champ, qui sera inséré dans le message d'erreur (sera fait dans le fichier de vue).

Nous appelons $ this-> form_validation-> run (), qui peut revenir VRAI ou FAUX. Si une règle que nous avons définie a été enfreinte,
reviendra FAUX et nous appelons simplement notre indice() méthode. Dans les fichiers de vue appelés par la méthode index (), le
les messages d'erreur seront affichés après la création de nos vues.

else $ message = $ this-> input-> post ('message'); // récupère les données du compte utilisateur $ account = $ this-> twitter_model-> getActiveAccount (); $ nom d'utilisateur = $ compte-> nom d'utilisateur; $ password = $ compte-> mot de passe; // envoie un tweet if ($ this-> twitter_model-> update_status ($ username, $ password, $ message)) redirect ('twitter');  else $ data ['error'] = 'Une erreur est survenue lors de la mise à jour de votre statut'; $ this-> load-> view ('en-tête', $ data); $ this-> load-> view ('error'); $ this-> load-> view ('footer'); 

Merci à notre twitter_model, encore une fois, il est si facile de récupérer le Nom d'utilisateur et le mot de passe de l'utilisateur actif actuel.
On pourrait aussi faire $ username = $ this-> twitter_model-> getActiveAccount () -> nom d'utilisateur mais je pense que pour ce tutoriel c'est
un peu plus facile à comprendre.

En utilisant $ this-> twitter_model-> update_status () nous appelons la méthode qui "parlera" à Twitter. Il raconte Twitter notre
Nom d'utilisateur, mot de passe et notre message. Si le statut a été mis à jour avec succès, nous redirigeons en utilisant réorienter() du assistant url.

Si quelque chose n'allait pas, nous définissons un message d'erreur et chargeons quelques fichiers de vue, qui seront créés à l'étape suivante :).
Le contrôleur ressemble maintenant à ceci:

 la classe Twitter étend Controller function Twitter () parent :: Controller (); $ this-> load-> model ('twitter_model');  function index () $ data ['heading'] = 'Bonjour, envoie un tweet!'; $ data ['last_message'] = $ this-> twitter_model-> getLastMessage (); $ data ['active_user'] = $ this-> twitter_model-> getActiveAccount () -> nom d'utilisateur; $ this-> load-> view ('en-tête', $ data); $ this-> load-> view ('index'); $ this-> load-> view ('footer');  // mise à jour de notre statut sur twitter (nouveau message) function update () if ($ this-> input-> post ('submit')) $ this-> load-> library ('form_validation'); $ this-> form_validation-> set_error_delimiters ('
','
'); $ this-> form_validation-> set_rules ('message', 'Message', 'trim | required | longueur_min [5] | longueur_max [140]'); if ($ this-> form_validation-> run () == FALSE) $ this-> index ();  else $ message = $ this-> input-> post ('message'); // récupère les données du compte utilisateur $ account = $ this-> twitter_model-> getActiveAccount (); $ nom d'utilisateur = $ compte-> nom d'utilisateur; $ password = $ compte-> mot de passe; // envoie un tweet if ($ this-> twitter_model-> update_status ($ username, $ password, $ message)) redirect ('twitter');  else $ data ['error'] = 'Une erreur est survenue lors de la mise à jour de votre statut'; $ this-> load-> view ('en-tête', $ data); $ this-> load-> view ('error'); $ this-> load-> view ('footer');  else redirect ('twitter'); 

5. Créer les vues

Nous allons maintenant créer nos fichiers de vue. Aller à système / application / vues et créez les fichiers suivants:

• header.php
• footer.php
• index.php
• error.php

le header.php contiendra les méta-informations html de base, notre lien CSS et les balises d'ouverture de nos divs principaux,
#wrapper et #principale.

Nous utilisons base_url () que nous avons configuré pour référencer notre fichier CSS, qui sera créé à l'étape suivante.

le footer.php contient simplement nos balises de fermeture.