<\/p>\n
Facebook hat zum Zeitpunkt der Erstellung dieses Beitrags bereits mehr als 25 Millionen aktive Nutzer allein in Deutschland. Gute Chancen also, dass Sie unter den Nutzern sind – und Zeit, sich einmal mit der Programmierschnittstelle von Facebook zu beschäftigen. Was viele nämlich nicht wissen: Es gibt durchaus Alternativen zum Browser für den Zugriff auf Facebook. Was auch hier und da nötig ist – nicht überall bietet die Benutzeroberfläche die Möglichkeiten, die sich die Benutzer erhoffen.<\/b><\/p>\n
Einsatzmöglichkeiten<\/b><\/p>\n
Facebook bietet schon eine umfangreiche Benutzeroberfläche, aber hier und da wünscht man sich vielleicht doch noch die eine oder andere Optimierung. Da die Facebook-API Zugriff auf nahezu alle Daten bietet, auf die Sie auch als Facebook-Benutzer Zugriff haben, lassen sich bestimmt interessante Ideen entwickeln. Fürs Erste wollen wir einmal zeigen, wie Sie eine Statusmeldung auf Facebook anlegen, diese wieder löschen und wie Sie auf Ihre eigenen Statusmeldungen zugreifen.<\/p>\n
Dies lässt sich sicher nutzbringend in eine Anwendung integrieren – vielleicht möchte beispielsweise ein Unternehmen regelmäßig Produkte auf seiner Facebook-Seite vorstellen und kann diese Aufgabe dann von einer Access-Anwendung aus erledigen – natürlich, indem man die anzuzeigenden Inhalte wie Produktbeschreibungen oder Werbetexte aus einer Tabelle der Datenbank bezieht.<\/p>\n
Sollten Sie etwas ähnliches im Sinn haben, könnten Sie dann auch gleich die Kommentare der Benutzer auf diese Statusmeldungen einlesen und diese gegebenenfalls verschiedenen Mitarbeitern zur Beantwortung zuweisen. Sie sehen: Es gibt ausreichend Gründe für die Facebook-Integration.<\/p>\n
Voraussetzungen<\/b><\/p>\n
Wenn Sie die Beispiele der folgenden Lösung durchspielen möchten, benötigen Sie zunächst einen Facebook-Account. Außerdem müssen Sie sich als Entwickler registrieren. Dazu klicken Sie nach der Anmeldung bei Facebook ganz unten rechts auf den Menüeintrag Mehr|Entwickler (der Eintrag ist recht klein) und registrieren sich dann auf der folgenden Seite.<\/p>\n
Anwendung registrieren<\/b><\/p>\n
Für den Zugriff auf Facebook müssen Sie zunächst eine Anwendung bei Facebook registrieren, in deren Kontext Sie auf die Facebook-API zugreifen. Dies erledigen Sie über den Menüpunkt App erstellen <\/b>oben rechts im Menü (s. Bild 1). Voraussetzung hierfür ist, dass Sie selbst über einen Benutzeraccount bei Facebook verfügen. Anderenfalls legen Sie zuvor einen entsprechenden Zugang an.<\/p>\n
![\"Registrieren](\"..\/fileadmin\/_temp_\/2013_04\/pic_895_001.png\")
<\/p>\n
Bild 1: Registrieren einer neuen Anwendung<\/span><\/b><\/p>\n Im folgenden Dialog klicken Sie dann auf die Schaltfläche Neue Anwendung erstellen<\/b>. Einen Dialog weiter geben Sie bereits den Anwendungsnamen ein. Dieser darf verschiedene Elemente nicht enthalten, wie zum Beispiel Facebook <\/b>oder Book <\/b>(s. Bild 2). Also legen wir die neue Anwendung unter dem Namen aiuBaceFook <\/b>an. Hier meckert Facebook nicht. Einen Dialog weiter fordert Facebook weitere Informationen an. Hier müssen Sie vor allem eine Integrationsart wählen. Am einfachsten geschieht dies mit der ersten Option Webseite mit Facebook-Anmeldung <\/b>und der Angabe einer URL inklusive http: <\/b>(s. Bild 3). Den Sandbox-Modus können Sie vorerst beibehalten – nach ersten Tests werden die Statusmeldungen auch in diesem Modus ganz normal veröffentlicht. Warum das Ganze Damit Sie die oben ersichtlichen Daten App ID <\/b>und App Secret <\/b>entnehmen können.<\/p>\n Bild 2: Erstellen der neuen Anwendung – hier fehlgeschlagen, da der Anwendungsname den Namen Facebook enthält<\/span><\/b><\/p>\n Bild 3: Eintragen der Detaildaten zur neuen Anwendung<\/span><\/b><\/p>\n Token ermitteln<\/b><\/p>\n Die Ermittlung des für den Zugriff auf die Facebook-API notwendigen Token ist etwas hakelig. Geben Sie die folgende URL in den Browser ein:<\/p>\n Dabei ersetzen Sie die Platzhalter wie folgt:<\/p>\n Die drei Werte für Eine Liste der Berechtigungen für verschiedene Bereiche finden Sie unter https:\/\/developers.facebook.com\/docs\/reference\/login\/#permissions<\/b>.<\/p>\n Facebook ruft dann die als Diesen Code müssen Sie auslesen und damit einen erneuten Aufruf starten. Dieser sieht dann wie folgt aus:<\/p>\n Darauf antwortet Facebook dann, indem es zu einer URL weiterleitet, die wieder aus der angegebenen Redirect-URL und dem Token besteht:<\/p>\n Mit diesem Token können Sie nun alle Aktionen durchführen, welche die angegebenen Zugriffsrechte erlauben. Wenn Sie also etwa publish_stream <\/b>angegeben haben, können Sie unter Angabe des Tokens Beiträge im Namen des mit der Anwendung verbundenen Benutzers posten.<\/p>\n Noch einmal zusammengefasst: Sie starten die Anfrage an Facebook, Facebook zeigt einen Dialog an, mit dem Sie die Anfrage bestätigen müssen, und ruft dann die Redirect-URL mit einem Code als Parameter auf.<\/p>\n Diesen Code fügen Sie in einen weiteren Aufruf von Facebook ein und Facebook ruft erneut die Redirect-URL auf – diesmal allerdings mit dem gewünschten Token als Parameter. Normalerweise würde die unter Redirect-URL angegebene Webseite die Parameter auswerten und die weiteren Aufrufe starten. Allerdings wollen wir ja keine Webseite betreiben, um auf Facebook zuzugreifen, sondern dies von Access aus erledigen. Der Ablauf sieht prinzipiell allerdings ähnlich aus.<\/p>\n Token automatisch holen<\/b><\/p>\n Wir haben ein Formular entwickelt, das den Token automatisch bezieht beziehungsweise erneuert. Dieses basiert auf einer kleinen Tabelle, welche die Anwendungsdaten speichert und die auch den Token aufnehmen soll. Die Tabelle ist wie in Bild 4 aufgebaut und heißt tblOptionen<\/b>. Tragen Sie dort die über die Facebook-Anwendungsseite ermittelten Werte in die Felder AppID <\/b>und AppSecret <\/b>ein.<\/p>\n Bild 4: Tabelle zum Speichern der Anwendungsdaten für den Zugriff auf Facebook<\/span><\/b><\/p>\n Für Scope <\/b>tragen Sie eine kommaseparierte Liste der Zugriffsrechte ein, also beispielsweise read_stream,publish_actions,publish_stream<\/b>. Redirect <\/b>nimmt die URL der Seite auf, zu der Facebook nach dem Erstellen des Token weiterleiten soll.<\/p>\n Welche Sie verwenden, spielt keine Rolle – Sie benötigen diese nur, weil Facebook an diese nach dem Weiterleiten den Token anhängt. Aber es muss die gleiche URL sein, die Sie weiter oben bei der Registrierung der Anwendung angegeben haben, sonst tritt beim Abruf des Tokens ein Fehler auf. Nach dem Füllen und dem Einlesen des Tokens sieht der einzige Datensatz dieser Tabelle etwa wie in Bild 5 aus.<\/p>\n Bild 5: Tabelle mit Anwendungsdaten und Token<\/span><\/b><\/p>\n Token-Formular<\/b><\/p>\n Nun kümmern wir uns um das Formular, welches das Einlesen des Tokens für uns übernimmt. Das Formular heißt frmToken <\/b>und enthält lediglich ein Webbrowser<\/b>-Steuerelement namens ctlWebbrowser<\/b>. Im Klassenmodul des Formulars legen Sie die folgende Zeile an, um eine Objektvariable zum Speichern des Webbrowser<\/b>-Steuerelements zu deklarieren:<\/p>\n Das Schlüsselwort WithEvents <\/b>ist wichtig, weil wir später ein Ereignis des Webbrowser<\/b>-Steuerelements nutzen möchten. Dieses wird beim Beenden des Ladevorgangs einer Internetseite ausgelöst.<\/p>\n Danach hinterlegen Sie die Prozedur aus Listing 1, die durch das Ereignis Beim Laden <\/b>des Formulars ausgelöst werden soll. Diese Prozedur füllt die Variable obj-Webbrowser <\/b>mit einem Verweis auf das Webbrowser<\/b>-Steuerelement und liest die Werte der drei Felder AppID<\/b>, Scope <\/b>und Redirect <\/b>in entsprechende Variablen ein. Die Funktion AddSlash <\/b>untersucht die Redirect-URL dahingehend, ob diese mit einem Slash-Zeichen endet, und ergänzt dieses gegebenenfalls (s. Listing 2).<\/p>\n Listing 1: Beim öffnen ruft das Formular die Webseite zum Freischalten des Tokens auf.<\/span><\/b><\/p>\n Das Webbrowser<\/b>-Steuerelement zeigt daraufhin den Dialog aus Bild 6 an. Hier bestätigen Sie, dass die Facebook-Anwendung die von Ihnen angeforderten Berechtigungen freigeben darf. Wenn Sie hier auf OK <\/b>klicken, dürfen Sie auf das öffentliche Profil und die Freundesliste zugreifen sowie Neuigkeiten posten.<\/p>\n Bild 6: Manuelle Freigabe des Zugriffs<\/span><\/b><\/p>\n Sobald dieses Dokument erscheint, wird die Ereignisprozedur aus Listing 3 erstmals ausgelöst. Dieses Dokument wollen wir jedoch nicht per Code untersuchen – an dieser Stelle ist lediglich der Klick auf die OK<\/b>-Schaltfläche gefragt. Daher prüfen wir die mit dem Parameter URL gelieferte Internetadresse auf das Auftreten der Zeichenkette Code<\/b>, die aber erst in der nachfolgend aufgerufenen Seite enthalten ist.<\/p>\n Listing 3: Nach dem Laden des Dokuments wird eine weitere URL aufgerufen. <\/span><\/b><\/p>\n Der Klick auf die OK<\/b>-Schaltfläche führt jedoch dazu, dass Facebook die Redirect-URL mit dem Code aufruft. Im Webbrowser-Steuerelement wird nun die von Ihnen mit Redirect-URL angegebene Internetseite geöffnet.<\/p>\n Wenn die Seite fertig geladen ist, löst dies wiederum das Ereignis objWebbrowser_DocumentComplete <\/b>aus. Diesmal enthält die mit dem Parameter URL <\/b>gesendete Internetadresse den Parameter Code<\/b>.<\/p>\n Diesen wertet die Prozedur nun aus, indem sie den Code zunächst in der Variablen strCode <\/b>speichert. Mit dieser Information und einigen weiteren, die wiederum aus der Tabelle tblOptionen <\/b>ausgelesen werden, rufen wir erneut eine URL bei Facebook auf – diesmal allerdings nicht über das Webbrowser-Steuerelement, sondern mit dem HTTPRequest<\/b>-Objekt. Um dieses zu nutzen, müssen Sie zuvor einen Verweis auf die Bibliothek Microsoft XML, v6.0 <\/b>hinzufügen.<\/p>\n Dies erlaubt es, einfach auf gelieferte Ergebnisse zu reagieren. Die URL wird mit der Variablen strURL <\/b>an die Funktion HTTPRequest <\/b>übergeben, welche den Request durchführt und im Erfolgsfall das Ergebnis, den sogenannten Response, an die aufrufende Prozedur zurückliefert – und zwar mit dem Rückgabeparameter strResponse<\/b>.<\/p>\n Der eigentliche Funktionswert ist einer Boolean<\/b>-Variable vorbehalten, die über den Erfolg des Requests Auskunft gibt (s. Listing 4).<\/p>\n <\/p>\n Listing 4: Die Funktion HTTPRequest<\/span><\/b><\/p>\n strResponse <\/b>enthält im Erfolgsfall einen Ausdruck wie den folgenden:<\/p>\n Hier muss die Prozedur noch das führende access_token= <\/b>und das Verfallsdatum am Ende, das mit &expires= <\/b>eingeleitet wird, entfernen. Schließlich enthält die Variable strToken <\/b>den reinen Token, der so im Feld Token <\/b>der Tabelle tblOptionen <\/b>gespeichert wird. Die Haltbarkeit des Tokens beträgt übrigens 60 Tage – danach müssen Sie diesen erneut beantragen. Das öffnen des Formulars frmToken <\/b>reicht dazu völlig aus – den Rest erledigen Sie per Mausklick.<\/p>\n Die eigenen Berechtigungen abrufen<\/b><\/p>\n Starten wir mit einem einfachen Beispiel. Wir wollen prüfen, welche Berechtigungen die Anwendungen für den Zugriff auf die Daten des mit der Anwendung verknüpften Benutzers hat. Dazu würden Sie im Browser die folgende URL absetzen:<\/p>\n Wie ist diese Abfrage aufgebaut https:\/\/graph.facebook.com <\/b>ist die URL für alle Anfragen an Facebook. me <\/b>ist der Platzhalter für das Konto des Accounts, in dessen Kontext die Anwendung erstellt wurde. Sie können hier auch explizit den Namen oder die ID des zu verwendenden Accounts angeben. permissions <\/b>gibt den Inhalt an, der abgefragt werden soll. Und der Parameter access_token <\/b>übergibt Ihren Token an Facebook. Das Ergebnis dieser Abfrage können Sie Bild 7 entnehmen.<\/p>\n Bild 7: Einfaches Beispiel: die Abfrage der Zugriffsrechte<\/span><\/b><\/p>\n Wie aber ermitteln wir dieses Ergebnis, ohne den Webbrowser zu bemühen Schließlich wollen wir es ja auch einmal weiterverarbeiten können. Weiter oben haben Sie bereits die Funktion HTTP-Re-quest <\/b>kennengelernt – und genau die hilft uns auch jetzt weiter.<\/p>\n Am einfachsten übergeben wir die zuvor in einer Variablen gespeicherte URL an diese Funktion und lesen das Ergebnis ebenfalls in eine zuvor deklarierte Variable ein. Deren Wert geben wir dann anschließend im Direktbereich des VBA-Editors aus. Die Prozedur BerechtigungenEinfach <\/b>sieht wie in Listing 5 aus. Sie ermittelt den Token und stellt die URL in der Variablen strURL <\/b>zusammen. Der Aufruf liefert indes das folgende Ergebnis – nicht gerade das, was wir erwartet haben:<\/p>\n Listing 5: Einfacher Aufruf der Facebook-API<\/span><\/b><\/p>\n Die Erklärung ist allerdings einfach: Wir haben die Anfrage als POST<\/b>-Anfrage formuliert und nicht als GET<\/b>. Also fügen wir zur folgenden Zeile noch GET <\/b>als letzten Parameter hinzu:<\/p>\n Nun erhalten wir das gewünschte Ergebnis, also genau das JSON-Dokument, das auch der Webbrowser angezeigt hat:<\/p>\n JSON<\/b><\/p>\n Aber was ist das für ein Format, in dem diese Abfrage erfolgt Dabei handelt es sich nicht, wie bei anderen Webdiensten, um XML, sondern um JSON. Mehr zu JSON und wie Sie Dokumente in diesem Format parsen können, erfahren Sie im Beitrag JSON-Dokumente mit VBA parsen <\/b>(www.access-im-unternehmen.de\/893<\/b>). Dort lernen Sie auch eine Funktion namens JSONParsen <\/b>kennen, welche das JSON-Dokument in ein Collection<\/b>-Objekt verwandelt, das mitunter weitere verschachtelte Collection<\/b>-Objekte enthält.<\/p>\n Statusmeldung erstellen<\/b><\/p>\n Um diese Funktion zu testen, rufen wir eine Facebook-Methode auf, die eine relativ einfache Antwort zurückliefert. Dabei handelt es sich um das Anlegen einer neuen Statusmeldung auf der eigenen Pinnwand. Als Methode geben wir diesmal nicht permissions<\/b>, sondern feed <\/b>an. Außerdem benötigen wir einen zusätzlichen Parameter namens message<\/b>, der den Meldungstext übergibt. Die URL sieht beispielsweise so aus:<\/p>\n Die Prozedur, um den Aufruf einfach durchzuführen, finden Sie in Listing 6. Das Ergebnis enthält lediglich den Namen des Elements (id<\/b>) und den Wert (die ID der neuen Statusmeldung):<\/p>\n Listing 6: Erstellen einer einfachen Statusmeldung<\/span><\/b><\/p>\n Rufen wir die Prozedur direkt danach erneut mit den gleichen Werten auf, erhalten wir diese Antwort:<\/p>\n Im Falle eines Fehlers landen Fehlerbeschreibung und weitere Informationen ebenfalls in einem JSON-Dokument. In diesem Fall tritt ein Fehler auf, weil die gleiche Meldung gleich zweimal hintereinander aufgegeben wurde.<\/p>\n JSON parsen<\/b><\/p>\n Wie aber verarbeiten wir diese Antworten nun Zunächst einmal parsen wir diese mit der Funktion JSONParsen <\/b>und schreiben das Ergebnis in ein Collection<\/b>-Objekt:<\/p>\n Danach können wir mit der entsprechenden Syntax auf die Elemente zugreifen. Im Falle der id <\/b>sieht dies so aus:<\/p>\n id <\/b>ist das einzige Element und kann somit über die Ausrufezeichen-Syntax ausgelesen werden. Tritt ein Fehler auf, ermitteln Sie die einzelnen Elemente wie folgt:<\/p>\n Auf diese Weise greifen Sie auf einfache Elemente zu, bei Auflistungen kommt noch die Klammer-Syntax hinzu – dazu später mehr.<\/p>\n Formular für neue Statusmeldung<\/b><\/p>\n Nun wollen wir ein kleines Formular entwerfen, mit dem Sie eine Statusmeldung eingeben und an Facebook schicken können. Dieses enthält lediglich ein Textfeld und eine Schaltfläche zum Absenden der Meldung – s. Bild 8. Der Code, der durch das Anklicken der Schaltfläche ausgelöst wird, sieht wie in Listing 7 aus. Und jetzt speichern wir den Status und das Ergebnis in einer Tabelle der Datenbank, oder Nein! Man muss ja nicht alles, was man von Access aus erschafft, direkt in der Datenbank speichern.<\/p>\n Bild 8: Statusmeldung absenden<\/span><\/b><\/p>\n In diesem Fall allerdings mit gutem Grund: Sie können das Posting ja über die Benutzeroberfläche von Facebook wieder entfernen. Die Datenbank würde dann Informationen enthalten, die gar nicht mehr existieren – also sparen wir uns das Speichern frisch erzeugter Statusmeldungen.<\/p>\n Vorherige Statusmeldungen ermitteln<\/b><\/p>\n Nun wollen wir auch kontrollieren, was wir dort auf Facebook veröffentlicht haben. Das können Sie natürlich über die Weboberfläche von Facebook erledigen. Viel interessanter ist es für uns allerdings, per API auf unsere Statusmeldungen zuzugreifen.<\/p>\n Die reine URL sieht so aus:<\/p>\n Wir greifen also wie schon beim Erstellen der Statusmeldung wieder auf den Feed zu. Diesmal liefern wir aber keine neue Statusmeldung, sondern wollen lediglich Daten abfragen. Das Ergebnis ist bereits so umfangreich, dass wir es hier aus Platzgründen nicht abbilden können. Uns interessieren aber auch ohnehin nur wenige Daten – und zwar die ID eines Eintrags und die Meldung.<\/p>\n Diese Aufgabe übernimmt die Prozedur aus Listing 8. Die Prozedur liest wiede-rum den Token aus der Tabelle tblOptionen <\/b>ein und stellt dann die URL für den Request zusammen. Hier handelt es sich wieder um einen GET<\/b>-Request, denn wir wollen ja nur Daten einlesen, aber nicht schreiben – deshalb hat der dritte Parameter der Funktion HTTPRequest <\/b>den Wert GET<\/b>.<\/p>\n![\"Erstellen](\"..\/fileadmin\/_temp_\/2013_04\/pic_895_002.png\")
<\/p>\n![\"Eintragen](\"..\/fileadmin\/_temp_\/2013_04\/pic_895_003.png\")
<\/p>\nhttps:\/\/www.facebook.com\/dialog\/\r\noauthclient_id=<client_id>\r\n&scope=<scope>&response_type=token&\r\nredirect_uri=<redirect_uri><\/pre>\n
\n
\n
http:\/\/www.access-basics.de\/\r\ncode=AQDR9eNN3DRzme9ubqUwAk5J6HmLeRu\r\nESJXcTS1XAlydVjnF<\/pre>\n
https:\/\/graph.facebook.com\/oauth\/access_tokenclient_id=\r\n147265685342185&redirect_uri=\r\nhttp:\/\/www.access-im-unternehmen.de\/\r\n&client_secret=7eed5c5ef46c69c90c0ec511\r\nedd73734&code=AdDR9eNN3DRzme9ubqUwAk5J6H\r\nmLeRuESJXcTS1XAlyLVjnF<\/pre>\n
http:\/\/www.access-im-unternehmen.de\/\r\n#access_token=CAAGxIOTNxqMBACV5AkFqWK\r\nl9TWZBrZB9ucXd0dTC1CfyXaL6pCmfz1OfvT\r\nXP67YXymi5AsffjaIROOWcfu5Cfe50HNro3kI\r\nvDahulaYONVNmzDdMgjKc3vnTMuGDVUmOQD\r\nGBe9Hg50GDrt5yinuvUtaeRYEWjO9OVlQ9gPx\r\nAZDZD&expires_in=5894<\/pre>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2013_04\/pic_895_004.png\")
<\/p>\n![\"Tabelle](\"..\/fileadmin\/_temp_\/2013_04\/pic_895_005.png\")
<\/p>\nDim <\/span>WithEvents objWebbrowser As <\/span>WebBrowser<\/pre>\nPrivate Sub <\/span>Form_Load()\r\n Dim <\/span>strClientID As String<\/span>\r\n Dim <\/span>strScope As String<\/span>\r\n Dim <\/span>strURL As String<\/span>\r\n Dim <\/span>strRedirect As String<\/span>\r\n Set<\/span> objWebbrowser = Me!ctlWebbrowser.Object\r\n strClientID = DLookup(\"AppID\", \"tblOptionen\")\r\n strScope = DLookup(\"Scope\", \"tblOptionen\")\r\n strRedirect = DLookup(\"Redirect\", \"tblOptionen\")\r\n strRedirect = AddSlash(strRedirect)\r\n strURL = \"https:\/\/graph.facebook.com\/oauth\/authorizeclient_id=\" _\r\n & strClientID & \"&scope=\" & strScope & \"&redirect_uri=\" & strRedirect\r\n objWebbrowser.Navigate strURL\r\nEnd Sub<\/span><\/pre>\n![\"Manuelle](\"..\/fileadmin\/_temp_\/2013_04\/pic_895_006.png\")
<\/p>\nPrivate Sub <\/span>objWebbrowser_DocumentComplete(ByVal pDisp As Object<\/span>, URL As Variant<\/span>)\r\n Dim <\/span>strToken As String<\/span>\r\n Dim <\/span>strClient As String<\/span>\r\n Dim <\/span>strAppSecret As String<\/span>\r\n Dim <\/span>strCode As String<\/span>\r\n Dim <\/span>strURL As String<\/span>\r\n Dim <\/span>strRedirect As String<\/span>\r\n Dim <\/span>strResponse As String<\/span>\r\n If <\/span>InStr<\/span>(1, URL, \"code=\") > 0 Then<\/span>\r\n strCode = URL\r\n strCode = Mid<\/span>(strCode, InStr<\/span>(1, strCode, \"code=\") + 5)\r\n strClient = DLookup(\"AppID\", \"tblOptionen\")\r\n strAppSecret = DLookup(\"AppSecret\", \"tblOptionen\")\r\n strRedirect = DLookup(\"Redirect\", \"tblOptionen\")\r\n strRedirect = AddSlash(strRedirect)\r\n strURL = \"https:\/\/graph.facebook.com\/oauth\/access_tokenclient_id=\" _\r\n & strClient & \"&redirect_uri=\" & strRedirect & \"&client_secret=\" _\r\n & strAppSecret & \"&code=\" & strCode\r\n If <\/span>HTTPRequest(strURL, strResponse) = True<\/span> Then<\/span>\r\n strToken = Replace<\/span>(strResponse, \"access_token=\", \"\")\r\n CurrentDb.Execute \"UPDATE tblOptionen SET Token = ''\" & strToken _\r\n & \"''\", dbFailOnError\r\n Else<\/span>\r\n Debug.Print<\/span> strResponse\r\n End If<\/span>\r\n DoCmd.Close acForm, Me.Name\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPublic Function <\/span>HTTPRequest(strURL As String<\/span>, strResponse As String<\/span>, _\r\n Optional<\/span> strMethod As String<\/span> = \"POST\") As Boolean<\/span>\r\n Dim <\/span>objHTTP As <\/span>ServerXMLHTTP\r\n Set<\/span> objHTTP = CreateObject(\"MSXML2.ServerXMLHTTP\")\r\n With<\/span> objHTTP\r\n .Open strMethod, strURL, False<\/span>\r\n .setRequestHeader \"Content-Type\", \"application\/x-www-form-urlencoded\"\r\n .Send\r\n strResponse = objHTTP.responseText\r\n If <\/span>.status = 200 Then<\/span>\r\n HTTPRequest = True<\/span>\r\n End If<\/span>\r\n End With<\/span>\r\nEnd Function<\/span><\/pre>\naccess_token=CAACF7ZCbcxZBkBAOipq8Qp\r\nzdMA2dvw3rE...&expires=5181905<\/pre>\n
https:\/\/graph.facebook.com\/me\/\r\npermissionsaccess_token=CAAH7dz9zXZCoB\r\nBP9J9g35HwACZAICiiDs8Dmvit4eavqL2i...<\/pre>\n
![\"Einfaches](\"..\/fileadmin\/_temp_\/2013_04\/pic_895_007.png\")
<\/p>\nPublic Sub <\/span>BerechtigungenEinfach()\r\n Dim <\/span>strURL As String<\/span>\r\n Dim <\/span>strResponse As String<\/span>\r\n Dim <\/span>strToken As String<\/span>\r\n strToken = DLookup(\"Token\", \"tblOptionen\")\r\n strURL = \"https:\/\/graph.facebook.com\/me\/permissionsaccess_token=\" & strToken\r\n HTTPRequest strURL, strResponse\r\n Debug.Print<\/span> strResponse\r\nEnd Sub<\/span><\/pre>\n{\"error\":\r\n {\r\n \"message\":\"Unsupported post request.\",\r\n \"type\": \"GraphMethodException\",\r\n \"code\":100\r\n }\r\n}<\/pre>\nHTTPRequest strURL, strResponse, \"GET\"<\/pre>\n
{\"data\":[{\"installed\":1,\"basic_info\":1\r\n,\"read_stream\":1,\"status_update\":1,\r\n\"photo_upload\":1,\"video_upload\":1,\r\n\"create_note\":1,\"share_item\":1,\r\n\"publish_stream\":1,\"publish_actions\":1\r\n}],\"paging\":{\"next\":\"https:\\\/\\\/graph.\r\nfacebook.com\\\/100000445458715\\\/\r\npermissionsaccess_token=CAACF7ZC\r\nbcxZBkBAGZCWYupEWKqZCM7wwuhgIZBwW\r\nO68FuyrZCp1wnOrfZA8FkT6CWQF91W2853Bn7\r\nKssL63ywhSyFc7GRGfD0rmSl5k4HcH6S1M7nZ\r\nCmzuZBd9qasLXe7lSRd77BI4MayRfVTSLIZCrc\r\nJZA&limit=5000&offset=5000\"}}<\/pre>\nhttps:\/\/graph.facebook.com\/me\/\r\nfeedmessage=Testmeldung&access_token=\r\nCAACF7ZCbcxZBkBAGZCW...<\/pre>\n
Public Sub <\/span>StatusErstellenEinfach()\r\n Dim <\/span>strURL As String<\/span>\r\n Dim <\/span>strResponse As String<\/span>\r\n Dim <\/span>strToken As String<\/span>\r\n Dim <\/span>strMessage As String<\/span>\r\n Dim <\/span>colResponse As <\/span>Collection\r\n strToken = DLookup(\"Token\", \"tblOptionen\")\r\n strMessage = \"Testmeldung\"\r\n strURL = \"https:\/\/graph.facebook.com\/me\/feedaccess_token=\" & strToken _\r\n & \"&message=\" & strMessage\r\n HTTPRequest strURL, strResponse, \"POST\"\r\n Debug.Print<\/span> strResponse\r\nEnd Sub<\/span><\/pre>\n{\"id\":\"100000445458715_645112295513613\"}<\/pre>\n{\"error\":{\"message\":\"(#506) Duplicate \r\nstatus message\",\"type\":\"OAuthException\",\r\n\"code\":506,\"error_data\":\r\n{\"kError\":1455006}}}<\/pre>\nSet<\/span> colResponse = JSONParsen(strResponse)<\/pre>\nDebug.Print<\/span> colResponse!id<\/pre>\n\n
![\"Statusmeldung](\"..\/fileadmin\/_temp_\/2013_04\/pic_895_008.png\")
<\/p>\nhttps:\/\/graph.facebook.com\/me\/\r\nfeedaccess_token=\r\nCAACF7ZCbcxZBkBAGZCWY...<\/pre>\n
Public Sub <\/span>StatusmeldungenEinlesen()\r\n Dim <\/span>strURL As String<\/span>\r\n Dim <\/span>strToken As String<\/span>\r\n Dim <\/span>strResponse As String<\/span>\r\n Dim <\/span>colFeed As <\/span>Collection\r\n Dim <\/span>strID As String<\/span>\r\n Dim <\/span>strMessage As String<\/span>\r\n Dim <\/span>l As Long<\/span>\r\n strToken = DLookup(\"Token\", \"tblOptionen\")\r\n strURL = \"https:\/\/graph.facebook.com\/me\/feedaccess_token=\" & strToken\r\n If <\/span>HTTPRequest(strURL, strResponse, \"GET\") = True<\/span> Then<\/span>\r\n Set<\/span> colFeed = JSONParsen(strResponse)\r\n For l = 1 To colFeed!Data.Count\r\n With<\/span> colFeed\r\n strID = colFeed!Data(l)!id\r\n On Error Resume Next<\/span>\r\n strMessage = \"#Keine Meldung.\"\r\n strMessage = GetElement(!Data(l)!message)\r\n On Error GoTo<\/span> 0\r\n End With<\/span>\r\n Debug.Print<\/span> strID, strMessage\r\n Next<\/span> l\r\n Else<\/span>\r\n MsgBox<\/span> \"Fehler: \" & JSONParsen(strResponse)!Error!message\r\n End If<\/span>\r\n