Social Development mit .NET

Mario Fraiß Social Development mit .NET Für meine Eltern Brigitte und Siegfried, meine Freundin Rebekka und all meine...

Author: Mario Fraiß

115 downloads 1576 Views 3MB Size Report

This content was uploaded by our users and we assume good faith they have the permission to share this book. If you own the copyright to this book and it is wrongfully on our website, we offer a simple DMCA procedure to remove your content from our site. Start by pressing the button below!
Report copyright / DMCA form

DOWNLOAD PDF

Mario Fraiß Social Development mit .NET

Für meine Eltern Brigitte und Siegfried, meine Freundin Rebekka und all meine Freunde. Ihr seid es, die mich immer wieder aufs Neue zu Höchstleistungen motivieren und jederzeit zu mir stehen.

Mario Fraiß Social Development mit .NET ISBN: 978-3-86802-243-8 © 2010 entwickler.press Ein Imprint der Software & Support Media GmbH

Bibliografische Information Der Deutschen Bibliothek Die Deutsche Bibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.ddb.de abrufbar.

Ihr Kontakt zum Verlag und Lektorat: Software & Support Media GmbH entwickler.press Geleitsstr. 14 60599 Frankfurt am Main Tel.: +49 (0)69 630089-0 Fax: +49 (0)69 930089-89 [email protected] http://www.entwickler-press.de

Lektorat: Sebastian Burkart Korrektorat: Frauke Pesch Satz: Pobporn Fischer Belichtung, Druck & Bindung: M.P. Media-Print Informationstechnologie GmbH, Paderborn Alle Rechte, auch für Übersetzungen, sind vorbehalten. Reproduktion jeglicher Art (Fotokopie, Nachdruck, Mikrofilm, Erfassung auf elektronischen Datenträgern oder anderen Verfahren) nur mit schriftlicher Genehmigung des Verlags. Jegliche Haftung für die Richtigkeit des gesamten Werks kann, trotz sorgfältiger Prüfung durch Autor und Verlag, nicht übernommen werden. Die im Buch genannten Produkte, Warenzeichen und Firmennamen sind in der Regel durch deren Inhaber geschützt.

I

Inhaltsverzeichnis

Inhaltsverzeichnis

5

Vorwort

9

V.1 An wen richtet sich dieses Buch?

10

V.2 Über den Autor

10

V.3 Danksagung

11

1 Einleitung 1.1 Social! Überall? 1.2 Über soziale Welten

13 13 14

1.2.1 Social Networks

14

1.2.2 Social Services

15

1.2.3 Social Apps

16

1.3 Was Sie in diesem Buch erwartet

16

1.3.1 Website zum Buch

17

1.3.2 Benötigte Software

17

1.4 Entwicklung für soziale Welten 1.5 Grundlegende Hinweise

17 18

1.5.1 Entwicklerzugang und Anwendungsregistrierung

18

1.5.2 Berücksichtigung der Guidelines („Spielregeln“)

19

1.5.3 Plausibilität des Projekts

19

1.6 Es geht los!

Social Development mit .NET

20

5

Inhaltsverzeichnis

Teil A Integration mit Social Networks

21

2 facebook

23

2.1 Empfohlene Ressourcen für den Einstieg

23

2.2 Struktur des API

24

2.2.1 Soziale Plug-ins

24

2.2.2 Graph-API und FQL

25

2.2.3 SDKs und „Code Inside“

26

2.3 Anwendung bei facebook registrieren 2.3.1 Anwendungsarten 2.4 Entwicklung des Basisframeworks

28 29

2.4.1 Hello „facebook“

30

2.4.2 Implementierung der facebook-Authentifizierung

31

2.5 Datenabfragen

43

2.5.1 Abfragen mithilfe des Graph-API

43

2.5.2 Kurzeinführung JSON

48

2.6 Komplexe Abfragen mit der FQL

63

2.7 Inhaltsveröffentlichung

81

2.7.1 Erweiterte Berechtigungen

81

2.7.2 REST-API

96

2.7.3 HTTP POST Publishing mit dem Graph-API

101

2.8 Nutzung des Messaging-Systems

115

2.9 Zusammenfassung

130

2.9.1 Mögliche Integrationsszenarien

130

2.9.2 Projekt-Checkliste

130

3 LinkedIn 3.1 LinkedIn in für Entwickler

6

26

133 133

3.1.1 Empfohlene Ressourcen für den Einstieg

134

3.1.2 OAuth-Authentifizierung bei LinkedIn

134

3.1.3 Anwendungsregistrierung

134

Inhaltsverzeichnis 3.2 Hello „LinkedIn“

136

3.2.1 LinkedIn-Anwendungsauthentifizierung

139

3.2.2 Serviceanbindung

144

3.2.3 API-Nutzung

146

3.3 Zusammenfassung

153

Teil B Integration von Social Services

155

4 twitter

157

4.1 Hello „twitter“

159

4.1.1 Nutzung des API

163

4.1.2 OAuth-Authentifizierung

166

4.1.3 Statusaktualisierung

174

4.1.4 Zugriff auf Followings und Followers

176

4.2 Zusammenfassung 5 flickr 5.1 Hello „flickr“

185 187 187

5.1.1 Anwendungsregistrierung

187

5.1.2 Fotosuche

188

5.2 Zusammenfassung 6 YouTube

198 199

6.1 Google Data API

199

6.2 Hello „YouTube“

200

6.2.1 YouTube-Anwendungsregistrierung

201

6.2.2 Abfragen von Video-Feeds

202

6.2.3 Zugriff auf Communitybeiträge

211

6.2.4 Zugriff auf Benutzerprofile

215

6.3 Zusammenfassung


218

7

Inhaltsverzeichnis

Teil C Planung und Architektur

219

7 Soziale Anwendungen planen

221

7.1 Anwendungstyp

221

7.2 Basistechnologien

222

7.2.1 Programmierumgebung und Framework

222

7.2.2 Anwendungsarchitektur und Infrastruktur

222

7.3 Unterstützung von Standards

224

7.3.1 OpenSocial

224

7.3.2 OAuth

227

7.4 Zusammenfassung

229

Nachwort

231

Stichwortverzeichnis

233

8

V Vorwort

Betrachtet man die heutige Internetlandschaft, so steht eines fest: Der Hype der Social Networks und Social Services nimmt kontinuierlich seinen Lauf und wir stehen gerade erst am Beginn dieser gewaltigen technischen Revolution. Daher ist es entscheidend, die Chancen und Risiken, aber auch die Potenziale dieser neuen Technologien rechtzeitig zu identifizieren und zu erkennen, um sie bestmöglich zur Erfüllung der eigenen Bedürfnisse zu nutzen. Nein, das Buch, das Sie in Ihren Händen halten, ist keine Anleitung zur Nutzung von sozialen Angeboten und Diensten. Vielmehr wirft es einen kritischen Blick hinter die Kulissen dieser „neuen Welt“ und zeigt auf, welche Möglichkeiten sich durch den sinnvollen kombinierten Einsatz der unterschiedlichen Social Services innerhalb von Softwarelösungen ergeben. In den Vordergrund werden dabei der professionelle Einsatz im Rahmen von Businesslösungen sowie die gezielte Nutzung der unterschiedlichen Angebote als strategische Wertschöpfungsinstrumente gestellt. Nicht zu vernachlässigen ist dabei die heutige und zukünftige Rolle der Software- und Dienstleistungsindustrie. Während kontinuierlich Trends wie Cloud Computing oder SaaS (Software as a Service) in Businesslösungen Einzug halten, werden innerhalb der Geschäftsanwendungen von morgen zunehmend Fragestellungen und Anforderungen im Bereich der Social Services auftreten. Die nächste Generation der SoftwareentwicklerInnen wird gefordert sein, gewisse Paradigmen in neue Anwendungs- und Systemkonzepte mit einfließen zu lassen und sie als „selbstverständlich“ zu betrachten, weswegen dieses Buch auch eben aufgezeigte Aspekte nicht außer Betracht lässt.


9

Vorwort

V.1

An wen richtet sich dieses Buch?

Dieses Buch fokussiert mehrere Zielgruppen und vereinigt unterschiedliche Sichtweisen und Perspektiven gegenüber den sozialen Technologien. Zum einen richtet es sich an IT-Entscheider und Personen in strategischen Managementpositionen. In diesem Kontext soll dieses Buch Hilfestellungen bieten, wenn es darum geht, soziale Technologien im Rahmen eigener oder fremder Projekte gezielt einzusetzen. Ergänzend dazu werden gesellschaftliche Aspekte sozialer Technologien sowie die grundlegende Funktionalität sozialer Anwendungen erläutert und im Rahmen praxisorientierter Problemstellungen beispielhaft präsentiert. Für.NET EntwicklerInnen, die sich aktuell mit der Anbindung an soziale Dienste beschäftigen bzw. den Einsatz sozialer Technologien in zukünftigen Projekten planen, stellt dieses Buch einen effizienten und praxisorientierten Ratgeber dar. Es erläutert die grundlegende Architektur sozialer Geschäftsanwendungen, zeigt die Vorgehensweise bei Entwicklung von sozialen Clientanwendungen und gibt Hinweise auf Integrationsmöglichkeiten sozialer Funktionen in ihre eigenen Webanwendungen.

V.2

Über den Autor Mario Fraiß, DI(FH), geboren am 21. Juni 1985 in Graz, ist Gründer und Inhaber der FRAISS – IT Consulting und Mediendesign, ein auf Softwareentwicklung und Technologie-Innovation spezialisiertes Unternehmen mit Sitz in Graz, Österreich. Außerdem arbeitet er seit mehr als zehn Jahren als freiberuflicher Consultant, Trainer und Autor mit dem Schwerpunkt Softwareentwicklung unter .NET und bietet ergänzend dazu Expertise im Java-Umfeld und weiteren Pro-

10

Vorwort grammiersprachen. Er betreut mittelgroße bis große Unternehmen und war unter anderem bereits als Technologieberater für Microsoft Österreich tätig. Sie erreichen ihn über seinen Blog http://www.mariofraiss.com sowie unter http://www.fraiss.IT. Anmerkungen und Anregungen zu den Inhalten und Buchbeispielen sind erwünscht. Sie können mir diese gerne via E-Mail an meine Adresse [email protected] zukommen lassen. Ich wünsche Ihnen viel Vergnügen beim Lesen und Durcharbeiten dieses Buches und möchte mich herzlich für den Erwerb bedanken.

V.3

Danksagung

Ich möchte mich an dieser Stelle bei all jenen Personen bedanken, die mich im Rahmen der Bucherstellung unterstützt haben, und mich gleichzeitig bei jenen entschuldigen, die auf Grund dieses Projektes von mir vernachlässigt wurden. Gleichermaßen großen Dank möchte ich auch gegenüber meinem Lektor Sebastian Burkart, der während der Entstehung dieses Buches stets all meine Fragen beantwortet hat, sowie dem beteiligten entwickler.press-Verlagsteam aussprechen.


11

1 1

Einleitung

Um einen Einstieg in das Thema der Social Services zu finden, wird im Rahmen dieses ersten Kapitels ein Überblick zum Thema Social Services gegeben und gezeigt, in welche Kategorien sich diese zusammenfassen lassen.

1.1

Social! Überall?

Die Beantwortung dieser Frage, bezogen auf die aktuelle Internetlandschaft sowie die derzeitigen technologische Entwicklungen, bedarf der Berücksichtigung einer Vielzahl an unterschiedlichen Faktoren. Zum einen wäre da die Tatsache, dass die Menschen in der heutigen Zeit offensichtlich ständig und überall Kommunikation betreiben wollen. Zum anderen zeigen die unterschiedlichen Anwendungen, die im Laufe der letzten Jahre im Kontext der Social Services entwickelt wurden, dass es immer wieder neue Mittel und Wege gibt, dieses Bedürfnis nach ständiger Kommunikation zu forcieren. Versucht man die anfangs gestellte Frage auf Basis dieser beiden Tatsachen zu beantworten, so wird man zu dem Ergebnis kommen: Ja, Social Services sind in der heutigen Zeit ein fixer Bestandteil unseres Alltags und nahezu überall anzutreffen. Bestätigt wird diese Antwort auch dadurch, dass erst das Aufkommen der Social Services dazu geführt hat, dass sich unser aller Leben verändert hat. Während die Social Services in der Zwischenzeit goße Beeinflussung auf das Privatleben ausüben, zeigen die Erfolge, die soziale Businessnetzwerke oder kollaborative Geschäftsanwendungen verzeichnen, dass wir an dem Punkt angekommen sind, an dem die Forderung nach der Integration der sozialen Dienste in professionelle Anwendungen immer lauter wird.


13

1 – Einleitung

1.2

Über soziale Welten

Im Internet gibt es eine Vielzahl an sozialen Angeboten und Dienstleistungen. Dieser Abschnitt versucht, sie in übergeordnete Gruppen einzuteilen, und geht dabei auf die unterschiedlichen Eigenschaften sowie Vor- und Nachteile ein. Sinn ist es, kurz und prägnant die Vielfalt der verfügbaren Services unterscheiden zu können.

1.2.1

Social Networks

Die wohl bekanntesten Vertreter innerhalb der Social World und des Web 2.0 sind die so genannten Social Networks, auch Social Communites genannt. Dabei handelt es sich um Netzwerke, innerhalb derer die User die Möglichkeit haben, eigene Inhalte zu erstellen um diese mit weiteren Usern zu teilen. Während es zu Beginn, als die ersten sozialen Netzwerke entstanden, nur möglich war, einfache Textnachrichten oder Bilder zu veröffentlichen, bieten diese heute auf Grund ihrer hohen Erweiterbarkeit unendliche viele Möglichkeiten. Die derzeit populärsten sozialen Netzwerke sind folgende:

Private und freizeitorientierte Netzwerke

•• facebook (www.facebook.com) •• MySpace (www.myspace.com) •• StudiVZ, MeinVZ, SchülerVZ Businessorientierte Netzwerke

•• LinkedIn (www.linkedin.com) •• XING, ehemals openBC (www.xing.com) Der Trend der Social Networks zeigt auch, dass diese mehr und mehr in Alltagsgeräte integriert werden, z. B. Handys und Fernseher. Oberste Zielsetzung ist es dabei stets, den Zugang zu den sozialen Netzwerken so einfach wie möglich zu gestalten. Anzumerken is auch, dass zuneh14

Über soziale Welten mend mehr Websites um soziale Funktionalität erweitert werden, bspw. Funktionen wie „Gefällt mir“, „Teilen“ u. a.

1.2.2

Social Services

An zweiter Stelle sind die so genannten Social Services anzuführen. Deren Nutzung kann über die entsprechenden Anwendungswebsites erfolgen, aber auch durch entsprechende offene Schnittstellen. Diese bilden mitunter die Grundlage für die Nutzung der sozialen Dienste innerhalb eigener Applikationen und stellen ergänzend die entsprechenden Hilfsmittel dafür bereit. In der Zwischenzeit gibt es eine Vielzahl an unterschiedlichsten Services und Angeboten im Internet, wobei die nachfolgende Aufzählung einige der wichtigsten Anbieter zeigt:

Populäre Social Services

•• Micro-Blogging-Dienst (twitter.com) •• Dienste im Bereich des „URL-Shortening“, (bit.ly, t.co) •• Dienste zur Authentifizierung (OAuth, Windows Live) •• Mapping-Services (Google-Maps, Bing-Maps) •• Bloganbieter (wordpress.com, blogger.com) •• Dienste zur Datenkonvertierung Im Laufe der letzten Jahre haben sich immer wieder neue Ideen für nützliche Dienste und Anwendungsmöglichkeiten ergeben, die sich erfolgreich am Markt etablieren konnten. Oft stehen neue Services in direktem Zusammenhang mit der Veröffentlich neuer Onlineplattformen oder dienen zur Vereinfachung von Funktionen bereits existierender Onlineangebote.


15

1 – Einleitung

1.2.3

Social Apps

Das Aufkommen der sozialen Netzwerke und der sozialen Services führte zum Entstehen der so genannten Social Apps, auch soziale Anwendungen genannt. Von einer sozialen Anwendung spricht man, wenn sie bestimmte Funktionalitäten durch den kombinierten Einsatz von bereits existierenden oder neuen Social Services bereitstellt und das innerhalb von sozialen Netzwerken tut. Ein weiteres Ziel, das von diesen Anwendungen verfolgt wird, ist es, die gemeinsame, wenn möglich sogar zeitgleiche, Arbeit innerhalb der Applikation zu ermöglichen.

Populäre Social Apps

•• Spiele, „Fun“- oder Marketinganwendungen, die innerhalb sozialer Netzwerke bereitgestellt werden (facebook.com, StudiVZ)

•• Werkzeuge zur Zusammenarbeit (Google Docs, Office Live) •• Anwendungen für Screen- oder Präsentations-Sharing 1.3

Was Sie in diesem Buch erwartet

Wie bereits am Anfang dieses Kapitels erläutert, dient dieses Buch dazu, Konzepte näher zu bringen, mit deren Hilfe soziale Technologien innerhalb eigener Anwendungen genutzt werden können. Die einzelnen Kapitel vermitteln daher teilweise theoretisches Hintergrundwissen und zeigen anhand unterschiedlicher Praxisbeispiele, wie die Arbeit mit den jeweiligen sozialen Diensten funktioniert. Der Fokus liegt dabei auf der Entwicklung für soziale Netzwerke und der Nutzung von sozialen Diensten. Als Programmiersprache kommen C# innerhalb des Microsoft .NET Frameworks sowie unterschiedliche Technologien wie Windows Forms, WPF (Windows Presentation Foundation), ASP.NET (Active Server Pages) und Silverlight zum Einsatz. Sollten Sie Probleme mit dem Nach-

16

Entwicklung für soziale Welten vollziehen der einzelnen Beispiele haben, finden Sie diese auf der Website www.socialdevelopment.at auch als Download.

1.3.1

Website zum Buch

Sobald dieses Buch am Markt erhältlich ist, wird auch die Website zum Buch www.socialdevelopment.at freigeschaltet werden. Dort ist es möglich, bereits ergänzte Errata zu beziehen, sowie mit dem Autor in Kontakt zu treten. Möglicherweise werden von Zeit zu Zeit auch einige Ergänzungen und interessante Links zum Thema bereitgestellt. Eine Kontaktaufnahme mit dem Autor ist über die Website sowie über die E-MailAdresse [email protected] möglich.

1.3.2

Benötigte Software

Um die Funktionalität der Beispiele aus dem Buch zu garantieren, ist es erforderlich, dass Sie das Microsoft .NET Framework 4.0 auf Ihrem System installieren. Sie können es unter http://www.microsoft.com/germany/net/ net-framework.aspx unter dem Eintrag Download herunterladen. Als Entwicklungsumgebung können Sie Microsoft Visual Studio 2010 in allen Versionen einsetzen, wobei auch die Verwendung einer der kostenlosen Express-Editionen möglich ist. Sie erhalten diese unter der Adresse http://www.microsoft.com/germany/express/download/default.aspx. Im Rahmen der Beispiele werden unterschiedliche freie Bibliotheken von Dritten eingesetzt – die jeweiligen Bezugsmöglichkeiten werden innerhalb der einzelnen Kapitel angeführt.

1.4

Entwicklung für soziale Welten

Den Einstieg in das Thema des Social Development bildet die Nutzung von Funktionen und Möglichkeiten, die durch die unterschiedlichen sozialen Netzwerke bereitgestellt werden. Das nachfolgende Kapitel be-


17

1 – Einleitung fasst sich daher mit den populären Netzwerken facebook und LinkedIn. Das hat die folgenden Gründe:

•• Die Anbindung an soziale Netzwerke erfolgt über ein bereits existierendes, gut dokumentiertes API (Application Programning Interface)

•• Viele praktische Anwendungsfälle und Aufgabenstellungen lassen

sich durch die Integration von Social-Network-Funktionalität bereits abdecken.

1.5

Grundlegende Hinweise

Bevor es aber mit der tatsächlichen Entwicklung losgeht, zuvor noch einige allgemein gültigen Regeln und Voraussetzungen, die vor dem Entwickeln von sozialen Anwendungen berücksichtigt bzw. erfüllt werden sollten.

1.5.1

Entwicklerzugang und Anwendungsregistrierung

Um eine Anwendung für ein soziales Netzwerk, einen sozialen Dienst oder eine soziale Anwendung realisieren zu können, ist im Regelfall eine Registrierung notwendig, wodurch man dazu berechtigt wird, die entsprechenden Dienste zu nutzen. Nach erfolgreichem Abschluss erhält man einen so genannten Private Key. Dieser wird von den einzelnen Anbietern im Rahmen eines schlüsselbasierten Verfahrens eingesetzt, um die Anwendung dadurch authentifizieren bzw. deren Integrität gewährleisten zu können und vor möglichem Missbrauch zu schützen. Wie oft der Registrierungsvorgang wiederholt werden muss, hängt vom jeweiligen Anbieter ab. Einige verlangen eine Registrierung pro Entwickler, andere wiederum pro Anwendung. Man unterscheidet also zwischen den folgenden Registrierungsmechanismen:

•• Registrierung auf Basis der Entwickleridentifikation •• Registrierung auf Anwendungsbasis •• Registrierung auf Basis der eingesetzten Domain 18

Grundlegende Hinweise

1.5.2

Berücksichtigung der Guidelines („Spielregeln“)

Vor dem Entwicklungsbeginn von sozialen Anwendungen empfiehlt es sich, die jeweiligen Richtlinien, die durch die einzelnen Anbieter veröffentlicht werden, zu lesen. Sie beinhalten teils sehr interessante Informationen für Entwickler sowie mögliche Ausschlussgründe für eingereichte bzw. veröffentliche Anwendungen. Diese Ausschlussgründe können im schlechtesten Fall dazu führen, dass die Anwendung ohne Angabe von Gründen durch den jeweiligen Anbieter entfernt wird, was besonders im Rahmen professioneller und geschäftsorientierter Anwendungen vermieden werden sollte. Meistens werden die Guidelines innerhalb der Entwicklerbereiche der Anbieter bereitgestellt. Nachfolgend die Adressen zu den Guidelines einiger populärer Anbieter:

•• facebook

http://developers.facebook.com/policy/

•• LinkedIn

http://developer.linkedin.com/docs/DOC-1091

•• YouTube

http://code.google.com/apis/youtube/terms.html

•• twitter

http://dev.twitter.com/pages/api_terms

•• OpenSocial

http://code.google.com/apis/opensocial/terms.html

1.5.3

Plausibilität des Projekts

Bevor Sie mit der aktiven Umsetzung einer sozialen Anwendung bzw. mit deren Anbindung beginnen, sollten Sie Ihre Idee bzw. Ihr Konzept genauestens hinterfragen. Nutzen Sie Suchmaschinen und vergewissern Sie sich, dass es Ihre Anwendung in der geplanten oder einer ähnlichen Form noch nicht gibt. Das Social Web wächst schnell und niemand wird Ihre Anwendung bzw. Ihr Angebot nutzen, sofern es in abgewandelter Social Development mit .NET

19

1 – Einleitung oder gleicher Form bereits existiert. Durchsuchen Sie auch bereits existierende Netzwerke und Foren, um sicherzustellen, dass Ihre Anwendung tatsächliche eine Bereicherung für soziale Netze darstellt – niemand wird Ihnen dankbar sein, wenn Sie der x-te Anbieter einer bereits bekannten Anwendung sind.

1.6

Es geht los!

An dieser Stelle bleibt mir nur noch, Ihnen viel Vergnügen und entsprechenden Lernerfolg beim Durcharbeiten der Beispiele dieses Buches zu wünschen. Hinweis: Sämtliche Rückmeldungen des Servers in den nachfolgenden Beispielen müssen in der Form ähnlich sein, unterscheiden sich aber in jedem Fall durch die übermittelten Daten, da Sie die Anwendung mit einem Ihrer eigenen Accounts ausführen. Formulierungen wie „folgende Antwort/Rückmeldung“ sind daher im Sinne von „ähnliche/r Antwort/Rückmeldung“ zu verstehen.

20

Teil A Integration mit Social Networks Der erste Teil dieses Buches befasst sich mit der Entwicklung von Anwendungen, die Funktionalität von unterschiedlichen Social Networks integrieren. Für Anwendungen dieser Art gilt es, Voraussetzungen bzw. Einschränkungen zu beachten:

•• Eine Anwendung, die Funktionalität von sozialen Netzwerken oder Diensten nutzen möchte, muss sich bei Start der Anwendung immer authentifizieren.

•• Sofern benutzerbezogene Mitteilungen versendet oder Informationen abgerufen werden sollen, muss die Verbindung über ein entsprechendes Benutzerkonto hergestellt werden.

•• Anwendungen müssen den Richtlinien folgen, die durch die jeweiligen Anbieter gefordert werden.


21

2 2

facebook

Wenn heutzutage von sozialen Anwendungen gesprochen wird, spricht man damit implizit über facebook. Facebook selbst bietet aber weit mehr Möglichkeiten, als den meisten Nutzern bewusst ist. Haben Sie schon einmal daran gedacht, facebook für folgende Tätigkeiten zu nutzen:

•• Erstellen einer grafischen Abbildung von Kundenbeziehungen und Partnernetzwerken

•• Automatisches Senden von Informationen zu Sonderangeboten und Aktionen durch Integration in das eigene CRM-System

•• Erstellen von automatische Auswertungen, die das eigene Geschäft betreffen, und das mit aktuellem Datenbestand

•• Untersuchen der Kundenbindung zur Konkurrenz Solche Fragestellungen und viele mehr lassen sich durch den kreativen Einsatz von facebook und anderen sozialen Diensten im Handumdrehen beantworten – und das ganz ohne teure Marktforschungskampagnen. Wie, das lernen Sie anhand von praxisorientierten Beispielen in diesem Kapitel.

2.1

Empfohlene Ressourcen für den Einstieg

Bevor Sie mit der eigentlichen Entwicklung beginnen, sollten Sie sich mit dem Thema „facebook Developement“ im Allgemeinen auseinandersetzen. Machen Sie sich mit der grundlegenden Anwendungsstruktur vertraut und eignen Sie sich notwendiges Basiswissen an. Einen guten Einstieg dazu bieten Ihnen die nachfolgend angeführeten Adressen:


23

2 – facebook

•• Facebook-Entwicklerportal

http://developers.facebook.com/

•• Facebook-Entwicklungsdokumentation http://developers.facebook.com/docs/

2.2

Struktur des API

Innerhalb des facebook-API wird prinzipiell zwischen zwei unterschiedlichen Entwicklungsbereichen unterschieden:

•• Bereitstellung sozialer Plug-ins •• Anbindung/Nutzung des Graph-API Während so genannte soziale Plug-ins dafür zuständig sind, bestimmte Funktionen aus dem Netzwerk innerhalb der eigenen Website bereitzustellen, so bildet das Graph-API die Grundlage für die dahinter liegenden Datenobjekte. Die Nutzung dieser Technologien wird ergänzend dazu durch zahlreiche SDKs und frei erhältliche Bibliotheken vereinfacht.

2.2.1

Soziale Plug-ins

Facebook bietet die einfache und schnelle Möglichkeit, soziale Funktionalität aus dem Netzwerk innerhalb der eigenen Website bereitzustellen. Dafür existieren derzeit acht unterschiedliche Social Plug-ins:

•• Like-Button (Gefällt mir) •• Recommendations (Empfehlungen) •• Login-Button (Anmeldung via Facebook) •• Comments (Kommentare) •• Activity Feed (Aktivitäten) •• Like-Box (Erweiterte Form von Gefällt mir) •• Facepile (Benutzerbilder bereits angemeldeter facebook User) •• Live Stream (Live-Unterhaltungen) 24

Struktur des API Sie werden sich im Rahmen dieses Buches nicht weiter mit den sozialen Plug-ins auseinandersetzen, da deren Verwendung meist recht einfach und mit nur wenig zusätzlichem Programmieraufwand möglich ist. Hinweis: Weitere Informationen bezüglich der sozialen Plug-ins und wie Sie diese verwenden können, finden Sie unter http://developers.facebook.com/plugins.

2.2.2

Graph-API und FQL

Das Graph-API ist das wichtigste Instrument, wenn es um die Entwicklung von Anwendungen für und rund um facebook geht. Sie bietet alle notwendigen Schnittstellen und Datenstrukturen, um den Datenbestand des Netzwerks zu nutzen – d. h. Sie werden im Rahmen der folgenden Praxisbeispiele das Graph-API erlernen, um damit Anfragen an facebook zu richten. Ergänzend dazu werden Sie die so genannte Facebook Query Language (FQL) dazu nutzen, um diese Anfragen, ähnlich wie im Rahmen eines Datenbanksystems in einem der Sprache SQL ähnlichen Stil zu formulieren. Ein mögliches Statement wäre bspw. das folgende: SELECT name FROM user WHERE uid = me()

Welche Möglichkeiten die FQL bietet und wie Sie diese im Rahmen von .NET nutzen können, auch das werden Sie im Rahmen der bevorstehenden Praxisbeispiele erarbeiten. Diese beiden Themen werden im Rahmen dieses Kapitels ausführlich behandelt. Hinweis: Weitere Informationen bezüglich des Graph-API finden Sie unter http://developers.facebook.com/docs/reference/api/ bzw. über die FQL unter http://developers.facebook.com/docs/reference/fql/.


25

2 – facebook

2.2.3

SDKs und „Code Inside“

Selbstverständlich existiert bereits eine Vielzahl an unterschiedlichen SDKs und Bibliotheken im Netz, die Sie zur Programmierung von facebook-Anbindungen nutzen können und sollen. Dennoch empfiehlt es sich, sich auch mit den Grundlagen der facebook-Programmierung auseinanderzusetzen. Sie werden im Rahmen der Beispiele teilweise „zu Fuß“, aber auch mithilfe bereits bestehender Code-Libraries Anwendungen realisieren und so facebook-Integration ermöglichen.

2.3

Anwendung bei facebook registrieren

Bevor Sie tatsächlich mit der Entwicklung Ihrer ersten Anwendung beginnen können, ist es erforderlich, dass Sie 1. sich einen facebook-Account erzeugen und 2. Sie Ihre Anwendung bei facebook registrieren. Für jede neue Anwendung, die Sie erstellen möchten, begeben Sie sich bitte auf die folgende Website http://www.facebook.com/developers/createapp.php und füllen Sie das in der nachfolgenden Abbildung gezeigte Formular aus. Vergessen Sie nicht, den Allgemeinen Geschäftsbedingungen von facebook zuzustimmen und betätigen Sie die Schaltfläche Anwendung erstellen.

26

Anwendung bei facebook registrieren

Abbildung 2.1: Registrieren einer neuen facebook-Anwendung

Herzlichen Glückwunsch! Im Prinzip haben Sie gerade Ihre erste facebook-Anwendung erstellt. Wenn Sie sich jetzt zu Ihrer Anwendungsübersicht begeben, zu finden unter http://www.facebook.com/developers/ apps.php, sollten Sie Ihre Anwendung bereits sehen können.

Abbildung 2.2: Anwendungsübersicht im facebook-Entwicklerbereich


27

2 – facebook In diesem Bereich stehen Ihnen auch die wesentlichsten Informationen über Ihre soeben erstelle Anwendung zur Verfügung. Diese sind:

•• Anwendungs-ID •• API-Schlüssel •• Anwendungsgeheimcode (Anwendungs-Secret) Sie benötigen diese Daten in weiterer Folge, um sich im Rahmen der Entwicklung entsprechend authentifizieren zu können. Achtung: Halten Sie diese Daten in jedem Fall geheim, da ansonsten Ihre Anwendung zu missbräuchlichen Zwecken eingesetzt werden könnte. Im schlimmsten Fall gelingt es Angreifern sogar, damit eine falsche Identität vorzugeben.

Weitere Informationen und Einstellungsmöglichkeiten im Rahmen Ihrer Anwendung erhalten Sie, wenn Sie sich über den Link Einstellungen bearbeiten in den Konfigurationsbereich Ihrer Anwendung begeben.

2.3.1

Anwendungsarten

Facebook unterstützt insgesamt drei unterschiedliche Anwendungsarten, die beliebig miteinander kombiniert werden können. Die durch facebook bereitgestellten Anwendungsarten sind folgende:

•• Desktopanwendung •• Webanwendung •• Mobile Anwendung (Unterscheidung zwischen nativer oder HTML5) Während in der Vergangenheit eine strikte Trennung der unterschiedlichen Anwendungstypen erfolgte, ist es aktuell möglich, die verschiedenen Arten miteinander zu kombinieren. Beispielsweise eine Desktop anwendung, die aber auch einen mobilen Client zur Verfügung stellt. Die Art einer Anwendung bestimmt zu wesentlichen Teilen, welche

28

Entwicklung des Basisframeworks Möglichkeiten man als Entwickler erhält, um mit facebook zu kommunizieren, aber auch, wie die jeweilige Anwendung sich authentifiziert. Im Bereich der mobilen facebook-Anwendungen wird es dadurch sogar möglich, Rücksicht auf einzelne Frameworks wie das iPhone- oder auch Android SDK zu nehmen. Weitere Informationen zu den einzelnen Anwendungstypen sowie Details zu den technischen Unterschieden finden Sie auf den folgenden Seiten:

•• Webanwendung

http://developers.facebook.com/docs/guides/web

•• Anwendung auf facebook.com

http://developers.facebook.com/docs/guides/canvas

•• Mobile Anwendungen

http://developers.facebook.com/docs/guides/mobile/ Hinweis: Überlegen Sie bereits in der Konzeptionsphase Ihrer Anwendungen, welche Anwendungsarten für Sie relevant sind und in welcher Form Sie diese unterstützen möchten. Nicht immer ist es erforderlich, auch eine mobile Variante der Anwendung bereitzustellen.

2.4

Entwicklung des Basisframeworks

In diesem Abschnitt werden Sie Ihre erste Desktopanwendung mit facebook-Anbindung erstellen. Im Rahmen Ihrer Anwendung wird es möglich sein, sich über facebook zu authentifizieren und auf Daten des sozialen Netzwerks zuzugreifen. Für sämtliche Kommunikationsvorgänge werden Sie dabei die Basisfunktionen des facebook-Graph-API einsetzen und gänzlich auf die Verwendung von Drittanbieterbibliotheken verzichten. Um den Authentifizierungsvorgang besser zu verstehen, werden Sie Ihre eigene Facebook-Kommunikationsbibliothek erstellen und sämtliche Authentifizierungsschritte manuell implementieren.


29

2 – facebook

2.4.1

Hello „facebook“

Jetzt, nachdem Sie sich bereits mit den Grundlagen der facebook-Entwicklungsthematik auseinandergesetzt haben, freuen Sie sich bestimmt schon darauf, Ihre ersten „sozialen Anwendungen“ zu entwickeln – ich wünsche Ihnen dafür viel Erfolg im Rahmen Ihres ersten „Hello facebook“-Projekts. Starten Sie bitte Microsoft Visual Studio, erzeugen Sie ein neues Windows-Forms Projekt mit dem Namen 01_HelloFacebook und nennen Sie die zugehörige Projektmappe SocialDevelopment. Erstellen Sie innerhalb der Projektmappe ein weiteres Projekt, diesmal vom Typ Klassenbibliothek, und geben Sie dem Projekt die Bezeichnung SocialDevelopmentTools. Damit haben Sie das Grundgerüst für Ihre Anwendung erstellt. Außerdem benötigen Sie die soeben generierte Projektmappe für alle weiteren Beispiele im Buch. Sie sollten in Ihrem Projektmappen-Explorer folgende Einträge sehen:

Abbildung 2.3: Visual-Studio-Projektmappenstruktur

Fügen Sie dem Projekt SocialDevelopmentTools jetzt bitte folgende Projektelemente hinzu und entfernen Sie die nicht weiter benötigte Klasse Class1:

30


•• Klasse FacebookClient •• Windows-Form FacebookAuthorizationForm In weiterer Folge werden diese beiden Elemente die Kapselung der folgenden Funktionalitäten übernehmen:

•• Bereitstellen eines Formulars zur Anmeldung bei Facebook •• Durchführen des Authentifizierungsvorgangs •• Speichern der Authentifizierungsinformationen Der nächste Abschnitt beschäftigt sich mit dem facebook-Authentifizierungsvorgang und beschreibt dessen Implementierung im Detail.

2.4.2

Implementierung der facebookAuthentifizierung

Der Authentifizierungsvorgang in facebook gliedert sich insgesamt in folgende Abschnitte: 1. Aufrufen der Graph-API-Authentifizierungsseite 2. Bestätigung der Anwendungsfreigabe durch den Benutzer 3. Abschließen des Authentifizierungsvorgangs Fügen Sie bitte folgende Properties public public public public

String fb_ApplicationID { get; set; } Boolean fb_Authorized { get; set; } String fb_AccessToken { get; set; } String[] fb_Errors { get; set; }

Ihrer Klasse FacebookAuthorizationForm hinzu und nachfolgende Eigenschaften Ihrer Klasse FacebookClient:


31

2 – facebook //Facebook Anwendungs-ID public String ApplicationID { get; set; } //AccessToken der nach der Authentifizierung ausgestellt wird public String AccessToken { get; set; } //true wenn Authentifizierung erfolgreich durchgeführt public Boolean Authorized { get; set; } //Properties zur Speicherung etwaiger von facebook //zurückgegebener Fehler public String ErrorReason { get; set; } public String Error { get; set; } public String ErrorDescription { get; set; }

Sie werden diese Eigenschaften zur Speicherung der im Rahmen des Authentifizierungsvorgangs benötigten und übermittelten Daten verwenden. Um die gewünschte Funktionalität zu erhalten, nämlich die eines Anmeldeformulars, ist es erforderlich, das Aussehen des Windows-Formulars FacebookAuthorizationForm anzupassen. Außerdem werden Sie dynamisch ein entsprechendes WebBrowser-Steuerelement hinzufügen, um darin das facebook-Formular zur Anwendungsauthentifizierung anzuzeigen. Ergänzen Sie dazu bitte den Konstruktor des Formulars um folgenden Code: public FacebookAuthorizationForm() { InitializeComponent(); //Formular anpassen this.Size = new Size(640, 360); this.StartPosition = FormStartPosition.CenterParent; this.Text = "Facebook-Anmeldung erforderlich"; this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedToolWindow; this.MaximizeBox = false; this.MinimizeBox = false;

32

Entwicklung des Basisframeworks //WebBrowser-Steuerelement dynamisch konfigurieren und //hinzufügen WebBrowser fbAuthorizeBrowser = new WebBrowser(); fbAuthorizeBrowser.Dock = DockStyle.Fill; this.Controls.Add(fbAuthorizeBrowser); }

Um die Klasse FacebookClient in externen Anwendungen sinnvoll nutzen zu können, werden Sie die Klasse public setzen und deren Konstruktor ein wenig abändern. Außerdem wird sie um eine Methode Authorize ergänzt. Ziel ist es, bereits bei der Initialisierung der Klasse die facebookApplicationID zu erfassen. Ergänzen Sie die Klasse daher wie folgt: //Konstruktor zur Übernahme der Application-ID public FacebookClient(String fb_ApplicationID) { if (fb_ApplicationID != "") this.ApplicationID = fb_ApplicationID; } //Methode zum Einleiten des Anmeldevorganges public void Authorize() { //Erzeugen des Authentifizierungs-Formulars FacebookAuthorizationForm fbAuthorizationForm = new FacebookAuthorizationForm(); //Setzen der facebook ApplicationID fbAuthorizationForm.fb_ApplicationID = this.ApplicationID; //Anzeigen des Authentifizierungs-Formulars fbAuthorizationForm.ShowDialog(); }

Um den derzeitigen Code zu testen, wechseln Sie in das Projekt 01_Hello Facebook und ergänzen Sie den Code um folgenden Abschnitt: //Erzeugen des Facebook-Client-Objekts private FacebookClient fbClient = null;


33

2 – facebook Behandeln Sie jetzt das Shown-Ereignis des Formulars und implementieren folgende Ereignisbehandlungsroutine. Vergessen Sie nicht, Ihre Anwendungs-ID entsprechend anzupassen. private void frmMain_Shown(object sender, EventArgs e) { //Facebook-Client erstellen und mit ApplicationID //initialisieren fbClient = new FacebookClient(""); //Facebook-Authentifizierung beginnen fbClient.Authorize(); }

Um den Code jetzt lauffähig zu machen, ist es erforderlich, dass Sie dem Projekt 01_HelloFacebook den Verweis auf das Projekt SocialDevelopmentTools konfigurieren und außerdem folgene Using-Direktive ergänzen: using SocialDevelopmentTools;

Abbildung 2.4: Projektabhängigkeit SocialDevelopmentTools

Wenn Sie die Anwendung jetzt starten, dann sollten Sie direkt nach dem Start ein Fenster mit weißem Inhalt erhalten. An dessen Stelle wird später die facebook-Anmeldeseite angezeigt werden. Die nachfolgende Abbildung veranschaulicht den aktuellen Anwendungszustand:

34


Abbildung 2.5: Anwendung mit vorbereitetem Anmeldungsfenster

Um der Anwendung etwas mehr „Leben“ einzuhauchen, fügen Sie innerhalb des Konstruktors der Klasse FacebookAuthorizationForm bitte dynamisch einen Event Handler zur Behandlung des Load-Events hinzu und implementieren ihn folgendermaßen: public FacebookAuthorizationForm() { ... //Lade-Eventhandler hinzufügen this.Load += new EventHandler(FacebookAuthorizationForm_Load); } //Lädt beim Laden der Form die facebook-Anmeldeseite //innerhalb des integrierten WebBrowsers void FacebookAuthorizationForm_Load (object sender, EventArgs e) { //Erzeugen der passenden Authorization-URL //unter Angabe der Application-ID String authorizeURL = "https://graph.facebook.com/oauth/ authorize?client_id=" + fb_ApplicationID + "&redirect_uri= http://www.facebook.com/connect/login_success.html&type= user_agent&display=popup";


35

2 – facebook //Umleiten auf die soeben zusammengestellte Authorization-URL ((WebBrowser)((Form)sender).Controls[0]). Navigate(authorizeURL); }

Im Rahmen der oben stehenden Ereignisbehandlung wird der für die erfolgreiche Authentifizierung notwendige URL zusammengestellt. Im Rahmen des Graph-API nutzt facebook zur Authentifizierung das OAuth-Protokoll (http://www.oauth.net). Es besteht aus folgenden Teilen:

•• https://graph.facebook.com/oauth/authorize? •• client_id= •• &redirect_uri=http://www.meinewebsite.at/success.html •• &type=user_agent •• &display=popup •• &scope= Dabei ist zu beachten, dass Sie Ihre eigene Anwendungs-ID übergeben und auch sämtliche Parameter entsprechend definieren. Etwas Freiheit lässt Ihnen facebook beim Parameter redirect_uri, dieser kann von Ihnen frei gewählt werden und unterliegt keinerlei Vorgaben. Der von facebook vorgesehene Standard-URL lautet http://www.facebook.com/connect/ login_success.html. Hinweis: Der genaue Ablauf ist in Abschnitt 1.3 der OAuth-Protokollspezifikation nachzulesen. Sie finden diese unter http://tools.ietf. org/html/draft-ietf-oauth-v2-10.

Besonders wichtig ist auch die Angabe des Parameters scope, da er die Rechte repräsentiert, die Ihre Anwendung anfordert. Mit den erweiterten Rechten werden Sie sich allerdings erst in einem späteren Abschnitt beschäftigen.

36

Entwicklung des Basisframeworks Wenn Sie die Anwendung jetzt erneut ausführen, sollten Sie bereits kurz nach dem Start auf die facebook-Anmeldeseite umgeleitet werden. Diese beinhaltet unter anderem Informationen darüber, welche Anwendung entsprechenden Datenzugriff beantragt. Ihre Anwendung sollte daher in etwa folgendermaßen aussehen:

Abbildung 2.6: Anwendung mit geladener facebook-Anmeldeseite

Wenn Sie jetzt eine der beiden Schaltflächen Zulassen oder Nicht zulassen betätigen, hat das derzeit noch keine Auswirkung auf Ihren Authentifizierungsstatus, da dazu die Behandlung der Antworten der facebookAnmeldeseite noch fehlt. Facebook reagiert auf Ihre unterschiedlichen Eingaben, also das Akzeptieren oder Ablehnen der Anforderung, folgendermaßen:

•• bei Erfolg wird auf die von Ihnen im Parameter redirect_uri weiter-

geleitet und im Rahmen der Umleitung der zugeteilte Access-Token übermittelt

•• bei Misserfolg wird auf die von Ihnen im Parameter redirect_uri weitergeleitet und zusätzlich werden die Parameter error_reason, error und error_description durch facebook hinzugefügt


37

2 – facebook

Hinweis: Weiterführende Informationen zu den im Rahmen des Authentifizierungsvorgangs vorkommenden Parametern finden Sie unter dieser Adresse: http://developers.facebook.com/docs/ authentication/desktop.

Um die soeben beschriebenen Szenarien Erfolg und Misserfolg zu implementieren, werden Sie das Event Navigating nutzen, das durch das WebBrowser-Steuerelement zur Verfügung gestellt wird. Behandeln wir zuerst den Erfolgsfall, d. h. im Detail werden Sie

•• den von facebook aufgerufenen URI parsen und •• den zugeteilten Access Token auslesen und speichern. Fügen Sie zur Behandlung der erfolgreichen Authentifizierung innerhalb des Konstruktors der Klasse FacebookAuthorizationForm die dynamische Zusweisung eines Event Handlers Navigating hinzu und implementieren Sie diesen wie nachfolgend gezeigt: public FacebookAuthorizationForm() { ... //Navigating-Eventhandler hinzufügen ((WebBrowser)this.Controls[0]). Navigating +=new WebBrowserNavigatingEventHandler (fbAuthorizeBrowser_Navigating); ... } void fbAuthorizeBrowser_Navigating(object sender, WebBrowserNavigatingEventArgs e) { //Auslesen der Redirect URI Uri uri = new Uri(e.Url.AbsoluteUri); //Auslesen des URI-Fragments (jener Teil hinter #) String uriFragment = uri.Fragment; //Aufteilen auf einzelne Fragment-Teile

38

Entwicklung des Basisframeworks String[] uriFragmentSections = uriFragment.Split('&'); //Auslesen des access-Tokens String[] uriFragmentSectionAccessToken = uriFragmentSections[0].Split('='); if (uriFragmentSectionAccessToken.Length == 2 && uriFragmentSectionAccessToken[1] != null) { String fb_access_token = uriFragmentSectionAccessToken[1]; //Speichern des access-Tokens im gekapselten Objekt fb_AccessToken = fb_access_token; fb_Authorized = true; ((Form)((WebBrowser)sender).Parent).Close(); } }

Außerdem ist es erforderlich, den Access Token und den Zustand der Authentifizierung im Rahmen der Klasse FacebookClient zu speichern. Passen Sie daher die Methode Authorize entsprechend an: public void Authorize() { ... //Auslesen der facebook Rückgabewerte this.Authorized = fbAuthorizationForm.fb_Authorized; this.AccessToken = fbAuthorizationForm.fb_AccessToken; }

Um die Auswirkungen des vorhin implementieren Navigating-Handlers zu bemerken, ist es notwendig, den Code der Klasse Form1 des Projekts 01_HelloFacebook ein wenig zu modifizieren. In diesem Beispiel färben Sie die Hintergrundfarbe bei erfolgreicher Authentifizierung hellgrün. Ergänzen Sie den bestehenden Code daher um folgende Zeilen:


39

2 – facebook private void Form1_Shown(object sender, EventArgs e) { ... //Überprüfen ob Authentifizierung erfolgreich war if (fbClient.Authorized) { this.BackColor = Color.LightGreen; } }

Starten Sie Ihre Anwendung und überprüfen Sie Ihre Implementierung, indem Sie der Anwendung den Zugriff auf Ihr Profil statten. Dadurch sollten Sie erfolgreich authentifiziert sein und die Hintergrundfarbe des Formulars Hellgrün sein. Wenn Sie die Anwendung schließen und erneut ausführen, werden Sie feststellen, dass Sie das von Ihnen implementierte Authentifizierungsfenster nur mehr kurz sehen und Ihr Status weiterhin authentifiziert ist. Um Ihren Status von authentifiziert auf nicht authentifiziert zu ändern, ist es erforderlich, dass Sie die folgende Seite Ihres facebook-Profils aufrufen: http://www.facebook.com/settings/?tab=applications Diese Seite zeigt Ihnen die Liste der Anwendungen, denen Sie vertrauen, d. h. die Zugriff auf Ihr Profil erhalten. Begeben Sie sich an das Ende der Liste und entfernen Sie den Eintrag, der den Namen Ihrer Anwendung trägt, durch Klicken auf die kleine Schaltfläche x.

Abbildung 2.7: Entfernen von Anwendungsberechtigungen

40


Hinweis: Um den Anmeldungsvorgang erfolgreich testen zu können, ist es notwendig, dass Sie die Anwendung nach jeder erfolgreichen Anwendung manuell aus der Liste der vertrauenswürdigen Anwendungen entfernen.

Da Ihre Anwendung im Rahmen der Authentifizierung bisher nur den Erfolgsfall behandelt, werden Sie jetzt den Code zur ordentlichen Fehlerbehandlung implementieren, d. h. Sie werden den Navigating Handler der Klasse FacebookAuthorizationForm erweitern, wodurch die durch facebook übermittelten Querystring-Parameter error_reason, error und error_description ausgelesen und gespeichert werden. void fbAuthorizeBrowser_Navigating(object sender, WebBrowserNavigatingEventArgs e) { ... //Überprüfen des Query-Strings ob facebook einen Fehler //zurückgemeldet hat if (e.Url.Query != null && e.Url.Query != "") { if (e.Url.Query.Contains("error_reason")) { String[] queryStringParts = e.Url.Query.Split('?')[1].Split('&'); //Speichern der Fehlerrückmeldungen String error_reason = queryStringParts[0].Split('=')[1]; String error = queryStringParts[1].Split('=')[1]; String error_description = queryStringParts[2].Split('=')[1]; fb_Errors = queryStringParts; ((Form)((WebBrowser)sender).Parent).Close(); } } }


41

2 – facebook Ergänzen Sie jetzt die Methode Authorize der Klasse FacebookClient um folgende Codezeilen, um dafür zu sorgen, dass auch hier die Fehlerrückgabewerte korrekt gespeichert werden. public void Authorize() { ... //Speichern der Fehlerwerte bei nicht erfolgreicher //Authentifizierung if (!this.Authorized) { this.ErrorReason = fbAuthorizationForm.fb_Errors[0].Split('=')[1]; this.Error = fbAuthorizationForm.fb_Errors[1].Split('=')[1]; this.ErrorDescription = fbAuthorizationForm.fb_Errors[2].Split('=')[1]; } }

Passen Sie zum Abschluss noch den Konstruktor der Klasse Form1 des Projekts 01_HelloFacebook an, um bei fehlerhafter Authentifizierung das Formular hellrot zu färben und eine entsprechende Fehlermeldung auszugeben: private void Form1_Shown(object sender, EventArgs e) { ... //Überprüfen ob Authentifizierung erfolgreich war if (fbClient.Authorized) { this.BackColor = Color.LightGreen; } else { this.BackColor = Color.LightCoral; MessageBox.Show("Anmeldung nicht erfolgreich\r\nFehler: " + fbClient.ErrorReason); } }

42

Datenabfragen Herzlichen Glückwunsch! Damit ist die Implementierung des eigentlich „einfachen“, facebook-Authentifizierungsprozesses abgeschlossen und Sie wissen, welche Schritte dafür erforderlich sind. Im nächsten Abschnitt werden Sie aktiv unter Verwendung des Graph-API auf Codeebene Daten aus dem Netzwerk abfragen.

2.5

Datenabfragen

In diesem Abschnitt werden Sie sich mit dem Abfragen von Daten aus dem facebook-Netzwerk beschäftigen und mit der Frage, wie Sie diese mit .NET-Bordmitteln und der freien JSON- (JavaScript-Object-Nota tion-)Implementierung JSON.net entsprechend weiterverarbeiten und auswerten können.

2.5.1

Abfragen mithilfe des Graph-API

Erstellen Sie dazu ein neues Projekt vom Typ WPF-Anwendung und benennen Sie es mit 02_FacebookGraphAPI. Integrieren Sie jetzt in die soeben erstellte Anwendung die Funktionalität aus dem vorherigen Beispiel, sodass Sie sich in der neuen Anwendung entsprechend über facebook anmelden können. Dazu sind nur wenige Zeilen Code erforderlich. Verwenden Sie als Start Event Handler das Ereignis Loaded und fügen Sie dem Fenster ein Label-Steuerelement mit der Bezeichnung lblStatus hinzu. private FacebookClient fbClient = null; private void Window_Loaded(object sender, RoutedEventArgs e) { fbClient = new FacebookClient(""); fbClient.Authorize(); if (fbClient.Authorized) { lblStatus.Content = "Erfolgreich angemeldet"; } }


43

2 – facebook Entfernen Sie jetzt die Anwendungsberechtigung Ihrer facebook-Applikation und starten Sie im Anschluss die WPF-Anwendung. Sie sollten den bereits bekannten Anmeldedialog erhalten und im Anschluss ein weißes Fenster mit dem entsprechenden Label sehen können.

Abbildung 2.8: WPF-Anwendung mit facebook-Zugriff

Sie werden jetzt die Funktionalität der bestehenden Anwendung erweitern, indem Sie mithilfe des facebook-Graph-API Informationen abrufen. Im ersten Schritt werden dies Daten über die aktuell angemeldete Person sein. Eine Abfrage an das facebook-Graph-API muss über SSL erfolgen und einen so genannten Query-Path sowie ein aktives Authorization-Object beinhalten. Im Rahmen des Graph-API sind daher alle Abragen folgendermaßen zu formulieren:

•• https://graph.facebook.com/

44

Datenabfragen Dabei bezieht sich der Query Path auf das jeweilige Objekt bzw. die Objekte, die abgefragt werden sollen, und das Authorization-Objekt auf den bereits bekannten Access Token, den man bei der Authentifizierung durch die Server erhalten hat. Jedes in facebook erfasste und verfügbare Objekt besitzt eine ID. Über diese eindeutige Kennung können Sie Daten zum jeweiligen Objekt anfordern. Um den Zugang zu den entsprechenden Informationen und die Abfrageformulierung zu erleichtern, bietet facebook im Rahmen des Graph-API jedoch auch vereinfachte Query Paths an. Query-Path /

Direkter Zugriff auf ein Objekt über dessen ID

/me

Bezieht sich immer auf den autorisierten User

/me/friends

Freunde

/me/home

News-Feed

/me/feed

Wall

/me/likes

„Gefällt mir“-Einträge

/me/movies

Filme

/me/books

Bücher

/me/notes

Notizen

/me/photos

Foto-Tags

/me/albums

Fotoalben

/me/videos

Videos

/me/videos/uploaded

Videos, die hochgeladen wurden

/me/events

Veranstaltungen

/me/groups

Gruppen

/me/checkins

Registrierte Checkins

Tabelle 2.1: facebook-Query-Path-Übersicht

Fügen Sie Ihrer bestehenden Anwendung jetzt bitte ein TextBox-Steuer element mit dem Namen txtAccessToken hinzu und ergänzen Sie den Code innerhalb des Loaded-Ereignisses um folgende Zeile: Social Development mit .NET

45

2 – facebook private void Window_Loaded(object sender, RoutedEventArgs e) { ... if (fbClient.Authorized) { ... txtAccessToken.Text = fbClient.AccessToken; } }

Starten Sie die Anwendung jetzt erneut und betrachten Sie den Access Token, der Ihnen von facebook ausgestellt wird. Er sollte in etwa so aussehen: 122349811234464%7C2.SJl9mioR1LulIgERkUyWZw__.3600.12888216001337028662%7Cf24ruBkbRsmf6VeVh6S10MA3Res Der Access Token besteht aus drei Teilen, um die Sie sich aber nicht weiter kümmern müssen. Sie werden den Access Token ausschließlich als komplette Zeichenfolge verwenden. %< TOKEN>%< SECRET> Öffnen Sie jetzt einen Browser Ihrer Wahl und begeben Sie sich auf die folgende Website: https://graph.facebook.com/me Sie sollten die folgende Antwort erhalten: {

"error": { "type": "OAuthException", "message": "An active access token must be used to query information about the current user." }

}

Diese Antwort ist in JSON formuliert und weist Sie darauf hin, dass Sie bei Ihrer Abfrage an das Graph-API keinen aktiven und gültigen Access Token übergeben haben.

46

Datenabfragen Fügen Sie dem bereits bekannten URL jetzt Ihren Access Token hinzu und rufen Sie die Website erneut ab:

•• https://graph.facebook.com/me?access_token=122349811234464%7C2.

SJl9mioR1LulIgERkUyWZw__.3600.12888216001337028662%7Cf24ruBkbRsmf6VeVh6S10MA3Res

In diesem Fall erhalten Sie sämtliche Informationen zu dem von Ihnen gewünschten Objekt /me, also den aktuell angemeldeten User. { "id": "1337028662", "name": "Mario Frai\u00df", "first_name": "Mario", "last_name": "Frai\u00df", "link": "http://www.facebook.com/fraiss", "about": "freut sich des Lebens, \u00fcber seine Beziehung und \u00fcber den Erfolg seines Unternehmens in genau dieser Reihenfolge :)", "hometown": { "id": "109859345710059", "name": "Graz, Austria" }, "location": { "id": "109859345710059", "name": "Graz, Austria" }, "work": [ { "employer": { "id": "152054151488864", "name": "FRAISS - IT Consulting & Mediendesign" }, "start_date": "0000-00", "end_date": "0000-00" } ], ...


47

2 – facebook Hinweis: Sie können ausschließlich auf Daten zugreifen, für die sich auch die entsprechenden Berechtigungen besitzen, bspw. können Sie nur auf öffentliche Profildaten zugreifen und nicht auf die Freunde anderer Profile. Um Zugriff auf diese Daten zu erhalten, wäre es erforderlich, dass dieses Profil Ihrer Anwendung die notwendigen Freigaben erteilt.

2.5.2

Kurzeinführung JSON

Die JavaScript Object Notation, kurz JSON, ist ein einfaches, mit wenig Overhead auskommendes Datenformat, das als Alternative zu XML geschaffen wurde. In der Zwischenzeit findet es im Rahmen vieler unterschiedlicher Softwaresysteme Anwendung und kommt vor allem dann zum Einsatz, wenn es darum geht, mit Ressourcen wie Speicherplatz oder CPU-Leistung sparsam umzugehen. Eines der dabei wichtigsten Einsatzgebiete ist die Entwicklung von aktuellen Webanwendungen. In JSON formulierte Datensätze sind klar strukturiert und befolgen folgende Regeln:

•• Objektdeklaration innerhalb von { und }, wobei es erlaubt ist, eine Liste an Eigenschaften anzugeben, deren Elemente durch Kommata getrennt sind.

•• Eine Eigenschaft setzt sich aus einem Schlüssel und einem Wert zusammen. Die Trennung erfolgt durch einen Doppelpunkt.

•• Ein Schlüssel ist als Zeichenkette zu formulieren. •• Ein Array wird mit [ eingeleitet und endet mit ]. Die Trennung der Elemente erfolgt durch Kommata.

•• Eine Zeichenkette wird durch ein Anführungszeichen “ eingeleitet und endet mit selbigem. Erlaubt sind dabei die Verwendung von UnicodeZeichen und Escape-Sequenzen.

48

Datenabfragen

•• Ein boolescher Wert wird durch true oder false dargestellt. Hierbei werden keine Einleitungs- und Endzeichen benötigt.

•• Eine Zahl kann die Ziffern 0-9 annehmen und durch ein negatives Vor-

zeichen - eingeleitet sowie durch einen Dezimalpunkt . unterbrochen sein. Außerdem ist die Angabe eines Exponenten e oder E möglich. Dieser kann ebenfalls durch ein positives oder negatives Vorzeichen eingeleitet werden und besteht aus einer Zahl.

•• Leerzeichen können beliebig oft eingesetzt und verwendet werden. •• Ein Wert kann folgende Einträge repräsentieren: •• weiteres Objekt •• Array •• Zeichenkette •• Zahl •• Boolesches Ergebnis (true oder false) •• null Hinweis: Weitere Informationen zum JSON-Format finden Sie auf der offiziellen JSON-Seite http://json.org/json-de.html.

Ein einfaches Beispiel für ein gültiges JSON-Objekt wäre also das folgende: { "buch_titel" : "Social Development .NET", "buch_erscheinungsjahr" : 2010, "buch_autor" : { "autor_name" : "Mario Fraiss", "autor_geschlecht" : "männlich" }, "buch_zweitautor" : null, "buch_verlag" : "entwickler.press",


49

2 – facebook "buch_erschienen" : true, "buch_tags": [ ".NET", "Entwicklung", "Social Development" ] }

Hinweis: Ein sehr praktisches Werkzeug, das ich in diesem Zusammenhang kurz vorstellen möchte, ist der auf Codeplex unter http://jsonviewer.codeplex.com/ erhältliche JSON Viewer. Leser, die Installationen gerne vermeiden, sollten lieber auf folgende Onlinevariante, genannt Online JSON Parser, zurückgreifen: http://json.parser. online.fr/.

Wenn Sie jetzt die Antwort, die Sie bei Ihrer der Anfrage an das facebookGraph-API erhalten haben, erneut betrachten, so werden Sie erkennen, dass diese die Repräsentation des aktuell angemeldeten Benutzerobjekts ist. Sie werden Ihre Anwendung jetzt dahingehend erweitern, dass sie in der Lage ist, Anfragen an das Graph-API zu stellen und die Antwort als JSON-Objekt zu parsen, also zu verarbeiten. Um Abfragen an das Graph-API zu ermöglichen, erweitern Sie die Klasse FacebookClient um folgenden Code: using System.Net; ... //Angabe der aktuellen Graph-API URL private static Uri GRAPH_API_URL = new Uri("https://graph.facebook.com"); //Webclient für das Übermitteln von Abfrage und Antwort private WebClient httpsClient = new WebClient(); public String GraphAPIQuery(String path) { String result = ""; result = httpsClient.DownloadString(GRAPH_API_URL.AbsoluteUri + path.ToString() + "?access_token=" + AccessToken); return result; }

50

Datenabfragen Dieser Code nutzt den durch das .NET Framework angebotenen Web Client, um entsprechende HTTPS-Anfragen an den facebook-Endpunkt https://graph.facebook.com zu senden und dessen Antwort zu empfangen. Um die Abfragen möglichst einfach und schnell stellen zu können, erstellen Sie im Rahmen des Projekts SocialDevelopmentTools eine öffentliche statische Klasse mit der Bezeichnung GraphAPIPath. Diese wird lediglich verschiedene statische Strings bereitstellen, um die Abfrageformulierung zu vereinfachen. Den Code für diese Klasse finden Sie nachfolgend: using System; namespace SocialDevelopmentTools { public static class GraphAPIPath { public static String me = "me"; public static String friends = me + "/friends"; public static String home = me + "/home"; public static String feed = me + "/feed"; public static String likes = me + "/likes"; public static String movies = me + "/movies"; public static String books = me + "/books"; public static String notes = me + "/notes"; public static String photos = me + "/photos"; public static String albums = me + "/albums"; public static String videos = me + "/videos"; public static String videos_uploaded = me + "/" + videos + "/uploaded"; public static String events = me + "/events"; public static String groups = me + "/groups"; public static String checkins = me + "/checkins"; } }

Ergänzen Sie jetzt die bestehende Window_Loaded-Methode Ihrer WPFAnwendung um folgende Zeilen, um unter Verwendung der kürzlich erstellten Helper-Klasse GraphAPIPath eine Abfrage zu stellen und deren Antwort anzuzeigen: Social Development mit .NET

51

2 – facebook using System.Windows; ... private void Window_Loaded(object sender, RoutedEventArgs e) { ... if (fbClient.Authorized) { ... String jsonCurrentUser = fbClient.GraphAPIQuery(GraphAPIPath.me); MessageBox.Show(jsonCurrentUser); } }

Wenn Sie die Anwendung jetzt starten, sollte sich eine eine MessageBox mit der JSON-Antwort der facebook-Server öffnen. Wenn dem so ist, dann herzlichen Glückwunsch! Sie haben soeben Ihre erste erfolgreiche Anfrage mithilfe des facebook-Graph-API abgesetzt. Die Antwort, die Sie erhalten haben, ist, wie erwähnt, in JSON formuliert. Um sie zu verarbeiten werden Sie die frei erhältliche JSON-Implementierung JSON.net einsetzen. Laden Sie die Bibliothek jetzt von der Projekt homepage http://json.codeplex.com/, da sie im nächsten Schritt benötigt wird. Um JSON.net im Rahmen Ihres Projekts 02_FacebookGraphAPI einsetzen zu können, fügen Sie diesem, nachdem Sie JSON.net heruntergeladen und entpackt haben, einen Verweis auf die Datei Newtonsoft.Json.dll hinzu. Eine der zentralen Klassen ist JObject. Sie wird dazu verwendet, um JSON-Datensätze in entsprechende .NET-Objekte zu kapseln. Gehen wir von dem nachfolgenden beispielhaften JSON-Objekt aus, erfolgen dessen Erstellung sowie der Zugriff auf die im Objekt gespeicherten Daten dann in der folgenden Form: using Newtonsoft.Json.Linq; ... /* JSON Beispielobjekt { "myProperty" : "Sampledata", "myArray" : ["Eins","Zwei","Drei"],

52

Datenabfragen "mySubObject" : { "mySubProperty" : "SubSampledata" } } */ //Erzeugung des Objektes String jsonText = "{\"myProperty\":\"Sampledata\",\"myArray\": [\"Eins\",\"Zwei\",\"Drei\"],\"mySubObject\":{\"mySubProperty\" :\"SubSampleData\"}}"; //Parsen des Objektes JObject parsedJsonText = JObject.Parse(jsonText); //Zugriff auf Objektdaten und Sub-Objekte String myProperty = parsedJsonText["myProperty"].ToString(); String myArrayOne = parsedJsonText["myArray"][0].ToString(); String mySubObject = parsedJsonText["mySubObject"]["mySubProperty"].ToString();

Das nachfolgende Codestück parst die JSON-Antwort des Graph-API und schreibt den Vor- und Nachnamen des aktiven Users in das entsprechende Label. Adaptieren Sie daher jetzt den Code innerhalb des Window_Loaded-Ereignisses. Die früher im Code verwendete Message-Box wird nicht länger benötigt. using System.Windows; ... private void Window_Loaded(object sender, RoutedEventArgs e) { ... if (fbClient.Authorized) { ... String jsonCurrentUser = fbClient.GraphAPIQuery(GraphAPIPath.me); JObject currentUser = JObject.Parse(jsonCurrentUser); lblStatus.Content = "Angemeldet als " + currentUser["first_name"].ToString() + " " + currentUser["last_name"].ToString(); lblStatus.Content =


53

2 – facebook lblStatus.Content.ToString().Replace("\"", ""); } }

Da die in der Praxis vorkommenden JSON-Objekte meist sehr umfangreich und komplex zusammengesetzt sind, werden sie häufig in Objektklassen serialisiert, wodurch der Umgang mit den entsprechenden Objekten erheblich erleichtert wird. Sie werden daher im nächsten Schritt eine entsprechende Klasse erstellen, die in der Lage ist, die wichtigsten Daten eines facebook-Profils zu speichern. Erstellen Sie dazu jetzt innerhalb des Projekts SocialDevelopmentTools einen Ordner Objects und darin einen weiteren Ordner Facebook. Diesem fügen Sie die neuen Klassen FacebookObject, FacebookProfile und FacebookLocation hinzu. Diese Klassen beinhalten lediglich Properties, um die Daten des JSON-Objekts zu halten. Den Code dieser Klassen finden Sie nachfolgend: Achtung: Wenn Sie JSON-Objekte automatisiert mit JSON.net deserialisieren möchten, ist es erforderlich, dass die Namen der Properties der Serialisierungsklassen mit jenen der Objekt- und Attributwerte des JSON-Objekts übereinstimmen. Das gilt auch für die eingesetzten Datentypen.

//FacebookObject.cs using using using using

System; System.Collections.Generic; System.Linq; System.Text;

namespace SocialDevelopmentTools.Objects.Facebook { public class FacebookObject { public String id { get; set; } } }

54

Datenabfragen //FacebookProlfile.cs using using using using


namespace SocialDevelopmentTools.Objects.Facebook { public class FacebookProfile : FacebookObject { public String uid { get; set; } public String name { get; set; } public String first_name { get; set; } public String last_name { get; set; } public String link { get; set; } public String about { get; set; } public String birthday { get; set; } public String gender { get; set; } public FacebookLocation hometown { get; set; } public FacebookLocation location { get; set; } } } //FacebookLocation.cs using using using using


namespace SocialDevelopmentTools.Objects.Facebook { public class FacebookLocation : FacebookObject { public String name { get; set; } } }

Die Deserialisierung des empfangenen Objekts erfolgt dann durch diesen Code, den Sie innerhalb des Window_Loaded-Ereignisses aktualisieren:


55

2 – facebook using SocialDevelopmentTools.Objects.Facebook; using Newtonsoft.Json; ... private void Window_Loaded(object sender, RoutedEventArgs e) { ... if (fbClient.Authorized) { ... String jsonCurrentUser = fbClient.GraphAPIQuery(GraphAPIPath.me); FacebookProfile currentUser = JsonConvert. DeserializeObject(jsonCurrentUser); lblStatus.Content = "Angemeldet als " + currentUser.first_name + " " + currentUser.last_name; } }

Die in diesem Beispiel erstellte Klasse FacebookProfile beinhaltet lediglich ein Subset der verfügbaren Informationen, die über das Graph-API abrufbar sind. Implementieren Sie diese je nach Bedarf. Profitipp: Wenn Sie in Ihrer Organisation beispielsweise Microsoft Active Directory oder ein anderes LDAP-System einsetzen und eine Verbindung zwischen den Benutzerkonten sowie dazugehörigen Social-Networks-Accounts, bspw. facebook, herstellen möchten, empfiehlt es sich, den LDAP-Katalog um ein eigenes Attribut, z. B. facebook_profileid, zu erweitern. Innerhalb Ihrer Unternehmensanwendungen, etwa im Rahmen von Microsoft Sharepoint, können Sie dann mit den eben gezeigten Mitteln Meta-Informationen aus facebook in Echtzeit innerhalb Ihrer Anwendung verfügbar werden lassen.

Um den Objektzugriff bestmöglich zu kapseln, erweitern Sie jetzt die Klasse FacebookClient um unten stehende Methode und fügen Sie dem Projekt SocialDevelopmentTools ebenfalls den Verweis auf die JSON.netBibliothek hinzu:

56

Datenabfragen using SocialDevelopmentTools.Objects.Facebook; using Newtonsoft.Json; ... public FacebookProfile GraphAPIGetProfile(String path) { String result = GraphAPIQuery(path); FacebookProfile profile = JsonConvert.DeserializeObject(result); return profile; }

Durch diese Änderung ist die Abfrage eines Facebook-Profilobjekts jetzt auf einfache und komfortable Weise möglich, wie die aktualisierte Version des Window_Loaded-Events zeigt: private void Window_Loaded(object sender, RoutedEventArgs e) { ... if (fbClient.Authorized) { ... FacebookProfile currentUser = fbClient.GraphAPIGetProfile(GraphAPIPath.me); lblStatus.Content = "Angemeldet als " + currentUser.first_name + " " + currentUser.last_name; } }

Hinweis: Die soeben implementierte Methode GraphAPIGetProfile(String path) ist nur ein Beispiel. Realisieren Sie für die unterschiedlichen Objekte, die für Sie relevant sind, die entsprechenden Methoden.

Das von Ihnen im Rahmen der letzten Schritte geschaffene Basismodell zur Nutzung des Graph-API versetzt Sie in die Lage, auch weitaus komplexere Abfragen durchzuführen. Anhand der gezeigten Mittel sind Sie Social Development mit .NET

57

2 – facebook bereits in der Lage, folgende Aufgabenstellung, die bspw. im Bereich der Marktforschung interessant sein könnte, schnell und effizient zu lösen.

•• Abfragen bestimmter facebook-Seiten, die Ihre Konkurrenz betreibt und die Anzeige der Anzahl an Usern, denen die Seite gefällt

Eine mögliche Vorgehensweise für diese Abfrage wäre folgende: 1. Finden Sie die IDs Ihrer Seiten heraus (jene, deren Beliebtheit Sie untersuchen möchten) 2. Laden Sie die Daten zu den einzelnen Seiten 3. Akkumulieren Sie die Daten in einer Liste, sortieren Sie die Daten bspw. in absteigender Reihenfolge und zeigen Sie diese an Um die ID einer bestimmten facebook-Seite zu finden, gibt es folgende Möglichkeiten: a) Sie begeben sich direkt auf die Seite, deren ID sie herausfinden möchten, bei den meisten Seiten lässt sich die ID dann anhand des aufgerufenen URL ablesen: http://www.facebook.com/pages/.../52545196775 b) Sie geben den gewünschten Seitennamen in das Suchfeld ein, klicken auf „Weitere Ergebnisse anzeigen“ und analysieren im Anschluss den Link „# Personen gefällt das“ der bei der gewünschten Seite erscheint (siehe nachfolgende Abbildungen). http://www.facebook.com/ajax/social_graph/dialog/popup.php? id=52545196775

Abbildung 2.9: Suchoption „Weitere Ergebnisse anzeigen“ 58

Datenabfragen

Abbildung 2.10: Link „Personen gefällt das“

Sie werden das soeben beschriebene Beispiel jetzt anhand folgender Seiten-IDs implementieren: Seiten-ID

Seitenname

7706457055

DELL

56232316996

Sony

108642545826733

HP

256554547543

Acer

115494032177

ASUS

58352312819

Fujitsu

25448656869

Samsung

52545196775

Medion

Tabelle 2.2: Seiten-IDs der Beispielseiten

Fassen Sie, um auf die angegebenen IDs entsprechend komfortabel zugreifen zu können, diese innerhalb einer Liste zusammen, bspw. in folgender Form: List idOfPagesToMonitor = new List() { "7706457055", "56232316996", "108642545826733", "256554547543", "115494032177", "58352312819", "25448656869", "52545196775" };


59

2 – facebook Um die Informationen der einzelnen Seiten strukturiert speichern zu können, fügen Sie dem Projekt SocialDevelopementTools innerhalb des Ordners Facebook eine neue Klasse FacebookPage hinzu. Diese repräsentiert den Informationsdatensatz einer facebook-Seite. using using using using


namespace SocialDevelopmentTools.Objects.Facebook { public class FacebookPage : FacebookObject { public String name { get; set; } public String picture { get; set; } public Int32 fan_count { get; set; } } }

Um die Informationen zu den einzelnen Seitenobjekten abfragen zu können, bzw. deren Abfrage auch möglichst einfach zu gestalten, erweiteren Sie jetzt auch noch die Klasse FacebookClient um eine weitere Methode GraphAPIGetPage(String id). public FacebookPage GraphAPIGetPage(String id) { String result = GraphAPIQuery(id); FacebookPage page = JsonConvert.DeserializeObject(result); return page; }

Damit wären alle Vorbereitungen getroffen, welche die eigentliche Datenabfrage betreffen. Jetzt ist es nur noch erforderlich, die entsprechenden Seiten durch Iteration über das Array mit den Seiten-IDs abzufragen und die Ergebnisse entsprechend visuell darzustellen.

60

Datenabfragen Bevor Sie damit beginnen, den letzten Codeteil zu implementieren, fügen Sie über den XAML-Editor Ihrem WPF-Formular die nachfolgend gezeigten Window-Ressourcen sowie eine ListBox hinzu. Setzen Sie Breite und Höhe des Fensters auf 680 bzw. 536 und den Namen der ListBox auf lstControlledPages. Der unten stehende Code beinhaltet ergänzend dazu auch die beiden Steuerelemente, die bereits für die vorigen Schritte benötigt wurden.

Nachdem das GUI nun entsprechend erweitert wurde, können Sie den restlichen Code, also die Abfrage der Seiten und deren Anzeige, so implementieren, dass sie in absteigender Reihenfolge, nach Fan-Anzahl, und inklusive des Seitenlogos, erfolgt. Ergänzen Sie dazu den bereits bekannten Code aus Ihrem Window_Loaded-Handler. List idOfPagesToMonitor = new List() { "7706457055", "56232316996", "108642545826733", "256554547543", "115494032177", "58352312819", "25448656869", "52545196775" }; List pagesToMonitor = new List(); private void Window_Loaded(object sender, RoutedEventArgs e) { ... if (fbClient.Authorized) { ... //Iteration über zu beobachtende Seiten-IDs foreach (String pageId in idOfPagesToMonitor) { FacebookPage page = fbClient.GraphAPIGetPage(pageId); pagesToMonitor.Add(page); } //Nach Anzahl in absteigender Reihenfolge geordnet lstControlledPages.ItemsSource = pagesToMonitor.OrderByDescending(p => p.fan_count); } }

Mit diesem Codestück haben Sie die Implementierung abgeschlossen. Wenn Sie jetzt Ihre Anwendung starten, sollten Sie innerhalb Ihrer vorhin erzeugten ListBox folgende (oder ähnliche) Ausgabe sehen können:

62

Komplexe Abfragen mit der FQL

Abbildung 2.11: Fertige Ausgabe des Seiten-Rankings

PROFITIPP: Nutzen Sie die Abfragetools, die Sie in den letzten Abschnitten kennen gelernt haben, um jene Objekte auszulesen die für Ihr Business relevant sind. Es spielt dabei keine Rolle, ob Sie ein Benutzerprofil, einzelne Seiten, Gruppen oder Anwendungen analysieren möchten.

Im nächsten Abschnitt werden Sie Wege kennen lernen, mit denen Sie Ihre Abfragen noch detaillierter formulieren und effizienter absenden können.

2.6


Bis jetzt haben Sie Ihre Abfragen ausschließlich mithilfe des Graph-API und der entsprechenden Standardpfade durchgeführt, um die Objekte dann innerhalb des Codes entsprechend zu verarbeiten bzw. zu filtern. Wenn Ihre Aufgabenstellungen aber komplexer sind und bspw. Abfragefilter und andere nützliche Funktionen benötigt werden, empfiehlt es sich, auf die FQL (Facebook Query Language) zurückzugreifen.


63

2 – facebook Wie der Name schon vermuten lässt, handelt es sich bei FQL um eine der Datenbankabfragesprache SQL sehr ähnliche Sprache. Sie bietet Ihnen die Möglichkeit, auf sehr einfache und schnelle Art und Weise komplexe Anfragen an facebook zu senden. Das spart Zeit bei der Entwicklung, aber verkürzt vor allem auch die Übertragungsdauer. Ausgehend vom Beispiel des letzten Abschnitts, werden Sie die sehr mächtigen Möglichkeiten, die Ihnen die FQL bietet, anhand von praxisorientierten Szenarien erarbeiten und kennen lernen. Wenn Sie eine Abfrage über FQL durchführen möchten, müssen Sie diese an folgenden facebook-Serverendpunkt richten:

•• https://api.facebook.com/method/fql.query Die eigentliche Abfrage-Query wird dann in gewohnter Weise als Parameter übergeben. Um die Funktionalität sicherzustellen, ist auch hier die Übermittlung des bereits bekannten Access Tokens notwendig.

•• ?query=&access_token=... Um beispielsweise die Daten des aktiven angemeldeten Users abzufragen, reicht folgendes FQL-Statement: SELECT uid, name, sex FROM user WHERE uid=me()

Die korrekte Übermittlung müsste dann durch folgenden Aufruf passieren: https://api.facebook.com/method/fql.query?query=SELECT uid, name, sex FROM user WHERE uid=me()&access_token=...

Zum Unterschied zum Graph-API erfolgt die Antwort standardmäßig jedoch diesmal nicht in JSON, sondern in einem XML-basierten Format. Teilweise, je nach Formulierung der Abfrage, kann das zurückgegebene XML aber auch JSON-Datensätze enthalten. Die Antwort für soeben abgesetztes Statement sieht folgendermaßen aus: 1337028662 Mario Fraiß männlich

Die Verarbeitung der resultierenden XML-Daten kann natürlich entsprechend komfortabel mit den Bordmitteln des .NET Frameworks erfolgen, doch mehr dazu weiter unten innerhalb dieses Abschnitts. Selbstverständlich ist es auch möglich, das Ergebnis im bereits bekannten JSON-Format zu erhalten. Dazu ist es jedoch erforderlich, einen weiteren Parameter format bei der Abfrage mit zu übergeben. Außerdem kann durch die zusätzliche Angabe des Parameters locale auch die Sprache der Antwort entsprechend angepasst werden. Das ist zum Beispiel dann notwendig, wenn Benutzerobjekte nach dem Geschlecht gefiltert werden sollen – das funktioniert aus Serverperformancegründen nur in englischer Sprache, wie Sie später im Rahmen der Beispiele sehen werden. Den locale-Parameter können Sie übrigens auch im Rahmen der Graph-API-Abfragen des vorherigen Abschnitts einsetzen, den formatParameter nicht.

•• &format={ JSON} •• &locale={ de_AT | en_US | ... } Führen wir obige Abfrage noch einmal aus, diesmal allerdings unter Einsatz der beiden eben vorgestellten Parameter, so erhalten wir folgende Antwort: [{"name":"Mario Frai\u00df","sex":"male","uid":1337028662}]

Was bereits dieses kleine Beispiel gut erkennen lässt, ist die unterschiedliche Länge der beiden Formate. Während es bei der XML-Ausgabe 271 Zeichen sind, benötigt JSON mit dem gleichen Informationsgehalt lediglich 59 Zeichen. Der Unterschied beträgt ca. das 4,5fache, und dabei wurde nur ein einziges Mal ein einzelnes User-Objekt abgefragt. Social Development mit .NET

65

2 – facebook Profitipp: Berücksichtigen Sie im Rahmen der Architekturphase Ihrer Anwendung, ob dabei Übertragungszeiten eine Rolle spielen, und der Abfragekomfort, den man im Rahmen von XML mit Technologien wie XQuery oder XPATH erhält, den „hohen“ Preis des Geschwindigkeitsverlusts wirklich wert ist. Veranschaulichen möchte ich diesen gravierenden Unterschied mit folgendem Rechenbeispiel: Angenommen, Sie entwickeln eine Businessanwendung, die nach dem Rollout von 1 000 Anwendungsnutzern verwendet wird. Diese Nutzer führen eine Abfrage von 100 Userobjekten durch (bspw. beim Programmstart), wobei die UID, der Name, das Geschlecht und die Daten zum Wohnort abgefragt werden. Programmstarts: 5 Tage x 4 Wochen x 12 Monate = 240x Datenmenge bei XML: 1 000 x 516 Bytes x 240 = 117,19 MB Datenmenge bei JSON: 1 000 x 198 Bytes x 240 = 23,65 MB Differenz: 93,54 MB Diese Datenmenge käme bereits bei nur einer Abrage pro Tag zu Stande, und all das, um ein wenig an Programmieraufwand zu sparen. Nicht mit einkalkuliert wurden dabei Mehrfachstarts aufgrund von Programmabstürzen, Systemneustarts u. a. Vorkommnisse. Ich hoffe, ich konnte Ihnen verdeutlichen, wie bedeutsam das Miteinbeziehen der Datenmenge gerade im Kontext von sozialen Anwendungen ist.

Zu Übungszwecken, und da in unserem fiktiven Szenario die Datenmenge nicht berücksichtigt werden muss, werden Sie das nachfolgende Beispiel aber trotzdem unter Einsatz des XML-Formats implementieren. Ziel ist es, Sie in die Lage zu versetzen, im Rahmen sozialer Anwendungen mit JSON und XML-Datenobjekten arbeiten zu können. Wie bereits erwähnt, ähnelt FQL in seiner Grammatik sehr der Sprache SQL, weswegen mehrfach verschachtelte Abfragen kein Problem darstellen. Die Realisierung der Abfrage des Beispiels des vorherigen Abschnitts ist daher problemlos innerhalb eines Statements möglich:

66

Komplexe Abfragen mit der FQL SELECT name,fan_count FROM page WHERE page_id IN (7706457055, 56232316996,108642545826733,256554547543,115494032177, 58352312819,25448656869,52545196775)

Das Resultat ist, wie erwartet, eine Liste mit den Namen sowie der FanAnzahl der jeweiligen facebook-Seite in wohlgeformtem XML. Dell 283261 Sony 279447 Hewlett-Packard 8252 Acer 57181 ASUS Official Page 54036 Fujitsu 3391 Samsung 64503 Medion 567


67

2 – facebook Erzeugen Sie im Rahmen der bereits existierenden Projektmappe ein weiteres WPF-Projekt mit der Bezeichnung 03_FacebookFQL. Um das Layout für dieses Beispiel zu erstellen, fügen Sie in der XAML-Datei zwischen den window-Nodes Ihrer Anwendung unten stehendes Markup ein und setzen Sie Höhe und Breite des Fensters auf 480 bzw. 640 Einheiten. Implementieren Sie im Anschluss die Minimalfunktionalität, um die Anwendung facebook-tauglich zu machen und nutzen Sie dazu den Window_Loaded-Handler. Vergessen Sie dabei nicht die Verweise der benötigten Bibliotheken JSON.net und SocialDevelopmentTools.

68

Komplexe Abfragen mit der FQL Ihre Anwendung sollte innerhalb des WPF-Designers folgendermaßen aussehen:

Abbildung 2.12: Layout der WPF-Anwendung

Um eine FQL-Anfrage an den Server stellen zu können, erweitern Sie die Klasse FacebookClient des Projekts SocialDevelopmentTools um folgenden Code: private static Uri FB_API_URL = new Uri("https://api.facebook.com"); private static String FB_DEFAULT_LOCALE = "de_AT"; public String FQLQuery(String query, String locale, String format) { //Verarbeiten des Parameters locale if (locale == "") locale = FB_DEFAULT_LOCALE;


69

2 – facebook //Verarbeiten des Parameters format if (format == "") format = "XML"; String result = ""; //Aktivieren von UTF8-Enkodierung für die korrekte XML-Darstellung httpsClient.Encoding = new UTF8Encoding(); result = httpsClient.DownloadString(FB_API_URL.AbsoluteUri + "method/fql.query?query=" + query + "&locale=" + locale+ "&format=" + format + "&access_token=" + AccessToken); return result; }

Die soeben von Ihnen implementierte Methode ist in der Lage, Anfragen an das facebook-API zu richten und dabei auf die FQL-Funktionalität zuzugreifen. Um für eine korrekte XML-Verarbeitung zu sorgen, aktivieren wir für den kommunizierenden WebClient als Enkodierungsformat UTF8. Testen Sie die neue Methode, indem Sie im Authorized-Block innerhalb des Window_Load-Ereignisses folgenden Code ausführen: String fqlTestXml = fbClient.FQLQuery("SELECT name, sex FROM user WHERE uid=me()", "de_AT", "XML"); System.Windows.Forms.MessageBox.Show(fqlTestXml); String fqlTestJson = fbClient.FQLQuery("SELECT name, sex FROM user WHERE uid=me()", "de_AT", "JSON"); System.Windows.Forms.MessageBox.Show(fqlTestJson);

Sie sollten innerhalb der Meldungsfenster folgende Antworten erhalten:

70


Abbildung 2.13: Antwort der XML-Anfrage

Abbildung 2.14: Antwort der JSON-Anfrage

Löschen Sie jetzt die vier soeben hinzugefügten Codezeilen oder kommentieren Sie diese aus, sie werden nicht mehr benötigt. Wie bereits weiter oben erklärt, werden Sie jetzt die XML-Daten parsen, um sie zu verarbeiten. Um die Verarbeitung entsprechend sinnhaftig implementieren zu können, betrachten wir zuerst die Struktur der FQL-XML-Antworten etwas genauer. Als Beispiel dient die Ihnen bereits bekannte Abfrage zu Beginn dieses Abschnitts.


71

2 – facebook

Abbildung 2.15: Struktur einer FQL-XML-Antwort

Jede Abfrage, die Sie mittels FQL an den Server stellen, folgt dem in der oben gezeigten Abbildung und besteht aus folgenden Elementen:

•• XML-Header •• 0..n •• n * 0..m

Objekte Daten (entspr. Eigenschaften und Subobjekten)

Hinweis: Unter einem Objekt versteht man einen Datensatz aus einer der zahlreichen über FQL zugänglichen facebook-Servertabellen. Eine Eigenschaft wird durch die jeweilige Tabellenspalte repräsentiert. Welche Tabellen existieren und welche Spalten, also welche Eigenschaften, es gibt, können Sie unter http://developers.facebook. com/docs/reference/fql/ nachlesen.

72

Komplexe Abfragen mit der FQL Achtung: Beachten Sie, dass das Ergebnis einer FQL-Abfrage maximal einen Objekttyp auf der Hauptebene und beliebig viele Subobjekte und Eigenschaften innerhalb des Hauptobjekts zulässt, hingegen ist es möglich, innerhalb der FQL-Abfrage-Query beliebige Objekte durch entsprechende Sub-Queries einzusetzen.

Um eine Struktur, die diesen Regeln folgt, parsen zu können, implementieren Sie folgende Methode innerhalb der Klasse FacebookClient: using System.Xml; ... public XmlNodeList FQLGetXMLObjectList(String query, String objectType, String locale, String format) { //Senden der FQL Abfrage und empfangen der Antwort String fql_response = FQLQuery(query, locale, format); //Erzeugen eines XML-Dokumentes aus der Antwort XmlDocument fqlXmlDocument = new XmlDocument(); fqlXmlDocument.LoadXml(fql_response); //Auslesen der Objekte die dem Namenskriterium entsprechen XmlNodeList objectNodeList = fqlXmlDocument.GetElementsByTagName(objectType); return objectNodeList; }

Damit ist die Implementierung des XML-Objekt-Parsers abgeschlossen. Anhand des oben gezeigten Codes sind Sie in der Lage, jede beliebige FQL-Antwort zu parsen, bei der die XML-Struktur keine verschachtelten Unterobjekte beinhaltet, und die gewünschten Eigenschaften auszulesen. Um die bereits bekannten Page-Objekte inklusive zugehöriger FanAnzahl zu ermitteln, ist folgendes FQL-Statement ausreichend: SELECT name,fan_count FROM page WHERE page_id IN (7706457055, 56232316996,108642545826733,256554547543,115494032177, 58352312819,25448656869,52545196775)


73

2 – facebook Fügen Sie jetzt innerhalb des Window_Loaded-Ereignisses folgende Zeilen ein, um die Abfrage dieser FQL-Query zu implementieren: using System.Xml; ... //FQL-Abfrage mit XML-Result und Auswertung des //Objekttypes page XmlNodeList pagesWithFanCount = fbClient.FQLGetXMLObjectList("SELECT name,fan_count FROM page WHERE page_id IN (7706457055,56232316996,108642545826733, 256554547543,115494032177,58352312819,25448656869,52545196775)", "page", "de_AT", "XML"); //Iteration über alle Objekte der Liste foreach (XmlNode node in pagesWithFanCount) { lstControlledPages.Items.Add(node["name"].InnerText + ": " + node["fan_count"].InnerText); }

Starten Sie die Anwendung und betrachten Sie die Ausgabe.

Abbildung 2.16: Ausgabe der gewünschten Seiten inkl. Fan-Anzahl 74

Komplexe Abfragen mit der FQL Hinweis: Um im Rahmen des Aufrufs der Methode FQLGetXMLObjectList hinsichtlich des Parameters objectType Fehler zu vermeiden, empfiehlt es sich, ähnlich der Klasse GraphAPIPath eine entsprechende Klasse zu erstellen, die die zulässigen Tabellennamen enthält. Sofern Sie möchten, können Sie nachfolgende Klasse FQLObjectType dem Projekt SocialDevelopmentTools hinzufügen.

using using using using


namespace SocialDevelopmentTools { public static class FQLObjectTypes { public static string checkin = "checkin"; public static string place = "place"; public static string album = "album"; public static string comment = "comment"; public static string friend = "friend"; public static string event_member = "event_member"; public static string domain_admin = "domain_admin"; public static string comments_info = "comments_info"; public static string connection = "connection"; public static string application = "application"; public static string friend_request = "friend_request"; public static string friendlist_member = "friendlist_member"; public static string eventtable = "event"; public static string domain = "domain"; public static string group = "group"; public static string link = "link"; public static string link_stat = "link_stat"; public static string like = "like"; public static string insights = "insights"; public static string note = "note"; public static string page = "page";


75

2 – facebook public static string page_fan = "page_fan"; public static string mailbox_folder = "mailbox_folder"; public static string friendlist = "friendlist"; public static string group_member = "group_member"; public static string permissions_info = "permissions_info"; public static string metrics = "metrics"; public static string notification = "notification"; public static string permissions = "permissions"; public static string page_admin = "page_admin"; public static string message = "message"; public static string standard_friend_info = "standard_friend_info"; public static string photo = "photo"; public static string object_url = "object_url"; public static string stream = "stream"; public static string photo_tag = "photo_tag"; public static string privacy = "privacy"; public static string standard_user_info = "standard_user_info"; public static string profile = "profile"; public static string translation = "translation"; public static string stream_tag = "stream_tag"; public static string stream_filter = "stream_filter"; public static string thread = "thread"; public static string video = "video"; public static string user = "user"; public static string family = "family"; public static string developer = "developer"; public static string video_tag = "video_tag"; public static string cookies = "cookies"; public static string status = "status"; } }

Sie werden dieses Beispiel jetzt fortführen, indem Sie die beiden verbleibenden Listboxen mit Ihren Freunden füllen. Um zu lernen, wie zusammengesetzte Queries in FQL funktionieren, sollen diese zusätzlich nach dem Geschlecht getrennt werden, d. h. in der oberen ListBox sollen die männlichen und in der unteren die weiblichen User-Objekte angezeigt 76

Komplexe Abfragen mit der FQL werden. Angezeigt werden sollen aber nicht die Namen, sondern die Profilbilder der jeweiligen facebook-Accounts. Die Profilbilder bzw. die URIs zu den Bildern sind innerhalb der Tabelle user in der Spalte pic_square auszulesen, wogegen Sie die Information, ob Sie mit jemandem befreundet sind oder nicht, aus der Tabelle friend auslesen müssen. Die Problemstellung erfordert also eine Abfrage, die mehr als eine Tabelle und damit mehr als einen Objekttyp betrifft.

Abbildung 2.17: Benötigte Tabellen zur Abfrage von Freunden

Während die Tabelle user sämtliche User-Objekte beinhaltet, fungiert die Tabelle friend als n:m-Beziehungstabelle, d. h. Freunde ergeben sich aus folgenden Beziehungen: uid1=me(), uid2=UID der Freunde bzw. uid2=me(), uid1=UID der Freunde

Welche der beiden Beziehungen Sie wählen, spielt keine Rolle, das Ergebnis bleibt das gleiche. Ergänzend zu diesen Beziehungen soll die Abfrage aber auch bestimmte Benutzerdaten als Resultat liefern, d. h. es soll Folgendes erreicht werden: aus Tabelle user, uid=UID eines Freundes aus Tabelle user, uid=UID des zweiten Freundes ...

Erreichen können Sie das durch folgende synchronisierte Subquery: Social Development mit .NET

77

2 – facebook SELECT name,pic_square FROM user WHERE uid IN ( SELECT uid1 FROM friend WHERE uid2=me() )

Um letzten Endes auch noch nach Geschlecht filtern zu können, ist wie folgt zu ergänzen: AND sex='male'

Jetzt müssen Sie nur noch die Query korrekt innerhalb der zuvor implementierten Methode einsetzen und die Objekte vom Typ user auslesen. Achtung: Die Filter-Abfrage auf das Geschlecht funktioniert nur, wenn Sie als locale die Sprache en_US angeben.

Bevor Sie sich an die Implementierung der eigentlichen Abfragen machen, erstellen Sie bitte noch eine Klasse mit der Bezeichnung FacebookFriend. Speichern Sie diese in den Ordner Facebook innerhalb des Ordners Objects als Teil des Projekts SocialDevelopmentTools. Der Code ist für die aktuelle Beispielanwendung relativ simpel: using using using using


namespace SocialDevelopmentTools.Objects.Facebook { public class FacebookFriend { public String name { get; set; } public String pic_square { get; set; } } }

78

Komplexe Abfragen mit der FQL Damit ist es möglich, die gesammelten Informationen objektorientiert zu kapseln. Ergänzen Sie jetzt noch den unten stehenden Code innerhalb der Window_Load-Ereignisbehandlungsroutine: //Abfrage der männlichen Freunde XmlNodeList friendsMale = fbClient.FQLGetXMLObjectList("SELECT name,pic_square FROM user WHERE uid IN (SELECT uid1 FROM friend WHERE uid2=me()) AND sex='male'", FQLObjectTypes.user, "en_US", "XML"); List friendsListMale = new List(); foreach (XmlNode friend in friendsMale) friendsListMale.Add(new FacebookFriend() { name = friend["name"].InnerText, pic_square = friend["pic_square"].InnerText } ); lstFriendsMale.ItemsSource = friendsListMale; //Abfrage der weiblichen Freunde XmlNodeList friendsFemale = fbClient.FQLGetXMLObjectList("SELECT name,pic_square FROM user WHERE uid IN (SELECT uid1 FROM friend WHERE uid2=me()) AND sex='female'", FQLObjectTypes.user, "en_US", "XML"); List friendsListFemale = new List(); foreach (XmlNode friend in friendsFemale) friendsListFemale.Add(new FacebookFriend() { name = friend["name"].InnerText, pic_square = friend["pic_square"].InnerText } ); lstFriendsFemale.ItemsSource = friendsListFemale;


79

2 – facebook Die Darstellung der Bilder erreichen Sie wie im letzten Beispiel über das DataBinding der WPF. Verantwortlich dafür ist das von Ihnen bereits am Beginn dieses Abschnitts eingefügte DataTemplate. Hier noch einmal das Snippet zur Wiederholung: ... ...

Wenn Sie Ihre Anwendung jetzt starten, sollten Sie folgendes bzw. ähnliches Ergebnis erhalten:

Abbildung 2.18: Seitenranking, männliche (oben) und weibliche (unten) Freunde

80

Inhaltsveröffentlichung Damit ist dieses Beispiel abgeschlossen. Sinn und Zweck war es, Ihnen zu zeigen, wie Sie mithilfe der FQL Ihre Abfragen optimiert und mit weniger Zeitaufwand realisieren können. Sie sollten jetzt in der Lage sein, beliebige Abfragen an facebook zu senden und die sehr wertvollen Daten aus dem Netzwerk zu nutzen. Der nächste Abschnitt beschäftigt sich mit der Nutzung der umfangreichen facebook-API-Funktionsbibliothek, führt aber zuvor in das Thema der erweiterten Berechtigungen ein und bildet in Form eines umfangreichen Szenarios gleichzeitig den Abschluss dieses Kapitels.

2.7

Inhaltsveröffentlichung

Während Sie sich im Rahmen des vergangenen Abschnitts ausschließlich mit der Durchführung von einfachen und komplexen Datenabfragen beschäftigt haben, werden Sie in diesem letzten Teil lernen, wie Sie innerhalb von facebook Daten veröffentlichen können. Dazu stehen Ihnen folgende APIs zur Verfügung:

•• Old REST API (wie der Name schon sagt, veraltet) •• Graph-API Sie werden beispielhaft eine Methode des Old REST API nutzen, um den Umgang mit ihr zu erlernen, die Veröffentlichungen werden Sie aber unter Verwendung des neuen Graph-API durchführen. Damit Sie damit für die Praxis sinnvolle Ergebnisse erzielen können, ist es zuvor noch notwendig, sich dem System der so genannten Extended Permissions auseinanderzusetzen, da eine Veröffentlichung nur mit durch den User erteilten erweiterten Rechten erfolgreich möglich ist.

2.7.1

Erweiterte Berechtigungen

Wenn Sie eine Anwendung erstellen, die Zugriff auf Daten aus dem facebook-Netzwerk erhalten soll, so ist es, wie bereits bekannt, erforderlich,


81

2 – facebook dass Sie den angemeldeten User um Erlaubnis fragen und dieser Ihrer Anwendung die entsprechende Freigabe erteilt. Facebook unterscheidet daher im Rahmen des Berechtigungssystems für Anwendungen zwischen folgenden Stufen:

•• Standard Permissions

Standardberechtigungen mit Zugriff auf die allgemeinen Daten

•• Extended Permissions

Erweiterte Berechtigungen mit Zugriff auf bis zu alle meine gespeicherten Daten und Inhalte

Im Rahmen der Standard Permissions ist keine weitere Unterteilung möglich, d.h. dies ist das Minimum an Berechtigungen, die ein User erteilen muss. Die Extended Permissions hingegen bestehen aus drei weiteren Kategorien und innerhalb dieser gibt es einzelne Berechtigungen, die eine Anwendung benötigt, wenn sie bestimmte Vorgänge durchführen möchte. Eine vollständige Liste aller möglichen Berechtigungen sehen Sie in der unten stehenden Tabelle. Berechtigungsname

Berechtigungen

STANDARD PERMISSIONS Automatisch nach Login

Name Profilbild Geschlecht Netzwerke Nutzerkennnummer Freundesliste Öffentliche Informationen

PUBLISHING PERMISSIONS publish_stream

82

Veröffentlichen von Inhalten, Kommentaren Ändern von „Gefällt mir“ bei eigenen Beiträgen und bei denen von Freunden

Inhaltsveröffentlichung Berechtigungsname

Berechtigungen

create_event

Erstellen und Bearbeiten von Veranstaltungen

rsvp_event

Erlaubt das Antworten auf Veranstaltungseinladungen

sms

Senden von Mobilnachrichten an den Benutzer

offline_access

Ausgestellte Access Token laufen nicht ab

publish_checkins

Bekanntgabe des Ortes via facebook Places

DATA PERMISSIONS (hierbei ist es möglich user_ durch friends_ zu tauschen um Zugriff auf die Daten der Freunde zu erhalten) user_about_me

Zugriff auf die „Über mich“-Seite

user_activities

Zugriff auf die Aktivitätenliste

user_birthday

Zugriff auf das Geburtsdatum

user_education_history

Zugriff auf Ausbildung

user_events

Zugriff auf Veranstaltungen mit Teilnahme

user_groups

Zugriff auf Gruppen, bei denen der User Mitglied ist

user_hometown

Zugriff auf den Wohnort

user_interests

Zugriff auf die Interessen

user_likes

Zugriff auf alle Seiten, für die „Gefällt mir“ aktiviert wurde

user_location

Zugriff auf den aktuellen Aufenthaltsort

user_notes

Zugriff auf Notizen

user_online_presence

Zugriff auf den Onlinestatus

user_photo_video_tags

Zugriff auf mit Tags versehene Fotos

user_photos

Zugriff auf hochgeladene Fotos


83

2 – facebook Berechtigungsname

Berechtigungen

user_relationships

Zugriff auf Informationen zur Familie Zugriff auf persönliche Beziehungen Zugriff auf den Beziehungsstatus

user_relationship_details

Zugriff auf die Beziehungseinstellungen

user_religion_politic

Zugriff auf politische und religiöse Informationen

user_status

Zugriff auf die aktuelle Statusnachricht

user_videos

Zugriff auf hochgeladene Videos

user_website

Zugriff auf die eingetragene Homepage

user_work_history

Zugriff auf berufliche Informationen

email

Zugriff auf die eingetragene E-MailAdresse

read_friendlists

Zugriff auf die Freundeslisten

read_insights

Zugriff auf facebook-Insight-Informationen

read_mailbox

Zugriff auf alle Nachrichten

read_requests

Zugriff auf Freundschaftsanfragen

read_stream

Zugriff auf alle Einträge im News-Feed Durchsuchen des gesamten News-Feed

xmpp_login

Integration am facebook-Chatsystem

ads_management

Verwalten aller facebook-Ad-Einstellungen

user_checkins

Zugriff auf Checkins des Users

PAGE PERMISSIONS manage_pages

Verwalten aller durch User verwalteten Seiten (nur innerhalb des Graph-API verfügbar)

Tabelle 2.3: Vollständige Liste der facebook-Berechtigungen

84


Hinweis: Weiterführende Informationen zu den Berechtigungen sowie zu deren jeweiligen Voraussetzungen erhalten Sie unter http://developers.facebook.com/docs/authentication/permissions.

Die Anforderung dieser Zusatzrechte passiert, wie bereits in einem der vorigen Abschnitte erklärt, innerhalb des Aufrufs zur Authentifizierung mithilfe des Parameters scope. Die einzelnen Berechtigungen sind durch Komma getrennt entsprechend anzuführen. Die Zusammensetzung des abzurufenden URI wäre dann wie folgt:

•• https://graph.facebook.com/oauth/authorize? •• client_id= •• &redirect_uri=http://www.meinewebsite.at/success.html •• &type=user_agent •• &display=popup •• &scope=publish_stream,user_birthday,user_status Würden wir jetzt diesen Authentification-URI entsprechend aufrufen, so wäre folgender Dialog sichtbar, der zur Anforderung von erweiterten Rechten auffordert. Diese werden übersichtlich in einer Liste innerhalb des linken Fensterbereichs dargestellt.


85

2 – facebook

Abbildung 2.19: Anmeldedialog mit Extended Permissions

Um die erweiterten Berechtigungen im Rahmen Ihrer nächsten Anwendung einsetzen zu können, ist es jedoch erforderlich, dass Sie den Authentifizierungsprozess etwas erweitern. Öffnen Sie die Klasse Facebook AuthorizationForm des Projekts SocialDevelopmentTools und passen Sie den Default-Konstruktor der Klasse folgendermaßen an: //Liste an benötigten Permissions private List extendedPermissions = new List(); //Neuer Parameter extendedPermissions public FacebookAuthorizationForm (List extendedPermissions) { InitializeComponent(); this.Size = new Size(640, 360); this.StartPosition = FormStartPosition.CenterParent; this.Text = "Facebook-Anmeldung erforderlich"; this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedToolWindow; this.MaximizeBox = false; this.MinimizeBox = false;

86

Inhaltsveröffentlichung //Permissions speichern if(extendedPermissions != null) this.extendedPermissions = extendedPermissions; ... }

Sie haben Ihrem Formular jetzt einen neuen Initialisierungsparameter hinzugefügt und speichern ihn in der Klasse ab, um später darauf zugreifen zu können. Im nächsten Schritt ist es notwendig, die Methode, die für den Aufbau der Authentication-URI verantwortlich ist, abzuändern. Dazu wird über die Liste mit den angeforderten Zusatzrechten iteriert und mithilfe eines StringBuilders der benötigte Parameter scope konfiguriert. Ersetzen Sie daher den bisherigen FacebookAuthorizationForm_Load-Handler durch folgenden: //Lädt beim Laden der Form die facebook-Anmeldeseite //innerhalb des integrierten WebBrowsers //inklusive Advanced Permissions void FacebookAuthorizationForm_Load (object sender, EventArgs e) { String authorizationURI = ""; //Keine besonderen Berechtigungen angefordert //daher Standard-URI if (this.extendedPermissions.Count == 0) { authorizationURI = "https://graph.facebook.com/oauth/ authorize?client_id=" + fb_ApplicationID + "&redirect_ uri=http://www.facebook.com/connect/login_success. html&type=user_agent&display=popup"; } //Besondere Berechtigungen wurden angefordert else { //Zusammenbau des Parameters Scope StringBuilder extendedPermissionsString = new StringBuilder();


87

2 – facebook extendedPermissionsString.Append("&scope="); foreach (String requiredPermission in extendedPermissions) { extendedPermissionsString.Append(requiredPermission); extendedPermissionsString.Append(","); } extendedPermissionsString. Remove(extendedPermissionsString.Length - 1, 1); //Fensterhöhe vergößern falls mehr als 3 Rechte //angefordert werden if (extendedPermissions.Count > 3) { this.Size = new Size(640, Screen.PrimaryScreen.WorkingArea.Height); this.Location = new Point(this.Location.X, 0); } //AuthenticationURI mit Parameter scope authorizationURI = "https://graph.facebook.com/oauth/authorize?client_id=" + fb_ApplicationID + "&redirect_uri=http://www.facebook.com/ connect/login_success.html&type=user_agent&display=popup" + extendedPermissionsString;

}

((WebBrowser)((Form)sender).Controls[0]). Navigate(authorizationURI); }

Damit wären die Anpassungen hinsichtlich des Authentifizierungsformulars abgeschlossen. Jetzt ist es nur noch notwendig, den Aufruf innerhalb der Klasse FacebookClient zu ermöglichen. Dazu überarbeiten (refactorn) wir die Methode Authorize() ein wenig und erzeugen eine zweite Implementierung. Diese erhält die Signatur Authorize(List extendedPermissions), um dadurch eine einfache Möglichkeit zu erhalten, beim Aufruf eine Liste mit erforderlichen Berechtigungen übergeben zu können. Ersetzen Sie den bestehenden Code der Authorize-Methode, in-

88

Inhaltsveröffentlichung tegrieren Sie die signaturunterschiedliche zweite Methode und lagern Sie gewisse Codeteile in die Methode PerformAuthorizationProcess(Face bookAuthorizationForm fbAuthorizationForm) aus. //Methode zum Einleiten des Anmeldevorganges public void Authorize() { //Erzeugen des Authentifizierungs-Formulars FacebookAuthorizationForm fbAuthorizationForm = new FacebookAuthorizationForm(null); PerformAuthorizationFormProcess(fbAuthorizationForm); } //Methode zum Einleiten des Anmeldevorganges mit //erweiterten Berechtigungen welche aus Teilen //der alten Methode Authorize() besteht public void AuthorizeWithExtendedPermissions (List extendedPermissions) { //Erzeugen des Authentifizierungs-Formulars FacebookAuthorizationForm fbAuthorizationForm = new FacebookAuthorizationForm(extendedPermissions); PerformAuthorizationFormProcess(fbAuthorizationForm); } //Methode, die ab sofort den Authentifizierungs-Formular //Prozess übernimmt private void PerformAuthorizationFormProcess (FacebookAuthorizationForm fbAuthorizationForm) { //Setzen der facebook ApplicationID fbAuthorizationForm.fb_ApplicationID = this.ApplicationID; //Anzeigen des Authentifizierungs-Formulars fbAuthorizationForm.ShowDialog(); //Auslesen der facebook Rückgabewerte this.Authorized = fbAuthorizationForm.fb_Authorized; this.AccessToken = fbAuthorizationForm.fb_AccessToken;


89

2 – facebook //Speichern der Fehlerwerte bei nicht erfolgreicher //Authentifizierung if (!this.Authorized) { this.ErrorReason = fbAuthorizationForm.fb_Errors[0].Split('=')[1]; this.Error = fbAuthorizationForm.fb_Errors[1].Split('=')[1]; this.ErrorDescription = fbAuthorizationForm.fb_Errors[2].Split('=')[1]; } }

Damit wurden alle für den Einsatz von erweiterten Berechtigungen erforderlichen Änderungen am Code vorgenommen. Erzeugen Sie jetzt ein weiteres neues WPF-Projekt mit dem Namen 04_ FacebookAPIMethods und bereiten Sie es wie gewohnt für den Zugriff auf facebook vor. Vergessen Sie dabei nicht, auf die Bibliotheken JSON.net und SocialDevelopementTools zu referenzieren. Erzeugen Sie einen Window_Loaded-Handler und implementieren Sie ihn folgendermaßen: private FacebookClient fbClient = null; private void Window_Loaded(object sender, RoutedEventArgs e) { fbClient = new FacebookClient(""); List extendedPermissions = new List(); extendedPermissions. Add("user_status"); fbClient. AuthorizeWithAdvancedPermissions(extendedPermissions); if (fbClient.Authorized) { } }

90

Inhaltsveröffentlichung Setzen Sie die Berechtigungen für Ihre Anwendung auf der facebookWebsite zurück und starten Sie die Anwendung. Sofern bei der Implementierung nichts schiefgelaufen ist, sollte Ihre Anwendung nach den zwei Rechten fragen, wie die nachfolgende Abbildung zeigt.

Abbildung 2.20: Anforderung des erweiterten Rechts „user_status“

Damit Ihnen bei der Anforderung der Extended Permissions zukünftig keine Fehler unterlaufen, implementieren Sie die nachfolgende Klasse. Sie beinhaltet sämtliche Berechtigungen, die von einer Anwendung angefordert werden können. Erzeugen Sie eine neue Klasse FacebookPermissions und fügen Sie diese dem Projekt SocialDevelopmentTools hinzu. Den Code dafür sehen Sie nachfolgend. using using using using


namespace SocialDevelopmentTools { public class FacebookPermissionsPublishing { public static string publish_stream = "publish_stream";


91

2 – facebook public public public public public }

static static static static static

string string string string string

create_event = "create_event"; rsvp_event = "rsvp_event"; sms = "sms"; offline_access = "offline_access"; publish_checkins = "publish_checkins";

public class FacebookPermissionsData { //User-Data-Permissions public static string user_about_me = "user_about_me"; public static string user_activities = "user_activities"; public static string user_birthday = "user_birthday"; public static string user_education_history = "user_education_history"; public static string user_events = "user_events"; public static string user_groups = "user_groups"; public static string user_hometown = "user_hometown"; public static string user_interests = "user_interests"; public static string user_likes = "user_likes"; public static string user_location = "user_location"; public static string user_notes = "user_notes"; public static string user_online_presence = "user_online_presence"; public static string user_photo_video_tags = "user_photo_video_tags"; public static string user_photos = "user_photos"; public static string user_relationships = "user_relationships"; public static string user_relationship_details = "user_relationship_details"; public static string user_religion_politics = "user_religion_politics"; public static string user_status = "user_status"; public static string user_videos = "user_videos"; public static string user_website = "user_website"; public static string user_work_history = "user_work_history"; //Friends-Data-Permissions public static string friends_about_me = "friends_about_me"; public static string friends_activities = "friends_activities";

92

Inhaltsveröffentlichung public static string friends_birthday = "friends_birthday"; public static string friends_education_history = "friends_education_history"; public static string friends_events = "friends_events"; public static string friends_groups = "friends_groups"; public static string friends_hometown = "friends_hometown"; public static string friends_interests = "friends_interests"; public static string friends_likes = "friends_likes"; public static string friends_location = "friends_location"; public static string friends_notes = "friends_notes"; public static string friends_online_presence = "friends_online_presence"; public static string friends_photo_video_tags = "friends_photo_video_tags"; public static string friends_photos = "friends_photos"; public static string friends_relationships = "friends_relationships"; public static string friends_relationship_details = "friends_relationship_details"; public static string friends_religion_politics = "friends_religion_politics"; public static string friends_status = "friends_status"; public static string friends_videos = "friends_videos"; public static string friends_website = "friends_website"; public static string friends_work_history = "friends_work_history"; public static string email = "email"; public static string read_friendlists = "read_friendlists"; public static string read_insights = "read_insights"; public static string read_mailbox = "read_mailbox"; public static string read_requests = "read_requests"; public static string read_stream = "read_stream"; public static string xmpp_login = "xmpp_login"; public static string ads_management = "ads_management"; public static string user_checkins = "user_checkins"; public static string friends_checkins = "friends_checkins"; } public class FacebookPermissionsPageManagement { public static string manage_pages = "manage_pages"; } }


93

2 – facebook Verwenden Sie jetzt die soeben erzeugte Klasse im Rahmen des neuen WPF-Projekts: List extendedPermissions = new List(); extendedPermissions. Add(FacebookPermissionsData.user_status);

Fügen Sie jetzt testweise folgende Berechtigungen hinzu: extendedPermissions. Add(FacebookPermissionsData.user_birthday); extendedPermissions. Add(FacebookPermissionsData.user_work_history); extendedPermissions. Add(FacebookPermissionsData.user_photos); extendedPermissions. Add(FacebookPermissionsData.user_activities); extendedPermissions. Add(FacebookPermissionsData.user_online_presence); extendedPermissions. Add(FacebookPermissionsPublishing.publish_checkins); extendedPermissions. Add(FacebookPermissionsPublishing.offline_access); extendedPermissions. Add(FacebookPermissionsPublishing.rsvp_event); extendedPermissions. Add(FacebookPermissionsPublishing.sms); extendedPermissions. Add(FacebookPermissionsPublishing.create_event);

Starten Sie die Anwendung, um sie erneut zu testen. Wie Sie sehen können, werden die angeforderten Berechtigungen entsprechend innerhalb des Authorization-Dialogs angezeigt:

94


Abbildung 2.21: Anwendung mit Anforderung von erweiterten Berechtigungen

Beachten Sie dabei auch, dass beim Eintrag Auf meine Profilinformationen zugreifen sämtliche Einträge, auf die Sie Zugriff erhalten möchten, gesondert ausgewiesen werden. Entfernen Sie jetzt nach diesem kurzen Test wieder alle Berechtigungsanforderungen bis auf user_status, wir werden diese im Rahmen dieses Beispiels benötigen.


95

2 – facebook

2.7.2

REST-API

Wie bereits erwähnt, handelt es sich bei dem REST-API um eine veraltete Version des facebook-API, das in der Zwischenzeit zu einem großen Teil durch das Graph-API abgelöst wurde. Hinweis: Sie sollten in Ihren facebook-Projekten auf das GraphAPI aufbauen, da die Weiterentwicklung und Pflege dieser Schnittstelle durch facebook garantiert wird.

Damit Sie aber auch in der Lage sind, die Methoden der REST API zu nutzen, werden Sie eine Methode mit dem Namen status.get aufrufen um damit den aktuellen Benutzerstatus auszulesen. Hinweis: Zugriff auf die vollständige Dokumentation des RESTAPI erhalten Sie unter http://developers.facebook.com/docs/reference/rest/.

Ergänzen Sie die Klasse FacebookClient um folgende Zeile, um eine Property für das Speichern des Standardantwortformats zu definieren: public String ApiDefaultResponseFormat { get; set; }

Setzen Sie diese Property jetzt innerhalb des Window_Loaded-Ereignisses auf den String-Wert JSON. Sie werden diese im Laufe des Beispiels dazu verwenden, um als Standardformat für API-Antworten JSON zu definieren. private void Window_Loaded(object sender, RoutedEventArgs e) { ... fbClient.ApiDefaultResponseFormat = "JSON"; if (fbClient.Authorized) {

96

Inhaltsveröffentlichung } }

Ohne es zu merken, da ich Sie bewusst nicht darauf hingewiesen habe, haben Sie bereits erfolgreich eine Methode des REST-API benutzt. Rufen Sie sich doch noch einmal den URI zur Durchführung von FQL-Abfragen in Erinnerung. https://api.facebook.com/method/fql.query

Wie Sie bei Analyse des URI erkennen können, nutzten Sie dabei die Methode fql.query, die Bestandteil des REST-API ist. Im Klartext bedeutet das, dass wir für die Nutzung des REST-API nur den URI-Pfad entsprechend anpassen und die richtigen Parameter übergeben müssen. Da Sie die API-Methode status.get nutzen möchten, muss der API-Aufrufs-URI also wie folgt lauten: https://api.facebook.com/method/status.get

Erweitern Sie jetzt, um alle verfügbaren Statusnachrichten abzurufen, die Klasse FacebookClient um folgende Methode und erzeugen Sie im Anschluss die Klasse FacebookUserStatus innerhalb des Ordners Facebook: public List API_GetStatusList() { String result = httpsClient.DownloadString(FB_API_URL.AbsoluteUri + "method/status.get?access_token=" + this.AccessToken + "&format=" + this.ApiDefaultResponseFormat); List status = JsonConvert. DeserializeObject(result); return status; }


97

2 – facebook Klasse FacebookUserStatus: public class FacebookUserStatus { public string message { get; set; } public double time { get; set; } public string status_id { get; set; } public string source { get; set; } public string uid { get; set; } }

Da die Methode API_GetStatusList(), wie die Bezeichnung schon sagt, eine Liste aller Statusmeldungen zurückgibt, empfiehlt es sich, noch eine kleine Hilfsmethode zu implementieren, die ausschließlich den letzten Status als Ergebnis liefert. Ergänzen Sie diese Methode in der Klasse FacebookClient. public FacebookUserStatus API_GetCurrentStatus() { List statusList = API_GetStatusList(); if (statusList != null && statusList.Count > 0) { return API_GetStatusList()[0]; } else { return null; } }

Um das für die nächsten Schritte benötigte GUI zu erhalten, fügen Sie in der XAML-Date Ihrer WPF-Anwendung im Bereich ... folgendes Markup ein und setzen Sie Höhe und Breite des Fensters auf 745 bzw. 885 Einheiten: ...

98

Inhaltsveröffentlichung ...

Um den Status jetzt abzurufen, müssen Sie nur noch den Window_Loaded-Handler anpassen. Damit das Aktualisieren der Statusmeldung entsprechend gekapselt ist, verpacken Sie die Hauptfunktionalität in eine eigene Methode UpdateStatus(). using SocialDevelopmentTools.Objects.Facebook; ... private void Window_Loaded(object sender, RoutedEventArgs e) { ... if (fbClient.Authorized) { UpdateStatus(); } } //Methode um die aktuelle Statusmitteilung abzurufen private void UpdateStatus() { FacebookUserStatus status = fbClient.API_GetCurrentStatus(); if (status != null)


99

2 – facebook { txtStatus.Text = status.message; } else { txtStatus.Text = "Status ist derzeit nicht verfügbar."; } }

Wenn Sie die Applikation jetzt starten, sollte Ihre aktuelle Statusmeldung in dem dafür vorgesehenen Feld angezeigt werden:

Abbildung 2.22: Abrufen der Statusmeldung mit REST API

Sie werden diesen Abruf jetzt noch durch die Ausgabe des Zeitpunkts ergänzen, dazu ist es jedoch erforderlich, die Zeitangabe in das passende Format zu konvertieren. Dazu implementieren Sie folgende statische Hilfsmethode innerhalb der Klasse FacebookClient: //Methode zum Konvertieren von Facebook-Zeiten public static DateTime ConvertFacebookDateToLocalDate (Double facebookDateTime) { //Facebook-Basiszeitpunkt = 1.1.1970 00:00:00 DateTime facebookBaseTime = new DateTime(1970, 1, 1, 0, 0, 0); ; //Berechnung des Zeitwertes durch //Basiszeit + (Zeitwert aus Datensatz (=vergangene Zeit)) DateTime convertedDate = facebookBaseTime.AddSeconds(facebookDateTime); //Konvertierung in lokales Zeitformat convertedDate = TimeZone.CurrentTimeZone.ToLocalTime(convertedDate);

100

Inhaltsveröffentlichung return convertedDate; }

Aktualisieren Sie jetzt noch die Ausgabe der Statusmeldung innerhalb der entsprechenden Methode. //Methode um die aktuelle Statusmitteilung abzurufen private void UpdateStatus() { ... if (status != null) { txtStatus.Text = "Zuletzt aktualisiert: " + FacebookClient.ConvertFacebookDateToLocalDate (status.time) +"\r\n" + status.message; } ... }

Wenn Sie die Anwendung erneut starten, sollten Sie jetzt auch das entsprechende Datum der Statusmeldung sehen können. Hinweis: Die soeben implementierte Methode zur Konvertierung von Zeiteinheiten können Sie für alle innerhalb von facebook verfügbaren Objekte einsetzen.

2.7.3

HTTP POST Publishing mit dem Graph-API

Im nächsten Schritt werden Sie eine Möglichkeit implementieren, um den Status zu aktualisieren. Dazu werden Sie aber nicht länger das RESTAPI nutzen, sondern fortan wieder auf die Funktionalitäten des GraphAPI zurückgreifen. Damit eine Statusaktualisierung aber erfolgen kann, ist es notwendig, ein weiteres Recht publish_stream, anzufordern.


101

2 – facebook

Profitipp: Eine sehr praktische Eigenschaft der Rechteanforderung ist es, dass diese in additiver Form genutzt werden kann, d. h. Sie können im Rahmen Ihrer Anwendung Rechte zu unterschiedlichen Zeitpunkten anfordern. Sofern das Recht noch nicht erteilt wurde, erscheint der Autorisierungsdialog erneut und fordert ausschließlich das neue Recht an. User tendieren bei Anwendungen, die bei der Erstausführung zuviele Berechtigungen anfordern, dazu, diese nicht zu erteilen und die Anwendung als Folge daraus nicht zu benutzen. Fordern Sie zum Zeitpunkt des ersten Anwendungsstarts daher wirklich nur jene Berechtigungen an, die Ihre Applikation auch tatsächlich benötigt. Berechtigungen, die erst im Laufe der Anwendung erforderlich sind, können problemlos auch später entsprechend nachgefordert werden.

Um dieses zusätzliche Recht anzufordern, ergänzen Sie Ihre XAML-Datei um folgendes Markup: ... ...

Erzeugen Sie einen Click-Handler für den soeben hinzugefügten Button und implementieren Sie ihn wie folgt:

102

Inhaltsveröffentlichung private void btnRequestPublishingPermissions_Click (object sender, RoutedEventArgs e) { List extendedPublishingPermissions = new List(); extendedPublishingPermissions. Add(FacebookPermissionsPublishing.publish_stream); fbClient.AuthorizeWithExtendedPermissions (extendedPublishingPermissions); }

Starten Sie die Anwendung und lösen den soeben erzeugen Handler aus´, indem Sie auf den Button Publishing klicken. Dadurch erscheint der Autorisierungsdialog erneut und fordert zur Erteilung des Rechts publish_stream auf.

Abbildung 2.23: Anforderung des publish_stream-Rechts

Wenn Sie sich jetzt zu den Anwendungsberechtigungen auf der facebook-Seite begeben, sehen Sie, dass die Anwendung die entsprechende Berechtigung erhalten hat.


103

2 – facebook

Abbildung 2.24: Anzeige der erteilten Berechtigungen

Facebook merkt sich dabei auch, welche Rechte beim ersten Anwendungsstart und welche erst im Laufe der Anwendungsnutzung angefordert worden. Man unterscheidet hierbei zwischen folgenden Kategorien:

•• Erforderliche Rechte •• Optionale Rechte Die obige Abbildung zeigt die erforderlichen Rechte (1) und die optionalen Rechte (2). Wie Sie sehen können, ist es möglich, optionale Rechte im Nachhinein zurückzunehmen, während erforderliche Rechte nur durch das Entfernen der Anwendung entzogen werden können. Erinnern Sie sich an den Aufrufpfad des Graph-API, bspw. um die Wall eines Benutzers abfzurufen, er lautet folgendermaßen: https://graph.facebook.com//feed

Wenn Sie an diesen Endpunkt ein korrekt geformtes HTTP POST absenden und dabei die erforderlichen Parameter inkludieren, können Sie über diese Schnittstelle nicht nur Daten abfragen, sondern sie auch veröffentlichen. Um beispielsweise die Statusmeldung zu aktualisieren, werden folgende Parameter benötigt:

•• message •• access_token 104

Inhaltsveröffentlichung Um den HTTP POST entsprechend durchführen zu können, implementieren Sie im Rahmen der Klasse FacebookClient folgende Methode: using System.IO; ... //Allgemein gültige GraphAPI POST Methode public bool GraphAPIPost (String methodName, Dictionary parameters) { //Zusammensetzen der Parameter und entsprechende URL//Enkodierung StringBuilder postDataBuilder = new StringBuilder(); //Iteration über alle Parameter foreach (String parameter in parameters.Keys) postDataBuilder. Append(parameter + "=" + parameters[parameter] + "&"); //Hinzufügen des finalen Parameter Access-Token postDataBuilder.Append("access_token=" + AccessToken); //Fertige Post-Daten String postData = postDataBuilder.ToString(); //Vorbereiten des korrekten Endpunktes Uri postUri = new Uri(GRAPH_API_URL.AbsoluteUri + methodName); //Zum Speichern der Serverantwort String result = ""; try { //Enkodierung httpsClient.Encoding = Encoding.UTF8; //HTTP POST ausführen httpsClient.UploadString(postUri, postData); } catch (WebException fbErrorException) {


105

2 – facebook //Servermeldung abfragen StreamReader postResponseStream = new StreamReader (fbErrorException.Response.GetResponseStream()); //Serverantwort speichern result = postResponseStream.ReadToEnd(); } //Simple Überprüfung auf Fehler if (!result.Contains("error")) return true; else return false; }

Mithilfe der soeben implementierten Methode sind Sie in der Lage, jedes beliebige Objekt mithilfe des Graph-API im Rahmen von facebook zu veröffentlichen; vorausgesetzt, Ihre Anwendung besitzt die dafür erforderlichen Rechte. Ergänzen Sie jetzt folgendes XAML, um das GUI entsprechend zu erweitern: ... ...

Da Sie für die Aktualisierung Ihres Status unter anderem auch Ihre UID benötigen, ergänzen Sie die Klasse FacebookClient um nachfolgende ReadOnly-Property. Sie dient dazu, die Daten des aktiven Benutzers

106

Inhaltsveröffentlichung komfortabel mithilfe der FQL abzurufen. Beachten Sie, dass im Rahmen dieser Implementierung lediglich die Benutzer-ID abgerufen wird. //Property um die Daten des aktiven Users abzurufen public FacebookProfile CurrentUser { get { String currentProfile = FQLQuery ("SELECT uid FROM user WHERE uid=me()", "de_AT", "JSON"); List activeUser = JsonConvert.DeserializeObject (currentProfile); return activeUser[0]; } }

Erzeugen Sie im Anschluss einen Click-Handler für den neu hinzugefügten btnUpdateStatus und implementieren Sie ihn wie unten gezeigt: using System.Windows.Forms; ... //Aktualisierung der Statusmeldung private void btnUpdateStatus_Click (object sender, RoutedEventArgs e) { if (txtSetStatus.Text != "") { //Daten für ein Statusupdate vorbereiten Dictionary parameter = new Dictionary(); parameter.Add("message", txtSetStatus.Text); //Statusupdate durch HTTP POST durchführen if (fbClient.GraphAPIPost(fbClient.CurrentUser.uid + "/feed", parameter)) { System.Windows.Forms.MessageBox.Show("Erfolgreich");


107

2 – facebook //Status im GUI aktualisieren UpdateStatus(); } else { System.Windows.Forms.MessageBox.Show ("Nicht erfolgreich"); } } }

Starten Sie die Anwendung und aktualisieren Sie Ihren Status mithilfe der Anwendung. Begeben Sie sich im Anschluss auf Ihre facebook-Seite und betrachten Sie die aktualisierte Statusmeldung.

Abbildung 2.25: Anwendung inklusive Möglichkeit zur Statusaktualisierung

Abbildung 2.26: In Facebook aktualisierter Status

108

Inhaltsveröffentlichung Wenn Sie die Statusmeldung genau betrachten, können Sie daraus folgende Informationen ablesen:

•• Zeitpunkt der Aktualisierung •• Name der Anwendung, die den Status veröffentlicht hat (falls vorhanden)

Das Praktische an der zuvor implementierten Methode, um HTTP POSTRequests durchzuführen, ist, das Sie mit ihr nun jede beliebige Operation im Rahmen der Graph-API-Publishing-Mechanismen ausführen können. Erweitern Sie das XAML-Markup Ihrer Anwendung jetzt um nachfolgende GUI-Elemente: ...


109

2 – facebook ...

Erzeugen Sie bereits in den vergangen Fällen einen Click-Handler für die Schaltfläche btnPublish. Kopieren Sie dazu den Code des Click-Handlers des Buttons btnUpdateStatus und passen Sie die relevanten Zeilen entsprechend an: private void btnPublishStream_Click(object sender, RoutedEventArgs e) { if (txtStreamMessage.Text != "" && txtStreamLink.Text != "" && txtStreamLinkCaption.Text != "") { //Daten für einen Post inkl. Link und Beschreibung //vorbereiten Dictionary parameter = new Dictionary(); //Nachricht parameter.Add("message", txtStreamMessage.Text); //Link im format http://www.socialdevelopment.at parameter.Add("link", txtStreamLink.Text); //Beschreibung zum Link parameter.Add("caption", txtStreamLinkCaption.Text); if (fbClient.GraphAPIPost(fbClient.CurrentUser.uid + "/feed", parameter)) { System.Windows.Forms.MessageBox.Show("Erfolgreich"); } ... }

Begeben Sie sich auf Ihr facebook-Profil und betrachten den hinzugefügten Post:

110


Abbildung 2.27: Anwendung inklusive Stream-Publishing

Abbildung 2.28: Neuer veröffentlichter Post mit Link und Beschreibung

Im nächsten Schritt werden Sie Ihre neue Publishing-Implementierung zur Automation nutzen. Gehen Sie davon aus, dass Sie eine Liste an verschiedenen Produkten haben, und zu diesen Produkten Sonderrabatte auf Ihrem facebook-Profil oder einer Ihrer facebook-Seiten (Pages) veröffentlichen möchten. Die Daten zu den Produkten erhalten Sie tagesaktuell aus einer Datenbank, und die Veröffentlichung passiert auf Knopfdruck durch einen Mitarbeiter der Marketingabteilung. Fiktion? Nein, implementieren Sie die Funktionalität und lassen Sie diese Vorstellung zur Realität werden.


111

2 – facebook Ergänzen Sie dazu ein weiteres Mal das vorliegende XAML-GUI und erzeugen Sie im Anschluss daran einen Click-Handler für die Schaltfläche btnAutoPublish: ... ...

Implementieren Sie jetzt die Funktionalität für den kürzlich erzeugten Click-Handler: private void btnAutoPublish_Click (object sender, RoutedEventArgs e) { //Simulierte Datenbank, diese beinhaltet Produktnamen //sowie die aktuellen Rabattwerte für die Sonderangebote Dictionary currentPromotions = new Dictionary(); currentPromotions.Add("Software", "5"); currentPromotions.Add("Hardware", "3"); currentPromotions.Add("Beratungsdienstleistungen", "8"); currentPromotions. Add("Trainings und Zertifizierungen", "1"); currentPromotions.Add("Spezialangebote", "7"); Dictionary sendingReport = new Dictionary();

112

Inhaltsveröffentlichung foreach (String key in currentPromotions.Keys) { //Simulierter Marketingtext aus dem internen CRM-System String promotionText = "Jetzt Sonderrabatte sichern"; String companyURL = "http://www.mycompany.com/products/"; //Datenvorlage für Angebot mit Produktseitenlink //vorbereiten Dictionary parameter = new Dictionary(); parameter.Add("message", promotionText); parameter.Add("link", companyURL + key); parameter.Add("caption", "Zur Produktseite"); parameter.Add("description", "Jetzt " + key + " um bis zu " + currentPromotions[key] + "% reduziert"); //Daten veröffentlichen und Sendeergebnis inkl. Timestamp //zur späteren Versandkontrolle speichern if (fbClient.GraphAPIPost (fbClient.CurrentUser.id + "/feed", parameter)) sendingReport. Add("Veröffentlicht: " + key, DateTime.Now); else sendingReport.Add("NICHT veröffentlicht:" + key, DateTime.Now); } //Alte Versandprotokolle löschen lstAutoPublishResult.Items.Clear(); //Einträge im Versandprotokoll ausgeben foreach (String product in sendingReport.Keys) lstAutoPublishResult.Items.Add(product + ", " + sendingReport[product]); }


113

2 – facebook

Abbildung 2.29: Innerhalb weniger Sekunden automatisiert erzeugte Postings

114

Nutzung des Messaging-Systems

Abbildung 2.30: Anwendung mit integriertem Auto-Publishing

Starten Sie Ihre Anwendung und betätigen Sie die Schaltfläche AutoPublish. Begeben Sie sich dann erneut auf Ihr facebook-Profil und betrachten Sie die, innerhalb weniger Sekunden veröffentlichten neuen Beiträge. Damit haben Sie den letzten und umfangreichsten Teil dieser Beispielapplikation erreicht. In der finalen Ausbaustufe werden Sie in Ihre Anwendung den Zugriff auf das facebook-Messaging-System integrieren und dafür fast ausschließlich bereits von Ihnen implementierte Methoden nutzen.

2.8


Das facebook-Messaging System ist das im Rahmen von facebook verfügbare System zum Austausch von Nachrichten zwischen facebook-Usern, aber auch zwischen dem System und facebook-Anwendungen. Um Zugriff auf die Nachrichten eines Users zu erhalten bzw. um Nachrichten an User zu senden, benötigen Sie das erweiterte Recht read_mailbox. Erweitern Sie daher Ihr bestehendes GUI, um folgendes XAML und implementieren Sie den im Anschluss gezeigten Click-Handler der neu hinzugefügten Schaltfläche btnRequestDataPermissions, um dieses Recht anzufordern. Social Development mit .NET

115

2 – facebook ...

Der rechte obere Bereich Ihrer Anwendung sollte nun in etwa so aussehen:

Abbildung 2.31: Schaltfläche zur Anfrage für DataPermission read_mailbox

Implementieren Sie den neuen Handler wie unten stehend und führen Sie die Anwendung aus. private void btnRequestDataPermissions_Click (object sender, RoutedEventArgs e) { List extendedDataPermissions = new List(); extendedDataPermissions. //Anfordern des Rechtes read_mailbox Add(FacebookPermissionsData.read_mailbox); fbClient. AuthorizeWithExtendedPermissions(extendedDataPermissions); }

116

Nutzung des Messaging-Systems Sie sollten beim Betätigen der neuen Schaltfläche die entsprechende Aufforderung zur Erteilung des neuen Rechts erhalten.

Abbildung 2.32: Anforderung der Zusatzberechtigung read_mailbox

Ab dem Zeitpunkt, zu dem ein User Ihnen dieses Recht erteilt, erhalten Sie Zugriff auf sämtliche Nachrichten, die der User empfangen oder gesendet hat, und können außerdem in seinem Namen Nachrichten an andere User versenden. Achtung: Sofern Sie dieses Recht in einer veröffentlichten Anwendung fordern, also innerhalb einer Anwendung, die Sie anderen Usern zur Verfügung stellen, ist es erforderlich, Ihre Anwendung durch facebook prüfen zu lassen. Facebook bezeichnet diesen Prozess als White-Listing des Postfach-API und fordert dann die Entwickler dazu auf, zu begründen, warum dieses Recht innerhalb der Anwendung erforderlich sei. Mehr Informationen dazu erhalten Sie unter folgender Adresse: http://www.facebook.com/help/contact.php?show_form=inbox_api_ whitelist


117

2 – facebook Hinweis: Solange sich die Anwendung im Entwicklungsstadium befindet, ist der Einsatz des Rechts read_mailbox jederzeit und problemlos und ohne Freigabeprozess durch facebook möglich.

Bevor Sie sich an die Implementierung Ihres facebook Messaging Gate ways heranwagen, sollten Sie sich mit den Grundlagen des Systems auseinandersetzen. Dabei ist das Wichtigste, das es zu verstehen gilt, die im Rahmen des Netzwerks auftretende Objekthierachie. Dies ist letzten Endes ausschlaggebend für die FQL-Abfragen, die Sie im Rahmen der Fortführung des aktuellen Beispiels durchführen werden. Das facebook-Messaging unterscheidet innerhalb der internen Organisation zwischen folgenden Objekten: Objekt

Beschreibung

mailbox_folder

Ordner, in dem Nachrichten gespeichert werden (besitzt ID)

thread

Thema/Unterhaltung, dem Nachrichten zugeordnet werden (befindet sich in einem Ordner)

message

Nachrichtenobjekt (gehört zu einem Thread)

Tabelle 2.4: Objekthierachie innerhalb des facebook-Messaging-Systems

Hinweis: Die Bezeichnung der Objekte stimmt, wie bereits bekannt, mit dem Namen der Tabellen überein, an die Sie die FQLAbfragen richten müssen.

Der erste Schritt besteht darin, das GUI entsprechend zu erweitern, um Bereiche für folgende Funktionalitäten zu erhalten:

•• Anzeigen der mailbox-Ordner •• Anzeigen des Ordnerinhalts

118

Nutzung des Messaging-Systems Ergänzen Sie Ihre XAML-Datei um folgendes Markup und achten Sie auf die korrekte Platzierung innerhalb des Codes: ... Ungelesen: ...


119

2 – facebook

Sofern beim Einfügen des Markups keine Fehler aufgetreten sind, sollte Ihre Anwendung fehlerfrei starten und folgendermaßen aussehen:

Abbildung 2.33: Abgeschlossenes Anwendungslayout

120

Nutzung des Messaging-Systems Im ersten Implementierungsschritt werden Sie, wie bereits angekündigt, eine Liste mit den verfügbaren Ordnern abrufen. Vorbereitend dafür erzeugen Sie innerhalb des Projekts SocialDevelopmentTools im Ordner Facebook die neuen Klassen FacebookMailboxFolder, FacebookMessageThread und FacebookMessage. Den Code für diese Klassen finden Sie nachstehend. //FacebookMailboxFolder.cs using using using using


namespace SocialDevelopmentTools.Objects.Facebook { public class FacebookMailboxFolder { public string folder_id { get; set; } public string viewer_id { get; set; } public string name { get; set; } public int unread_count { get; set; } } } //FacebookMessageThread using using using using


namespace SocialDevelopmentTools.Objects.Facebook { public class FacebookMessageThread { public string thread_id { get; set; } public string folder_id { get; set; } public string subject { get; set; } public int unread { get; set; } public string snippet { get; set; }


121

2 – facebook public string snippet_author { get; set; } public int message_count { get; set; } } } //FacebookMessage.cs using using using using


namespace SocialDevelopmentTools.Objects.Facebook { public class FacebookMessage { public string message_id { get; set; } public string thread_id { get; set; } public string author_id { get; set; } public string body { get; set; } public double created_time { get; set; } public string viewer_id { get; set; } } }

Nutzen Sie die FQL, um die entsprechenden Ordner anhand der folgenden Query abzufragen: SELECT name, folder_id, unread_count FROM mailbox_folder WHERE viewer_id = me()

Hinweis: Weiterführende Informationen zum mailbox_folder-Objekt finden Sie unter http://developers.facebook.com/docs/reference/ fql/mailbox_folder.

Implementieren Sie diese Abfrage innerhalb einer neuen Methode LoadMessagingFolders() und deserialisieren Sie die JSON-Objekte, die Sie er-

122

Nutzung des Messaging-Systems halten, typisiert als FacebookMailboxFolder-Objekte. Fügen Sie den unten stehenden Code Ihrer WPF-Anwendung hinzu. using Newtonsoft.Json; ... private void LoadMessagingFolders() { //Selektiere alle Ordner die dem aktiven User gehören String folderList = fbClient.FQLQuery ("SELECT name, folder_id, unread_count FROM " + "mailbox_folder WHERE viewer_id = me()", "de_AT", "JSON"); List folders = JsonConvert.DeserializeObject (folderList); //Anzeige der Folder innerhalb der Listbox lstFolders //linker Messaging-Bereich lstFolders.ItemsSource = folders; }

Jetzt ist es nur noch erforderlich, Ihre Methode aufzurufen. Ein guter Zeitpunkt dafür ist direkt nach dem Erteilen der Berechtigung read_mailbox. Adaptieren Sie den Event Handler daher wie folgt: private void btnRequestDataPermissions_Click (object sender, RoutedEventArgs e) { ... //Laden der Mailbox-Ordner LoadMessagingFolders(); }

Wenn Sie Ihre Anwendung jetzt starten und die Schaltfläche zur Erteilung der erweiterten Data-Permissions betätigen, sollte die ListBox mit den entsprechenden Ordnern gefüllt und die dazugehörigen Informationen sollten angezeigt werden.


123

2 – facebook

Abbildung 2.34: Anzeige der verfügbaren Mailbox-Ordner

Um fortführend die Themenliste der jeweiligen Ordner zu erhalten, ist folgendes FQL-Skript, diesmal an die Tabelle thread gerichtet, geeignet: SELECT thread_id, folder_id, subject, message_count, snippet, snippet_author FROM thread WHERE folder_id=

Hinweis: Weiterführende Informationen zum thread-Objekt finden Sie unter http://developers.facebook.com/docs/reference/fql/thread.

Die Themenliste soll immer dann aktualisiert werden, wenn sich der aktuell ausgewählte Ordner innerhalb der ListBox lstFolders ändert. Die Implementierung der weiteren Funktionalitäten wird also im Rahmen des SelectionChanged-Handlers der Liste erstellt. Nachdem die neue Themenliste geladen wurde, sollen deren Inhalte in Form einer Tabelle innerhalb des Steuerelements dataGridThreads angezeigt werden. 124

Nutzung des Messaging-Systems Erzeugen Sie jetzt den SelectionChanged-Handler für die betreffende ListBox und implementieren Sie ihn wie nachfolgend gezeigt. using System.Data; ... private void lstFolders_SelectionChanged (object sender, SelectionChangedEventArgs e) { //Sicherheitscheck ob Ordner ausgewählt wurde if (lstFolders.SelectedItem != null) { //Folder-Id bestimmen String folder_id = ((FacebookMailboxFolder)lstFolders.SelectedItem). folder_id; //Themenliste des Ordners laden String threadList = fbClient.FQLQuery("SELECT thread_id, folder_id" + ", subject, message_count, snippet, snippet_author " + "FROM thread WHERE folder_id=" + folder_id, "de_AT", "JSON"); List threads = JsonConvert.DeserializeObject (threadList); //Thementabelle aufbauen DataTable messageTable = new DataTable(); messageTable.Columns.Add("Betreff", typeof(string)); messageTable.Columns.Add("Nachrichten", typeof(string)); messageTable.Columns. Add("Vorschau letzte Nachricht", typeof(string)); messageTable.Columns.Add("thread_id", typeof(string)); //Themeneinträge der Datentabelle hinzufügen foreach (FacebookMessageThread thread in threads) messageTable.Rows.Add(thread.subject, thread.message_count, thread.snippet, thread.thread_id); //Thementabelle über Databinding anzeigen


125

2 – facebook dataGridThreads.ItemsSource = messageTable.DefaultView; //Spalte mit den Themen-IDs verbergen dataGridThreads.Columns[3].Visibility = System.Windows.Visibility.Hidden; } }

Starten Sie die Anwendung und wählen Sie ein Element der Ordnerliste aus. Gleich darauf sollten die Themen, die sich in dem Ordner befinden, innerhalb des DataGrid-Steuerelements angezeigt werden.

Abbildung 2.35: Anzeige der Themenliste eines Ordners

Die letzte Ausbaustufe besteht darin, die Nachrichten zu einem Thema, nachdem auf dessen Eintrag in der Datentabelle doppelt geklickt wurde, in geordneter Reihenfolge in Form von Dialogfeldern auszugeben. Dabei sollen folgende Daten angezeigt werden: 1. Nachrichteninhalt 2. Name des Absenders/Empfängers 126

Nutzung des Messaging-Systems 3. Zeitpunkt gesendet/empfangen 4. Nachrichtennummer x/y insgesamt Wie bereits erklärt, gehören Nachrichten zu einem bestimmten Thread. Daher muss der Thread der jeweiligen Nachricht entsprechend in der FQL-Query berücksichtigt werden, die für die Abfrage der Nachrichten folgendermaßen aussieht: SELECT author_id, body, created_time FROM message WHERE thread_id=

Hinweis: Weiterführende Informationen zum message-Objekt finden Sie unter http://developers.facebook.com/docs/reference/fql/ message.

Um den Vorgang erfolgreich zu implementieren, erzeugen Sie einen MouseDoubleClick-Event-Handler für das Steuerelement dataGridThreads und implementieren Sie diesen wie unten stehend. private void dataGridThreads_MouseDoubleClick (object sender, MouseButtonEventArgs e) { if (dataGridThreads.SelectedItem != null) { //Thread_id aus Tabelle auslesen String thread_id = ((DataRowView)dataGridThreads. SelectedItem)["thread_id"].ToString(); //Nachrichten zu Thread abrufen String messageList = fbClient.FQLQuery("SELECT author_id, body, " + "created_time FROM message WHERE thread_id=" + thread_id, "de_AT", "JSON"); List messages = JsonConvert.DeserializeObject


127

2 – facebook (messageList); //Nachrichtenindex merken int messageCounter = 1; //Alle Nachrichten der Reihe nach als MessageBox ausgeben foreach (FacebookMessage message in messages) { //Daten über den Nachrichtenautor laden String authorProfile = fbClient.FQLQuery("SELECT first_name, last_name " + "FROM user WHERE uid=" + message.author_id, "de_AT", "JSON"); List author = JsonConvert.DeserializeObject (authorProfile); //Nachricht anzeigen System.Windows.Forms.MessageBox. Show("ERHALTEN/GESENDET: " + FacebookClient.ConvertFacebookDateToLocalDate( message.created_time) + "\r\n\r\n" + message.body, "Nachricht (" + messageCounter + "/" + messages.Count + ") von/an " + author[0].first_name + " " + author[0].last_name, System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Information); //Nachrichtenindex erhöhen messageCounter++; } } }

Starten Sie die Anwendung und testen Sie die neue Funktionalität. Sie sollten beim Doppelklicken auf einen Themeneintrag die entsprechenden Nachrichten angezeigt bekommen.

128


Abbildung 2.36: Anzeigen einer Nachricht aus dem Ordner „inbox“

Die oben stehende Abbildung zeigt die zuvor spezifizierten Daten: 1. Name des Absenders/Empfängers 2. Zeitpunkt gesendet/empfangen 3. Nachrichteninhalt 4. Nachrichtennummer x/y insgesamt Herzlichen Glückwunsch! Damit haben Sie dieses Beispiel abgeschlossen und besitzen jetzt das notwendige Know-How, um innerhalb Ihrer Anwendungen mitunter das Nachrichtensystem von facebook, aber auch die zahlreichen anderen Systemkomponenten einzusetzen.


129

2 – facebook

2.9

Zusammenfassung

Sie haben im Laufe des letzten Abschnitts im Rahmen des Projekts SocialDevelopmentTools Ihr eigenes Basisframework zur Kommunikation mit dem Social Network facebook entwickelt. Ich habe Ihnen dabei bewusst, keines der fertigen Frameworks oder SDK bereitgestellt, da ich Ihnen zeigen wollte, dass die Kommunikation, aber auch die Nutzung des API „from the scratch“ mit den Bordmitteln, die das Microsoft .NET Framework bietet, problemlos möglich ist.

2.9.1

Mögliche Integrationsszenarien

Facebook bietet im Kontext von Integration hervorragende Möglichkeiten, um die entsprechenden Funktionalitäten in eigene Anwendungen zu integrieren. Anregungen für sinnvolle Integrationsszenarien wären beispielsweise:

•• Interne CRM- oder ERP-Systeme •• Microsoft Sharepoint und andere Portale •• Interne Betriebsanwendungen •• Anwendungen für den Außendienst •• u. v. a. 2.9.2

Projekt-Checkliste

Stellen Sie sich in der Planungsphase vor der Implementierung Ihrer facebook-Anwendung folgende Fragen und planen Sie dann die passende Systemarchitektur: 1. Welche Integrationspunkte gibt es und welche Anwendungen sind davon betroffen? 2. Welche Daten sollen genutzt werden?

130

Zusammenfassung 3. Werden Daten nur passiv (lesend) genutzt, oder soll auch die Möglichkeit bestehen, Daten zu veröffentlichen? 4. Sollen Daten automatisiert veröffentlicht werden? 5. Welche Sicherheitsanforderungen müssen erfüllt werden? 6. Wie viele Benutzer wird die Anwendung haben und wie hoch ist die Auslastung? Im nächsten Kapitel werden Sie mit der Integration von Daten aus dem Social-Business-Netzwerk LinkedIn beginnen.


131

3 3

LinkedIn

Im Rahmen dieses Kapitels werden Sie lernen, wie Sie LinkedIn in Ihre Desktopanwendungen integrieren und auf die Funktionen des API zugreifen können. Ähnlich wie bei facebook ist dieses API Web-Servicebasiert und fordert entsprechend korrekte Anforderungen. Als Antwortformat kommt dabei in der Regel XML zum Einsatz. Im vergangenen Kapitel haben Sie die Anbindung für facebook von Beginn an selbst und ohne fertige SDK oder Dritt-Library implementiert, um sich die technischen Basics zu erarbeiten, bzw. um auch die Hintergrundprozesse besser kennen zu lernen. Das war und ist mühsam, sofern Sie diesen Implementierungsschritt jedes Mal aufs Neue Durchlaufen müssten. Keine Panik, im Gegensatz dazu werden Sie in den kommenden Beispielen die Funktionen, die durch das LinkedIn-API bereitgestellt werden, mithilfe des folgenden relativ neuen SDKs realisieren:

•• LinkedIn Developer Toolkit

http://linkedintoolkit.codeplex.com

Laden Sie das SDK in der aktuellen Version herunter und entpacken es an einen Ort Ihrer Wahl. Damit sind alle Vorbereitungen getroffen und Sie können sich an die Implementierung Ihrer ersten LinkedIn-integrierten Anwendung heranwagen.

3.1

LinkedIn in für Entwickler

LinkedIn (www.linkedin.com) ist neben XING eines der bekanntesten Businessnetzwerke, wo Informationen auf beruflicher bzw. professioneller Ebene ausgetauscht werden können. Genauso wie viele andere


133

3 – LinkedIn Netzwerke bietet es die Möglichkeit, ein Profil anzulegen und dort relevante Informationen zu hinterlegen.

3.1.1

Empfohlene Ressourcen für den Einstieg

Einen guten Einstieg und die erforderlichen Informationen für einen schnellen Start hinsichtlich der Entwicklung mithilfe des LinkedIn-API finden Sie unter:

•• http://developer.linkedin.com/ Ebenfalls beachten sollten Sie die offizielle Dokumentation zu den einzelnen API-Funktionen, aber auch zum eigentlichen Authentifizierungsvorgang, mit dem Sie sich gleich zu Beginn befassen werden (müssen).

•• Offizielle API-Dokumentation

http://developer.linkedin.com/community/apis?view=documents

•• OAuth-Authentifizierung bei LinkedIn

http://developer.linkedin.com/docs/DOC-1008

3.1.2

OAuth-Authentifizierung bei LinkedIn

Genau wie facebook setzt auch LinkedIn den offenen Standard OAuth im Rahmen seines Authentifizierungsprozesses ein, allerdings akzeptiert LinkedIn im Rahmen der Anmeldung keinen reinen HTTP POSTS mit Query Strings, sondern verlangt, dass diese über den HTTP-HeaderBereich mit übergeben werden.

3.1.3

Anwendungsregistrierung

Bevor Sie mit dem Entwickeln eigener LinkedIn-Anwendungen beginnen können, ist es erforderlich, die Anwendung zu registrieren, um dadurch den persönlichen API-Key und zugehöriges Secret zu erhalten. Erstellen Sie sich dazu, falls noch nicht geschehen, einen LinkedIn-Account unter http://www.linkedin.com und begeben Sie sich im Anschluss auf folgende Website: 134

LinkedIn in für Entwickler

•• https://www.linkedin.com/secure/developer Nachdem Sie sich entsprechend authentifiziert haben, gelangen Sie zu Ihrer Anwendungsliste:

Abbildung 3.1: Anwendungsübersicht

Klicken Sie auf Neue Anwendung hinzufügen und füllen Sie das erscheinende Formular entsprechend korrekt und fehlerfrei aus. Bezeichnen Sie Ihre Anwendung mit socialdev_02_HelloLI und wählen Sie als Anwendungstyp die Option Desktop Application. Bestätigen Sie den Vorgang mit der Schaltfläche Anwendung hinzufügen, um diesen abzuschließen. Jetzt werden Sie auf eine Seite weitergeleitet, auf der Ihnen Ihr API- und Ihr Geheimschlüssel mitgeteilt werden:


135

3 – LinkedIn

Abbildung 3.2: Abschluss des Anwendungsregistrierungsvorgangs

Sie haben jetzt Ihren API-Schlüssel und Ihren Geheimschlüssel erhalten. Merken Sie sich, dass im Kontext der OAuth-Prozesse der API-Schlüssel als consumer_key und der Geheimschlüssel als consumer_secret bezeichnet werden.

3.2

Hello „LinkedIn“

Öffnen Sie Ihre aus den vorigen Beispielen existente Projektmappe und fügen Sie ihr ein weiteres WPF-Projekt mit der Bezeichnung 05_Linked InAPIWithSDK hinzu. Klicken Sie, nachdem Sie das Projekt erstellt haben, mit der rechten Maustaste auf den Projekteintrag und öffnen Sie die Projekteigenschaften. Im darauf erscheinenden Dialog selektieren Sie als Zielframework .NET Framework 4 und nicht .NET Framework 4 Client Profile, um Probleme beim Einbinden des SDKs zu vermeiden.

136

Hello „LinkedIn“

Abbildung 3.3: Definition des Zielframeworks unter Visual Studio

Öffnen Sie jetzt den Windows Explorer und wechseln in das Verzeichnis der SDK. Kopieren Sie folgende Dateien in Ihr Projektverzeichnis: Bin\Release\LinkedIn.dll Shared Libraries\DotNetOpenAuth\DotNetOpenAuth.dll Shared Libraries\Kerr.Credentials\Kerr.Credentials.dll Samples\WindowsForms\Utilities.cs Samples\WindowsForms\WindowsCredentialStoreTokenManager.cs

Konfigurieren Sie in Ihrem Projekt die entsprechenden Verweise auf die DLL-Dateien, die Sie soeben kopiert haben. Im Anschluss fügen Sie Ihrem Projekt die zwei neuen Klassen hinzu. Wählen Sie dazu das Projekt im Projektmappen-Explorer aus und führen dann die Tastenkombination UMSCHALT + ALT + A aus. Nach Abschluss dieser Schritte sollte Ihre Projektmappe folgendermaßen aussehen:


137

3 – LinkedIn

Abbildung 3.4: Korrekte Projektmappenstruktur

Würden Sie das Projekt jetzt ausführen wollen, so würden Sie zahlreiche Fehler erhalten, da derzeit noch diverse Using-Direktiven fehlen und entsprechende Namespace-Konflikte vorliegen. Öffnen Sie daher jetzt die beiden Klassen Utilities und WindowsCreden tialStoreTokenManager und korrigieren die Namespaces wie folgt: namespace LinkedIn.Samples.WindowsForms namespace _05_LinkedInAPIWithSDK

Hinweis: Sollten Sie beim Speichern eine Fehlermeldung erhalten, entfernen Sie bitte den Schreibschutz der beiden Dateien.

138

Hello „LinkedIn“ Versuchen Sie Ihre Anwendung zu starten, sie sollte fehlerfrei ausgeführt werden. Damit haben Sie die Integration des SDKs abgeschlossen und können jetzt mit der Implementierung des Authentifizierungsvorgangs beginnen. Hinweis: Die im Rahmen dieses Szenarios gezeigten Schritte, um die Authentifizierung zu realisieren, basieren auf der im Rahmen der SDK verfügbaren Beispielimplementierung, die dann fortlaufend um eigene Funktionen erweitert wird.

3.2.1

LinkedIn-Anwendungsauthentifizierung

Öffnen Sie die Anwendungskonfigurationsdatei app.config Ihres Projekts und passen diese folgendermaßen unter Verwendung Ihres eigenen APIbzw. Geheimschlüssels an:

Praktischerweise nutzt das von Ihnen eingesetzte SDK die Anwendungskonfigurationsdatei, um diese geheimen Daten zu verwalten. Achtung: Sorgen Sie im Rahmen von öffentlichen Projekten, insbesondere Webanwendungen, dafür, dass die Daten innerhalb der app.config niemals im Klartext, sondern verschlüsselt gespeichert werden.


139

3 – LinkedIn Fügen Sie Ihrem Projekt jetzt einen Verweis auf das Assembly System. Configuration hinzu, um den Zugriff auf die Daten der Anwendungskonfigurationsdatei zu ermöglichen. Öffnen Sie jetzt die Codedatei zu MainWindow.xaml und ergänzen folgende Zeilen: using DotNetOpenAuth.OAuth.ChannelElements; using System.Configuration; ... //Token-Manager zum speichern der Authentifizierungsdaten private IConsumerTokenManager tokenManager; private IConsumerTokenManager TokenManager { get { if (this.tokenManager == null) { //Abrufen der Anwendungskonfiguration string consumerKey = ConfigurationManager. AppSettings["LinkedInConsumerKey"]; string consumerSecret = ConfigurationManager. AppSettings["LinkedInConsumerSecret"]; //Erzeugen eines neuen TokenManager mit der //entsprechenden Hilfsklasse this.tokenManager = new WindowsCredentialStoreTokenManager (consumerKey, consumerSecret); } return this.tokenManager; } }

140

Hello „LinkedIn“ Damit haben Sie eine Möglichkeit geschaffen, die durch LinkedIn übermittelten Daten zur Authentifizierung längerfristig zu speichern. Im nächsten Schritt ist es erforderlich, den eigentlichen Aufruf der Authentifizierung zu implementieren. Erweitern Sie die bestehende Anwendung daher um folgenden Code: using LinkedIn; ... //Instanzklasse zur Durchführung der Authorisation private DesktopOAuthAuthorization authorization; private DesktopOAuthAuthorization Authorization { get { if (this.authorization == null) { //Hier könnte ein bereits vorhandener Access-Token //bspw. aus einem lokalen Anwendungsprofil //abgerufen werden, um Mehrfach-Authorisation zu //vermeiden string accessToken = string.Empty; //Durchführen der Desktop-Authorisation this.authorization = new DesktopOAuthAuthorization (TokenManager, accessToken); //Auffordern zur PIN-Eingabe this.authorization.GetVerifier = AuthorizationPIN; accessToken = this.authorization.Authorize(); //Hier könnte ein erhaltener Access-Token in ein //lokales Anwendungsprofil gespeichert werden //um darauf später wieder zuzugreifen } return this.authorization; } }


141

3 – LinkedIn //Property um einen PIN zu erhalten private string AuthorizationPIN() { return string.Empty; }

Während des Authentifizierungsprozesses wird, ähnlich wie bei facebook, ein Browserfenster angezeigt, um die Authentifizierung durchzuführen. Der Unterschied dabei ist aber, dass der User zusätzlich eine PIN erhält, die er innerhalb der Anwendung eingeben muss. Um diesen PIN-Dialog zu realisieren, fügen Sie Ihrem Projekt bitte ein neues Fenster mit der Bezeichnung AuthorizationPinDialog hinzu und platzieren auf diesem folgende Steuerelemente:

•• Button (btnOK) •• Label (lblTitle) •• TextBox (txtAuthorizationPin) Ihr PIN-Eingabedialog sollte in etwa so aussehen:

Abbildung 3.5: PIN-Eingabedialog

Implementieren Sie jetzt für die Schaltfläche btnOK den folgenden ClickHandler und stellen Sie ebenfalls eine Property für den Zugriff auf die Texteigenschaft der TextBox txtAuthorizationPin bereit:

142

Hello „LinkedIn“ private void btnOK_Click(object sender, RoutedEventArgs e) { this.DialogResult = DialogResult.HasValue; Close(); } public String AuthorizationPIN { get { return txtAuthorizationPin.Text; } }

Sorgen Sie jetzt im Rahmen des Hauptfensters dafür, dass der Eingabedialog für die PIN bei Bedarf angezeigt wird. Passen Sie dazu den Getter der Property AuthorizationPin innerhalb der Codeklasse des Fensters MainWindow an. //Property um einen PIN zu erhalten private string AuthorizationPIN() { AuthorizationPinDialog authorizationPinDialog = new AuthorizationPinDialog(); if (authorizationPinDialog.ShowDialog() == DialogResult.HasValue) { return authorizationPinDialog.AuthorizationPIN; } return string.Empty; }

Durch diese Änderung haben Sie im Rahmen des Desktop-Authentifizierungsprozesses eine Eingabemöglichkeit für die PIN zur Verfügung gestellt.


143

3 – LinkedIn Damit haben Sie die Implementierung des Authentifizierungsvorganges abgeschlossen und werden im nächsten Abschnitt die Serviceanbindung hinzufügen.

3.2.2

Serviceanbindung

Da Sie im vergangenen Abschnitt bereits alle notwendigen Vorbereitungen für eine erfolgreiche Authentifizierung getroffen haben, ist die Anbindung des Services mit einer einzigen Codezeile möglich. Um die Funktionalität jedoch überprüfen zu können, fügen Sie Ihrem WPFAnwendungshauptformular an einer beliebigen Stelle ein Label mit der Bezeichnung lblStatus sowie eine Schaltfläche mit der Bezeichnung btnLogin hinzu. Implementieren Sie den Click-Handler diese Schaltfläche wie unten stehend und vergessen Sie nicht, die Member-Variable linkedInService zu deklarieren. using LinkedIn.ServiceEntities; ... //Servicedeklaration private LinkedInService linkedInService = null; private void btnLogin_Click (object sender, RoutedEventArgs e) { try { //Durchführen der Desktop-Authorisation linkedInService = new LinkedInService(this.Authorization); //Abrufen des aktuellen Users Person currentUser = linkedInService.GetCurrentUser(ProfileType.Public); //Ausgabe des Namens des aktuellen Users lblStatus.Content = "Willkommen bei LinkedIn - " + currentUser.Name; }

144

Hello „LinkedIn“ catch (Exception ex) { MessageBox.Show(ex.Message); } }

Wenn Sie Ihre Anwendung jetzt starten und die Schaltfläche btnLogin auslösen, sollte sich ein Browserfenster mit dem LinkedIn-Anmeldedialog öffnen:

Abbildung 3.6: LinkedIn: Desktop-Anwendungsautorisierung

Bestätigen Sie diesen mit OK, gelangen Sie zu einem weiteren Dialog, in dem Ihnen Ihre Zugriffs-PIN mitgeteilt wird:


145

3 – LinkedIn

Abbildung 3.7: Von LinkedIn ausgestellte Zugriffs-PIN

Geben Sie diesen jetzt in den in der Zwischenzeit bereits geöffneten PINEingabedialog ein und bestätigen Sie mit OK. Im Anschluss sollte Ihre Anwendung Sie bei LinkedIn Willkommen heißen:

Abbildung 3.8: Über LinkedIn integrierte Anwendung

Gratulation! Sie haben soeben Ihre erste LinkedIn-integrierte Anwendung fertig gestellt. Der nächste Abschnitt gibt einen Überblick über die weiteren Funktionalitäten, die über das SDK und das LinkedIn-API bereitgestellt werden.

3.2.3

API-Nutzung

Dieser Abschnitt dient dazu, Ihnen das Basiswissen in Bezug auf das LinkedIn-API zu vermitteln und veranschaulicht, wie Sie diese mithilfe der aktuell verwendeten SDK nutzen können.

146

Hello „LinkedIn“ Das LinkedIn API ist prinzipiell in drei Bereiche einzuteilen und beinhaltet folgende Sub-APIs: Sub-API-Bezeichnung

Funktionalität

PEOPLE Profile API

Abrufen von Profilinformationen

People Search API

Suchen von Profilen

Connections API

Zugriff auf Profilverbindungen

COMMUNICATIONS Invitation API

Verwaltung von Einladungen

NETWORK UPDATES/STATUS Get Network Updates API

Zugriff auf Nachrichten aus den Netzwerk

Post Network Update

Veröffentlichen von Statusaktualisierungen

Commenting ON & Reading Comments in Network Updates

Zugriff auf Kommentarfunktionen

Share API

Zugriff auf die LinkedIn-Share-Funktionalität

Tabelle 3.1: LinkedIn: API-Übersicht

Die wichtigsten Methoden, die Ihnen das SDK zur Nutzung dieser APIs zur Verfügung stellt, sind folgende: API-Bereich

Methode

PEOPLE Profile API

GetCurrentUser GetProfileByMemberId GetProfilesByMemberId

People Search API

Search


147

3 – LinkedIn API-Bereich

Methode

Connections API

GetConnectionsByMemberId GetConnectionsForCurrentUser

COMMUNICATIONS Invitation API

InvitePerson

NETWORK UPDATES / STATUS Get Network Updates API

GetNetworkUpdates GetNetworkStatistics

Post Network Update

DeleteStatus PostNetworkUpdate UpdateStatus

Commenting ON & Reading Comments in Network Updates

CommentOnNetworkUpdate LikeNetworkUpdate UnlikeNetworkUpdate

Share API

CreateReShare CreateShare

Der Aufruf der jeweiligen Methode passiert dann entsprechend über eine deklarierte Instanz der Klasse LinkedInService, wie Sie es bereits im Rahmen der aktuellen Anwendung innerhalb des Click-Handlers der Schaltfläche btnLogin implementiert haben. Mit diesem Wissen werden Sie das aktuelle Beispiel jetzt um folgende Funktionalitäten erweitern:

•• Laden Ihrer Kontaktliste •• Laden von Profilinformationen Ihrer Kontakte •• Anzeigen Ihrer Kontaktliste •• Anzeigen der Profilinformationen inklusive Profilbild

des ausge-

wählten Kontakts

Um die ersten drei Punkte zu realisieren, erweitern Sie die XAML-Datei Ihrer Anwendung um folgendes Markup:

148

Hello „LinkedIn“ ... ...

Implementieren Sie jetzt den Click-Handler für die Schaltfläche btnLoadContacts wie unten stehend, um die Liste Ihrer Kontakte mithilfe der SDK abzurufen. private void btnLoadContacts_Click (object sender, RoutedEventArgs e) { //Laden aller eigenen Kontakte Connections contacts = linkedInService.GetConnectionsForCurrentUser(); //Setzen der Datenquelle für die ListBox //contacts.Items ist eine Liste vom Typ


149

3 – LinkedIn //LinkedIn.ServiceEntities.Person lstContacts.ItemsSource = contacts.Items; }

Starten Sie nun die Anwendung und authentifizieren Sie sich über LinkedIn. Wenn Sie auf die Schaltfläche Kontakte klicken, sollte Ihre Kontaktliste geladen werden:

Abbildung 3.9: Geladene LinkedIn-Kontaktliste

Ergänzen Sie jetzt Ihr GUI um folgenden XAML-Code, um die Steuerelemente bzw. DataTemplates für die Darstellung der Kontaktdetails bereitzustellen: ... Branche: ...

Sie werden sich vielleicht wundern, aber damit ist die Implementierung bereits abgeschlossen, da die Datenbindung rein auf Basis des WPF-Data-Binding realisiert wurde und auf die entsprechenden Properties der Einträge der Kontaktliste zugegriffen werden kann.


151

3 – LinkedIn Starten Sie die Anwendung erneut. Wenn Sie jetzt einen der Kontaktlisten einträge auswählen, erscheinen die Details der entsprechenden Person im dafür vorgesehenen Bereich.

Abbildung 3.10: Fertige Anwendung inklusive Kontaktdetailanzeige

Ergänzend möchte ich Ihnen noch die Möglichkeit zeigen, wie Sie, um Bandbreite bei der Abfrage von Daten zu sparen, die Abfrage einschränken können. Zu diesem Zweck bietet die SDK die Möglichkeit, jene Liste an Profilfeldern mit zu übergeben, die abgefragt werden sollen. Betrachten Sie dazu folgenden Beispielcode Wenn es Sie interessiert, können Sie damit ein wenig experimentieren und ihn in Ihre Anwendung integrieren. //Selektion der Datenfelder die abgefragt werden sollen //Um Übertragungszeit zu optimieren List queryFields = new List {

152

Zusammenfassung ProfileField.PictureUrl, ProfileField.LastName, }; //Laden der eigenen Kontakte mit bestimmten Details Connections contacts = linkedInService.GetConnectionsForCurrentUser (queryFields, 0, 100);

Hinweis: Weiterführende Informationen zu den einzelnen Profilfeldern sowie eine vollständige Liste dieser finden Sie unter der folgenden Adresse: http://developer.linkedin.com/docs/DOC-1061 Innerhalb der SDK steht Ihnen dafür diese Enumeration zur Verfügung: LinkedIn.ServiceEntities.ProfileField

3.3

Zusammenfassung

Damit haben Sie dieses Beispiel erfolgreich abgeschlossen und sind am Ende des Kapitels zum Thema der Integration mit LinkedIn angelangt. Ich hoffe, es ist mir gelungen, Ihnen zu veranschaulichen, wie einfach und schnell eine Anbindung an LinkedIn zu realisieren ist. Abschließend möchte ich Sie darauf hinweisen, dass die Nutzung der Daten aus dem Businessnetzwerk auf sehr unterschiedliche Weise Möglichkeiten für sinnvolle Integrationsszenarien anbietet, bspw.

•• Integration der Daten in Adressbücher von LDAP- oder Exchange/ Notes-Verzeichnissen

•• Nutzung der Daten innerhalb der unternehmensweiten Human-Resources-Anwendung

•• Unterstützung bei der automatisierten Erstellung von Bewerberprofilen


153

3 – LinkedIn

•• Aggregationsmöglichkeiten zwischen facebook und LinkedIn sowie weiteren beliebigen Datenquellen

•• Integration als Datenquelle in SharePoint oder anderen Portalen um nur einige Ideen zu nennen. Im nächsten Kapitel werden Sie sich im Kontext der Entwicklung das erste Mal mit dem Begriff Social Services auseinandersetzen. Den Einstieg dazu bildet der populäre Micro-Blogging-Dienst twitter.com.

154

Teil B Integration von Social Services In der Einleitung habe ich Sie darauf hingewiesen, dass keine Technologie die wir heute im Web 2.0 bzw. 3.0 vorfinden, ohne die Nutzung von Social Services auskommt. Umso wichtiger ist es, zu verstehen, warum diese Helferlein so bedeutend für heutige Freizeit- und Geschäftsanwendungen sind und welchen Stellenwert die unterschiedlichen Angebote weltweit einnehmen. Der zweite Teil dieses Buches bringt Ihnen wichtige Vertreter der Social Services näher und zeigt, wie sie im Rahmen eigener Anwendungen sinnvoll und zeitoptimiert integriert werden können. In diesem Zusammenhang werden Sie auch auf bereits existierende API-Implementierung für .NET zurückgreifen, um die folgenden Szenarien zu realisieren. Glauben Sie mir, wenn ich Ihnen sage, dass Sie schon bald die „Zwitscheritis“ packen wird. In diesem Sinne heiße ich Sie herzlich willkommen in der Welt der Social Services, wo keine Anfrage der anderen gleicht und Zeit keine Rolle spielt.


155

4 4

twitter

twitter ist einer der Begriffe, der zum Thema Social Web vermutlich am häufigsten fällt. Die Erfolgsgeschichte des heute so populären MikroBlogging-Diensts twitter.com begann im März 2006, als das erste Mal gezwitschert wurde. Sie werden im Rahmen dieses Kapitels lernen, wie Sie die freie Bibliothek TweetSharp einsetzen können, um Ihre Anwendungen twitter-fähig werden zu lassen. Zu Beginn bitte ich Sie, falls noch nicht geschehen, sich unter www.twitter.com einen neuen Account zu erzeugen. Begeben Sie sich im Anschluss daran auf die Seite

•• http://dev.twitter.com/apps/new um, wie bereits bei facebook und LinkedIn, eine neue Anwendung zu registrieren. Geben Sie ihr den Namen socialdev_03_HelloTW und wählen Sie als Anwendungstyp die Option Client. Beantragen Sie außerdem Schreib- und Lesezugriff (Read & Write). Klicken Sie auf Register Application und akzeptieren Sie die AGB. Im Anschluss daran erhalten Sie Ihre API-Zugangsdaten und die Informationen, an welchen Endpunkten das API erreichbar ist, womit der Registrierungsvorgang erfolgreich abgeschlossen ist.


157

4 – twitter

Abbildung 4.1: Twitter: API-Zugangsinformationen 158

Hello „twitter“ Hinweis: Sie werden im Rahmen des Beispiels, das Sie in diesem Abschnitt implementieren werden, die API-Authentifikationsdaten nicht benötigen, da diese nur im Rahmen der OAuth-Authentifizierung erforderlich sind.

Bevor wir mit der Entwicklung der Anwendung starten, laden Sie bitte die freie Twitter-Implementation TweetSharp herunter. Sie erhalten sie unter:

•• http://tweetsharp.codeplex.com/ Hinweis: TweetSharp ist eine der bekanntesten und besten Bibliotheken, wenn es um die Integration mit dem Microsoft .NET Framework geht, da es das offizielle Twitter-API zu 100 % unterstützt.

Des Weiteren werden Sie im Rahmen der Beispielanwendung die Software Microsoft Visual Studio Express für Windows Phone oder, falls Sie keine der Visual Studio-Express-Versionen einsetzen, die Microsoft Windows Phone Developer Tools RTW benötigen, die Sie unter den folgenden Adressen kostenlos beziehen können:

•• http://www.microsoft.com/Germany/Express/products/phone.aspx •• http://www.microsoft.com/downloads/details.aspx?FamilyID=04704acfa63a-4f97-952c-8b51b34b00ce&displayLang=de

4.1

Hello „twitter“

Starten Sie Visual Studio, erzeugen ein neues Projekt vom Typ Windows Phone Application und geben Sie ihm den Namen 06_HelloTwitterMobile. Anwendungen für Windows Phone basieren auf der Technologie Silverlight, und diese wiederum nutzt genauso wie die WPF die MarkupSprache XAML. Die Anwendung, die Sie im Moment erstellen, ist eine seitenbasierte Anwendung und besteht im Prinzip aus einzelnen Fens-


159

4 – twitter tern. Das Hauptfenster der Anwendung, MainPage.xaml, wurde beim Erzeugen des Projekts automatisch für Sie erstellt. Ändern Sie nun im Hauptfenster den Titel der Anwendung von MY APPLICATION in HelloTwitterMobile und die Beschriftung page name in home. Fügen Sie im Anschluss innerhalb des Grid-Steuerelements mit dem Namen ContentPanel folgenden XAML-Code ein:

Das Design Ihrer Windows-Phone-Anwendung sollte jetzt in etwa folgendermaßen aussehen:

Abbildung 4.2: Design der Anwendungs-Startseite

160

Hello „twitter“ Damit haben Sie die Startseite Ihrer ersten sozialen Windows-Phone-Anwendung fertiggestellt. Fügen Sie dem Projekt jetzt ein neues Element vom Typ Windows Phone Portrait Page mit dem Namen PagePublicTweets hinzu und ändern Sie wie im ersten Schritt die Bezeichnung MY APPLICATION in HelloTwitterMobile. Vergeben Sie diesmal als Seitenname public tweets.

Abbildung 4.3: Design der zweiten Anwendungsseite

Fügen Sie dem Layout Ihrer zweiten Anwendungsseite folgendes Markup hinzu:


161

4 – twitter Nach dem Einfügen ist keine sichtbare Änderung zu sehen, aber Sie werden die ListBox die Sie soeben erzeugt haben, dazu benötigen, um die entsprechenden Tweets, die Sie im nächsten Schritt automatisiert laden werden, anzuzeigen. Damit haben Sie alle Seitenelemente, die in Ihrer Anwendung benötigt werden, erstellt. Wechseln Sie jetzt wieder zum Hauptfenster und implementieren einen Click-Handler für die Schaltfläche btnPublicTweets in unten stehender Form. Starten Sie im Anschluss Ihre Anwendung und testen Sie die Navigationsfunktionalität. private void btnGotoPublicTweets_Click (object sender, RoutedEventArgs e) { //Zu Seite PublicTweets navigieren NavigationService.Navigate (new Uri("/PagePublicTweets.xaml", UriKind.Relative)); }

Begeben Sie sich jetzt mithilfe des Windows Explorers in das Verzeichnis in das Sie die heruntergeladene Bibliothek TwitterSharp entpackt haben und öffnen Sie folgenden Ordner: TweetSharp-Binaries\dotNET 4.0\Windows Phone 7 CTP

Kopieren Sie folgende Dateien in Ihren Projektordner: Hammock.WindowsPhone.dll ICSharpCode.SharpZipLib.WindowsPhone.dll Newtonsoft.Json.Silverlight.dll TweetSharp.Twitter.WindowsPhone.dll TweetSharp.WindowsPhone.dll

Definieren Sie nach Abschluss des Kopiervorgangs innerhalb Ihres Visual-Studio-Projekts die entsprechenden Verweise auf die soeben kopierten Dateien und bestätigen Sie etwaige dabei erscheinende Warnmeldungen.

162

Hello „twitter“

Abbildung 4.4: Benötigte Verweise für die Nutzung von TweetSharp

4.1.1

Nutzung des API

Im Rahmen dieses ersten Beispiels werden Sie mithilfe der freien Bibliothek TweetSharp das Twitter-API nutzen, um von der so genannten PublicTimeLine die aktuellsten Tweet-Einträge zu laden. Die Implementierung dafür gestaltet sich relativ einfach. Hinweis: Bei der Public-Timeline handelt es sich um die 20 letzten Tweets, die durch nicht geschützte twitter-Accounts veröffentlicht wurden. Mehr Informationen dazu finden Sie unter http://dev.twitter. com/doc/get/statuses/public_timeline.

Erzeugen Sie einen Loaded-Handler für das Objekt PagePublicTweets und implementieren Sie darin folgende Funktionalität:


163

4 – twitter using TweetSharp.Twitter.Fluent; ... private void PhoneApplicationPage_Loaded (object sender, RoutedEventArgs e) { //TwitterClient laden var query = FluentTwitter. //Anfrage erzeugen CreateRequest(). //Statusmelden (Tweets) abfragen Statuses(). //Auf der öffentlichen Timeline OnPublicTimeline(). //Methode die nach Abschluss der asynchronen //Request die Tweets verarbeitet CallbackTo(RequestFinished); query.BeginRequest(); }

Um den oben stehenden Code kompilierfähig zu machen, ist es noch erforderlich, dass Sie den entsprechenden Callback-Handler implementieren. using TweetSharp.Twitter.Model; using TweetSharp.Twitter.Model; ... private void RequestFinished (object sender, TwitterResult response, object u) { //Dispatcher für UI-Cross-Threadzugriff System.Windows.Threading.Dispatcher uiDispatcher = Deployment.Current.Dispatcher; List statuses = (List)response.AsStatuses(); //alternativ //var statuses = response.AsStatuses(); foreach (TwitterStatus status in statuses)

164

Hello „twitter“ { TwitterStatus currentStatus = status; //Tweets der ListBox hinzufügen //und dabei auf UI Cross-Threading achten uiDispatcher.BeginInvoke(() => lstTweets.Items.Add(currentStatus)); } }

Damit haben Sie die Implementierung erfolgreich abgeschlossen. Starten Sie die Anwendung und begeben sich in den Bereich public tweets. Wie sie sehen, werden die einzelnen Tweets entsprechend automatisiert über den twitter-Server geladen.

Abbildung 4.5: Über TweetSharp geladene Public Timeline Tweets


165

4 – twitter Herzlichen Glückwunsch, Sie haben Ihre erste twitter-fähige Anwendung entwickelt. Insgesamt bietet das API viele unterschiedliche Funktionen, die größtenteils auch durch die sehr populären .NET-TwitterImplementationen TweetSharp und Twitterizer abegedeckt werden. Weitere Informationen hinsichtlich des twitter-API sowie den primären Einstiegspunkt für den Bereich Twitter-Entwicklung finden Sie unter http://dev.twitter.com/doc.

4.1.2

OAuth-Authentifizierung

Um das gesamte twitter-API nutzen zu können, sind die bisherigen Implementierungsschritte nicht ausreichend. Dafür ist es nämlich erforderlich, sich entsprechend zu authentifizieren. Da twitter mit 31.08.2010 seine API-Authentifizierung zur Gänze auf den OAuth-Prozess umgestellt hat, werden Sie im Rahmen dieses Beispiels den gesamten OAuthAuthentifikationsprozess realisieren und nicht auf nicht mehr verfügbare Mechanismen setzen. Um zu lernen, wie Sie Twitter-Funktionalität bspw. in Ihre Intranetanwendungen einbinden können, werden Sie das gesamte Szenario in Form einer ASP.NET Webanwendung realisieren. Erzeugen Sie dazu innerhalb Ihrer bestehenden Projektmappe ein neues Projekt vom Typ Leere ASP.NET-Webanwendung und vergeben die Bezeichnung 06_HelloTwitterWeb. Begeben Sie sich nun wieder mithilfe des Windows Explorers in das Verzeichnis, in das Sie die heruntergeladene Bibliothek TwitterSharp entpackt haben, öffnen Sie den Ordner TweetSharp-Binaries\dotNET 4.0\.NET Framework 4.0

und kopieren folgende Dateien in Ihren Projektordner: Hammock.dll Newtonsoft.Json.dll TweetSharp.dll Twitter.Twitter.dll TweetSharp.Yammer.dll

166

Hello „twitter“ Bitte definieren Sie nach dem Abschließen des Kopiervorgangs innerhalb Ihres Visual-Studio-Projekts die neuen Verweise auf die kopierten Dateien.

Abbildung 4.6: Korrekte Projektverweise zur Nutzung von TweetSharp

Fügen Sie Ihrem Webanwendungsprojekt jetzt ein neues Element Default.aspx vom Typ WebForm hinzu und platzieren Sie darin folgenden HTML- bzw. ASP.NET-Code: www.socialdevelopment.at - HelloTwitterWeb BODY { font-family: Verdana; font-size: 12; } IMG { border: none; }


167

4 – twitter H2 { font-size: 12pt; }

Starten Sie die Webanwendung, um die Lauffähigkeit zu testen, und merken Sie sich den Port Ihres lokalen ASP.net Development Servers in der http://localhost:[Port]-Adresse, die beim Aufruf erscheint. Wechseln Sie im Anschluss in den Code Ihrer ASP.NET-Seite Default. Für die erfolgreiche Authentifizierung mit OAuth ist es erforderlich, folgende Schritte zu implementieren:

•• Anforderung eines Request Tokens •• Abrufen der Authentifikationsseite •• Rückumleitung über einen so genannten Callback-URL zur Anwendung

•• Anforderung eines Access Tokens Achtung: Um die folgende Schritte nachvollziehen zu können, ist es erforderlich, dass Sie unter http://dev.twitter.com/apps eine neue Twitter-Applikation registrieren und als Anwendungstyp die Option Browser wählen. Bezeichnen Sie diese beispielsweise mit socialdev_03_HelloTWWeb.

168

Hello „twitter“ Ergänzen Sie unten stehenden Code, um die ersten beiden Schritte, die Anforderung eines Request Tokens und die Umleitung zur Twitter-Authentifkationsseite zu implementieren. Passen Sie innerhalb der Methode StartTwitterAuthorization den Port Ihres lokalen Anwendungsservers entsprechend an. using TweetSharp.Twitter.Fluent; using TweetSharp.Twitter.Extensions; ... String twitterConsumerKey = ""; String twitterConsumerSecret = ""; protected void Page_Load(object sender, EventArgs e) { if (!IsPostBack) { //Auslesen des durch Twitter erhaltenen Tokens var parameterRequestToken = Request["oauth_token"]; //Auslesen des durch Twitter erhaltenen Verifiers var parameterRequestVerifier = Request["oauth_verifier"]; if (parameterRequestToken == null) { //Sofern noch kein Token vorhanden ist //wird der Authorisationsprozess gestartet StartTwitterAuthorization(); } } } private void StartTwitterAuthorization() { //Anforderung eines Request Token mit der Callback-URL //http://localhost:[Port] var requestToken = FluentTwitter.CreateRequest().Authentication. GetRequestToken (twitterConsumerKey, twitterConsumerSecret, "http://localhost:[YOUR_PORT]").Request().AsToken();


169

4 – twitter

//Anfordern der URL zur Twitter-Authorisationsseite String authorizeUrl = FluentTwitter.CreateRequest().Authentication. GetAuthorizationUrl(requestToken.Token); //Umleiten auf die Authorisationsseite Response.Redirect(authorizeUrl); }

Wenn Sie Ihre Anwendung jetzt starten, sollten Sie zu unten gezeigten Seiten und am Ende wieder zur Anwendung selbst weitergeleitet werden:

Abbildung 4.7: Erstauthentifikation

170

Hello „twitter“

Abbildung 4.8: Erneute Anwendungsanmeldung

Abbildung 4.9: Automatischer Redirect auf den Callback-URL

Im nächsten Schritt ist es erforderlich, den erhaltenen Request Token einzusetzen, um darauf aufbauend einen Access Token anzufordern. Ergänzen Sie den Code zur Realisierung dieses Vorgangs folgendermaßen: using TweetSharp.Model; using TweetSharp.Twitter.Model; ...


171

4 – twitter //Aktueller Access Token private static OAuthToken accessToken = null; //Aktiver User private static TwitterUser activeUser = null; protected void Page_Load(object sender, EventArgs e) { if (!IsPostBack) { //Auslesen des durch Twitter erhaltenen Tokens var parameterRequestToken = Request["oauth_token"]; //Auslesen des durch Twitter erhaltenen Verifiers var parameterRequestVerifier = Request["oauth_verifier"]; if (parameterRequestToken == null) { ... } //Es wurde bereits ein Request-Token übermittelt else { //Anfordern des Access Tokens unter Verwendung der //Parameter GetAccessToken (parameterRequestToken, parameterRequestVerifier); //Sofern ein Access Token empfangen werden konnte if (accessToken != null) { //wird die Authentifizierung des Users überprüft var user = FluentTwitter.CreateRequest(). AuthenticateWith (twitterConsumerKey, twitterConsumerSecret, accessToken.Token, accessToken.TokenSecret). Account().VerifyCredentials().AsXml(). Request().AsUser(); //und der aktive User gespeichert activeUser = user; }

172

Hello „twitter“ //Aktionen wenn erfolgreich angemeldet if (activeUser != null & accessToken != null) { //UI-Ausgaben aktualisieren UpdateUI(); } } } } private void GetAccessToken (string requestToken, string requestVerifier) { //Anforderung eines Access Tokens var newAccessToken = FluentTwitter.CreateRequest(). Authentication.GetAccessToken (twitterConsumerKey, twitterConsumerSecret, requestToken, requestVerifier).Request().AsToken(); //und bei Erfolg die Speicherung dieses Tokens if(newAccessToken != null) accessToken = newAccessToken; }

Implementieren Sie im Anschluss noch die Methode, um die Ausgaben des UI zu aktualisieren: private void UpdateUI() { //Ausgabe des twitter-Namens lblStatus.Text = "Angemeldet als: " + activeUser.ScreenName; //und des Profilbildes imgCurrentUserProfile.ImageUrl = activeUser.ProfileImageUrl; }

Starten Sie jetzt Ihre Anwendung erneut. Nach Abschluss der Autorisierung sollten Sie den Namen Ihres twitter-Accounts sowie Ihr Profilbild sehen können:


173

4 – twitter

Abbildung 4.10: Erfolgreich bei twitter über OAuth angemeldet

Herzliche Gratulation, damit haben Sie die Implementierung des OAuthProzesses erfolgreich abgeschlossen.

4.1.3

Statusaktualisierung

Sie werden Ihre Anwendung jetzt um die Möglichkeit der Statusaktualisierung erweitern. Dazu ist es erforderlich, den HTML-Code der Seite ein wenig zu erweitern, um das Eingabefeld für den neuen Status bereitzustellen: ...

Ihre Anwendung sollte nach dem Start folgendermaßen aussehen:

Abbildung 4.11: Aktualisiertes UI

174

Hello „twitter“ Erzeugen Sie nun für die Schaltfläche btnUpdateStatus einen Click-Handler und implementieren Sie ihn wie folgt: protected void btnUpdateStatus_Click (object sender, EventArgs e) { //Status aktualisieren var updateStatus = FluentTwitter.CreateRequest(). AuthenticateWith(twitterConsumerKey, twitterConsumerSecret, accessToken.Token, accessToken.TokenSecret). Statuses().Update(txtNewStatus.Text).Request(); //Eingabefeld zurücksetzen txtNewStatus.Text = ""; }

Testen Sie die neue Funktionalität, indem Sie die Applikation ausführen und Ihren Status aktualisieren. Begeben Sie sich dann auf Ihre twitterProfilseite, und Sie sollten die neue Statusmeldung bereits sehen können. Beachten Sie dabei, dass der Name Ihrer Anwendung, also die TweetQuelle, ebenfalls übertragen wurde und daher ebenfalls angezeigt wird.

Abbildung 4.12: Eingabe der neuen Statusmeldung


175

4 – twitter

Abbildung 4.13: Aktualisierter Twitter-Status auf der Profilseite

Profitipp: Nutzen Sie die soeben implementierte Funktionalität, um beispielsweise automatisiert zeitgleich identische Tweet-Nachrichten auf unterschiedlichen Profilen zu Produkt- oder Servieceangeboten zu veröffentlichen. Ihre Marketing- bzw. CRM-Abteilung wird es Ihnen danken.

4.1.4

Zugriff auf Followings und Followers

Die nächste Erweiterung Ihres eigenen Twitter-Webinterface besteht darin, die Liste jener User auszulesen, denen Sie folgen (Followings) und die Ihnen folgen (Followers). Am Ende sollen deren Profilbilder und die entsprechenden Links zu den twitter-Profilen angezeigt werden. Für die Abfrage der erforderlichen Daten innerhalb der ASP.NET-Seite werden Sie das klassische DataBinding einsetzen. Erweitern Sie dazu den bestehenden HTML-Code erneut um einige Steuerelemente:

176

Hello „twitter“ ... Followers You Follow

Ergänzen Sie im Anschluss die folgenden Methoden in Ihrer Klasse: private void UpdateFollowerList() { //Liste jener User die mir folgen abfragen var followerList = FluentTwitter.CreateRequest(). AuthenticateWith(twitterConsumerKey,twitterConsumerSecret, accessToken.Token,accessToken.TokenSecret) .Users().GetFollowers().Request().AsUsers(); //Datenbindung an den ASP.net Repeater lstFollowers.DataSource = followerList;


177

4 – twitter lstFollowers.DataBind(); } //Für die spätere Verwendung speichern private IEnumerable youFollowList = null; private void UpdateYouFollowList() { //Liste jener User denen ich folge abfragen youFollowList = FluentTwitter.CreateRequest(). AuthenticateWith(twitterConsumerKey,twitterConsumerSecret, accessToken.Token,accessToken.TokenSecret) .Users().GetFriends().Request().AsUsers(); //Datenbindung an den ASP.net Repeater lstYouFollow.DataSource = youFollowList; lstYouFollow.DataBind(); }

Passen Sie außerdem die Methode UpdateUI an, um die Abfrage der Follower und Followings auszuführen: private void UpdateUI() { ... //Abfragen der Follower UpdateFollowerList(); //Abfragen der Followings UpdateYouFollowList(); }

Führen Sie Ihre Webanwendung jetzt aus, so können Sie nach erfolgreicher Anmeldung die Profilbilder Ihrer Followings und Followers sehen und gelangen bei Klick auf das Profilbild zum entsprechenden TwitterProfil.

178

Hello „twitter“

Abbildung 4.14: Grafische Anzeige der Followings und Followers

In der letzten Ausbaustufe werden Sie die Applikation modifizieren, sodass Sie

•• eine Liste Ihrer letzten 5 Statusmeldungen und •• eine Liste der letzten Statusmeldung der User, denen Sie folgen ausgeben. Stellen Sie dazu im ersten Schritt die entsprechenden HTMLund ASP.NET-Elemente bereit: ...

Meine Tweets

Last tweet from people you are following

180

Hello „twitter“

#

Starten Sie die Anwendung nach dem Einfügen dieses doch sehr umfangreichen Stück Markups, um die Fehlerfreiheit zu überprüfen. Im Vergleich dazu sind die unten stehenden Methoden, die Sie jetzt bitte implementieren, realtiv einfach gehalten. private void UpdateStatusList() { //Laden der letzten 5 eigenen Tweets var lastOwnTweets = FluentTwitter. CreateRequest().Statuses().OnUserTimeline(). Take(5).For(activeUser.Id).Request().AsStatuses(); //Datenbindung an den ASP.net Repeater lstTweetEntries.DataSource = lastOwnTweets; lstTweetEntries.DataBind(); } private void UpdateTweetsYouFollow() { //Sofern die Follower-Liste vorhanden ist if (youFollowList != null) { //Liste in die die Following-Tweets geschrieben werden List tweetsYouFollow = new List();


181

4 – twitter //Für alle Follower foreach (TwitterUser user in youFollowList) { //Lade den letzten Tweet (entspr. Take(1)) var userLastTweet = FluentTwitter. CreateRequest().Statuses().OnUserTimeline(). Take(1).For(user.Id).Request().AsStatuses(); //und füge diesen der oben erzeugten Liste hinzu tweetsYouFollow.AddRange(userLastTweet); } //Abschließend die Datenbindung inkl. absteigendem //Ordnen nach Datum lstTweetsYouFollow.DataSource = tweetsYouFollow. OrderByDescending(s => s.CreatedDate); lstTweetsYouFollow.DataBind(); } }

Abschließend sorgen Sie innerhalb der UpdateUI-Methode noch für den Aufruf der neuen Funktionalität: private void UpdateUI() { ... //Abfragen der letzten 5 eigenen Statusmeldungen UpdateStatusList(); //Abfragen der letzten Statusmeldung der Followings UpdateTweetsYouFollow(); }

Stellen Sie nun die Möglichkeit der manuellen Aktualisierung der Statusliste bereit, indem Sie einen Click-Handler für die Schaltfläche btn UpdateStatusList erzeugen, und setzen Sie ihn wie nachfolgend gezeigt um.

182

Hello „twitter“ protected void btnUpdateStatusList_Click (object sender, EventArgs e) { UpdateStatusList(); }

Um der Anwendung den letzten Schliff zu verpassen, ergänzen Sie den Click Handler der beim Aktualisieren des Status ausgelöst wird, um folgende zwei Zeilen: protected void btnUpdateStatus_Click (object sender, EventArgs e) { ... System.Threading.Thread.Sleep(2000); UpdateUI(); }

Dadurch erreichen Sie, dass direkt nach dem Absenden des neuen Status die Liste Ihrer eigenen Statusmeldungen aktualisiert wird. Da die Aktualisierung aber in der Regel schneller passiert als die Übertragung zum twitter-Server und die Verarbeitung Ihrer Anfrage, lassen Sie den ASP-Thread ein wenig pausieren, um die Änderung unmittelbar sehen zu können. Achtung: Setzen Sie in produktiven Anwendungen niemals manuelle Thread-Pausen, da dies die Performance Ihrer Applikation erheblich beeinflusst und zudem die User ärgert. Diese Implementierung dient im Rahmen dieses Beispiels ausschließlich zu Lernzwecken.

Wenn Sie die Anwendung jetzt erneut starten, dann sollte diese mit Leben gefüllt sein. Auf der linken Seite sind Ihre eigenen Tweets und rechts jene der Personen denen Sie folgen, in chronologisch absteigender Reihenfolge gelistet. Testen Sie auch die Statusaktualisierung, denn sobald Sie Ihren Status geändert haben, erscheint er in Ihrer Tweet-Liste. Alter-


183

4 – twitter nativ dazu können Sie Ihren Status auf der twitter.com-Seite ändern und im Anschluss die Schaltfläche Tweets neu laden betätigen.

Abbildung 4.15: Fertiges Twitter-Webportal

Herzlichen Glückwunsch, damit haben Sie das Twitter-Webbeispiel abgeschlossen.

184

Zusammenfassung

4.2

Zusammenfassung

Sie haben im Laufe des letzten Abschnitts die wichtigsten Funktionen des twitter-API kennen gelernt, und wie Sie es mithilfe der freien Bibliothek TweetSharp nutzen können. Darauf aufbauend sollten Sie jetzt in der Lage sein, Ihre Anwendungen in Zukunft von alleine zwitschern zu lassen. Betrachten Sie Twitter nicht nur als einen Dienst, auf dem Sie Ihren Status veröffentlichen können. Twitter fungiert in der Zwischenzeit als Sprachund teilweise auch Meinungsrohr der weltweiten Internetgemeinde und bietet daher in vielerlei Hinsicht unterschiedlichste Möglichkeiten, um an geschäftlich relevante Informationen zu gelangen. Hinweis: In der Zwischenzeit gibt es eine Vielzahl an Websites, die auf Basis der via Twitter geposteten Inhalte Meinungs- und Trendinformationen aggregieren. Eine dieser Websites und auf jeden Fall einen Besuch wert ist http://trendistic.com/. Dort haben Sie die Möglichkeit, nach einem bestimmten Begriff (Thema, Produkt, Dienstleistung u. a.) zu suchen, um sich die darauf bezogene Twitter-Resonanz anzeigen zu lassen.

Ein weiteres Anwendungsgebiet, etwas abseits der ursprünglichen Twitter-Idee, ist die Nutzung von Twitter zur Automation von Vorgängen, bspw. Um bestimmte Services bereitzustellen, um beim Eingang einer entsprechenden Twitter-Nachricht weitere Prozesse auszuführen. Damit ergeben sich im Kontext der Twitter-Nutzung völlig neue Möglichkeiten. Ihrer Fantasie sind dabei keine Grenzen gesetzt. Innerhalb des nächsten Abschnittes werden Sie im Rahmen einer Silverlight-Webanwendung das flickr-API kennen und verstehen lernen.


185

5 5

flickr

flickr ist der Vorzeige-Social-Service, wenn es darum geht, auf möglichst einfache Art und Weise lizenzfreie oder zur kostenlosen Nutzung freigegebene Fotos aus dem Internet zu erhalten. Umso wichtiger kann es beispielsweise sein, das API direkt innerhalb der eigenen Anwendung zu nutzen.

5.1

Hello „flickr“

Sie werden in diesem Abschnitt das flickr-API kennen lernen und unter Einsatz der freien .NET-Implementierung flickr.net eine SilverlightWebanwendung mit implementieren, mit der es Ihnen möglich ist, Fotos aus dem flickr-Netzwerk zu laden und auf die entsprechenden Daten zuzugreifen. Vorbereitend dafür, ist auch im Rahmen der Nutzung des flickr-API eine entsprechende Anwendungsregistrierung erforderlich. Hinweis: Den Einstieg und die Dokumentation zum flickr-API finden sie unter http://www.flickr.com/services/api/.

5.1.1

Anwendungsregistrierung

Falls noch nicht geschehen, erzeugen Sie sich einen flickr-Account und begegeben sich, um eine neue Anwendung zu erstellen, auf folgende Website:

•• http://www.flickr.com/services/apps/create/ Beantragen Sie jetzt Ihren API-Schlüssel und wählen Sie auf der darauffolgenden Seite, ob es sich um einen kommerziellen oder nicht kommerziellen Schlüsselantrag handelt. Social Development mit .NET

187

5 – flickr Achtung: Beachten Sie, dass bei der Anforderung eines kommerziellen API-Zugangs andere AGB als bei der privaten Nutzung in Kraft treten. Im folgenden Beispiel wird von einer nichtkommerziellen Registrierung ausgegangen.

Vergeben Sie socialdev_04_HelloFlickr als Anwendungsnamen, stimmen Sie den Lizenzbedingungen zu und schließen den Vorgang ab. Damit haben Sie den Registrierungsprozess erfolgreich durchgeführt und erhalten Ihre API-Zugangsdaten:

Abbildung 5.1: API-Zugangsdaten für flickr

5.1.2

Fotosuche

Bevor Sie mit der Implementierung beginnen, laden Sie sich bitte die kostenfreie Flickr-Implementation flickr.net von unten stehender Adresse herunter und entpacken die Bibliothek in ein Verzeichnis Ihrer Wahl.

•• http://flickrnet.codeplex.com Starten Sie Visual Studio, fügen Ihrer Projektmappe ein Projekt vom Typ Silverlight-Anwendung hinzu und vergeben Sie den Namen 07_HelloFlickr. Bestätigen Sie im erscheinenden Dialog die zusätzliche automatische Erstellung eines ASP.NET-Webanwendungsprojekts und setzen den Vorgang fort. Damit haben Sie die Erstellung der Projektstruktur abgeschlossen. 188

Hello „flickr“ Wechseln Sie jetzt mithilfe des Windows-Explorers in den Ordner, in den Sie die Bibliothek flickr.net entpackt haben, und kopieren Sie die darin enthaltene Datei FlickrNetSilverlight.dll in das Projektverzeichnis des Projekts 07_HelloFlickr. Definieren Sie abschließend innerhalb des Projekts 07_HelloFlickr noch einen Verweis auf die soeben kopierte Datei.

Abbildung 5.2: Richtige Projektstruktur

Setzen Sie über die XAML-Datei MainPage.xaml die Designhöhe des UserControls auf 768 und die Breite auf 1024, um das Layout besser gestalten zu können, und ändern Sie die Hintergrundfarbe des Grid-Objekts LayoutRoot auf Schwarz.


189

5 – flickr Platzieren Sie im Anschluss innerhalb des Grids folgendes Markup, um dadurch die Basis für das GUI zu schaffen:

Um mithilfe der von Ihnen eingesetzten Bibliothek eine Verbindung zu flickr aufzubauen, ist lediglich eine Zeile Code notwendig: using FlickrNet; ... Flickr flickrClient = new Flickr ("","");

Mithilfe des Objekttyps FlickrNet.Flicker ist es möglich, entsprechende Suchanfragen durchzuführen. Das Ergebnis dieser asynchron durchgeführten Abrage muss in einem entsprechenden Callback Handler behandelt werden, in diesem Fall PhotoSearchCompleted: //Etwaige Suchoptionen festlegen PhotoSearchOptions searchOptions = new PhotoSearchOptions(); //Asynchrone Suche starten flickrClient.PhotosSearchAsync (searchOptions, PhotoSearchCompleted); ... //Callback Handler zur Resultatsverarbeitung private void PhotoSearchCompleted

190

Hello „flickr“ (FlickrResult c) { ... }

In diesem konkreten Beispiel werden Sie Fotos suchen, denen ein bestimmter Tag zugeordnet wurde, und außerdem die Anzahl an Ergebnissen einschränken. Nach Abschluss der Suche werden die Fotos der vorhin erzeugten ListBox hinzugefügt und in Form kleiner Vorschaubilder angezeigt. Um diese Funktionalität zu realisieren, erzeugen Sie für das UserControl einen entsprechenden Loaded Handler und implementieren ihn wie folgt: using FlickrNet; ... private String flickrKey = ""; private String flickrSecret = ""; private void UserControl_Loaded (object sender, RoutedEventArgs e) { PhotoSearchOptions searchOptions = new PhotoSearchOptions(); //Nur Fotos mit dem Tag: makro searchOptions.Tags = "makro"; //Maximal 100 Ergebnisse searchOptions.PerPage = 100; Flickr flickrClient = new Flickr(flickrKey, flickrSecret); flickrClient.PhotosSearchAsync (searchOptions, PhotoSearchCompleted); }

Um den Code kompilierfähig zu machen, benötigen Sie jetzt noch den oben beschriebenen Callback Handler, den Sie bitte folgendermaßen umsetzen:


191

5 – flickr private void PhotoSearchCompleted (FlickrResult flickrResult) { //Für alle Fotos des Suchergebnisses foreach (Photo photo in flickrResult.Result) lstPhotos.Items.Add(photo); }

Damit haben Sie die Basisimplementierung abgeschlossen. Wenn Sie jetzt die Anwendung starten, sollten die ersten 100 Suchergebnisse, die den Kriterien entsprechen, in der ListBox auf der linken Seite als Thumbnails angezeigt werden. Profitipp: Im kommerziellen Bereich kommt es bei der Nutzung von Bildern oftmals zu Schwierigkeiten, weil die passenden Lizenzen nicht beachtet werden. Vermeiden können Sie das, indem Sie bspw. im Rahmen Ihrer Suche nur bestimmte Lizenzen zulassen. Möglich wird das durch folgenden Code:

searchOptions.Licenses. Add(LicenseType.AllRightsReserved); searchOptions.Licenses .Add(LicenseType.AttributionCC); searchOptions.Licenses. Add(LicenseType.AttributionNoDerivativesCC); searchOptions.Licenses. Add(LicenseType.AttributionNoncommercialCC); searchOptions.Licenses. Add(LicenseType.AttributionNoncommercialNoDerivativesCC); searchOptions.Licenses. Add(LicenseType.AttributionNoncommercialShareAlikeCC); searchOptions.Licenses. Add(LicenseType.AttributionShareAlikeCC); searchOptions.Licenses. Add(LicenseType.NoKnownCopyrightRestrictions); searchOptions.Licenses. Add(LicenseType.UnitedStatesGovernmentWork);

192

Hello „flickr“ PROFITIPP: Dadurch sind Sie in der Lage, bspw. ausschließlich Bilder abzufragen, für die Sie uneingeschränktes Nutzungsrecht für den geschäftlichen Bereich erhalten.

Abbildung 5.3: Anzeige der über flickr geladenen Thumbnails


193

5 – flickr Die Anzeige der Thumbnails wurde in diesem Fall unter Nutzung des WPF bzw. Silverlight-DataBindings realisiert. Die Daten dafür liefert der Objekttyp FlickrNet.Photo. Die Photo-Objekte wurde der Liste im Rahmen des zuvor erzeugten Callback Handlers hinzugefügt. Für die Darstellung selbst relevant war ausschließlich die Eigenschaft: FlickrNet.Photo.ThumbnailUrl

Im nächsten Schritt werden Sie die Anwendung dahingehend erweitern, sodass das aktuell ausgewählte Listenelement in größerer Form dargestellt wird. Zum Abschluss werden Sie der Applikation noch einen grafischen Schliff verpassen. Für die Anzeige der großen Bildvariante werden Sie auf die folgende Eigenschaft zurückgreifen: FlickrNet.Photo.MediumUrl

Außerdem werden Sie noch den Titel des jeweiligen Bildes anzeigen, den Sie folgendermaßen auslesen können: FlickrNet.Photo.Title

Erweitern Sie jetzt Ihr bestehendes GUI um folgenden XAML-Code und platzieren Sie ihn nach der ListBox der bisherigen Schritte: ...

194

Hello „flickr“

Starten Sie Ihre Anwendung erneut, denn weitere Implementierungsschritte sind aufgrund der praktischen Eigenschaften des Data Bindings nicht notwendig. Wählen Sie ein Bild aus der linken Liste und betrachten Sie die vergrößerte Darstellung:

Abbildung 5.4: Über flickr geladenes Bild

Wenn Sie möchten, können Sie, um die Optik der flickr-Gallerie noch ein wenig zu verbessern, das Bild noch mit einem dynamisch erzeugten Spiegeleffekt versehen. Für das Spiegelbild haben Sie im Zuge der letzten GUI-Erweiterung bereits ein Image-Steuerelement mit dem Namen imgMirror erstellt. Um den Effekt zu erzeugen, implementieren Sie einen entsprechenden SelectionChanged-Event-Handler für die ListBox lstPhotos wie nachfolgend gezeigt: Social Development mit .NET

195

5 – flickr private void lstPhotos_SelectionChanged (object sender, SelectionChangedEventArgs e) { //Bild um 180° drehen RotateTransform rotate = new RotateTransform(); rotate .Angle = 180; //Bild auf Basis der Ausgangskoordinaten sowie //Breite und Höhe entsprechend verschieben TranslateTransform translate = new TranslateTransform(); translate.Y = 380 + 480 + 100; translate.X = 640; //Bild entlang der vertikalen Achse spiegeln ScaleTransform scaleTransofrm = new ScaleTransform(); scaleTransofrm.ScaleX = -1; scaleTransofrm.ScaleY = 1; scaleTransofrm.CenterX = 320; scaleTransofrm.CenterY = 800; //Transformationen zu Gruppe zusammenfassen TransformGroup mirrorTransformGroup = new TransformGroup(); mirrorTransformGroup.Children.Add(rotate); mirrorTransformGroup.Children.Add(translate); mirrorTransformGroup.Children.Add(scaleTransofrm); //Transformation anwenden imgMirror.RenderTransform = mirrorTransformGroup; //Opazitätsmaske zur Regulierung der Durchsichtigkeit //erzeugen und anwenden LinearGradientBrush mask = new LinearGradientBrush(); mask.StartPoint = new Point(0, 0); mask.EndPoint = new Point(0, 1); mask.GradientStops.Add(new GradientStop() { Color = Colors.Transparent, Offset = 0.0 }); mask.GradientStops.Add(new GradientStop() { Color = Colors.Transparent, Offset = 0.85 }); mask.GradientStops.Add(new GradientStop() { Color = Colors.Black, Offset = 1.0 }); imgMirror.OpacityMask = mask;

196

Hello „flickr“ //Bildopazität auf 40% reduzieren imgMirror.Opacity = 0.4; }

Führen Sie Ihre Anwendung nun wieder aus und betrachten Sie die Spiegelung am unteren Bildbereich.

Abbildung 5.5: Anzeige der Grafik inklusive Spiegelung

Gratulation, damit haben Sie das Kapitel über die Nutzung von flickr abgeschlossen.


197

5 – flickr

5.2

Zusammenfassung

Im Laufe des letzten Abschnitts haben Sie gelernt, welche Möglichkeiten Ihnen flickr im Zusammenhang mit dem frei verfügbaren API bietet. Wichtig ist, dass Sie auch im Kontext von flickr darüber nachdenken, wie Sie das API im Geschäftsalltag sinnvoll einsetzen könnten. Finden Sie daher nachfolgend einige Anregungen:

•• Nutzen Sie flickr als freie Fotoquelle und schränken Sie die Suche automatisiert auf die für Sie passenden Lizenzen ein

•• Implementieren Sie eine Anbindung für flickr, um beispielsweise Ihre Sharepoint-Media-Library dynamisch zu erweitern

•• Realisieren Sie Anwendungen, die Ihnen beispielsweise über Nacht automatisiert Fotos, die für Sie relevant sein könnten, herunterladen

Ich kann Ihnen nur empfehlen: Begeben Sie sich auf eine Reise, schauen Sie über den Tellerrand hinaus und entdecken und erforschen Sie völlig neue Möglichkeiten. Das nächste Kapitel führt Sie weg von den stehenden Bildern zu bewegten, direkt Bildern direkt in das API von YouTube, der mächtigsten VideoCommunity der Welt.

198

6 6

YouTube

In diesem Kapitel werden Sie lernen, wie Sie die Social-Video-Community YouTube innerhalb Ihrer eigenen Anwendung nutzen können. Die Basis dafür bildet das Google YouTube API, und dieses wiederum ist ein Teil des so genannten Google Data API.

6.1

Google Data API

Das Google Data API ist das API, das hinter allen Anwendungen steht, die von Google bereitgestellt werden. Der Zugriff darauf ist nur mithilfe eines entsprechenden API-Schlüssels möglich, den Sie hier beantragen können:

•• http://code.google.com/apis/gdata/signup.html Dieser Schlüssel berechtigt nicht automatisch zur Nutzung der untergeordneten APIs, dafür sind teilweise seperate API-Schlüssel erforderlich. Das Google Data API besteht aus den in der unten stehenden Tabelle angeführten Sub-APIs, wobei zu beachten ist, dass nicht für alle dieser APIs auch bereits fertige Client Libraries zur Verfügung stehen. Sub-API-Bezeichnung

Client Libraries

Google Analytics Data Export API

JS, Java, PHP, Python, Ruby

Google Apps APIs

derzeit keine

Google Base Data API

derzeit keine

Blogger Data API

Java, .NET, PHP, Python, JS, Obj-C

Google Booksearch Data API

Java, PHP

Google Calendar Data API



199

6 – YouTube Sub-API-Bezeichnung

Client Libraries

Google Code Search Data API

derzeit keine

Google Contacts Data API


Google Documents List Data API

derzeit keine

Google Finance Portfolio Data API

derzeit keine

Google Health Data API

Java, .NET, PHP, Python, JS, Ruby

Google Maps Data API Google Web Albums Data API

Java, .NET, PHP, Python, Obj-C

Google Project Hosting Issue Tracker API

derzeit keine

Google Sidewiki Data API

Java, JS

Google Sites Data API


Google Spreadsheets Data API


Google Translator Toolkit Data API

derzeit keine

Google Webmaster Tools Data API

derzeit keine

YouTube Data API


Tabelle 6.1: Übersicht über alle Google Data APIs

Hinweis: Eine Übersicht zu den in der oben angeführten Tabelle enthaltenen APIs finden Sie unter http://code.google.com/apis/ gdata/docs/directory.html.

6.2

Hello „YouTube“

Im Rahmen des folgenden Beispiels werden Sie lediglich das YouTube Data API und die dafür bereitgestellte .NET Client Library einsetzen.

200

Hello „YouTube“

6.2.1

YouTube-Anwendungsregistrierung

Bevor Sie mit der Entwicklung des Beispiels beginnen können, laden Sie die Clientimplementierung herunter und installieren Sie diese in ein von Ihnen ausgewähltes Verzeichnis. Laden Sie die Datei YouTube SDK (1.6). msi, sie können sie über folgende Website beziehen:

•• http://code.google.com/p/google-gdata/downloads/list Im Anschluss registrieren Sie unter nachfolgender Adresse eine neue Anwendung und geben ihr den Namen socialdev_05_HelloYT, um einen gültigen API-Schlüssel zu erhalten:

•• http://code.google.com/apis/youtube/dashboard/

Abbildung 6.1: YouTube-API-Anwendungsregistrierung

Damit haben Sie die Voraussetzungen für die erfolgreiche Nutzung des API innerhalb einer .NET-Anwendung geschaffen und können nun mit der eigentlichen Entwicklung starten.


201

6 – YouTube

6.2.2

Abfragen von Video-Feeds

Erzeugen Sie mithilfe von Visual Studio ein neues WPF-Projekt und vergeben den Namen 08_HelloYouTube. Kopieren Sie jetzt aus dem Ordner Redist, der sich im Installationsverzeichnis des YouTube API SDK befindet, folgende Dateien in Ihr Projektverzeichnis und definieren Sie im Anschluss die entsprechenden Projektverweise: Google.GData.Client.dll Google.GData.Extensions.dll Google.GData.YouTube.dll

Abbildung 6.2: Korrekte Projektverweise

Achtung: Um die Funktionalität der Anwendung zu gewährleisten, stellen Sie, genauso wie im Rahmen des LinkedIn-Projekts, in den Projekteigenschaften der Anwendung als Zielframework .NET Framework 4 und nicht das Client Profile ein.

202

Hello „YouTube“ Um das GUI zu erzeugen, setzen Sie die Hintegrundfarbe des Hauptfensters auf DarkGray sowie Höhe und Breite auf 560 bzw. 1024 Einheiten. Platzieren Sie im Anschluss folgenden XAML-Code innerhalb Ihres Haupt-Grid-Elements: ...

Ihre Anwendung sollte jetzt in etwa wie unten gezeigt aussehen:

204

Hello „YouTube“

Abbildung 6.3: Aktuelles GUI der YouTube-Anwendung

Im ersten Schritt werden Sie die Basisvorgehensweise zum Erzeugen von YouTube-Abfragen kennen lernen und dann die weltweit am besten bewerteten Videos anzeigen. Die Grundlage für alle Aktivitäten bildet dabei die Klasse YouTubeRequest. Eine Request benötigt jedoch eine entsprechende Basiskonfiguration vom Objekttyp YouTubeRequestSettings. Implementieren Sie daher folgenden Code, um die für die Durchführung von Anfragen erforderliche Konfiguration der YouTube-Zugangsdaten durchzuführen: using Google.YouTube; ... //YouTube API Key private string youTubeAPIKey = ""; //YouTube-Abfrageeinstellungen private YouTubeRequestSettings youTubeRequestSettings = null; public MainWindow() { InitializeComponent();


205

6 – YouTube //Erzeugen neuer Einstellungen unter Verwendung des //YouTube API Keys youTubeRequestSettings = new YouTubeRequestSettings ("socialdev_05_HelloYT", youTubeAPIKey); }

Hinweis: Weiterführende Informationen hinsichtlich des YouTube-Anmeldungsprozesses sowie Hintergrunddetails zum Autorisierungsprozess finden Sie im Developer’s Guide, zu erreichen unter http://code.google.com/apis/youtube/2.0/developers_guide_ protocol_authentication.html.

Implementieren Sie im Anschluss einen Click-Handler für die Schaltfläche btnSearchMostRatedVideos in der folgenden Form: using Google.GData.Client; using Google.GData.YouTube; ... private void btnSearchMostRatedVideos_Click (object sender, RoutedEventArgs e) { //Erzeugen der Request unter Anwendung der Einstellungen YouTubeRequest youtubeRequest = new YouTubeRequest(youTubeRequestSettings); //Abrufen der Liste mit den beliebtesten Videos Feed searchResultVideos = youtubeRequest.GetStandardFeed(YouTubeQuery.MostPopular); //Leeren der Ergebnisliste lstResult.Items.Clear(); //Hinzufügen der Ergenisse zur Liste foreach (Video resultEntryVideo in searchResultVideos.Entries) lstResult.Items.Add(resultEntryVideo); }

206

Hello „YouTube“ Starten Sie die Anwendung, um die Funktionalität der Suche nach den beliebtesten Videos zu testen. Die korrekte Anzeige der Suchergebnisse übernimmt, wie auch in den vergangen Beispielen, die WPF-Datenbindung:

Abbildung 6.4: Anzeige der beliebtesten Videos mithilfe des YouTube API

Um zu ermöglichen, dass das aktuell ausgewählte Video geöffnet werden kann, ist es ausreichend, den MouseDoubleClick-Handler der ListBox lstResult wie unten gezeigt zu implementieren. Dabei wird lediglich der URL des aktuell ausgewählten Videos unter Verwendung der Eigenschaft VideoId zusammengesetzt: private void lstResult_MouseDoubleClick (object sender, MouseButtonEventArgs e) { if (lstResult.SelectedItem != null) { //Aufrufen des ausgewählten Videos Process.Start("http://www.youtube.com/watch?v=" + ((Video)lstResult.SelectedItem).VideoId); } }


207

6 – YouTube Der nächste Schritt in der Implementierung besteht darin, die tatsächliche Suchanfrage auf Basis von Suchbegriffen zu realisieren. Dazu ist in erster Linie der Objekttyp YouTubeQuery erforderlich. Für die Suche selbst erzeugen Sie daher bitte einen Click-Handler für die Schaltfläche btnSearchVideos in folgender Form: private void btnSearchVideos_Click (object sender, RoutedEventArgs e) { //Neue Anfrage erzeugen YouTubeRequest youtubeRequest = new YouTubeRequest(youTubeRequestSettings); //Suchkriterien zusammenstellen YouTubeQuery searchQuery = new YouTubeQuery(YouTubeQuery.DefaultVideoUri); //Suchbegriff hinzufügen searchQuery.Query = txtKeywords.Text; //Ergebnisse abrufen Feed searchResultVideos = youtubeRequest.Get(searchQuery); //Ergebnisliste leeren lstResult.Items.Clear(); //Neue Ergebnisse in absteigender Reihenfolge bzgl. Anzahl //der Aufrufe (ViewCount) anzeigen foreach (Video resultEntryVideo in searchResultVideos.Entries .OrderByDescending(video => video.ViewCount)) lstResult.Items.Add(resultEntryVideo); }

Hinweis: Weitere Informationen zu den Einstellungsmöglichkeiten der Klasse YouTubeQuery finden Sie unter der Adresse http://google-gdata.googlecode.com/svn/docs/folder47/ Properties_T_Google_GData_YouTube_YouTubeQuery.htm.

208

Hello „YouTube“ Starten Sie Ihre Anwendung und suchen Sie nach beliebigen Videos. Im unten gezeigten Beispiel wurden Videos zum Thema meiner Heimatstadt Graz gesucht und gefunden.

Abbildung 6.5: Mithilfe des YouTube API ausgeführte Videosuche

Im nächsten Schritt werden Sie Ihre Suche um die Möglichkeit der Kategoriesuche ergänzen. Realisieren Sie dazu einen neuen Click-Handler für die Schaltfläche btnSearchCategories gemäß dem nachfolgenden Code: private void btnSearchCategories_Click (object sender, RoutedEventArgs e) { //Anfrage erzeugen (wie bei Keyword-Suche) YouTubeRequest youtubeRequest = new YouTubeRequest(youTubeRequestSettings); YouTubeQuery searchQuery = new YouTubeQuery(YouTubeQuery.DefaultVideoUri); searchQuery.Query = txtKeywords.Text; //Hinzufügen der Kategorie Tech = Wissenschaft & Technologie searchQuery.Categories .Add(new QueryCategory( new AtomCategory("Tech", YouTubeNameTable.CategorySchema) ));


209

6 – YouTube //Suchergebnisse abrufen und ausgeben Feed searchResultVideos = youtubeRequest.Get(searchQuery); lstResult.Items.Clear(); foreach (Video resultEntryVideo in searchResultVideos.Entries.OrderByDescending (video => video.ViewCount)) lstResult.Items.Add(resultEntryVideo); }

Starten Sie Ihre Anwendung und suchen Sie nach beliebigen Videos unter Einsatz der neuen Funktionalität. Beachten Sie die unterschiedlichen Ergebnisse bei der Standard- bzw. Kategoriesuche.

Abbildung 6.6: Suchergebnisse für Österreich mit Kategoriesuche

210

Hello „YouTube“

Abbildung 6.7: Suchergebnisse für Österreich mit Standardsuche

Hinweis: Im aktuellen Beispielcode wurde als Kategoriename „Tech“ hinzugefügt. Dieser entstammt der offiziellen Kategorieliste, die durch YouTube bereitgestellt wird. Sie erhalten sie unter http://gdata.youtube. com/schemas/2007/categories.cat?hl=de-DE, wobei der Parameter am Ende die gewünschte Sprache repräsentiert. Mehr Informationen dazu erhalten Sie unter http://code.google.com/apis/youtube/2.0/ reference.html#Localized_Category_Lists.

Damit haben Sie den Abschnitt über YouTube-Suchabfragen abgeschlossen und werden sich im folgenden Teil mit Community-Inhalten wie Benutzerprofilen und Videokommentaren auseinandersetzen.

6.2.3

Zugriff auf Communitybeiträge

Innerhalb der nächsten Erweiterungen des aktuellen Beispiels werden Sie lernen, wie Sie auf die Inhalte der Community zugreifen können.


211

6 – YouTube Beginnen werden Sie mit der Anzeige der Kommentare, die zu einem Video abgegeben wurden. Dazu wird folgende Ergänzung der Benutzeroberfläche benötigt: ...

212

Hello „YouTube“

Damit haben Sie die ListBox bereitgestellt, in der Sie zukünftig die verfügbaren Videokommentare anzeigen werden.

Abbildung 6.8: Erweiterung um Kommentar-ListBox

Da mittels Data Binding bereits die erforderlichen Vorbereitungen bzgl. der Kommentaranzeige getroffen wurden, ist es, um die Funktionalität bereitzustellen, völlig ausreichend, den nachfolgenden SelectionChangedHandler der Listbox lstResult zu implementieren: private void lstResult_SelectionChanged (object sender, SelectionChangedEventArgs e) { if (lstResult.SelectedItem != null)


213

6 – YouTube { //Aktuell ausgewähltes Video in ein Objekt Casten Video currentVideo = (Video)lstResult.SelectedItem; //Anfrage erzeugen YouTubeRequest youtubeRequest = new YouTubeRequest(youTubeRequestSettings); //Kommentare zum aktuellen Video laden Feed comments = youtubeRequest.GetComments(currentVideo); //Kommentarliste leeren lstVideoComments.Items.Clear(); //Kommentare anzeigen foreach (Comment comment in comments.Entries) lstVideoComments.Items.Add(comment); } }

Hinweis: Weitere Informationen zum Abrufen und der Arbeit mit Kommentaren finden Sie unter http://code.google.com/apis/ youtube/2.0/developers_guide_dotnet.html#Comments.

Führen Sie die Anwendung erneut aus und suchen nach einem Video. Wenn Sie jetzt ein Video in der Ergebnisliste durch einfachen Mausklick auswählen, werden, sofern vorhanden, in der vorhin erzeugten ListBox die zum Video verfügbaren Kommentare angezeigt.

214

Hello „YouTube“

Abbildung 6.9: Anzeige der Videokommentare mithilfe des YouTube API

Zum Abschluss werden Sie jetzt noch auf die Benutzerinformationen des jeweiligen Kommentarautors zugreifen.

6.2.4

Zugriff auf Benutzerprofile

Erweitern Sie zur Bereitstellung der Anzeigemöglichkeit von Benutzerinformationen Ihre XAML-Datei um folgendes Markup:


215

6 – YouTube

Ihre Anwendung sollte nun vom Design ausgehend wie unten gezeigt aussehen:

Abbildung 6.10: Content Control zur Anzeige der Benutzerinformationen

Ähnlich wie bei der Anzeige der Kommentare passiert die Inhaltsaktualisierung innerhalb eines SelectionChanged-Handlers, diesmal allerdings gebunden an die ListBox lstVideoComments. Ein weiterer Unterschied liegt im Zugriff auf die Benutzerinformationen, denn dafür ist es notwendig, die Klasse YouTubeService zu instantiieren. Implementieren Sie den soeben genannten Handler folgendermaßen:

216

Hello „YouTube“ private void lstVideoComments_SelectionChanged (object sender, SelectionChangedEventArgs e) { if (lstVideoComments.SelectedItem != null) { //Aktuell ausgewählten Kommentar kapseln Comment currentComment = (Comment)lstVideoComments.SelectedItem; //Service instantiieren YouTubeService youTubeService = new YouTubeService ("socialdev_05_HelloYT", youTubeAPIKey); //Anfrage erstellen YouTubeRequest youtubeRequest = new YouTubeRequest(youTubeRequestSettings); //Benutzerfeed-URL zusammenstellen string userFeedURL = "http://gdata.youtube.com/feeds/api/users/" + currentComment.Author; //Benutzerprofil zur URL über das Service abrufen ProfileEntry userProfile = (ProfileEntry)youTubeService.Get(userFeedURL); //Datenkontext des Content Control setzen //wodurch via Datenbindung die Details angezeigt werden conCurrentCommentAuthor.DataContext = userProfile; } }

Wenn Sie die Anwendung jetzt starten, nach einem Video suchen und dann auf einen der Kommentarbeiträge klicken, werden auf der rechten Seite die Informationen über den Autor des Kommentars angezeigt. Voraussetzung dafür ist, dass er die Daten in seinem YouTube-Profil erfasst hat.


217

6 – YouTube

Abbildung 6.11: Abrufen von Benutzerprofilinformationen mit dem YouTube API

Herzlichen Glückwunsch, damit haben Sie das Implementierungsbeispiel zur Nutzung des YouTube API erfolgreich abgeschlossen.

6.3

Zusammenfassung

Das soeben abgeschlossene Beispiel sollte Ihnen zeigen, wie einfach Sie die YouTube-Datenbank nutzen können. Ob Sie dabei nur Videos suchen oder mithilfe des API die Meinungen von Usern auswerten, spielt dabei keine Rolle. Jetzt kennen Sie die notwendigen Werkzeuge und Hilfsmittel, um diese Aufgaben unter Verwendung der .NET-Technologie möglichst effizient durchzuführen. Das nächste und letzte Kapitel dieses Buches gibt Ihnen wertvolle Tipps für die praktische Planung und Umsetzung Ihrer zukünftigen sozialen Anwendungsprojekte.

218

Teil C Planung und Architektur In den ersten beiden Teilen dieses Buches haben Sie unterschiedliche soziale Netzwerke und Services kennen gelernt und erfahren, wie Sie diese in eigene Anwendungen integrieren können. Genauso wichtig ist es aber die richtige Anwendungsarchitektur zu planen, um am Ende nicht eine Lösung vorliegen zu haben, die aufgrund einer fehlerhaften Infrastruktur zum Scheitern verurteilt ist. Daher beschäftigt sich der dritte und letzte Teil, bestehend aus nur einem Kapitel, mit genau diesem Thema und liefert Ihnen Praxistipps zur richtigen Planung und Architektur sozialer Anwendungen. Beachten Sie dabei aber, dass es sich nur um exemplarische Szenarien handelt und die Realität oftmals eine Vielzahl unterschiedlichster Anforderungen stellt.


219

7 7

Soziale Anwendungen planen

Soziale Anwendung ist nicht gleich soziale Anwendung, und es gibt einige Bereiche, die vor der Implementierung einer Anwendung berücksichtigt werden sollten. Dieses abschließende Kapitel dient dazu, Ihnen sinnvolle Tipps für den Einstieg in die soziale Anwendungswelt bereitzustellen, und soll dabei auch als Leitfaden für Ihr erstes eigenes Projekt fungieren.

7.1

Anwendungstyp

Stellen Sie sich zu Beginn die Frage, in welche der folgenden Kategorien Ihre Anwendungen einzuordnen ist:

•• Lokal installierte Anwendung •• Interaktive Webanwendung •• Mobile Anwendung •• Mesh-Up-Anwendung (Mix aus allem) Davon abhängig sollten Sie sich im nächsten Schritt der Planungsphase überlegen, welche Technologien sinnhaft und zielführend genutzt werden könnten. Dabei spielt es eine große Rolle, die Faktoren Basisfunktionalität, Art des Inhalts bzw. auch die Zielgruppe zu berücksichtigen. Profitipp: Die Wahl des richtigen Anwendungstyps kann entscheidend für den Erfolg der selbigen sein. Beispielsweise macht es bedeutend weniger Sinn, eine mobile soziale Anwendungen für die Zielgruppe 65+ zu realisieren, als dies bei der Fokusgruppe bis 30 wäre. Wichtig ist, dass Sie sich bereits im Vorfeld Gedanken darüber machen, wer Ihre Anwendung letzten Endes nutzen soll.


221

7 – Soziale Anwendungen planen

7.2

Basistechnologien

Nachdem Sie nun die Art der Anwendung, die Sie planen und entwickeln möchten, festgelegt haben, ist es notwendig, die im Rahmen des Projekts eingesetzten Technologien festzulegen. Diese sind aufgrund gewisser Anwendungsarten teilweise vorgegeben, können in den meisten Fällen aber selbst gewählt werden.

7.2.1

Programmierumgebung und Framework

Planen Sie eine soziale iPhone-Anwendung, ist ziemlich schnell klar, dass Sie sich mit Objective-C und dem Cocoa-Framework auseinandersetzen müssen. Denken Sie aber daran, ein Social-Desktoptool zu entwickeln, haben Sie die Wahl zwischen C++, .NET, Java, Adobe AIR. In diesem Fall empfehle ich Ihnen, im Vorfeld zu evaluieren, für welche der sozialen Netzwerke oder Services, die im Rahmen Ihrer Anwendung unterstützen möchten, bereits funktionsfähige und brauchbare SDKs oder Bibliotheken existieren. Profitipp: Unterschätzen Sie die Aufgabe der Entwicklung eines eigenen Frameworks zur Nutzung eines existierenden API nicht. Wie Sie im Rahmen des Kapitels über facebook erfahren haben, bedarf es, um nur einige Funktionalitäten bereitstellen zu können, erheblichen Programmieraufwand. Versuchen Sie daher, je nach vorhandenem Budget einen Kompromiss zwischen dem Adaptieren bestehender Bibliotheken und der Neuentwicklung einer eigenen Lösung zu finden.

7.2.2

Anwendungsarchitektur und Infrastruktur

Einen weiteren wesentlichen Faktor bei der Planung Ihrer sozialen Lösung stellt auch die gesamte Anwendungsarchitektur und die damit verbundene, notwendige Infrastruktur dar. Eine Desktoplösung benötigt in

222

Basistechnologien der Regel keine sonderliche Infrastruktur, hingegen stellen mobile Anwendungen oftmals enorme Anforderungen an die zugrunde liegende Backend-Infrastruktur.

Clientlösung Im Rahmen einer reinen Clientlösung ist die Infrastruktur normalerweise relativ einfach gehalten, da generell keine weitere Backend-Unterstützung notwendig wird. Der meiste Aufwand besteht darin, die Anwendung entsprechend zu verteilen und für eine ordentliche Installationsmöglichkeit zu sorgen.

Mobile Clientlösung Die Bereitstellung von mobilen Lösungen kann sehr einfach sein, aber auch eine Vielzahl unterschiedlichster Anforderungen an die Basisinfrastruktur stellen. Das ist in erster Linie abhängig davon, ob Sie die Bereitstellung der Infrastruktur den unterschiedlichen Plattformherstellern wie etwa Apple, Google, Microsoft oder auch Nokia überlassen, oder dabei bevorzugt Ihre eigenen Systeme zum Einsatz bringen möchten. Praxistipp: Gerade bei der Einführung einer neuen Anwendung empfiehlt es sich, die grundlegende Infrastruktur, die durch die Plattformhersteller bereitgestellt wird, zu nutzen. Zum Einen bringt dies Vorteile im Bereich der Investitionskosten, zum anderen können Sie sich sicher sein, dass die Infrastruktur zu 99,9 % funktionieren wird und Sie sich ausschließlich auf die Kernfunktionalität der Anwendung konzentrieren müssen.

Server-Client-Lösung Die komplexesten Architekturen setzen meist Anwendungen voraus, bei denen teilweise die Anwendungsinhalte innerhalb der verschiedenen Plattformen, bspw. als integrierte facebook-Anwendung, eingebunden werden. Eine zusätzliche Erhöhung des Komplexitätsgrads tritt ein,


223

7 – Soziale Anwendungen planen wenn das Angebot dann für Desktopclients, als Webanwendung und für mobile Endgeräte bereitgestellt werden soll. Profitipp: Ich empfehle Ihnen, nicht gleich von Beginn an sämtliche Anwendungstypen bereitzustellen. Evaluieren Sie, welcher Anwendungstyp für Ihre Zielgruppe am besten geeignet ist, und veröffentlichen Sie nach dem ersten Impact weitere Versionen. So gelingt es Ihnen, auf der einen Seite Kosten einzusparen und auf der anderen Seite den Entwicklungsprozess überschaubar zu halten.

7.3

Unterstützung von Standards

Im Laufe der letzten Jahre haben sich im Umfeld von sozialen Technologien zwei wichtige Standards abgehoben. Zum einen ein Standard zur Entwicklung von sozialen Anwendungen, genannt OpenSocial, und zum anderen die Ihnen aus vorigen Beispielen bereits bekannte Authentifizierungstechnologie OAuth. Profitipp: Lassen Sie diese beiden Technologien bei der Planung Ihrer zukünftigen sozialen Anwendungen auf keinen Fall außer Acht, da nach dem momentanen Entwicklungsstand deren Verbreitung entsprechend zunehmen wird.

Nachfolgend erhalten Sie die wichtigsten Informationen zu diesen beiden Technologien in komprimierter Form und welche Rolle diese im Rahmen sozialer Lösungen einnehmen.

7.3.1

OpenSocial

OpenSocial wurde 2007 durch Google veröffentlicht und bezeichnet einen Standard zur Bereitstellung unterschiedlicher APIs im Rahmen von Web224

Unterstützung von Standards anwendungen. Dabei ist die oberste Zielsetzung, die anwendungsübergreifende Nutzung des API einfach und übersichtlich zu ermöglichen. In der Zwischenzeit wird die Initiative von vielen unterschiedlichen sozialen Netzwerken und Services unterstützt. Eine aktuelle Liste dieser finden Sie auf der Website des Standards unter

•• http://wiki.opensocial.org/index.php?title=Main_Page#Container_ Information

Die wichtigsten derzeit teilnehmenden Anbieter sind folgende:

•• Google Friend Connect •• iGoogle •• LinkedIn •• MySpace •• Orkut •• XING •• Yahoo! •• VZ-Netzwerke (SchülerVZ, StudiVZ, MeinVZ) OpenSocial bei deutschsprachigen Anbietern Leider ist von den Vertretern des deutschsprachigen Raums die Unterstützung des Standards bis jetzt nur rudimentär oder gar nicht vorhanden. Aktuell (Oktober 2010), erklärt sich beispielsweise XING nur dazu bereit, bestimmten Partnern, nämlich den Mitgliedern der XING OpenSocial Partner Community, Zugang zum Entwicklungsbereich zu gestatten. Etwas besser sieht der Support der Entwicklergemeinde in diesem Kontext innerhalb der VZ-Netzwerke aus, dort erhält man nach entsprechendem Registrierungsvorgang unter http://www.studivz.net/Developer zumindest einen Zugang zur VZ-Sandbox. Das ist ein abgeschlossener Bereich, in dem die eigenen Applikationen vorab getestet werden können. Die Möglichkeit der Veröffentlichung einer VZ-Anwendung ist derzeit nur in Abstimmung mit dem Betreiber möglich. Social Development mit .NET

225


Funktionsweise OpenSocial stellt im Rahmen seiner Funktionalität die Interoperabilität, d. h. den anwendungsübergreifenden Austausch von Daten, zur Verfügung. Dabei werden prinzipiell zwei unterschiedliche Techniken unterstützt:

•• Open-Social-API •• Open Social Gadgets Während das API die entsprechenden Schnittstellen für einen einheitlichen Zugang zu den unterschiedlichen Netzwerken bereitstellt, so handelt es sich bei den Open Social Gadgets um kleinere Widgets, die Funktionalitäten innerhalb von Webseiten zur Verfügung stellen, die in Zusammenhang mit den sozialen Diensten stehen. Das Open-Social-API ist abermals in folgende Bereiche zu unterteilen: API-Bereich

Beschreibung

Data

Zugriff auf Personendaten

People

Analyse des sozialen Graphen

Activities

Textbasierte Kommunikation zwischen Usern

Tabelle 7.1: API-Bereiche des Open-Social-API

Die Implementation von OpenSocial-Anwendungen erfolgt in der Regel mithilfe von HTML, XML oder auch JavaScript, und deren Ausführung passiert innerhalb eines so genannten Containers, der als Runtime der Applikationen fungiert. Hinweis: Die Entwicklung von OpenSocial-Anwendungen mit .NET ist zum jetzigen Zeitpunkt allerdings erst sporadisch möglich und mit entsprechendem Aufwand verbunden. Weiterführende Informationen zum Thema OpenSocial und wie damit Anwendungen realisiert werden können, finden Sie unter http://wiki.opensocial.org/. Eine erste frei erhältliche .NET-Implementierung ist unter http://code. google.com/p/opensocial-net-client/ zu beziehen.

226

Unterstützung von Standards

7.3.2

OAuth

OAuth ist im Umfeld von sozialen Anwendungen die am weitesten verbreitete Methode im Bereich der Benutzerauthentifizierung. Inzwischen kennen Sie OAuth aus den vorherigen Kapiteln, wo Sie beispielsweise im Rahmen von facebook einen entsprechende OAuth-Autorisierungsvorgang implementiert haben. OAuth liegt derzeit in der Version 1.0 vor, wobei die Spezifikation der Nachfolgeversion 2.0 bereits als WIP (Work in progress) beim IETF (Internet Engineering Task Force) vorliegt.

Authentifikationsprozess Wenn Sie sich dazu entscheiden, OAuth in einem Ihrer Projekte einzusetzen, können Sie davon ausgehen, dass Sie auf einen zukunftsstarken Trend setzen aber auch, dass damit entsprechender zusätzlicher Implementierungsaufwand verbunden ist. Das ist vor allem der Fall, wenn zu dem sozialen Dienst, den Sie gerne nutzen würden, noch keine entsprechende Implementierung besteht oder verfügbar ist. Die nachfolgende Abbildung zeigt sehr deutlich, dass der Authentifizierungsprozess nicht als trivial zu bezeichnen ist.


227


Abbildung 7.1: OAuth-Authentifizierungsprozess v1.0a

228

Zusammenfassung

Hinweis: Einen ausgezeichneten Überblick über die OAuthSpezifikation und die einzelnen Protokollschritte finden Sie unter http://hueniverse.com/oauth/ bzw. unter http://oauth.net/ core/1.0/#signing_process sowie auf der offiziellen Homepage http://oauth.net.

7.4

Zusammenfassung

Der meiste Aufwand bei der Umsetzung einer sozialen Anwendung sollte in der Regel in den Vorbereitungs- und Planungsphasen auftreten. Je besser und sorgfältiger Sie Ihre Angebote planen, desto wahrscheinlicher ist es, dass sie Erfolg haben und genutzt werden. Stellen Sie sich zu Beginn folgende Fragen, um einen einfachen Plausibilitäts-Check durchzuführen:

•• In welcher Form soll die Anwendung eine Bereicherung für den User darstellen?

•• Gibt es bereits Anwendungen, die gleiche oder ähnliche Funktionalitäten bereitstellen?

•• Wie unterscheidet sich Ihre Anwendung von den Mitbewerbern und was sind die Gründe, warum User an deren Stelle Ihre Anwendung nutzen sollten?

Gelingt es Ihnen, oben angeführte Fragen auf Anhieb und problemlos zu beantworten, dann gratuliere ich Ihnen: Sie sind auf dem besten Weg, die nächste Social-Hype-Anwendung zu entwickeln – halten Sie Ihre Idee geheim, denn Neider gibt es überall.


229

N

Nachwort Herzlichen Glückwunsch, hiermit sind Sie am Ende dieses Buches angelangt und besitzen jetzt das notwendige Know-how, um Ihre ersten eigenen sozialen Anwendungsprojekte zu starten. Ich hoffe, Sie hatten Spaß beim Durcharbeiten der beispielhaften Projekte und konnten daraus Lernnutzen ziehen. Außerdem hoffe ich, dass es mir gelungen ist, Sie davon zu überzeugen, wie mächtig die bereits vorhandenen sozialen Angebote sind und wie viel Sinn es machen kann, sie in eigene Anwendungen zu integrieren. Weiters würde ich mich freuen, wenn Sie mich über die Website zum Buch www.socialdevelopment.at, meinen Blog www.mariofraiss.com oder unter der E-Mail-Adresse [email protected] kontaktieren und mich über Ihre sozialen Anwendungsprojekte informieren. Abschließend möchte ich Ihnen den folgenden Ratschlag geben: Geben Sie besonders im Kontext der sozialen Anwendungen darauf Acht, Ihre Idee rechtzeitig zu überprüfen und nicht vor lauter Selbstbegeisterung Angebote zu entwickeln, die die Welt nicht braucht und die niemand nutzen wird, unterschätzen Sie dabei aber nicht die Experimentierfreudigkeit der Gemeinde des Web 2.0. In diesem Sinne wünsche ich Ihnen: Happy Social Development.

Ihr Mario Fraiß www.mariofraiss.com – www.fraiss.IT


231

S

Stichwortverzeichnis A

Anwendungsarchitektur 222 Clientlösung 223 Mobile Clientlösung 223 Server-Client-Lösung 223 Anwendungsregistrierung 18 Anwendungstyp 221

B Basistechnologien 222

E Entwicklerzugang 18

F facebook 23 Access Token 46 Anmeldeseite 37 Anwendung registrieren 26 Anwendungsarten 28 Anwendungsberechtigungen 103 Authentifizierung 31 Basisframework 29 Berechtigungen 81 Data Permissions 83 Datenabfragen 43 Social Development mit .NET

Extended Permissions 82 FQL 63 Graph-API 43 Inhaltsveröffentlichung 81 Integrationsszenarien 130 Messaging-System 115 Page Permissions 84 Projekt-Checkliste 130 Publishing-Automation 111 Publishing Permissions 82 REST-API 96 scope 85 Social Plug-ins 24 Standard Permissions 82 facebook-API 24 flickr 187 API 187 Authentifizierung 190 Bildanzeige 194 Fotosuche 188 Lizenzen 192 Thumbnail 194 FQL 63 Abfrage 64 Antwortstruktur 71 format 65 fql.query 64 locale 65 233

Stichwortverzeichnis page 67 Subquery 77 Framework 222

G Google Data API 199 Graph-API Abfrage 44 HTTP POST 101 publish_stream 101 Query-Path 44 Statusaktualisierung 101

I Infrastruktur 222

J JSON 48 Array 49 Boolesches Ergebnis 49 Eigenschaft 48 Leerzeichen 49 null 49 Objekt 49 Objektdeklaration 48 Regeln 48 Schlüssel 48 Zahl 49 Zeichenkette 49

234

L LinkedIn 133 Anmeldedialog 145 Anwendungsauthentifizierung 139 Anwendungsregistrierung 134 API 146 Authentifizierung 134 Communications API 147 Kontaktliste 148 Network API 147 People API 147 PIN 142 Profilinformationen 148 Ressourcen 134 SDK 133 Serviceanbindung 144

M Messaging-System message 127 Objekte 118 Ordner 122 read_mailbox 115 thread 124

O OAuth 227 Authentifikationsprozess 227 OpenSocial 224 Funktionsweise 226

Stichwortverzeichnis

P

U

Plausibilität 19 Programmierumgebung 222

Übertragungszeit 66

R REST API Aufruf 97 Methoden 96 Statusnachrichten 97

S SELECT 25 Social Apps 16 Social Development 17 Social Networks 14 Social Services 15 Standards 224

T twitter 157 Access Token 168 Anwendungsregistrierung 157, 187 API 163 Authentifizierung 166 Callback 168 Followers 176 Followings 176 PublicTimeline 163 Request Token 168 Statusaktualisierung 174 Tweets laden 163 Social Development mit .NET

W WebBrowser 33 Windows Phone 159 Navigation 162

Y YouTube 199 Abfragen 205 Anwendungsregistrierung 201 API 200 Benutzerprofile 215 Comment 214 Communitybeiträge 211 Kategoriesuche 209 Kommentare 212 MostPopular 206 ProfileEntry 217 SDK 201 Suchanfrage 208 Video-Feeds 202 YouTubeRequest 205 YouTubeRequestSettings 205 YouTubeService 216 YouTube Data API 200

235

Social Development mit .NET

Net Development Security Solutions

ASP NET 3.5 CMS Development

NET Framework Developer's Guide. Effektiv programmieren mit den .NET-Sprachen

XML Web Service-Anwendungen mit Microsoft .NET

XML Web Service-Anwendungen mit Microsoft .NET

XML mit .NET - Programmierung und Basisklassen

Managed C++ and .NET Development: Visual Studio .NET 2003 Edition

Social Policy for Development

Social Security and Development

Social Justice and Development

Social Justice and Development

Webapplication Development mit ColdFusion 4.5

Children's Personal and Social Development (Child Development)

Application Development Using Visual Basic® and .NET

Test-Driven Development in Microsoft .NET

Application Development Using C# and .NET

Microsoft .NET Framework 3.5, ADO.NET Application Development

Net

Personal, Social and Emotional Development

Social Innovation and Territorial Development

Conversational Competence and Social Development

Social Influences on Vocal Development

Financing Social Policy: Mobilizing Resources for Social Development (Social Policy in a Development Context)

Financing Social Policy: Mobilizing Resources for Social Development (Social Policy in a Development Context)

Rapid Web Development mit Ruby on Rails

Windows Presentation Foundation: Grafische Oberflachen entwickeln mit .NET 3.0

XML Web Service-Anwendungen mit Microsoft .NET GERMAN

Social Capital and Economic Development (Fundamentals of Development Economics)

Programmierung mit der .NET-Klassenbibliothek. Zugriff auf das Windows-Betriebssystem mit VB.NET und C# GERMAN

The Development of Shyness and Social Withdrawal (Social, Emotional, and Personality Development in Context)

Social Development mit .NET

Net Development Security Solutions

ASP NET 3.5 CMS Development

NET Framework Developer's Guide. Effektiv programmieren mit den .NET-Sprachen

XML Web Service-Anwendungen mit Microsoft .NET

XML Web Service-Anwendungen mit Microsoft .NET

XML mit .NET - Programmierung und Basisklassen

Managed C++ and .NET Development: Visual Studio .NET 2003 Edition

Social Policy for Development

Social Security and Development

Social Justice and Development

Social Justice and Development

Webapplication Development mit ColdFusion 4.5

Children's Personal and Social Development (Child Development)

Application Development Using Visual Basic® and .NET

Test-Driven Development in Microsoft .NET

Application Development Using C# and .NET

Microsoft .NET Framework 3.5, ADO.NET Application Development

Net

Personal, Social and Emotional Development

Social Innovation and Territorial Development

Conversational Competence and Social Development

Social Influences on Vocal Development

Financing Social Policy: Mobilizing Resources for Social Development (Social Policy in a Development Context)

Financing Social Policy: Mobilizing Resources for Social Development (Social Policy in a Development Context)

Rapid Web Development mit Ruby on Rails

Windows Presentation Foundation: Grafische Oberflachen entwickeln mit .NET 3.0

XML Web Service-Anwendungen mit Microsoft .NET GERMAN

Social Capital and Economic Development (Fundamentals of Development Economics)

Programmierung mit der .NET-Klassenbibliothek. Zugriff auf das Windows-Betriebssystem mit VB.NET und C# GERMAN

The Development of Shyness and Social Withdrawal (Social, Emotional, and Personality Development in Context)

Recommend Documents