Come aggiornare lo stato di Twitter con CodeIgniter

Ciao, in questo tutorial aggiorneremo il nostro stato di Twitter tramite l'API di Twitter utilizzando CodeIgniter. Ti raccomando di seguire passo dopo passo, piuttosto che sorvolare il tutorial. Scaviamo dentro!

Dettagli dell'esercitazione

• Programma: CodeIgniter PHP Framework
• Versione: 1.7.1
• Difficoltà: avanzata
• Tempo di completamento stimato: 30 minuti

1. Configurazione di CodeIgniter

Inizialmente dobbiamo modificare alcune impostazioni predefinite all'interno della sezione di configurazione dell'IC.

Apri il system / application / config / autoload.php e modifica il seguente da:

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

a:

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

Questo caricherà automaticamente il database. Avanti, aperto database.php e modificare le impostazioni di connessione del database - il nome di
il tuo database, utente e password. Come nome useremo ci_twitter_api.

Ora aperto config.php e cambia il base_url alla tua cartella CI. La mia cartella è chiamata twitter_api.
In quella cartella è il mio sistema cartella. Quindi il mio base_url sarà:

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

2. Riempiendo il database

Poiché lavoreremo con un database, avremo bisogno di alcuni dati con cui giocare. Aperto phpmyadmin o il tuo
strumento di gestione del database preferito e creare un nuovo database chiamato ci_twitter_api. Ora installeremo a
nuova tabella utilizzando la seguente query SQL, ma Attenzione, usa le tue credenziali utente e password twitter.

CREATE TABLE SE NON ESISTE "account" ('id' int (11) NOT NULL AUTO_INCREMENT, 'username' varchar (120) NOT NULL, 'password' varchar (32) NOT NULL, 'active' int (11) NOT NULL, 'last_message' varchar (140) NOT NULL, PRIMARY KEY ('id')) ENGINE = MyISAM DEFAULT CHARSET = latin1 AUTO_INCREMENT = 3; INSERIRE 'account' ('id', 'username', 'password', 'active', 'last_message') VALUES (1, 'IL TUO NOME UTENTE','LA TUA PASSWORD', 1,' Nessun messaggio inviato. ');

Clicca il ok pulsante sul lato destro e la query deve essere elaborata. Ora la tua struttura per il tavolo
conti dovrebbe apparire simile all'immagine qui sotto.

3. Costruire il modello

Vai a system / application / modelli e creare un nuovo file chiamato twitter_model.php.

Innanzitutto, dichiareremo due variabili globali nella parte superiore.

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

Così $ accounts_table si riferisce alla tabella che abbiamo creato poco prima e $ update_url è l'url che useremo
per aggiornare il nostro stato. Se Twitter cambia il proprio URL di aggiornamento, è sufficiente modificarlo una volta qui invece che ogni volta che viene utilizzato nel codice.

Ora creeremo il nostro primo metodo che restituirà semplicemente l'account utente attivo memorizzato nel database,
in base alla riga attivo e valore 1. Ho aggiunto questo perché alcune persone hanno due o più Twitter
conti.

 classe Twitter_model estende Model // ottiene l'account Twitter attivo dal database, per riga attivo = 1 funzione getActiveAccount () return $ this-> db-> get_where ($ this-> accounts_table, array ('active' => ' 1' )) -> riga (); 

Stiamo semplicemente usando i record attivi
per recuperare l'account attivo e restituire la riga interessata.

Il prossimo passo, costruiremo il metodo principale, il aggiornare metodo. Questo userà il nostro
nome utente, password e, naturalmente, il messaggio che vogliamo inviare e aggiornare il nostro stato su Twitter. A parte quello,
interpreterà il HTTP_CODE che viene restituito da Twitter per dirci se lo stato è stato aggiornato
con successo o no.

// aggiorna lo stato di twitter e l'ultimo messaggio sulla funzione di successo update_status ($ username, $ password, $ 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. ':'. $ password); curl_exec ($ ch); $ httpcode = curl_getinfo ($ ch, CURLINFO_HTTP_CODE); // se avessimo successo, dovremo aggiornare il nostro last_message if ($ httpcode == '200') $ this-> db-> where ('active', '1'); $ this-> db-> update ($ this-> accounts_table, array ('last_message' => $ message)); return TRUE;  else return FALSE; 

A prima vista il codice sopra può apparire un po 'complicato ma non è così difficile da capire. La parte più importante è
che usiamo cURL per comunicare con Twitter. È davvero fantastico
libreria che ci consente di inviare e ricevereHTTP POST dati da Twitter.

Ora quindi curl_init inizializza una sessione cURL e prende l'URL come parametro - nel nostro caso l'aggiornamento dello stato
URL dal API di Twitter.

Con curl_setopt impostiamo alcune opzioni necessarie per il trasferimento cURL.

• CURLOPT_POST: Impostiamo questo valore su "1" per utilizzare HTTP POST, che è lo stesso utilizzato nei moduli HTML.
• CURLOPT_POSTFIELDS: Questa opzione fa il punto Dati POST che vogliamo inviare. Nel nostro caso
  'status =' e il nostro Messaggio. Abbiamo bisogno di UrlEncode il messaggio per poter usare speciali
  personaggi come '% & /" .
• CURLOPT_RETURNTRANSFER: È importante per noi impostarlo su "1" perché restituirà il trasferimento
  come una stringa. Quella stringa ci dirà in seguito se lo stato è stato aggiornato con successo o meno.
• CURLOPT_USERPWD: Questa opzione è per l'autenticazione. Richiede semplicemente il nome utente e la password di Twitter
  nel formato username: password.

curl_exec ($ ch); $ httpcode = curl_getinfo ($ ch, CURLINFO_HTTP_CODE); // se avessimo successo, dovremo aggiornare il nostro last_message if ($ httpcode == '200') $ this-> db-> where ('active', '1'); $ this-> db-> update ($ this-> accounts_table, array ('last_message' => $ message)); return TRUE;  else return FALSE; 

In questa parte stiamo eseguendo il trasferimento con curl_exec () e recuperando il reso HTTP_CODE
utilizzando curl_getinfo (CURLINFO_HTTP_CODE). Questo HTTP_CODE ci dice se l'aggiornamento di stato è stato completato o meno.
Il codice "200" indica che ha funzionato e che l'aggiornamento è stato eseguito. È possibile visualizzare un elenco completo dei codici di stato HTTP
Qui.

Se otteniamo "200" restituito da Twitter, inviamo una query al nostro database che aggiorna la nostra riga last_message e infine
torniamo VERO. Se 200 non viene restituito, torniamo semplicemente FALSE.

Per finire il nostro twitter_model creeremo un ultimo metodo che otterrà il ultimo messaggio abbiamo inviato. Abbiamo bisogno
questo metodo perché mostreremo il nostro messaggio più recente in una vista.

// get the last_message, per riga active = 1 function getLastMessage () $ this-> db-> select ('last_message'); $ last_message = $ this-> db-> get_where ($ this-> accounts_table, array ('active' => '1')) -> row () -> last_message; restituisce htmlspecialchars ($ last_message); 

Questo metodo è piuttosto semplice. Seleziona il ultimo messaggio fila dal nostro account attivo e lo restituisce
convertito con htmlspecialchars in entità HTML.
Nostro twitter_model.php ora sembra così:

 la classe Twitter_model estende il modello var $ accounts_table = 'account'; var $ update_url = 'http://twitter.com/statuses/update.xml'; // ottiene l'account Twitter attivo dal database, per riga attivo = 1 funzione getActiveAccount () return $ this-> db-> get_where ($ this-> accounts_table, array ('active' => '1')) - > riga ();  // aggiorna lo stato di twitter e l'ultimo messaggio sulla funzione di successo update_status ($ username, $ password, $ 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. ':'. $ password); curl_exec ($ ch); $ httpcode = curl_getinfo ($ ch, CURLINFO_HTTP_CODE); // se avessimo successo, dovremo aggiornare il nostro last_message if ($ httpcode == '200') $ this-> db-> where ('active', '1'); $ this-> db-> update ($ this-> accounts_table, array ('last_message' => $ message)); return TRUE;  else return FALSE;  // get the last_message, per riga active = 1 function getLastMessage () $ this-> db-> select ('last_message'); $ last_message = $ this-> db-> get_where ($ this-> accounts_table, array ('active' => '1')) -> row () -> last_message; restituisce htmlspecialchars ($ last_message); 

4. Costruzione del controller

Ora vai a system / application / controller e creare un nuovo file chiamato twitter.php.
Aggiungiamo alcune linee:

classe Twitter estende Controller function Twitter () parent :: Controller (); $ This-> load-> modello ( 'twitter_model'); 

Questo è un semplice costruttore di CI che carica il nostro twitter_model. Quindi sarà a nostra disposizione all'interno dell'intero controller.
Ora arriva il indice() metodo.

function index () $ data ['heading'] = 'Ciao, manda un tweet!'; $ data ['last_message'] = $ this-> twitter_model-> getLastMessage (); $ data ['active_user'] = $ this-> twitter_model-> getActiveAccount () -> username; $ this-> load-> view ('header', $ data); $ This-> load-> view ( 'index'); $ This-> load-> view ( 'piè di pagina'); 

Stiamo passando informazioni come un testo, il nostro ultimo messaggio e il nome utente dell'utente attivo al $ data schieramento.
Grazie al nostro twitter_model è un gioco da ragazzi per afferrare l'ultimo messaggio e il nome utente attivo. Almeno stiamo caricando alcuni
visualizzazioni che creeremo dopo aver finito il nostro controller. Costruiamo il aggiornare metodo.

// aggiornamento del nostro stato su twitter (nuovo messaggio) 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 | min_length [5] | max_length [140]'); if ($ this-> form_validation-> run () == FALSE) $ this-> index ();  else $ message = $ this-> input-> post ('message'); // recupera i dati dell'account utente $ account = $ this-> twitter_model-> getActiveAccount (); $ username = $ account-> username; $ password = $ account-> password; // invia un tweet if ($ this-> twitter_model-> update_status ($ username, $ password, $ message)) redirect ('twitter');  else $ data ['error'] = 'Si è verificato un errore durante l'aggiornamento dello stato'; $ this-> load-> view ('header', $ data); $ This-> load-> view ( 'errore'); $ This-> load-> view ( 'piè di pagina'); 

Ciò potrebbe confondere ancora, ma lo esamineremo parte per parte.

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

Con $ This-> input-> Post ( 'submit') controlliamo se il modulo è stato inviato, che creeremo in seguito nella nostra view principale
file. Dopo ciò, carichiamo il form_validation libreria perché vogliamo garantire che determinati input richiedano alcune regole,
come una lunghezza minima e massima di 5 e 140 caratteri. Inoltre stiamo tagliando gli spazi bianchi con tagliare e
impostando il campo come necessario perché non abbiamo bisogno di un messaggio vuoto. La funzione set_rules prende, come primo parametro,
il nome del campo da, il nostro caso Messaggio (che verrà creato presto nella vista) e come secondo parametro umano
il nome di questo campo, che verrà inserito nel messaggio di errore (verrà eseguito nel file di visualizzazione).

Noi chiamiamo $ This-> form_validation-> run (), che può tornare VERO o FALSE. Se una regola che abbiamo impostato è stata infranta
tornerà FALSE e chiamiamo semplicemente il nostro indice() metodo. Nella vista file chiamati dal metodo index () il
i messaggi di errore verranno visualizzati dopo aver creato le nostre viste.

else $ message = $ this-> input-> post ('message'); // recupera i dati dell'account utente $ account = $ this-> twitter_model-> getActiveAccount (); $ username = $ account-> username; $ password = $ account-> password; // invia un tweet if ($ this-> twitter_model-> update_status ($ username, $ password, $ message)) redirect ('twitter');  else $ data ['error'] = 'Si è verificato un errore durante l'aggiornamento dello stato'; $ this-> load-> view ('header', $ data); $ This-> load-> view ( 'errore'); $ This-> load-> view ( 'piè di pagina'); 

Grazie al nostro twitter_model, di nuovo è così facile recuperare il nome utente e il parola d'ordine dell'attuale utente attivo.
Potremmo anche fare $ username = $ this-> twitter_model-> getActiveAccount () -> username ma penso che questo tutorial sia questo
un po 'più facile da capire.

utilizzando $ This-> twitter_model-> update_status () chiamiamo il metodo che "parlerà" con Twitter. Dice a Twitter il nostro
nome utente, parola d'ordine e il nostro messaggio. Se lo stato è stato aggiornato correttamente, reindirizziamo utilizzando reindirizzare() dal url helper.

Se qualcosa non andava, impostiamo un messaggio di errore e carichiamo alcuni file di visualizzazione, che verranno creati nel passaggio successivo :).
Il controller appare ora in questo modo:

 classe Twitter estende Controller function Twitter () parent :: Controller (); $ This-> load-> modello ( 'twitter_model');  function index () $ data ['heading'] = 'Ciao, manda un tweet!'; $ data ['last_message'] = $ this-> twitter_model-> getLastMessage (); $ data ['active_user'] = $ this-> twitter_model-> getActiveAccount () -> username; $ this-> load-> view ('header', $ data); $ This-> load-> view ( 'index'); $ This-> load-> view ( 'piè di pagina');  // aggiornando il nostro stato su twitter (nuovo messaggio) 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 | min_length [5] | max_length [140]'); if ($ this-> form_validation-> run () == FALSE) $ this-> index ();  else $ message = $ this-> input-> post ('message'); // recupera i dati dell'account utente $ account = $ this-> twitter_model-> getActiveAccount (); $ username = $ account-> username; $ password = $ account-> password; // invia un tweet if ($ this-> twitter_model-> update_status ($ username, $ password, $ message)) redirect ('twitter');  else $ data ['error'] = 'Si è verificato un errore durante l'aggiornamento dello stato'; $ this-> load-> view ('header', $ data); $ This-> load-> view ( 'errore'); $ This-> load-> view ( 'piè di pagina');  else redirect ('twitter'); 

5. Creazione delle viste

Ora creeremo i nostri file di visualizzazione. Vai a system / application / views e creare i seguenti file:

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

Il header.php conterrà le informazioni metriche HTML di base, il nostro link CSS e i tag di apertura delle nostre div principali,
#wrapper e #principale.

Stiamo usando base_url () che abbiamo configurato per fare riferimento al nostro file CSS, che verrà creato nel passaggio successivo.

Il footer.php semplicemente contiene i nostri tag di chiusura.