Interfejs Blogger Data API umożliwia aplikacjom klienckim wyświetlanie i aktualizowanie treści Bloggera w postaci plików danych Google Data API.
Za pomocą interfejsu Blogger Data API aplikacja klienta może tworzyć nowe posty na blogu, edytować i usuwać istniejące posty oraz wysyłać zapytania o posty spełniające określone kryteria.
Oprócz informacji o możliwościach interfejsu Blogger Data API dokument zawiera przykłady podstawowych interakcji z interfejsem Data API przy użyciu biblioteki klienta Pythona. Jeśli chcesz dowiedzieć się więcej o podstawowym protokole używanym przez bibliotekę, zapoznaj się z sekcją dotyczącą protokołu w tym przewodniku dla deweloperów.
Spis treści
Odbiorcy
Ten dokument jest przeznaczony dla programistów, którzy chcą pisać aplikacje klienta w Pythonie, które mogą wchodzić w interakcje z Bloggerem.
W tym dokumencie zakładamy, że rozumiesz ogólne założenia protokołu interfejsów Google Data API.
Ogólne informacje na temat interfejsu Blogger Data API znajdziesz w przewodniku po protokole.
Pierwsze kroki
Więcej informacji o konfigurowaniu biblioteki klienta znajdziesz w przewodniku Pierwsze kroki.
Biblioteka klienta Python wymaga wersji Python 2.2 lub nowszej. Po pobraniu biblioteki klienta musisz też pobrać i zainstalować pakiet ElementTree.
Tworzenie konta w Bloggerze
Możesz założyć konto Blogger na potrzeby testowania. Blogger korzysta z kont Google, więc jeśli masz już konto Google, nie musisz nic więcej robić.
Uruchamianie przykładowego kodu
Pełny działający przykładowy klient zawierający cały przykładowy kod pokazany w tym dokumencie jest dostępny w pliku BloggerExample.py
w katalogu gdata-python-client/samples/blogger/
.
Przykładowy klient wykonuje kilka operacji na podanym blogu, aby zademonstrować korzystanie z interfejsu Blogger Data API.
Przykład możesz uruchomić z tymi argumentami:
python BloggerExample.py --email [email_address] --password [password]
Aby użyć przykładów z tego dokumentu w swoim kodzie, musisz umieścić w nim te instrukcje: import
from gdata import service import gdata import atom
Uwierzytelnianie w usłudze Blogger
Za pomocą interfejsu Blogger Data API możesz uzyskać dostęp do plików danych publicznych i prywatnych. Publiczne kanały nie wymagają uwierzytelniania, ale są tylko do odczytu. Jeśli chcesz zmodyfikować blogi, Twój klient musi się uwierzytelnić, zanim poprosi o pliki danych prywatnych. Może się uwierzytelnić za pomocą dowolnego z 3 podejść:uwierzytelniania OAuth, uwierzytelniania serwera proxy AuthSub lub uwierzytelniania za pomocą nazwy użytkownika i hasła ClientLogin.
Więcej informacji o uwierzytelnianiu za pomocą interfejsów Google Data API znajdziesz w dokumentacji dotyczącej uwierzytelniania.
Większość przykładów w kolejnych sekcjach tego dokumentu zakłada, że masz uwierzytelniony GDataService
.
uwierzytelnianie OAuth,
Dokumentację dotyczącą uwierzytelniania OAuth za pomocą biblioteki GData w Pythonie znajdziesz w sekcji OAuth w bibliotekach klienta interfejsu Google Data Protocol.
Uwierzytelnianie proxy AuthSub
Uwierzytelnianie proxy AuthSub jest używane przez aplikacje internetowe, które muszą uwierzytelniać użytkowników na kontach Google. Operator witryny i kod klienta nie mają dostępu do nazwy użytkownika ani hasła użytkownika Bloggera. Zamiast tego klient uzyskuje specjalne tokeny AuthSub, które umożliwiają mu działanie w imieniu konkretnego użytkownika. Więcej szczegółowych informacji znajdziesz w dokumentacji AuthSub.
Gdy użytkownik po raz pierwszy odwiedza Twoją aplikację, nie został jeszcze uwierzytelniony. W takim przypadku musisz wyświetlić pewne informacje i link, który przekieruje użytkownika na stronę Google, gdzie będzie mógł uwierzytelnić Twoje żądanie dostępu do blogów. Biblioteka klienta Pythona udostępnia funkcję generowania adresu URL strony Google. Poniższy kod pobiera adres URL strony AuthSubRequest:
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
Metoda GenerateAuthSubURL
przyjmuje te parametry (odpowiadające parametrom zapytania używanym przez moduł obsługi AuthSubRequest):
- dalej
- Adres URL strony, na którą Google powinno przekierować użytkownika po uwierzytelnieniu.
- zakres
- Wskazuje, że aplikacja prosi o token dostępu do kanałów Bloggera. Użyj ciągu zakresu
http://www.blogger.com/feeds/
(oczywiście zakodowanego w formacie URL). - Bezpieczny
- Wskazuje, czy klient prosi o token zabezpieczony.
- sesja
- Wskazuje, czy zwrócony token można zamienić na token wielokrotnego użytku (sesji).
Powyższy przykład pokazuje wywołanie, które nie wymaga bezpiecznego tokena (wartość secure
to False
). Wygenerowany adres URL żądania może wyglądać tak:
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
Użytkownik klika link do witryny Google i uwierzytelnia się na swoim koncie Google.
Po uwierzytelnieniu użytkownika system AuthSub przekieruje go na adres URL określony w parametrze zapytania next
adresu URL AuthSubRequest. System AuthSub dołącza do tego adresu URL token uwierzytelniający jako wartość parametru zapytania token
. Na przykład:
http://www.example.com/welcome.pyc?token=yourAuthToken
Wartość tokena można pobrać z adresu URL na kilka sposobów, np.:
import cgi parameters = cgi.FieldStorage() authsub_token = parameters['token']
Ta wartość tokena reprezentuje token AuthSub jednorazowego użytku. W tym przykładzie, ponieważ podano wartość session = True
, token ten można zamienić na token sesji AuthSub za pomocą metody UpgradeToSessionToken
, która wywołuje usługę AuthSubSessionToken
:
blogger_service = service.GDataService() blogger_service.auth_token = authsub_token blogger_service.UpgradeToSessionToken()
Oznacza to, że przekazujesz token jednorazowego użytku do metody UpgradeToSessionToken
, a interfejs AuthSub zwraca token sesji.
Twoja aplikacja może następnie używać wartości tokena sesji w kolejnych interakcjach z Bloggerem. Biblioteka klienta automatycznie wysyła token wraz z żądaniami.
uwierzytelnianie za pomocą nazwy użytkownika i hasła ClientLogin
Użyj uwierzytelniania ClientLogin, jeśli Twój klient jest samodzielnym, jednoużytkownikowym klientem „zainstalowanym” (np. aplikacją na komputer). Wystarczy wywołać metodę ProgrammaticLogin()
w instancji GDataService
, a wszystkie kolejne interakcje z Bloggerem będą uwierzytelniane:
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()
W powyższym fragmencie kodu ustawiamy 3 właściwości instancji GDataService
. Pierwsza to nazwa naszej aplikacji w formie companyName-applicationName-versionID. Druga to nazwa usługi, z którą chcemy nawiązać interakcję. Trzecia to adres serwera.
Zwróć uwagę, że wartość account_type
jest jawnie ustawiona na GOOGLE
. Jeśli nie skonfigurujesz tego parametru, użytkownicy G Suite nie będą mogli korzystać z interfejsu Blogger API.
Więcej informacji o uwierzytelnianiu za pomocą ClientLogin, w tym przykładowe żądania i odpowiedzi, znajdziesz w dokumentacji Uwierzytelnianie w zainstalowanych aplikacjach.
Uwaga: używaj tego samego tokena do wszystkich żądań w danej sesji. Nie pobieraj nowego tokena dla każdego żądania Bloggera.
Uwaga: jak opisano w dokumentacji ClientLogin, żądanie uwierzytelnienia może zakończyć się niepowodzeniem i wymagać rozwiązania captcha. Jeśli chcesz, aby Google wyświetlał i obsługiwał test CAPTCHA, prześlij użytkownika do https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger
(zamiast do adresu URL obsługiwanego przez CAPTCHA podanego w dokumentacji ClientLogin).
Pobieranie listy blogów
Interfejs Blogger Data API udostępnia plik danych, który zawiera listę blogów danego użytkownika. Taki plik danych jest nazywany „metaplikiem danych”.
Poniższy przykładowy kod używa uwierzytelnionego wystąpienia GDataService
do pobierania metadanych, a następnie drukuje tytuł każdego bloga.
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
Zapisz adres URL używany przez metodę Get
. To domyślny URL metafeedu; zwraca listę blogów dla aktualnie uwierzytelnionego użytkownika.
Aby uzyskać dostęp do pliku danych innego użytkownika, możesz podać jego identyfikator zamiast znaku default
w adresie URL metapliku danych. Identyfikator użytkownika to ciąg cyfr na końcu adresu URL profilu użytkownika.
Fragment kodu poniżej pokazuje, jak wyodrębnić identyfikator bloga z kanału. Aby tworzyć, aktualizować i usuwać posty i komentarze, musisz podać identyfikator bloga. Fragment kodu poniżej wybiera pierwszy blog wyodrębniony dla danego użytkownika.
blog_id = feed.entry[0].GetSelfLink().href.split("/")[-1]
W przykładzie BloggerExample.py
tworzona jest klasa BloggerExample
, a identyfikator bloga jest ustawiany w konstruktorze, aby można było łatwo uzyskać do niego dostęp. W większości przykładów w tym dokumencie zmienna blog_id
jest przekazywana jako zmienna.
Tworzenie postów
Interfejs Blogger Data API umożliwia tworzenie i publikowanie nowych wpisów na blogu, a także tworzenie ich wersji roboczych.
Uwaga: nie można obecnie ustawić niestandardowego autora postów. Wszystkie nowe posty będą wyglądać tak, jakby zostały utworzone przez aktualnie uwierzytelnionego użytkownika.
Publikowanie posta na blogu
Możesz użyć biblioteki klienta Python, aby publikować nowe wpisy na blogu.
Najpierw utwórz instancję GDataEntry
, która będzie reprezentować post na blogu.
Następnie możesz ustawić tytuł, treść i inne atrybuty posta na blogu.
Na koniec użyj instancji GDataService
, aby wstawić post. Oto przykład, jak opublikować nowy post na blogu:
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!')
Tworzenie wersji roboczej posta na blogu
Posty w wersji roboczej są tworzone w taki sam sposób jak posty publiczne, ale musisz ustawić element rozszerzenia draft
w instancji GDataEntry
. Powyższy post na blogu można utworzyć jako wersję roboczą, dodając wyróżnione wiersze:
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?')
Aby przekształcić istniejący szkic posta na blogu w opublikowany post, pobierz szkic posta, ustaw atrybut szkicu na no
, a następnie zaktualizuj post. W następnych 2 sekcjach omówimy pobieranie i aktualizowanie postów.
Pobieranie postów
W sekcjach poniżej znajdziesz instrukcje pobierania listy wpisów na blogu z parametrami zapytania i bez nich.
Możesz wysyłać zapytania do publicznego kanału Bloggera bez uwierzytelniania. Dlatego przed pobraniem postów z publicznego bloga nie musisz ustawiać danych logowania ani przeprowadzać uwierzytelniania AuthSub.
Pobieranie wszystkich wpisów na blogu
Aby pobrać posty użytkownika, wywołaj metodę GetFeed
, podając adres URL kanału postów na blogu:
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
Pobieranie postów za pomocą parametrów zapytania
Interfejs Blogger Data API umożliwia żądanie zestawu wpisów, które odpowiadają określonym kryteriam, np. żądanie postów na blogu opublikowanych lub zaktualizowanych w określonym przedziale czasowym. Aby to zrobić, utwórz instancję Query
, a następnie wywołaj metodę Get()
.
Aby na przykład wysłać zapytanie dotyczące zakresu dat, ustaw właściwości published_min
i published_min
instancji Query
.
Ten fragment kodu wyświetla tytuł i treść każdego wpisu na blogu opublikowanego w okresie między podanym czasem początkowym a końcowym:
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
Zwróć uwagę, że obiekt Query
jest tworzony przy użyciu tego samego adresu URL kanału postów, który służy do pobierania postów.
Interfejs Blogger Data API obsługuje te właściwości Query
:
- kategorie
- Określa kategorie (zwane też etykietami) służące do filtrowania wyników w pliku danych. Na przykład
http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie
zwraca wpisy z etykietamiFritz
iLaurie
. Aby określić to zapytanie o kategorię w bibliotece klienta Pythona, możesz użyć funkcjiquery.categories = ['Fritz','Laurie',]
.
- max_results
- Maksymalna liczba wpisów do zwrócenia.
- published_min, published_max
- Granice dat publikacji wpisów.
- start_index
- Indeks pierwszego wyniku, który ma zostać pobrany (dla pobierania stron).
- updated_min, updated_max
- Granice dat aktualizacji wpisów. Te parametry zapytania są ignorowane, chyba że parametr
orderby
ma wartośćupdated
.
Więcej informacji o parametrach zapytań znajdziesz w przewodniku po interfejsie Blogger Data API oraz w przewodniku po interfejsach Google Data API.
Aktualizowanie postów
Aby zaktualizować istniejący post na blogu, najpierw pobierasz wpis, który chcesz zaktualizować, a potem go modyfikujesz i wysyłasz do Bloggera za pomocą metody Put
. Poniższy fragment kodu zmienia tytuł wpisu na blogu, zakładając, że został on już pobrany z serwera.
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)
Powyższy kod zwraca GDataEntry
zawierający cały nowo zaktualizowany post. Aby zaktualizować inne właściwości, ustaw je w instancji GDataEntry
przed wywołaniem Put
.
Uwaga: modyfikowanie danych autora powiązanych z postami nie jest obecnie obsługiwane.
Usuwanie postów
Aby usunąć post, prześlij adres URL edycji posta do metody Delete
obiektu GDataService
w ten sposób:
def DeletePost(blogger_service, edit_link_href): blogger_service.Delete(edit_link_href)
Komentarze
Interfejs Blogger Data API umożliwia tworzenie, pobieranie i usuwanie komentarzy. Aktualizowanie komentarzy nie jest obsługiwane (nie jest też dostępne w interfejsie internetowym).
Tworzenie komentarzy
Aby opublikować komentarz, utwórz obiekt GDataEntry
i wstaw go w ten sposób:
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)
Uwaga: obecnie możesz dodawać komentarze tylko do bloga należącego do uwierzytelnionego użytkownika.
Uwaga: nie można obecnie ustawić niestandardowego autora komentarzy. Wszystkie nowe komentarze będą wyglądać tak, jakby zostały utworzone przez aktualnie uwierzytelnionego użytkownika.
Pobieranie komentarzy
Komentarze do konkretnego posta możesz pobrać z adresu URL kanału komentarzy do tego posta:
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
Możesz też pobrać komentarze do wszystkich postów, korzystając z adresu URL kanału komentarzy bloga:
http://www.blogger.com/feeds/blogID/comments/default
Usuwanie komentarzy
Aby usunąć komentarz, prześlij adres URL edycji komentarza do metody Delete
obiektu GDataService
w ten sposób:
def DeleteComment(blogger_service, post_id, comment_id): feed_url = '/feeds/' + post_id + '/comments/default/' + comment_id blogger_service.Delete(feed_url)