Mit der Blogger Data API können Clientanwendungen Blogger-Inhalte in Form von Google Data API-Feeds abrufen und aktualisieren.
Ihre Clientanwendung kann die Blogger Data API verwenden, um neue Blogposts zu erstellen, vorhandene Blogposts zu bearbeiten oder zu löschen und nach Blogposts zu suchen, die bestimmten Kriterien entsprechen.
Neben Informationen zu den Möglichkeiten der Blogger Data API enthält dieses Dokument auch Beispiele für grundlegende Data API-Interaktionen mit der Python-Clientbibliothek. Weitere Informationen zum zugrunde liegenden Protokoll, das in der Bibliothek verwendet wird, finden Sie im Abschnitt zum Protokoll in diesem Entwicklerleitfaden.
Inhalt
Zielgruppe
Dieses Dokument richtet sich an Programmierer, die Python-Clientanwendungen schreiben möchten, die mit Blogger interagieren können.
In diesem Dokument wird davon ausgegangen, dass Sie mit den allgemeinen Ideen hinter dem Google Data APIs-Protokoll vertraut sind.
Allgemeine Informationen zur Blogger Data API finden Sie im Referenzhandbuch zum Protokoll.
Erste Schritte
Hilfe zum Einrichten der Clientbibliothek finden Sie im Startleitfaden.
Für die Python-Clientbibliothek ist Python 2.2 oder höher erforderlich. Nachdem du die Clientbibliothek heruntergeladen hast, musst du auch das Paket ElementTree herunterladen und installieren.
Blogger-Konto erstellen
Du kannst dich auch für ein Blogger-Konto registrieren. Blogger verwendet Google-Konten. Wenn Sie also bereits ein Google-Konto haben, müssen Sie nichts weiter tun.
Beispielcode ausführen
Ein voll funktionsfähiger Beispielclient, der den gesamten in diesem Dokument gezeigten Beispielcode enthält, ist in der Datei BloggerExample.py
im Verzeichnis gdata-python-client/samples/blogger/
verfügbar.
Der Beispielclient führt im angegebenen Blog mehrere Vorgänge aus, um die Verwendung der Blogger Data API zu demonstrieren.
Sie können das Beispiel mit den folgenden Argumenten ausführen:
python BloggerExample.py --email [email_address] --password [password]
Wenn Sie die Beispiele in diesem Dokument in Ihrem eigenen Code verwenden möchten, benötigen Sie die folgenden import
-Anweisungen:
from gdata import service import gdata import atom
Authentifizierung beim Blogger-Dienst
Mit der Blogger Data API können Sie sowohl auf öffentliche als auch auf private Feeds zugreifen. Für öffentliche Feeds ist keine Authentifizierung erforderlich, sie sind aber schreibgeschützt. Wenn du Blogs ändern möchtest, muss sich dein Client authentifizieren, bevor du private Feeds anfordern kannst. Für die Authentifizierung gibt es drei Möglichkeiten: die OAuth-Authentifizierung, die AuthSub-Proxyauthentifizierung oder die ClientLogin-Authentifizierung für Nutzernamen und Passwörter.
Weitere Informationen zur Authentifizierung mit Google Data APIs im Allgemeinen finden Sie in der Authentifizierungsdokumentation.
Bei den meisten Beispielen in den nachfolgenden Abschnitten dieses Dokuments wird davon ausgegangen, dass Sie eine authentifizierte GDataService
-Instanz haben.
OAuth-Authentifizierung
Informationen zur OAuth-Authentifizierung mit der Python GData-Bibliothek finden Sie unter OAuth in den Google Data Protocol-Clientbibliotheken.
AuthSub-Proxy-Authentifizierung
Die AuthSub-Proxy-Authentifizierung wird von Webanwendungen verwendet, die ihre Nutzer bei Google-Konten authentifizieren müssen. Der Websitebetreiber und der Clientcode haben keinen Zugriff auf den Nutzernamen und das Passwort für den Blogger-Nutzer. Stattdessen erhält der Client spezielle AuthSub-Tokens, die es dem Client ermöglichen, im Namen eines bestimmten Nutzers zu handeln. Weitere Informationen finden Sie in der AuthSub-Dokumentation.
Wenn ein Nutzer Ihre Anwendung zum ersten Mal aufruft, wurde er noch nicht authentifiziert. In diesem Fall musst du einige Informationen und einen Link anzeigen, der den Nutzer zu einer Google-Seite weiterleitet, damit deine Zugriffsanfrage für seine Blogs authentifiziert werden kann. Die Python-Clientbibliothek bietet eine Funktion zum Generieren der Google-Seite. Mit dem folgenden Code wird die URL der AuthSubRequest-Seite abgerufen:
def GetAuthSubUrl(): next = 'http://www.example.com/welcome.pyc' scope = 'http://www.blogger.com/feeds/' secure = False session = True blogger_service = service.GDataService() return blogger_service.GenerateAuthSubURL(next, scope, secure, session); authSubUrl = GetAuthSubUrl(); print '<a href="%s">Login to your Google account</a>' % authSubUrl
Die Methode GenerateAuthSubURL
verwendet die folgenden Parameter (entsprechend den Abfrageparametern, die vom AuthSubRequest-Handler verwendet werden):
- Weiter
- Die URL der Seite, auf die Google den Nutzer nach der Authentifizierung weiterleiten soll.
- Bereich
- Gibt an, dass die Anwendung ein Token für den Zugriff auf Blogger-Feeds anfordert. Der zu verwendende Bereichsstring ist
http://www.blogger.com/feeds/
(natürlich URL-codiert). - geschützt?
- Gibt an, ob der Client ein sicheres Token anfordert.
- session
- Gibt an, ob das zurückgegebene Token gegen ein Mehrzwecktoken (Sitzungsversion) eingetauscht werden kann.
Das obige Beispiel zeigt einen Aufruf, der kein sicheres Token anfordert (der Wert von secure
ist False
). Die resultierende Anfrage-URL könnte so aussehen:
https://www.google.com/accounts/AuthSubRequest?scope=http%3A%2F%2Fwww.blogger.com%2Ffeeds%2F&session=1&secure=0&next=http%3A%2F%2Fwww.example.com%2Fwelcome.pyc
Der Nutzer folgt dem Link zur Google-Website und authentifiziert sich für sein Google-Konto.
Nach der Authentifizierung des Nutzers werden sie vom AuthSub-System an die URL weitergeleitet, die Sie im Abfrageparameter next
der AuthSubRequest-URL angegeben haben. Das AuthSub-System hängt als Wert des Abfrageparameters token
ein Authentifizierungstoken an diese URL an. Beispiel:
http://www.example.com/welcome.pyc?token=yourAuthToken
Es gibt mehrere Möglichkeiten, den Tokenwert von der URL abzurufen. Beispiel:
import cgi parameters = cgi.FieldStorage() authsub_token = parameters['token']
Dieser Tokenwert stellt ein Einweg-Token für die einmalige Verwendung dar. Da in diesem Beispiel session = True
angegeben wurde, kann dieses Token mit der Methode UpgradeToSessionToken
, die den Dienst AuthSubSessionToken
aufruft, gegen ein AuthSub-Sitzungstoken eingetauscht werden:
blogger_service = service.GDataService() blogger_service.auth_token = authsub_token blogger_service.UpgradeToSessionToken()
Das heißt, Sie übergeben Ihr einmaliges Token an die Methode UpgradeToSessionToken
und die AuthSub-Schnittstelle gibt ein Sitzungstoken zurück.
Ihre Anwendung kann dann den Wert des Sitzungstokens bei nachfolgenden Interaktionen mit Blogger verwenden. Die Clientbibliothek sendet das Token automatisch zusammen mit Anfragen.
Authentifizierung mit Nutzername/Passwort für ClientLogin
Verwenden Sie die ClientLogin-Authentifizierung, wenn Ihr Client ein eigenständiger, einzelner Nutzerclient ist, z. B. eine Desktopanwendung. Rufen Sie einfach die Methode ProgrammaticLogin()
auf Ihrer GDataService
-Instanz auf. Alle nachfolgenden Interaktionen mit Blogger werden authentifiziert:
blogger_service = service.GDataService('user@example.com', 'secretPassword') blogger_service.source = 'exampleCo-exampleApp-1.0' blogger_service.service = 'blogger' blogger_service.account_type = 'GOOGLE' blogger_service.server = 'www.blogger.com' blogger_service.ProgrammaticLogin()
Im Snippet oben haben wir drei Attribute für die Instanz GDataService
festgelegt. Der erste ist der Name unserer Anwendung im Format companyName-applicationName-versionID. Der zweite ist der Name des Dienstes, mit dem wir interagieren möchten. Der dritte ist die Adresse des Servers.
Beachten Sie, dass account_type
explizit auf GOOGLE
gesetzt ist. Wenn Sie diesen Parameter nicht festlegen, können G Suite-Nutzer die Blogger API nicht verwenden.
Weitere Informationen zur ClientLogin-Authentifizierung, einschließlich Beispielanfragen und -antworten, finden Sie in der Dokumentation Authentifizierung für installierte Anwendungen.
Hinweis: Verwenden Sie für alle Anfragen in einer bestimmten Sitzung dasselbe Token. Erhalten Sie nicht für jede Blogger-Anfrage ein neues Token.
Hinweis: Wie in der ClientLogin-Dokumentation beschrieben, schlägt die Authentifizierungsanfrage möglicherweise fehl und fordert ein CAPTCHA an. Wenn Google die CAPTCHA-Abfrage ausstellen und verarbeiten soll, leite den Nutzer an https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger
weiter anstatt zur in der ClientLogin-Dokumentation angegebenen CAPTCHA-Verarbeitungs-URL.
Liste von Blogs abrufen
Die Blogger Data API bietet einen Feed, in dem die Blogs eines bestimmten Nutzers aufgelistet werden. Dieser Feed wird als Metametafeed bezeichnet.
Im folgenden Beispielcode wird eine authentifizierte GDataService
-Instanz verwendet, um den Metafeed abzurufen. Anschließend wird der Titel jedes Blogs ausgegeben.
def PrintUserBlogTitles(blogger_service): query = service.Query() query.feed = '/feeds/default/blogs' feed = blogger_service.Get(query.ToUri()) print feed.title.text for entry in feed.entry: print "\t" + entry.title.text
Notieren Sie sich die von der Methode Get
verwendete URL. Dies ist die Standard-Metafeed-URL. Sie gibt eine Liste von Blogs für den aktuell authentifizierten Nutzer zurück.
Um auf einen Feed für einen anderen Nutzer zuzugreifen, können Sie die ID des Nutzers anstelle von default
in der Meta-Feed-URL angeben. Die ID des Nutzers ist die Ziffernfolge am Ende der Profil-URL des Nutzers.
Das folgende Code-Snippet zeigt, wie eine Blog-ID aus dem Feed extrahiert wird. Zum Erstellen, Aktualisieren und Löschen von Beiträgen und Kommentaren benötigen Sie die Blog-ID. Mit dem folgenden Snippet wird der erste für einen Nutzer abgerufene Blog ausgewählt.
blog_id = feed.entry[0].GetSelfLink().href.split("/")[-1]
Im Beispiel BloggerExample.py
wird die Klasse BloggerExample
erstellt und die Blog-ID wird im Konstruktor für den einfachen Zugriff später festgelegt. Für die meisten der folgenden Beispiele in diesem Dokument wird blog_id
als Variable übergeben.
Beiträge erstellen
Mit der Blogger Data API können Sie sowohl neue Blogeinträge als auch Entwürfe erstellen und veröffentlichen.
Hinweis: Das Festlegen eines benutzerdefinierten Autors für Beiträge wird derzeit nicht unterstützt. Alle neuen Beiträge sehen so aus, als wären sie vom derzeit authentifizierten Nutzer erstellt worden.
Blogpost veröffentlichen
Sie können die Python-Clientbibliothek verwenden, um neue Blogeinträge zu veröffentlichen.
Erstellen Sie zuerst eine GDataEntry
-Instanz für den Blogpost.
Anschließend können Sie den Titel, den Inhalt und andere Attribute des Blogposts festlegen.
Verwenden Sie schließlich die Instanz GDataService
, um den Beitrag einzufügen. Hier ein Beispiel für die Veröffentlichung eines neuen Blogposts:
def CreatePublicPost(blogger_service, blog_id, title, content): entry = gdata.GDataEntry() entry.title = atom.Title('xhtml', title) entry.content = atom.Content(content_type='html', text=content) return blogger_service.Post(entry, '/feeds/%s/posts/default' % blog_id) blogEntry = CreatePublicPost(blogger_service, blog_id, title='I have the answer', content='Eureka! It is 42!')
Blogpostentwurf erstellen
Entwürfe werden auf die gleiche Weise wie öffentliche Beiträge erstellt. Sie müssen jedoch das Erweiterungselement draft
in der Instanz GDataEntry
festlegen. Der obige Blogpost könnte durch Hinzufügen der hervorgehobenen Zeilen als Entwurf erstellt werden:
def CreateDraftPost(blogger_service, blog_id, title, content): entry = gdata.GDataEntry() entry.title = atom.Title('xhtml', title) entry.content = atom.Content(content_type='html', text=content) control = atom.Control() control.draft = atom.Draft(text='yes') entry.control = control return blogger_service.Post(entry, '/feeds/%s/posts/default' % blog_id) draftEntry = CreateDraftPost(blogger_service, blog_id, title='I have the question', content='What do you get if you multiply six by nine?')
Du kannst einen vorhandenen Blogpost in einen veröffentlichten Beitrag umwandeln. Rufe dazu den Entwurfsbeitrag ab, setze das Entwurfsattribut auf no
und aktualisiere dann den Beitrag. In den nächsten beiden Abschnitten geht es um das Abrufen und Aktualisieren von Beiträgen.
Beiträge werden abgerufen
In den folgenden Abschnitten wird beschrieben, wie Sie eine Liste von Blogposts mit und ohne Suchparameter abrufen.
Sie können einen öffentlichen Blogger-Feed ohne Authentifizierung abfragen. Sie müssen daher vor dem Abrufen von Beiträgen aus einem öffentlichen Blog keine Anmeldedaten festlegen oder eine AuthSub-Authentifizierung durchführen.
Alle Blogposts werden abgerufen
Um die Beiträge des Nutzers abzurufen, rufen Sie die Methode GetFeed
mit der Blogpost-Feed-URL auf:
def PrintAllPosts(blogger_service, blog_id): feed = blogger_service.GetFeed('/feeds/' + blog_id + '/posts/default') print feed.title.text for entry in feed.entry: print "\t" + entry.title.text print "\t" + entry.content.text print "\t" + entry.updated.text print
Beiträge mit Suchparametern abrufen
Mit der Blogger Data API können Sie eine Reihe von Einträgen anfordern, die bestimmten Kriterien entsprechen, z. B. das Anfordern von Blogposts, die in einem bestimmten Zeitraum veröffentlicht oder aktualisiert wurden. Dazu erstellen Sie eine Query
-Instanz und rufen dann die Methode Get()
auf.
Wenn Sie beispielsweise eine Zeitraumabfrage senden möchten, legen Sie die Attribute published_min
und published_min
der Instanz Query
fest.
Das folgende Code-Snippet gibt den Titel und Inhalt jedes Blogposts aus, der zwischen dem angegebenen Start- und Enddatum veröffentlicht wurde:
def PrintPostsInDateRange(blogger_service, blog_id, start_time='2007-04-01', end_time='2007-04-25'): query = service.Query() query.feed = '/feeds/' + blog_id + '/posts/default' query.published_min = start_time query.published_max = end_time feed = blogger_service.Get(query.ToUri()) print feed.title.text + " posts between " + start_time + " and " + end_time for entry in feed.entry: print "\t" + entry.title.text print "\t" + entry.content.text print "\t" + entry.updated.text print
Das Objekt Query
wird mit derselben Postfeed-URL erstellt, die zum Abrufen von Beiträgen verwendet wurde.
Die Blogger Data API unterstützt die folgenden Query
-Properties:
- Kategorien
- Gibt Kategorien an (auch Labels genannt), um die Feedergebnisse zu filtern.
http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie
gibt beispielsweise Einträge mit den LabelsFritz
undLaurie
zurück. Wenn Sie diese Kategorieabfrage in der Python-Clientbibliothek angeben möchten, können Siequery.categories = ['Fritz','Laurie',]
verwenden - max_results
- Die maximale Anzahl der Einträge, die zurückgegeben werden sollen.
- Veröffentlicht_min, veröffentlicht_max
- Die Grenzen des Veröffentlichungsdatums des Eintrags.
- start_index
- Der 1-basierte Index des ersten abzurufenden Ergebnisses (für die Seitenordnung).
- aktualisiert_min, aktualisiert_max
- Die Grenzen für die Datumsaktualisierung. Diese Suchparameter werden ignoriert, sofern der Parameter
orderby
nicht aufupdated
gesetzt ist.
Weitere Informationen zu Suchparametern findest du im Referenzleitfaden für die Blogger Data API und im Referenzhandbuch für Google Data APIs.
Beiträge werden aktualisiert
Zum Aktualisieren eines vorhandenen Blogposts rufen Sie zuerst den Eintrag ab, den Sie aktualisieren möchten. Dann ändern Sie ihn und senden ihn dann mithilfe der Methode Put
an Blogger. Das folgende Code-Snippet ändert den Titel eines Blogeintrags unter der Annahme, dass du den Eintrag bereits vom Server abgerufen hast.
def UpdatePostTitle(blogger_service, entry_to_update, new_title='The REAL answer'): entry_to_update.title = atom.Title('xhtml', new_title) return blogger_service.Put(entry_to_update, entry_to_update.GetEditLink().href)
Der obige Code gibt ein GDataEntry
zurück, das den gesamten aktualisierten Beitrag enthält. Wenn Sie andere Attribute aktualisieren möchten, legen Sie diese einfach in der Instanz GDataEntry
fest, bevor Sie Put
aufrufen.
Hinweis: Das Ändern von mit Beiträgen verknüpften Autorendaten wird derzeit nicht unterstützt.
Beiträge löschen
Wenn Sie einen Beitrag löschen möchten, übergeben Sie die Bearbeitungs-URL des Beitrags an die Methode Delete
Ihres GDataService
-Objekts. Das sieht dann so aus:
def DeletePost(blogger_service, edit_link_href): blogger_service.Delete(edit_link_href)
Kommentare
Mit der Blogger Data API können Sie Kommentare erstellen, abrufen und löschen. Das Aktualisieren von Kommentaren wird weder unterstützt noch in der Weboberfläche verfügbar.
Kommentare erstellen
Wenn Sie einen Kommentar posten möchten, erstellen Sie ein GDataEntry
-Objekt und fügen Sie es so ein:
def CreateComment(blogger_service, blog_id, post_id, comment_text='Mostly harmless'): feed_uri = '/feeds/' + blog_id + '/' + post_id + '/comments/default' entry = gdata.GDataEntry() entry.content = atom.Content(content_type='xhtml', text=comment_text) return blogger_service.Post(entry, feed_uri)
Hinweis: Derzeit können Sie in einem Blog nur Kommentare veröffentlichen, deren Inhaber der authentifizierte Nutzer ist.
Hinweis: Das Festlegen eines benutzerdefinierten Autors für Kommentare wird derzeit nicht unterstützt. Alle neuen Kommentare werden so angezeigt, als wären sie vom derzeit authentifizierten Nutzer erstellt worden.
Kommentare werden abgerufen
So kannst du die Kommentare für einen bestimmten Beitrag über die Feed-URL des Beitrags abrufen:
def PrintAllComments(blogger_service, blog_id, post_id): feed_url = '/feeds/' + blog_id + '/' + post_id + '/comments/default' feed = blogger_service.Get(feed_url) print feed.title.text for entry in feed.entry: print "\t" + entry.title.text print "\t" + entry.updated.text print
Du kannst auch die Kommentare zu allen Beiträgen über die Kommentar-Feed-URL des Blogs abrufen:
http://www.blogger.com/feeds/blogID/comments/default
Kommentare löschen
Übergib den Bearbeitungs-URL des Kommentars an die Methode Delete
deines GDataService
-Objekts, um einen Kommentar zu löschen:
def DeleteComment(blogger_service, post_id, comment_id): feed_url = '/feeds/' + post_id + '/comments/default/' + comment_id blogger_service.Delete(feed_url)