<\/p>\n
Mit dem Automatisieren des Webdienstes Twitter hat Access im Unternehmen sich bereits beschäftigt. Allerdings hat Twitter mittlerweile die Authentifizierungsmethode gewechselt – auf das sogenannte OAuth. Die Programmierung des Zugriffs ist nicht ganz trivial, vor allem wegen der Erzeugung des notwendigen HMAC-SHA1-Ausdrucks, der zur Authentifizierung der Anfrage dient. Wie dies gelöst wurde und wie der Zugriff auf Twitter nun funktioniert, erfahren Sie in diesem Beitrag.<\/b><\/p>\n
Im Beitrag Twittern mit Access <\/b>(www.access-im-unternehmen.de\/715<\/b>) haben wir uns erstmalig mit Twitter beschäftigt. Damals gelang der Zugriff auf den Twitter-Webdienst noch über das einfache Basic Auth.<\/p>\n
Im Herbst 2010 hat Twitter dies jedoch auf OAuth umgestellt. Der Beitrag Twittern mit Access, Update <\/b>(www.access-im-unternehmen.de\/774<\/b>) lieferte eine erste Möglichkeit, mit OAuth zu arbeiten und somit wieder per VBA am Twitter-Geschehen teilnehmen zu können.<\/p>\n
Dies gelang über einen externen Anbieter, der die Authentifizierung auf Basis der übermittelten Daten vorgenommen hat. Die Performance leidet hier natürlich, außerdem weiß man nie, ob dieser (kostenlose) Anbieter nicht früher oder später seine Pforten schließt.<\/p>\n
Also wirft der vorliegende Beitrag einen etwas genaueren Blick auf OAuth. Vollständig zu entschlüsseln brauchten wir dies nicht – im Internet fand sich der eine oder andere Codeschnipsel, der die Lösung erleichterte.<\/p>\n
Grundlagen<\/b><\/p>\n
Grundlegende Informationen zu Twitter finden Sie im Beitrag Twittern mit Access <\/b>(www.access-im-unternehmen.de\/715<\/b>) und natürlich auf twitter.com <\/b>selbst.<\/p>\n
Voraussetzungen<\/b><\/p>\n
Für den Zugriff auf die Twitter-Schnittstelle per OAuth-Authentifizierung benötigen Sie einige Informationen. Als Erstes müssen Sie einen Twitter-Account anlegen, was Sie unter twitter.com <\/b>erledigen können (siehe Bild 1). Im nächsten Schritt bestätigen Sie dann die Benutzungsrichtlinien und erstellen Ihr Konto. Sie können dann einige Benutzer auswählen, denen Sie folgen und deren Statusmeldungen Sie lesen möchten. Sie erhalten eine Bestätigungs-E-Mail von Twitter, die einen Link zum Abschließen des Registrierungsvorgangs enthält.<\/p>\n
![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2011_04\/TwitterOAuth-web-images\/pic001.png\")
<\/p>\n
Bild 1: Registrieren bei twitter.com<\/span><\/b><\/p>\n Anwendung erstellen<\/b><\/p>\n Wechseln Sie nach erfolgter Registrierung zu dev.twitter.com<\/b>. Klicken Sie dort oben auf Your Apps<\/b>. Es erscheint die Übersicht der Anwendungen des aktuellen Kontos. Wenn Sie noch keine Anwendung erstellt haben, erledigen Sie dies jetzt mit einem Klick auf den Link Register a new application<\/b> (s. Bild 2).<\/p>\n Bild 2: Erstellen einer neuen Anwendung<\/span><\/b><\/p>\n Im folgenden Dialog tragen Sie nun die Eigenschaften der Anwendung ein (s. Bild 3):<\/p>\n Bild 3: Eingeben der Anwendungsdaten<\/span><\/b><\/p>\n Nach der Eingabe des Captcha-Codes registriert Twitter Ihre Anwendung. Auf der folgenden Seite erhalten Sie dann wichtige Informationen, die Sie später etwa zum Authentifizieren vor dem Zugriff auf twitter.com <\/b>via VBA benötigen (s. Bild 4).<\/p>\n Bild 4: Informationen zur Authentifizierung<\/span><\/b><\/p>\n Wo Sie gerade einmal hier sind: In der Beispieldatenbank zu diesem Beitrag finden Sie eine Tabelle namens tblApplications<\/b> (s. Bild 4 liefert beispielsweise die Werte für die Felder ConsumerKey <\/b>und ConsumerSecret<\/b>. Für ApplicationName <\/b>können Sie den Namen der Anwendung eintragen (dieses Feld dient lediglich der Identifizierung der zugeordneten Anwendung und hat keine Bedeutung für die Anwendung). SignatureMethod <\/b>erhält den Wert HMAC-SHA1<\/b>, für die Version <\/b>legen Sie den Wert 1.0 <\/b>fest.<\/p>\n Bild 5: Tabelle zum Speichern der Zugriffsdaten<\/span><\/b><\/p>\n Die beiden übrigen Werte Token <\/b>und TokenSecret <\/b>erhalten Sie, wenn Sie rechts auf den Link My Access Token <\/b>klicken. Tragen Sie die beiden Werte aus der nun erscheinenden Übersicht (s. Bild 6) in die Tabelle tblApplications <\/b>ein.<\/p>\n Bild 6: Ermitteln von Access Token und Secret<\/span><\/b><\/p>\n Damit sind die Arbeiten auf twitter.com <\/b>abgeschlossen – später werden Sie hier allerdings nachschauen, ob die von Access aus gesendeten Statusmeldungen auch dort angekommen sind.<\/p>\n Basisausstattung<\/b><\/p>\n Um das Rad nicht neu zu erfinden, bauen wir die Lösung dieses Beitrags auf der aus Twittern mit Access <\/b>(www.access-im-unternehmen.de\/715<\/b>) auf. Dort hatten wir bereits ein Formular programmiert, das vorhandene Statusmeldungen anzeigte und das Absenden neuer Statusmeldungen ermöglichte. Außerdem konnten Sie dort vorhandene Statusmeldungen löschen (s. Bild 7).<\/p>\n Bild 7: Die Benutzeroberfläche des Beispielformulars<\/span><\/b><\/p>\n Ein wichtiger Unterschied zur damaligen Lösung besteht darin, dass das Kombinationsfeld nicht mehr zur Auswahl eines Benutzers dient, sondern zur Ermittlung der zu verwendenden Anwendungsdaten. Wenn Sie mehrere Applications unter Ihrem Account anlegen möchten, können Sie die damit zusammenhängenden Daten in verschiedenen Datensätzen der Tabelle tblApplications <\/b>speichern.<\/p>\n Grundsätzlich ist die Beispiellösung als Single-User-Lösung zu betrachten. Sie können damit zwar verschiedene Daten von Twitter lesen (wie Benutzerdaten, Tweets, Follower et cetera), aber nur Statusmeldungen für den Benutzer erstellen oder löschen, in dessen Kontext Sie die Application bei Twitter erstellt haben.<\/p>\n Grundsätzlich ist es möglich, mit einer Anwendung auch die Daten anderer Benutzer zu ändern – das wäre interessant, wenn Sie die Beispiellösung nicht nur für sich selbst verwenden wollen, sondern diese an andere Benutzer weitergeben möchten.<\/p>\n Diese melden sich dann mit ihren eigenen Daten an und können selbst Statusmeldungen erstellen und löschen, Direktnachrichten versenden und so weiter. Der dazu nötige Workflow ist allerdings noch ein wenig aufwendiger als der nachfolgend vorgestellte. Gegebenenfalls gehen wir in einem weiteren Beitrag auf diese Erweiterung ein.<\/p>\n Formular der Beispiellösung<\/b><\/p>\n Das Formular stellt also zunächst ein Kombinationsfeld zur Auswahl der zu verwendenden Anwendungsdaten zur Verfügung, das mit den ersten beiden Feldern der Tabelle tblApplications <\/b>als Datensatzherkunft gefüllt ist.<\/p>\n Beim Öffnen des Formulars stellt die folgende, durch das Ereignis Beim Laden <\/b>ausgelöste Prozedur zunächst das Kombinationsfeld auf den ersten Eintrag ein.<\/p>\n Außerdem ruft sie die Prozedur TweetsLaden <\/b>auf, die für das Füllen des Listenfeldes mit Ihren letzten Statusmeldungen verantwortlich ist:<\/p>\n Die Prozedur TweetsLaden <\/b>ruft wiederum eine Funktion namens GetTweets_Listbox <\/b>auf, die eine Zeichenkette mit den im Listenfeld anzuzeigenden Daten zurückliefert. Das Ergebnis landet umgehend in der Eigenschaft RowSource <\/b>des Listenfelds und sieht beispielsweise so aus:<\/p>\n Danach markiert die Prozedur den ersten Eintrag des Listenfeldes und ruft die Routine TweetAnzeigen <\/b>auf:<\/p>\n TweetAnzeigen <\/b>hat nichts weiter zu tun, als das Datum der aktuell markierten Statusmeldung und ihren Text aus der Datensatzherkunft des Listenfeldes auszulesen und in die beiden Textfelder txtDatum <\/b>und txtTweet <\/b>einzutragen:<\/p>\n Ein Klick auf einen der übrigen Einträge im Listenfeld löst die folgende Ereignisprozedur aus, die ebenfalls die Prozedur zum Anzeigen der Details der Statusmeldung aufruft:<\/p>\n Das Aktualisieren des Listenfeldes erreicht der Benutzer durch einen Klick auf die Schaltfläche cmdTweetsLaden<\/b>:<\/p>\n Neue Statusmeldungen schreibt der Benutzer in das Textfeld txtNeuerTweet<\/b>. Damit der Benutzer immer weiß, wie viele Zeichen noch verbleiben, löst das Eingeben eines Zeichens jeweils das Ereignis Bei änderung <\/b>aus. Die entsprechende Ereignisprozedur sieht wie folgt aus:<\/p>\n Sie ermittelt aus der aktuellen Textlänge die verbleibenden Zeichen. Ist die Anzahl der Zeichen größer oder gleich 0, wird der aktuelle Text in der Variablen strTweet<\/b> gespeichert. Sollte diese Anzahl kleiner als 0 werden, stellt die Prozedur den Text vor der Eingabe dieses Zeichens aus der Variablen strTweet <\/b>wieder her. Zum Absenden der Statusmeldung klickt der Benutzer auf die Schaltfläche cmdTweetSenden<\/b>. Diese ruft die Funktion NeuerStatus <\/b>auf, die nach dem erfolgreichen Versenden die ID der neuen Statusmeldung zurückliefert. Ist dies der Fall, sorgt ein erneuter Aufruf der Prozedur TweetsLaden<\/b> dafür, dass das Listenfeld der zuletzt erstellten Statusmeldungen aktualisiert wird:<\/p>\n Fehlt nur noch das Löschen der aktuell markierten Statusmeldung. Dies wird durch einen Klick auf die Schaltfläche cmdTweetLoeschen <\/b>erreicht.<\/p>\n Die folgende Prozedur ruft dann die Funktion StatusLoeschen <\/b>auf, die nach erfolgter Löschung den Wert True <\/b>zurückliefert. Dies wird durch das Aktualisieren des Listenfeldes quittiert:<\/p>\n Dies zur Funktionsweise des Formulars – in den folgenden Abschnitten schauen wir uns an, was unter der Haube passiert, sprich: Wie der Zugriff auf die Twitter-API vonstatten geht.<\/p>\n Grundlegender Zugriff auf Twitter<\/b><\/p>\n Um es vorwegzunehmen: Der Zugriff auf die Twitter-API mit der Authentifizierung per OAuth<\/b> ist sehr aufwendig im Vergleich mit der zuvor möglichen Anmeldung per Basic Auth<\/b>.<\/p>\n Für den Zugriff benötigen Sie zunächst einmal eine Reihe Parameter, die zum größten Teil aus der Tabelle tblApplications <\/b>bezogen werden können. Zusätzlich benötigen Sie den Link für den Zugriff auf die gewünschte API-Funktion und die Zugriffsart (POST<\/b>\/GET<\/b>).<\/p>\n Den Link für den Zugriff entnehmen Sie der Dokumentation, für das Versenden einer neuen Statusmeldung etwa unter http:\/\/dev.twitter.com\/doc\/post\/statuses\/update<\/b>. Auf dieser Seite finden Sie am rechten Rand Links zu allen möglichen Aktionen, die Sie mit der Twitter-API ausführen können.<\/p>\n Für das Aktualisieren des Status rufen Sie beispielsweise die folgende Adresse auf:<\/p>\n Die Platzhalter [version] <\/b>und [format] <\/b>ersetzen wir in der Beispiellösung durch 1 <\/b>und xml<\/b>. In der Dokumentation erfahren Sie auch, dass das Aktualisieren des Status eine POST<\/b>-Anfrage nötig macht und dass eine Authentifizierung nötig ist.<\/p>\n <\/p>\n Die API-Funktion erwartet außerdem einen Parameter namens status<\/b>, der den Text der neuen Statusmeldung enthält. Der nackte Aufruf zum ändern des aktuellen Status sieht also etwa so aus:<\/p>\n Leer- und Sonderzeichen in der als Parameter übergebenen Statusmeldung werden durch URL-encodierte Zeichen ersetzt, beim Leerzeichen etwa durch %20<\/b>. Dies entspricht dem ASCII-Code des Leerzeichens (32<\/b>) in hexadezimaler Schreibweise (20<\/b>) plus einem vorangestellten Prozentzeichen, damit die API-Funktion die encodierten Zeichen erkennen und entsprechend zurückverwandeln kann.<\/p>\n Nun wäre es leicht, diesen API-Aufruf abzusetzen.Dies ginge beispielsweise so:<\/p>\n Das Problem ist nur, dass die Twitter-API Sie ohne vorherige Authentifizierung per OAuth mit einem lapidaren Could not authenticate you <\/b>wieder nach Hause schickt.<\/p>\n Authentifizieren mit OAuth<\/p>\n Also begeben wir uns auf den Weg, eine Authentifizierung per OAuth zu programmieren.<\/p>\n Dazu brauchen Sie zuerst einmal eine Liste der notwendigen Parameter:<\/p>\n Diese Parameter müssen in alphabetischer Reihenfolge sortiert und aneinandergehängt werden – etwa so:<\/p>\n In diesem Beispiel kommt noch der Parameter status <\/b>hinzu. Da je nach API-Aufruf ein oder mehrere verschiedene Parameter zum Einsatz kommen, gerät das Aneinanderketten der Parameter zu einer dynamischen Angelegenheit.<\/p>\n In der Beispiellösung haben wir daher eine Tabelle namens tblParameter <\/b>angelegt, die alle für den jeweiligen API-Aufruf notwendigen Parameter speichert. Später werden die Parameter in einem Recordset auf Basis dieser Tabelle mit einer einfachen ORDER BY<\/b>-Klausel sortiert und in der richtigen Reihenfolge zusammengesetzt.<\/p>\n Dieser Parameterliste fügt die Prozedur der Beispiellösung noch die Zugriffsmethode (hier POST<\/b>) und den Link zur API-Funktion hinzu (http:\/\/api.twitter.com\/1\/statuses\/update.xml<\/b>). Der resultierende Ausdruck wird wieder URL-encodiert und sieht dann beispielsweise so aus:<\/p>\n Dieser Ausdruck ist der Basisausdruck zum Ermitteln einer Signatur. Daneben benötigen Sie noch einen Key. Diesen bezieht die Prozedur DoTwitter<\/b> aus den Feldern ConsumerSecret <\/b>und TokenSecret <\/b>der Tabelle tblApplications<\/b>. Beide werden durch ein Kaufmanns-Und getrennt zusammengesetzt.<\/p>\n Mit diesen Informationen ermittelt die Lösung wiederum die für die Authentifizierung notwendige Signatur. Dieser Vorgang ist sehr kompliziert und wird zum größten Teil in einer eigenen Klasse durchgeführt. Die Signatur ist eine Zeichenkette wie die folgende:<\/p>\n Wozu diese Signatur Sie ist ein Extrakt aus den zu übermittelnden Daten, also den Informationen, die in der Parameterliste aufgeführt werden, sowie von Daten, die nicht übertragen werden – nämlich dem Key, der aus den beiden geheimen Schlüsseln aus der Tabelle tblApplications <\/b>besteht.<\/p>\n Die Signatur wird zur Authentifizierung gemeinsam mit den öffentlichen Parametern an Twitter gesendet, das ja die geheimen Informationen aus der Tabelle tblApplications <\/b>ebenfalls kennt. Twitter kann dann prüfen, ob die Signatur zu den übermittelten Daten und den beiden Schlüsseln passt.<\/p>\n Dadurch wird verhindert, dass auf dem Wege zwischen der Anwendung und Twitter die zu übermittelnden Daten von Dritten geändert werden. Sollte dies geschehen, würde die Signatur nicht mehr zu den übermittelten Daten passen und Twitter würde die Anmeldung zurückweisen.<\/p>\n Die komplizierte Ermittlung der Signatur ist dabei darauf zurückzuführen, dass Dritte keine Möglichkeit haben sollen, aus den gesendeten öffentlichen Parametern und der Signatur die geheimen Schlüssel zu ermitteln, und somit die Anfrage ändern oder eigene Anfragen senden können.<\/p>\n OAuth per VBA<\/b><\/p>\n In der Beispiellösung werden die Authentifizierung und gleichzeitig die Übermittlung der Anfrage inklusive Annahme der Antwort durch die Prozedur DoTwitter <\/b>erledigt (s. Listing 1). Die Prozedur erwartet die folgenden Parameter:<\/p>\n Listing 1: Das Grundgerüst für den Zugriff auf die Twitter-API<\/p>\n Die Prozedur löscht zunächst eventuell noch vorhandene Parameter aus der Tabelle tblParameter<\/b> (Zeile 13). Dann erstellt sie ein neues Recordset auf Basis dieser Tabelle, das gleich an die Routine SetSignatureBaseParameters <\/b>übergeben wird (s. Listing 2<\/a><\/span>).<\/p>\n Listing 2: Zusammenstellen der Basisparameter für die Authentifizierung<\/p>\n Diese Funktion ruft für jeden benötigten Parameter einmal eine weitere Funktion namens AddParameter <\/b>auf (s. Listing 3<\/a><\/span>). Diese fügt der Tabelle tblParameter <\/b>einen den übergebenen Daten entsprechenden Datensatz hinzu.<\/p>\n Listing 3: Eintragen eines Parameters in die Tabelle tblParameter<\/p>\n Dabei greift SetSignatureBaseParameters <\/b>teilweise auf die Daten in tblApplications<\/b> zu, teilweise werden die Werte aber auch statisch zugewiesen oder dynamisch generiert. Letzteres geschieht beispielsweise beim sogenannten Nonce<\/b>-Wert. Dies ist eine zufällig generierte Zeichenfolge mit 42 Zeichen, die für jeden Zugriff neu erzeugt wird und somit die Eindeutigkeit auch zweier sonst identischer Authentifizierungsvorgänge gewährleistet. Der Nonce<\/b>-Wert wird durch die Funktion GetOAuthNonce <\/b>erzeugt (s. Listing 4<\/a><\/span>).<\/p>\n Listing 4: Ermitteln einer zufälligen Zeichenfolge beliebiger Länge<\/p>\n Auch der Timestamp wird durch eine eigene Funktion erzeugt, die so aussieht:<\/p>\n Zurück zur Funktion DoTwitter<\/b>: Dort wird in Zeile 15 bis 20 eine For…Next<\/b>-Schleife durchlaufen, die jedes mit dem Parameter strParameters <\/b>übergebene Name\/Wert-Paar einmal durchlaufen soll. Da Name und Wert der Parameter in je einem Durchlauf bearbeitet werden sollen, enthält das For…Next<\/b>-Konstrukt den Zusatz Step 2<\/b>. Innerhalb der Schleife geschehen zwei Dinge: Erstens werden die Parameter über die Prozedur AddParameter <\/b>ebenfalls der Tabelle tblParameter <\/b>zugewiesen. Zweitens wird in der Variablen strParameterliste <\/b>eine Liste der Parameter erzeugt, wobei Name und Wert jeweils durch ein Gleichheitszeichen und die einzelnen Paare durch das Kaufmanns-Und voneinander getrennt werden, wobei der Wert noch URL-encodiert wird. Das erste Kaufmanns-Und vorn wird abgeschnitten, sodass ein Ausdruck wie status=Neuer%20Status <\/b>dabei herauskommt.<\/p>\n Die Prozedur URLEncode<\/b> sieht dabei übrigens wie in Listing 5<\/a><\/span> aus. Sie durchläuft alle Zeichen der als Parameter übergebenen Zeichenfolge und verschlüsselt alle Zeichen außer den Buchstaben des Alphabets (klein und groß), den Zahlen von 0 bis 9 und den Zeichen Punkt (.), Minus (-), Unterstrich (_) und Tilde (~). Dabei ermittelt sie erst den ASCII-Code, wandelt diesen in Hexadezimalcode um, ergänzt eine führende Null, wenn dieser Code nur ein Zeichen enthält, und fügt ein führendes Prozentzeichen hinzu. Aus dem Leerzeichen wird so %20<\/b>, aus dem Gleichheitszeichen wird %3D <\/b>und auch Umlaute und das scharfe S werden entsprechend verschlüsselt.<\/p>\n Listing 5: Diese Prozedur macht Zeichenketten URL-konform.<\/p>\n Danach erstellt die Funktion DoTwitter <\/b>den ersten Teil der beiden Elemente, die zum Erzeugen der für die Authentifizierung benötigten Signatur gebraucht werden. Dazu führt sie ab Zeile 24 die mit strMethod<\/b> übergebene Methode (POST\/GET), den URL-encodierten API-Aufruf und die nach dem Alphabet sortierte Liste der Parameter der Tabelle tblParameter <\/b>zusammen. Diese liefert die Funktion GetParameters<\/b> (s. Listing 6<\/a><\/span>). Diese Prozedur durchläuft alle Datensätze der Tabelle tblParameters<\/b> in alphabetischer Reihenfolge und fügt die Name-Wert-Paare zu einer Zeichenkette zusammen.<\/p>\n Listing 6: Diese Funktion liefert die Parameterliste für die Erzeugung der Signatur.<\/p>\n In Zeile 25 stellt DoTwitter <\/b>dann den Schlüssel zum Signieren zusammen. Dieser besteht aus den Werten für ConsumerSecret <\/b>und TokenSecret <\/b>der Tabelle tblApplications<\/b>. Die Signatur wird dann schließlich durch die Funktion GetSignature<\/b> ermitteln (s. Listing 7<\/a><\/span>). Diese Prozedur verwendet mehrere Methoden der Klasse clsHMACSHA1<\/b>, die wir [1] entnommen haben.<\/p>\n Listing 7: GetSignature liefert die Signatur für die Authentifizierung.<\/p>\n Zunächst wird der Schlüssel mit der Funktion StringToHex <\/b>(s. Listing 8<\/a><\/span>) in hexadezimale ASCII-Werte umgewandelt (A <\/b>wird so über den ASCII-Code 65 <\/b>zu 41<\/b>). Daraus erzeugt die Methode Decode <\/b>der Klasse clsHMACSHA1 <\/b>ein Byte-Array für die weitere Verarbeitung durch die Methode InitHMAC<\/b>.<\/p>\n Listing 8: Umwandeln eines Textes in hexadezimale ASCII-Codes<\/p>\n Danach wird die Parameterliste auf die gleiche Weise mit StringToHex <\/b>und Decode <\/b>behandelt und dann der Funktion HmacSha1 <\/b>übergeben, die das Ergebnis als Byte-Array zurückliefert. Nach der Behandlung mit den drei Funktionen Encode<\/b>, HexToText<\/b>, Encode64 <\/b>und URLEncode <\/b>erhalten wir die Signatur im gewünschten Format.<\/p>\n Die hier verwendete Funktion HexToText<\/b> wandelt mithilfe einer weiteren Funktion namens HexToDec <\/b>hexadezimale ASCII-Codes wieder in Zeichen um (s. Listing 9<\/a><\/span> und Listing 10<\/a><\/span>).<\/p>\n Listing 9: Text aus hexadezimalem ASCII-Code erzeugen<\/p>\n Listing 10: Hexadezimale Werte in dezimale Werte umwandeln<\/p>\n Erstere ermittelt dabei jeweils die Paare der Werte zwischen 00 <\/b>und FF <\/b>und gibt diese an die Funktion HexToDec <\/b>weiter, welche diese in Zahlen von 0 <\/b>bis 255 <\/b>umwandelt. Den ganzen Zirkus haben wir nur veranstaltet, um an diese Signatur zu kommen. Diese fügt die Funktion GetOAuthHeader <\/b>nun zu Headerdaten zusammen (s. Listing 11<\/a><\/span>).<\/p>\n Listing 11: Ermitteln der Headerdaten<\/p>\n Diese Daten, die zusammen mit der HTTP-Anfrage zur Authentifizierung an Twitter gesendet werden, sehen etwa so aus:<\/p>\n Mit diesen Informationen im Gepäck geht es an die eigentliche Kontaktaufnahme mit Twitter.<\/p>\n Das XMLHTTP<\/b>-Objekt ermöglicht es, die Anfrage unter Angabe der Header-Daten an Twitter zu senden. Dabei geben Sie die Methode (POST<\/b>\/GET<\/b>) und die URL mit Parameterliste als Parameter der Open<\/b>-Methode an und die Headerdaten als Parameter der Methode setRequestHeader<\/b>.<\/p>\n Nach dem Ausführen der send<\/b>-Methode enthält die Eigenschaft responseText <\/b>die Antwort von Twitter. Diese packen wir in ein XML-Dokument und geben diese als Funktionswert von DoTwitter<\/b> an die aufrufende Funktion zurück.<\/p>\n Twitter-Aufruf im Einsatz<\/b><\/p>\n Fehlen noch die Bindeglieder zwischen den Schaltflächen des Formulars frmTwittern<\/b> und der Funktion DoTwitter<\/b>. Die Prozedur hinter der Schaltfläche zum Aktualisieren der Statusmeldung etwa ruft die Funktion NeuerStatus <\/b>auf (s. Listing 12<\/a><\/span>). Diese legt die Methode (POST <\/b>als strMethode<\/b>) und die URL fest (http:\/\/api.twitter.com\/1\/statuses\/update.xml <\/b>als strAction<\/b>).<\/p>\n Listing 12: Aktualisieren der Statusmeldung<\/p>\n Dann ruft sie die Funktion DoTwitter <\/b>mit dem Parameternamen status <\/b>und der Statusmeldung als weitere Parameter auf und weist das Ergebnis der als DOMDocument <\/b>deklarierten Variablen objXML <\/b>zu.<\/p>\n![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2011_04\/TwitterOAuth-web-images\/pic002.png\")
<\/p>\n![\"pic003.png\"](\"..\/fileadmin\/_temp_\/2011_04\/TwitterOAuth-web-images\/pic003.png\")
<\/p>\n\n
![\"pic005.png\"](\"..\/fileadmin\/_temp_\/2011_04\/TwitterOAuth-web-images\/pic005.png\")
<\/p>\n![\"pic004.png\"](\"..\/fileadmin\/_temp_\/2011_04\/TwitterOAuth-web-images\/pic004.png\")
<\/p>\n![\"pic006.png\"](\"..\/fileadmin\/_temp_\/2011_04\/TwitterOAuth-web-images\/pic006.png\")
<\/p>\n![\"pic007.png\"](\"..\/fileadmin\/_temp_\/2011_04\/TwitterOAuth-web-images\/pic007.png\")
<\/p>\nPrivate Sub Form_Load()\r\n Me!cboApplication = _\r\n Me!cboApplication.ItemData(0)\r\n Call TweetsLaden\r\n End Sub<\/pre>\n
"85580978990493696";"28.06.2011 05:31:10";"Beispielstatusmeldung";"83562060692209664";"22.06.2011 15:48:42";"Noch eine Beispielstatusmeldung";...<\/pre>\n
Private Sub TweetsLaden()\r\n Me!lstTweets.RowSource = GetTweets_Listbox(Me!cboApplication)\r\n Me!lstTweets = Me!lstTweets.ItemData(0)\r\n Call TweetAnzeigen\r\n End Sub<\/pre>\n
Private Sub TweetAnzeigen()\r\n Me!txtDatum = Me!lstTweets.Column(1)\r\n Me!txtTweet = Me!lstTweets.Column(2)\r\n End Sub<\/pre>\n
Private Sub lstTweets_AfterUpdate()\r\n TweetAnzeigen\r\n End Sub<\/pre>\n
Private Sub cmdTweetsLaden_Click()\r\n Call TweetsLaden\r\n End Sub<\/pre>\n
Private Sub txtNeuerTweet_Change()\r\n Dim intZeichenUebrig As Integer\r\n Dim intPos As Integer\r\n intZeichenUebrig = _\r\n 140 - Len(Me!txtNeuerTweet.Text)\r\n If intZeichenUebrig < 0 Then\r\n intPos = Me!txtNeuerTweet.SelStart\r\n Me!txtNeuerTweet = strTweet\r\n Me!txtNeuerTweet.SelStart = intPos - 1\r\n Else\r\n Me!txtZeichenUebrig = intZeichenUebrig\r\n strTweet = Me!txtNeuerTweet.Text\r\n End If\r\n End Sub<\/pre>\n
Private Sub cmdTweetSenden_Click()\r\n Dim strID As String\r\n strID = NeuerStatus(Me!cboApplication, _\r\n Me!txtNeuerTweet)\r\n If Len(strID) > 0 Then\r\n Call TweetsLaden\r\n End If\r\n End Sub<\/pre>\n
Private Sub cmdTweetLoeschen_Click()\r\n If StatusLoeschen(Me!cboApplication, _\r\n Me!lstTweets) = True Then\r\n Call TweetsLaden\r\nEnd If\r\nEnd Sub<\/pre>\n
http:\/\/api.twitter.com\/[version]\/statuses\/update.[format]<\/pre>\n
http:\/\/api.twitter.com\/1\/statuses\/update.xmlstatus=Dies%20ist%20ein%20neuer%20Status<\/pre>\n
Set objXMLHTTP = CreateObject("MSXML2.XMLHTTP")\r\nWith objXMLHTTP\r\n.Open "POST", " http:\/\/api.twitter.com\/1\/\r\nstatuses\/update.xmlstatus=\r\nDies%20ist%20ein%20neuer%20Status", False\r\n.Send\r\nDebug.Print .responseText\r\nEnd With<\/pre>\n\n
oauth_consumer_key=W1wBuWOeTuendKsZKaBgfg&oauth_nonce=AIIWczdtLGKu4VJATkdpV6vQXcXDmL46OaP7a7es\r\n&oauth_signature_method=HMAC-SHA1&oauth_timestamp=1309283138&oauth_token=78842002-\r\ncOj7O8MOOUI07WP4Oam8SSNc5yv7W9tmyEvstcRw&oauth_version=1.0&status=Dies%20ist%20ein%20neuer%20Status<\/pre>\n
POST&http%3A%2F%2Fapi.twitter.com%2F1%2Fstatuses%2Fupdate.xml&oauth_consumer_key%3DW1wBuWOeTuendKsZKaBgfg\r\n%26oauth_nonce%3DRHJrsWaVYRcz1Xx72d6wGVdKDsMOqrZZK94oR8pH%26oauth_signature_method%3DHMAC-SHA1\r\n%26oauth_timestamp%3D1309283809%26oauth_token%3D78842002-cOj7O8MOOUI07WP4Oam8SSNc5yv7W9tmyEvstcRw\r\n%26oauth_version%3D1.0%26status%3DDies%2520ist%2520ein%2520neuer%2520Status<\/pre>\n
vP69PAcskjJ59vqHJRb04huocYs%3D<\/pre>\n
\n
01 Public Function DoTwitter(lngApplicationID As Long, strAction As String, strMethod As String, _\r\n02 ParamArray strParameters() As Variant) As MSXML2.DOMDocument\r\n03 Dim strSignatureBase As String\r\n04 Dim strSignatureKey As String\r\n05 Dim strSignature As String\r\n06 Dim db As DAO.Database\r\n07 Dim strParameterliste As String\r\n08 Dim strOAuthHeader As String\r\n09 Dim objXMLHTTP As MSXML2.XMLHTTP\r\n10 Dim objXML As MSXML2.DOMDocument\r\n11 Dim i As Integer\r\n12 Set db = CurrentDb\r\n13 db.Execute "DELETE FROM tblParameters", dbFailOnError\r\n14 SetSignatureBaseParameters lngApplicationID\r\n15 For i = LBound(strParameters) To UBound(strParameters) Step 2\r\n17 AddParameter strParameters(i), URLEncode(CStr(strParameters(i + 1)))\r\n18 strParameterliste = strParameterliste & "&" & strParameters(i) & "=" _\r\n19 & URLEncode(CStr(strParameters(i + 1)))\r\n20 Next i\r\n21 If Left(strParameterliste, 1) = "&" Then\r\n22 strParameterliste = Mid(strParameterliste, 2)\r\n23 End If\r\n24 strSignatureBase = strMethod & "&" & URLEncode(strAction) & "&" & URLEncode(GetParameters)\r\n25 strSignatureKey = DLookup("ConsumerSecret", "tblApplications", "ID = " & lngApplicationID) _\r\n26 & "&" & DLookup("TokenSecret", "tblApplications", "ID = " & lngApplicationID)\r\n27 strSignature = GetSignature(strSignatureBase, strSignatureKey)\r\n28 strOAuthHeader = GetOAuthHeader(strSignature, strAction)\r\n29 Set objXMLHTTP = CreateObject("MSXML2.XMLHTTP")\r\n30 With objXMLHTTP\r\n31 .Open strMethod, strAction & "" & strParameterliste, False\r\n32 .setRequestHeader "Authorization", strOAuthHeader\r\n33 .Send\r\n34 Set objXML = New MSXML2.DOMDocument\r\n35 objXML.loadXML CStr(.responseText)\r\n36 Set DoTwitter = objXML\r\n37 End With\r\n38 Set objXMLHTTP = Nothing\r\n39 End Function<\/pre>\nPublic Sub SetSignatureBaseParameters(lngApplicationID As Long)\r\n AddParameter "oauth_nonce", GetOAuthNonce(40)\r\n AddParameter "oauth_signature_method", "HMAC-SHA1"\r\n AddParameter "oauth_timestamp", GetTimestamp\r\n AddParameter "oauth_token", DLookup("Token", "tblApplications", "ID = " & lngApplicationID)\r\n AddParameter "oauth_version", "1.0"\r\n AddParameter "oauth_consumer_key", DLookup("ConsumerKey", "tblApplications", _\r\n "ID = " & lngApplicationID)\r\nEnd Sub<\/pre>\nPublic Function AddParameter(varParameter As Variant, varValue As Variant)\r\n Dim db As DAO.Database\r\n Set db = CurrentDb\r\n db.Execute "INSERT INTO tblParameters(Parametername, Parametervalue) VALUES (''" & varParameter _\r\n & "'', ''" & varValue & "'')", dbFailOnError\r\n Set db = Nothing\r\nEnd Function<\/pre>\nPublic Function GetOAuthNonce(intLength As Integer) As String\r\n Dim i As Integer\r\n Dim str As String\r\n Const c = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"\r\n For i = 1 To intLength\r\n str = str & Mid(c, Int((62 - 1 + 1) * Rnd + 1), 1)\r\n Next i\r\n GetOAuthNonce = str\r\nEnd Function<\/pre>\n
Public Function GetTimestamp()\r\n GetTimestamp = DateDiff("s", "1.1.1970", Now)\r\nEnd Function<\/pre>\nFunction URLEncode(StringVal As String) As String\r\n Dim intLen As Integer\r\n Dim i As Integer\r\n Dim intCharCode As Integer\r\n Dim strChar As String\r\n Dim strTemp As String\r\n intLen = Len(StringVal)\r\n If intLen > 0 Then\r\n For i = 1 To intLen\r\n strChar = Mid$(StringVal, i, 1)\r\n intCharCode = Asc(strChar)\r\n Select Case intCharCode\r\n Case 97 To 122, 65 To 90, 48 To 57, 45, 46, 95, 126\r\n strTemp = strTemp & strChar\r\n Case 0 To 15\r\n strTemp = strTemp & "%0" & Hex(intCharCode)\r\n Case Else\r\n strTemp = strTemp & "%" & Hex(intCharCode)\r\n End Select\r\n Next i\r\n URLEncode = strTemp\r\n End If\r\nEnd Function<\/pre>\n
Public Function GetParameters() As String\r\n Dim db As DAO.Database\r\n Dim str As String\r\n Dim rstParameters As DAO.Recordset\r\n Set db = CurrentDb\r\n Set rstParameters = db.OpenRecordset("SELECT * FROM " _\r\n & "tblParameters ORDER BY Parametername", dbOpenDynaset)\r\n Do While Not rstParameters.EOF\r\n str = str & "&" & rstParameters!Parametername & "=" _\r\n & rstParameters!ParameterValue\r\n rstParameters.MoveNext\r\n Loop\r\n If Left(str, 1) = "&" Then\r\n str = Mid(str, 2)\r\n End If\r\n GetParameters = str\r\nEnd Function<\/pre>\nPublic Function GetSignature(strData As String, strKey As String) As String\r\n Dim objHMACSHA1 As clsHMACSHA1\r\n Dim bytSig() As Byte\r\n Set objHMACSHA1 = New clsHMACSHA1\r\n With objHMACSHA1\r\n .InitHmac .Decode(StringToHex(strKey))\r\n bytSig = .HmacSha1(.Decode(StringToHex(strData)))\r\n GetSignature = URLEncode(Encode64(HexToText(.Encode(bytSig))))\r\n End With\r\nEnd Function<\/pre>\n
Public Function StringToHex(str As String) As String\r\n Dim i As Integer\r\n Dim strTemp As String\r\n For i = 1 To Len(str)\r\n strTemp = strTemp & Hex(Asc(Mid(str, i, 1)))\r\n Next i\r\n StringToHex = strTemp\r\nEnd Function<\/pre>\n
Public Function HexToText(strSignature) As String\r\n Dim str As String\r\n Dim intCount As Integer\r\n Dim strValue As String\r\n For intCount = 0 To 19\r\n strValue = Mid(strSignature, 1 + (intCount * 2), 2)\r\n str = str & Chr(HexToDec(strValue))\r\n Next\r\n HexToText = str\r\nEnd Function<\/pre>\n
Function HexToDec(strValue As String) As String\r\n Dim strChars As String\r\n Dim intValue As Integer\r\n Dim intLen As Integer\r\n Dim strChar As String\r\n Dim intPosition As Integer\r\n Dim i As Integer\r\n intValue = UCase(intValue)\r\n strChars = "0123456789ABCDEF"\r\n intValue = 0\r\n intLen = Len(strValue)\r\n For i = 1 To intLen\r\n strChar = Mid(strValue, i, 1)\r\n intPosition = InStr(strChars, strChar) - 1\r\n intValue = intValue + (intPosition * (16 ^ (intLen - i)))\r\n Next\r\n HexToDec = intValue\r\nEnd Function<\/pre>\n
Public Function GetOAuthHeader(strSignature As String, strAction As String) As String\r\n Dim str As String\r\n str = "OAuth realm=" & Chr(34) & strAction & Chr(34)\r\n str = str & ", oauth_nonce=" & Chr(34) & DLookup("ParameterValue", "tblParameters", _\r\n "Parametername = ''Oauth_nonce''") & Chr(34)\r\n str = str & ", oauth_signature_method=" & Chr(34) & "HMAC-SHA1" & Chr(34)\r\n str = str & ", oauth_timestamp=" & Chr(34) & DLookup("ParameterValue", "tblParameters", _\r\n "Parametername = ''oauth_timestamp''") & Chr(34)\r\n str = str & ", oauth_consumer_key=" & Chr(34) & DLookup("ParameterValue", "tblParameters", _\r\n "Parametername = ''Oauth_consumer_key''") & Chr(34)\r\n str = str & ", oauth_token=" & Chr(34) & DLookup("ParameterValue", "tblParameters", _\r\n "Parametername = ''Oauth_token''") & Chr(34)\r\n str = str & ", oauth_signature=" & Chr(34) & strSignature & Chr(34)\r\n str = str & ", oauth_version=" & Chr(34) & "1.0" & Chr(34)\r\n GetOAuthHeader = str\r\nEnd Function<\/pre>\nOAuth realm="http:\/\/api.twitter.com\/1\/statuses\/update.xml", oauth_nonce="g9PaJggXrabcs68yrjkOzzSuNmlKfC4qWxr5NMAg", \r\noauth_signature_method="HMAC-SHA1", oauth_timestamp="1309296231", \r\noauth_consumer_key="W1wBuWOeTesndKsZKaBgfg", oauth_token="78842002-cOj7O8MOOUI07WP4Oam8SSNc5cb7W9tmyEvstcRw", \r\noauth_signature="pFkleVGPqPT3Oacn4asIpTcy4hQ%3D", oauth_version="1.0"<\/pre>\n
Public Function NeuerStatus(lngID As Long, strStatus As String) As String\r\n Dim objXML As MSXML2.DOMDocument\r\n Dim strAction As String\r\n Dim strMethod As String\r\n strAction = "http:\/\/api.twitter.com\/1\/statuses\/update.xml"\r\n strMethod = "POST"\r\n Set objXML = DoTwitter(lngID, strAction, strMethod, "status", strStatus)\r\n On Error Resume Next\r\n NeuerStatus = objXML.selectSingleNode("status\/id").nodeTypedValue\r\n If Not Err.Number = 0 Then\r\n On Error GoTo 0\r\n MsgBox "Fehler: " & objXML.selectSingleNode("hash\/error").nodeTypedValue\r\n End If\r\nEnd Function<\/pre>\n