So aktualisieren Sie Ihren Twitter-Status mit CodeIgniter

Hallo, in diesem Tutorial werden wir unseren Twitter-Status über die 'Twitter-API' mit CodeIgniter aktualisieren. Ich empfehle, Schritt für Schritt zu folgen, anstatt das Tutorial zu beschönigen. Lass uns reinschauen!

Tutorial-Details

• Programm: CodeIgniter PHP Framework
• Ausführung: 1.7.1
• Schwierigkeit: Fortgeschritten
• Voraussichtliche Fertigstellungszeit: 30 Minuten

1. CodeIgniter konfigurieren

Zunächst müssen wir einige Standardeinstellungen in der CI-Konfigurationssektion bearbeiten.

Öffne das system / application / config / autoload.php und bearbeite folgendes von:

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

zu:

$ autoload ['libraries'] = Array ('Datenbank');

Dadurch wird die Datenbank automatisch geladen. Als nächstes öffnen database.php und bearbeiten Sie die Datenbankverbindungseinstellung - den Namen von
Ihre Datenbank, Benutzer und Passwort. Als Namen werden wir verwenden ci_twitter_api.

Jetzt offen config.php und ändern Sie die base_url in Ihrem CI-Ordner. Mein Ordner heißt twitter_api.
In diesem Ordner ist mein System Mappe. Also wird mein base_url sein:

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

2. Füllen Sie die Datenbank

Da wir mit einer Datenbank arbeiten werden, benötigen wir zum Spielen einige Daten. Öffnen phpmyadmin oder Ihre
Favorit Datenbankverwaltungstool und erstellen Sie eine neue Datenbank namens ci_twitter_api. Jetzt richten wir ein
neue Tabelle mit der folgenden SQL-Abfrage, aber Beachtung, Verwenden Sie Ihren Twitter-Benutzernamen und Ihr Kennwort.

CREATE TABLE WENN NICHT "Accounts" vorhanden sind ('id' int (11) NOT NULL) AUTO_INCREMENT, 'username' varchar (120) NOT NULL, 'password' varchar (32) NOT NULL, 'aktiv' int (11) NOT NULL, 'last_message' varchar (140) NOT NULL, PRIMARY KEY ('id')) ENGINE = MyISAM DEFAULT CHARSET = latin1 AUTO_INCREMENT = 3; INSERT INTO 'Konten' ('ID', 'Benutzername', 'Passwort', 'Aktiv', 'Last_message') VALUES (1, ')DEIN BENUTZERNAME','IHR PASSWORT', 1,' Keine Nachricht gesendet. ');

Drücke den OK Schaltfläche auf der rechten Seite und die Abfrage sollte verarbeitet werden. Nun deine Struktur für die Tabelle
Konten sollte dem folgenden Bild ähnlich aussehen.

3. Modell erstellen

Gehe zu System / Anwendung / Modelle und erstellen Sie eine neue Datei mit dem Namen twitter_model.php.

Zuerst deklarieren wir oben zwei globale Variablen.

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

So $ accounts_table bezieht sich auf die Tabelle, die wir gerade erstellt haben, und $ update_url ist die URL, die wir verwenden werden
um unseren Status zu aktualisieren. Wenn Twitter die Update-URL ändert, müssen Sie sie hier nur einmal ändern, anstatt jedes Mal, wenn sie im Code verwendet wird.

Jetzt erstellen wir unsere erste Methode, die einfach das in der Datenbank gespeicherte aktive Benutzerkonto zurückgibt,
basierend auf der Reihe aktiv und Wert 1. Ich habe dies hinzugefügt, weil einige Leute zwei oder mehr Twitter haben
Konten.

 Klasse Twitter_model erweitert Model // holt das aktive Twitter-Konto aus der Datenbank, um die Zeile active = 1 function getActiveAccount () return $ this-> db-> get_where ($ this-> accounts_table, array ('active' => ') 1 ')) -> Zeile (); 

Wir verwenden einfach aktive Datensätze
Abrufen des aktiven Kontos und Rückgabe der betroffenen Zeile.

Im nächsten Schritt bauen wir die Hauptmethode, die aktualisieren Methode. Dies wird unser verwenden
Benutzername, Passwort und natürlich die Nachricht, die wir unseren Status auf Twitter senden und aktualisieren möchten. Abgesehen davon,
es wird das interpretieren HTTP_CODE die von Twitter zurückgegeben wird, um uns mitzuteilen, ob der Status aktualisiert wurde
erfolgreich oder nicht.

// Twitterstatus und letzte Nachricht bei Erfolgsfunktion aktualisieren update_status ($ Benutzername, $ Kennwort, $ Nachricht) $ 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); // Wenn wir erfolgreich waren, müssen wir unsere letzte Meldung aktualisieren, wenn ($ httpcode == '200') $ this-> db-> where ('active', '1'); $ this-> db-> update ($ this-> accounts_table, array ('last_message' => $ message)); return TRUE;  else return FALSE; 

Auf den ersten Blick sieht der obige Code etwas kompliziert aus, ist aber nicht so schwer zu verstehen. Der wichtigste Teil ist
dass wir cURL verwenden, um mit Twitter zu kommunizieren. Es ist wirklich großartig
Bibliothek, die uns das Senden und Empfangen ermöglichtHTTP POST Daten von Twitter.

Nun dann curl_init initialisiert eine cURL-Sitzung und übernimmt die URL als Parameter - in unserem Fall die Statusaktualisierung
URL aus dem Twitter-API.

Mit curl_setopt Wir haben einige notwendige Optionen für die CURL-Übertragung festgelegt.

• CURLOPT_POST: Wir setzen diesen Wert auf '1', um HTTP POST zu verwenden. Dies ist das gleiche wie in HTML-Formularen.
• CURLOPT_POSTFIELDS: Diese Option ermöglicht das Post-Daten dass wir senden wollen. In unserem Fall
  'status =' und unser Botschaft. Wir müssen Urlencode die Nachricht, um spezielle verwenden zu können
  Zeichen wie '% & / " .
• CURLOPT_RETURNTRANSFER: Es ist wichtig für uns, diesen Wert auf '1' zu setzen, da die Überweisung zurückgegeben wird
  als Schnur. Diese Zeichenfolge sagt uns später, ob der Status erfolgreich aktualisiert wurde oder nicht.
• CURLOPT_USERPWD: Diese Option dient zur Authentifizierung. Es benötigt einfach unseren Twitter-Benutzernamen und das Passwort
  im Format Benutzername Passwort.

curl_exec ($ ch); $ httpcode = curl_getinfo ($ ch, CURLINFO_HTTP_CODE); // Wenn wir erfolgreich waren, müssen wir unsere letzte Meldung aktualisieren, wenn ($ httpcode == '200') $ this-> db-> where ('active', '1'); $ this-> db-> update ($ this-> accounts_table, array ('last_message' => $ message)); return TRUE;  else return FALSE; 

In diesem Teil führen wir die Übertragung mit aus curl_exec () und das zurückgebrachte zurückholen HTTP_CODE
mit curl_getinfo (CURLINFO_HTTP_CODE). Diese HTTP_CODE teilt uns mit, ob die Statusaktualisierung abgeschlossen wurde oder nicht.
Code '200' bedeutet, dass es funktioniert hat und das Update durchgeführt wurde. Sie können eine vollständige Liste der HTTP-Statuscodes anzeigen
Hier.

Wenn wir "200" von Twitter zurückgeben, senden wir eine Abfrage an unsere Datenbank, in der die Zeile last_message aktualisiert wird, und schließlich
wir kehren zurück WAHR. Wenn 200 nicht zurückgegeben wird, kehren wir einfach zurück FALSCH.

Um unser zu beenden twitter_model Wir werden eine letzte Methode erstellen, die die letzte Nachricht wir sendeten. Wir brauchen
diese Methode, weil wir unsere aktuellste Nachricht in einer Ansicht anzeigen.

// Holen Sie sich die letzte_Nachricht, Zeile = aktive Funktion 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); 

Diese Methode ist ziemlich einfach. Es wählt die letzte Nachricht Zeile von unserem aktiven Konto und gibt es zurück
mit htmlspecialchars in HTML-Entitäten konvertiert.
Unsere twitter_model.php sieht jetzt so aus:

 Klasse Twitter_model erweitert Model var $ accounts_table = 'accounts'; var $ update_url = 'http://twitter.com/statuses/update.xml'; // Abrufen des aktiven Twitter-Kontos aus der Datenbank durch Zeile active = 1 function getActiveAccount () return $ this-> db-> get_where ($ this-> accounts_table, array ('active' => '1')) - > Zeile ();  // Twitterstatus und letzte Nachricht bei Erfolgsfunktion aktualisieren update_status ($ Benutzername, $ Kennwort, $ Nachricht) $ 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); // Wenn wir erfolgreich waren, müssen wir unsere letzte Meldung aktualisieren, wenn ($ httpcode == '200') $ this-> db-> where ('active', '1'); $ this-> db-> update ($ this-> accounts_table, array ('last_message' => $ message)); return TRUE;  else return FALSE;  // Liefert die letzte Nachricht, Zeile = aktive Funktion 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. Aufbau des Controllers

Gehen Sie jetzt zu System / Anwendung / Steuerungen und erstellen Sie eine neue Datei mit dem Namen twitter.php.
Fügen wir einige Zeilen hinzu:

Klasse Twitter erweitert Controller Funktion Twitter () Parent :: Controller (); $ this-> load-> model ('twitter_model'); 

Dies ist ein einfacher CI-Konstruktor, der unseren lädt twitter_model. Es wird uns also im gesamten Controller zur Verfügung stehen.
Jetzt kommt der Index() Methode.

Funktionsindex () $ data ['heading'] = 'Hallo, sende einen Tweet!'; $ data ['last_message'] = $ this-> twitter_model-> getLastMessage (); $ data ['active_user'] = $ this-> twitter_model-> getActiveAccount () -> Benutzername; $ this-> load-> view ('header', $ data); $ this-> load-> view ('index'); $ this-> load-> view ('footer'); 

Wir übermitteln Informationen wie einen Text, unsere letzte Nachricht und den Benutzernamen des aktiven Benutzers an den $ data Array.
Danke an unsere twitter_model Es ist ein Kinderspiel, sich die letzte Nachricht und den aktiven Benutzernamen zu holen. Zumindest laden wir einige
Ansichten die wir erstellen werden, nachdem wir unseren Controller fertiggestellt haben. Lass uns das bauen aktualisieren Methode.

// Aktualisierung unseres Status auf Twitter (neue Nachricht) Funktion 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'); // Benutzeraccount-Daten abrufen $ account = $ this-> twitter_model-> getActiveAccount (); $ username = $ account-> Benutzername; $ password = $ account-> password; // einen Tweet senden wenn ($ this-> twitter_model-> update_status ($ username, $ password, $ message)) redirect ('twitter');  else $ data ['error'] = 'Beim Aktualisieren Ihres Status ist ein Fehler aufgetreten.'; $ this-> load-> view ('header', $ data); $ this-> load-> view ('error'); $ this-> load-> view ('footer'); 

Das mag wieder verwirrend sein, aber wir werden es Stück für Stück durchgehen.

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 (); 

Mit $ this-> input-> post ('submit') Wir prüfen, ob das Formular übermittelt wurde - das wir später in unserer Hauptansicht erstellen werden
Datei. Danach laden wir die form_validation Bibliothek, weil wir sicherstellen möchten, dass bestimmte Eingaben Regeln erfordern,
wie eine minimale und maximale Länge von 5 und 140 Zeichen. Zusätzlich wird der Whitespace mit abgeschnitten trimmen und
das Feld als einstellen erforderlich weil wir keine leere Nachricht brauchen. Die Funktion festgelegten Regeln nimmt als ersten Parameter,
der Name des Feldes aus unserem Fall Botschaft (die in der Ansicht bald erstellt werden) und als zweiten Parameter einen Menschen
der Name für dieses Feld, der in die Fehlernachricht eingefügt wird (wird in der View-Datei vorgenommen).

Wir nennen $ this-> form_validation-> run (), was kann zurückkehren WAHR oder FALSCH. Wenn eine von uns gesetzte Regel verletzt wurde
wird zurückkehren FALSCH und wir rufen einfach unsere an Index() Methode. In den View-Dateien, die von der index () -Methode aufgerufen werden
Fehlermeldungen werden angezeigt, nachdem wir unsere Ansichten erstellt haben.

else $ message = $ this-> input-> post ('message'); // Benutzeraccount-Daten abrufen $ account = $ this-> twitter_model-> getActiveAccount (); $ username = $ account-> Benutzername; $ password = $ account-> password; // einen Tweet senden wenn ($ this-> twitter_model-> update_status ($ username, $ password, $ message)) redirect ('twitter');  else $ data ['error'] = 'Beim Aktualisieren Ihres Status ist ein Fehler aufgetreten.'; $ this-> load-> view ('header', $ data); $ this-> load-> view ('error'); $ this-> load-> view ('footer'); 

Danke an unsere twitter_model, es ist wieder so einfach, das zu finden Nutzername und das Passwort des aktuell aktiven Benutzers.
Wir könnten es auch tun $ username = $ this-> twitter_model-> getActiveAccount () -> Benutzername aber ich denke für dieses Tutorial ist es das
etwas verständlicher.

Verwenden $ this-> twitter_model-> update_status () Wir nennen die Methode, die mit Twitter "spricht". Es sagt Twitter unser
Nutzername, Passwort und unsere Nachricht Wenn der Status erfolgreich aktualisiert wurde, leiten wir mithilfe von um umleiten() von dem URL-Helfer.

Wenn etwas nicht stimmte, setzen wir eine Fehlermeldung und laden einige Ansichtsdateien, die im nächsten Schritt erstellt werden :).
Der Controller sieht jetzt so aus:

 Klasse Twitter erweitert Controller Funktion Twitter () Parent :: Controller (); $ this-> load-> model ('twitter_model');  function index () $ data ['heading'] = 'Hallo, sende einen Tweet!'; $ data ['last_message'] = $ this-> twitter_model-> getLastMessage (); $ data ['active_user'] = $ this-> twitter_model-> getActiveAccount () -> Benutzername; $ this-> load-> view ('header', $ data); $ this-> load-> view ('index'); $ this-> load-> view ('footer');  // Aktualisierung unseres Status auf Twitter (neue Nachricht) Funktion 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'); // Benutzeraccount-Daten abrufen $ account = $ this-> twitter_model-> getActiveAccount (); $ username = $ account-> Benutzername; $ password = $ account-> password; // einen Tweet senden wenn ($ this-> twitter_model-> update_status ($ username, $ password, $ message)) redirect ('twitter');  else $ data ['error'] = 'Beim Aktualisieren Ihres Status ist ein Fehler aufgetreten.'; $ this-> load-> view ('header', $ data); $ this-> load-> view ('error'); $ this-> load-> view ('footer');  else Weiterleitung ('twitter'); 

5. Ansichten erstellen

Jetzt erstellen wir unsere Ansichtsdateien. Gehe zu System / Anwendung / Ansichten und erstellen Sie die folgenden Dateien:

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

Das header.php enthält die grundlegenden HTML-Meta-Informationen, unseren CSS-Link und die Eröffnungs-Tags unserer wichtigsten Divs,
#Verpackung und #Main.

Wir benutzen base_url () die wir so konfiguriert haben, dass sie auf unsere CSS-Datei verweist, die im nächsten Schritt erstellt wird.

Das footer.php enthält einfach unsere schließenden Tags.