Interfejs API danych Bloggera umożliwia aplikacjom klienckim wyświetlanie i aktualizowanie treści z Bloggera w postaci kanałów interfejsu API danych Google.
Aplikacja kliencka może używać interfejsu Blogger Data API do tworzenia nowych postów na blogu, edytowania i usuwania dotychczasowych postów oraz wysyłania zapytań dotyczących postów na blogu odpowiadających konkretnym kryteriom.
Znajdziesz w nim nie tylko informacje o możliwościach interfejsu API danych Bloggera, ale także przykłady podstawowych interakcji z interfejsem Data API za pomocą biblioteki klienta w języku Python. Jeśli chcesz dowiedzieć się więcej o podstawowym protokole, z którego korzysta biblioteka, zapoznaj się z sekcją Protokoł w tym przewodniku.
Spis treści
Odbiorców
Ten dokument jest przeznaczony dla programistów, którzy chcą tworzyć aplikacje klienckie Pythona, które mogą współpracować z Bloggerem.
W tym dokumencie zakładamy, że rozumiesz ogólne pomysły związane z protokołem interfejsów API danych Google.
Ogólne informacje o interfejsie API danych Bloggera znajdziesz w przewodniku po protokołach.
Pierwsze kroki
Aby uzyskać pomoc w konfigurowaniu biblioteki klienta, przeczytaj Przewodnik dla początkujących.
Biblioteka klienta Pythona wymaga Pythona w wersji 2.2 lub nowszej. Po pobraniu biblioteki klienta musisz też pobrać i zainstalować pakiet ElementTree.
Tworzenie konta w Bloggerze
Jeśli chcesz, możesz założyć konto w Bloggerze na potrzeby testów. Blogger korzysta z kont Google, więc jeśli masz już konto Google, masz wszystko gotowe.
Uruchamianie przykładowego kodu
W pełni działający przykładowy klient, który zawiera cały przykładowy kod widoczny w tym dokumencie, jest dostępny w pliku BloggerExample.py w katalogu gdata-python-client/samples/blogger/.
Przykładowy klient wykonuje kilka operacji na blogu, aby pokazać, jak można korzystać z interfejsu Blogger Data API.
Możesz go uruchomić z tymi argumentami:
python BloggerExample.py --email [email_address] --password [password]
Aby wykorzystać przykłady z tego dokumentu w swoim kodzie, potrzebujesz tych instrukcji import:
from gdata import service import gdata import atom
Uwierzytelnianie w usłudze Blogger
Za pomocą interfejsu Blogger Data API masz dostęp do kanałów publicznych i prywatnych. Publiczne kanały nie wymagają uwierzytelniania, ale są tylko do odczytu. Jeśli chcesz zmodyfikować blogi, klient musi uwierzytelnić się przed wysłaniem żądania prywatnych kanałów. Może uwierzytelniać się przy użyciu dowolnej z tych 3 metod:uwierzytelnianie OAuth, uwierzytelnianie serwera proxy AuthSub lub uwierzytelnianie użytkownika/hasła ClientLogin.
Więcej ogólnych informacji o uwierzytelnianiu za pomocą interfejsów Google Data API znajdziesz w dokumentacji uwierzytelniania.
Większość przykładów w kolejnych sekcjach tego dokumentu zakłada, że masz uwierzytelnioną instancję GDataService.
Uwierzytelnianie OAuth
Dokumentację na temat uwierzytelniania OAuth przy użyciu biblioteki Gythona GData znajdziesz w artykule Protokół OAuth w bibliotekach klienta protokołu danych Google.
Uwierzytelnianie serwera proxy AuthSub
Uwierzytelnianie serwera 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 otrzymuje specjalne tokeny uwierzytelniania, które pozwalają klientowi działać w imieniu konkretnego użytkownika. Więcej informacji znajdziesz w dokumentacji AuthSub.
Gdy użytkownik po raz pierwszy odwiedzi Twoją aplikację, nie zostanie on jeszcze uwierzytelniony. W takim przypadku musisz wyświetlić pewne informacje i link kierujący użytkownika na stronę Google, aby uwierzytelnić prośbę o dostęp do bloga. Biblioteka klienta w Pythonie zawiera funkcję generującą adres URL strony Google. Ten 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ą parametrom zapytania używanym przez moduł obsługi AuthSubRequest):
- dalej
- Adres URL strony, na którą Google ma przekierować użytkownika po uwierzytelnianiu.
- zakres
- Wskazuje, że aplikacja żąda tokena dostępu do kanałów Bloggera. Zakres zakresu do użycia to
http://www.blogger.com/feeds/(oczywiście zakodowany na potrzeby adresu URL). - Bezpieczny
- Wskazuje, czy klient żąda bezpiecznego tokena.
- sesja
- Wskazuje, czy zwrócony token można wymienić na token wielokrotnego użytku (sesja).
W przykładzie powyżej pojawia się wywołanie, które nie wymaga bezpiecznego tokena (wartość secure to False). Otrzymany 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 prowadzący do witryny Google i uwierzytelnia się na koncie Google.
Gdy użytkownik się uwierzytelni, system AuthSub przekierowuje go do adresu URL określonego w parametrze zapytania next AuthSubRequest. System AuthSub dodaje do tego adresu URL token uwierzytelniający jako wartość parametru zapytania token. Przykład:
http://www.example.com/welcome.pyc?token=yourAuthToken
Wartość tokena możesz pobrać z adresu URL na kilka sposobów:
import cgi parameters = cgi.FieldStorage() authsub_token = parameters['token']
Ta wartość odpowiada pojedynczemu tokenowi AuthSub. W tym przykładzie, ponieważ określono session = True, ten token można wymienić 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 jednorazowy token do metody UpgradeToSessionToken, a interfejs AuthSub zwraca token sesji.
Aplikacja może następnie użyć wartości tokena sesji w kolejnych interakcjach z Bloggerem. Biblioteka klienta automatycznie wysyła token wraz z żądaniami.
Uwierzytelnianie nazwy użytkownika i hasła klienta
Użyj uwierzytelniania ClientLogin, jeśli klient jest oddzielnym klientem (instalowanym przez klienta (np. aplikacją komputerową). Wystarczy, że wywołasz metodę ProgrammaticLogin() w instancji GDataService, a wszystkie dalsze 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 w instancji GDataService. Pierwszą z nich jest nazwa naszej aplikacji w formacie companyName-applicationName-versionID. Druga to nazwa usługi, z którą mamy wchodzić w interakcje, a trzecia to adres serwera.
Zwróć uwagę, że właściwość account_type jest wyraźnie ustawiona na GOOGLE. Jeśli nie ustawisz 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ładowych żądaniach i odpowiedziach, znajdziesz w dokumentacji dotyczącej uwierzytelniania zainstalowanych aplikacji.
Uwaga: użyj tego samego tokena dla wszystkich żądań w określonej sesji. Nie zdobywaj nowego tokena dla każdego żądania Bloggera.
Uwaga: jak opisano w dokumentacji ClientLogin, żądanie uwierzytelniania może się nie powieść i zażądać testu CAPTCHA. Jeśli chcesz, aby test CAPTCHA był przeprowadzany i obsługiwany przez tę funkcję, wyślij użytkownika na adres https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger (zamiast na adres URL obsługi CAPTCHA podany w dokumentacji ClientLogin).
Pobieranie listy blogów
Interfejs Blogger Data API zapewnia kanał z listą blogów wybranego użytkownika. Ten kanał jest nazywany „"metafeed."
Przykładowy kod używa uwierzytelnionego wystąpienia GDataService do pobrania metatagu, 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 w metodzie Get. Jest to domyślny adres URL metatagu, który zawiera listę blogów aktualnie uwierzytelnionego użytkownika.
Aby uzyskać dostęp do kanału innego użytkownika, możesz umieścić w metatagu adres URL identyfikatora użytkownika w miejscu default. 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. Będzie on potrzebny do wykonywania operacji tworzenia, aktualizowania i usuwania postów oraz komentarzy. Fragment kodu poniżej wybiera pierwszy blog pobrany dla 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 później łatwo uzyskać do niego dostęp. W większości przypadków w tym dokumencie wartość blog_id jest przekazywana jako zmienna.
Tworzenie postów
Interfejs API danych Bloggera umożliwia tworzenie i publikowanie nowych postów w blogach oraz tworzenie wersji roboczych wpisów.
Uwaga: ustawianie niestandardowego autora postów jest obecnie niemożliwe. Wszystkie nowe wpisy będą wyglądać tak, jakby zostały utworzone przez aktualnie uwierzytelnionego użytkownika.
Publikowanie posta na blogu
Aby opublikować nowe posty, możesz użyć biblioteki klienta w Pythonie.
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ć posta. Oto przykład publikacji nowego posta 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
Wersje robocze postów są tworzone w taki sam sposób jak posty publiczne, ale w instancji GDataEntry musisz ustawić element rozszerzenia draft. Powyższy post 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?')
Możesz zmienić istniejącego posta w blogu w opublikowany post, pobierając wersję roboczą posta, ustawiając atrybut wersji roboczej na no, a następnie aktualizując posta. W kolejnych 2 sekcjach omówimy pobieranie i aktualizowanie postów.
Pobieram posty
W sekcjach poniżej opisujemy, jak pobrać listę postów na blogu z parametrami zapytania i bez nich.
Do zapytań dotyczących publicznych kanałów Bloggera możesz wysyłać zapytania bez uwierzytelniania. W związku z tym nie musisz ustawiać danych logowania ani uwierzytelniać się w AuthSub przed pobieraniem postów z publicznego bloga.
Pobieranie wszystkich postów na blogu
Aby pobrać posty użytkownika, wywołaj metodę GetFeed za pomocą adresu URL kanału 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 z wykorzystaniem parametrów zapytania
Interfejs API danych Bloggera umożliwia żądanie zestawu wpisów spełniających określone kryteria, takich jak żądania postów opublikowanych na blogu lub opublikowanych w danym zakresie dat. 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 powoduje wyświetlanie tytułu i treści każdego posta na blogu między określonymi godzinami rozpoczęcia i zakończenia:
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 jest używany do pobierania postów.
Interfejs API danych Bloggera obsługuje te właściwości Query:
- kategorie
- Określa kategorie (nazywane też etykietami), aby filtrować wyniki pliku danych. Na przykład
http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Lauriezwraca wpisy z etykietamiFritziLaurie. Aby wskazać zapytanie o kategorię w bibliotece klienta w Pythonie, możesz użyćquery.categories = ['Fritz','Laurie',] - maks_wyniki
- Maksymalna liczba elementów do zwrócenia.
- opublikowana_min, opublikowana maks.
- Limity dat publikacji wpisów.
- indeks_początkowy
- Indeks oparty na 1 pierwszym wyniku do pobrania (na potrzeby stronicowania).
- updated_min, updated_max,
- Ograniczenia dotyczące dat aktualizacji wpisu. Te parametry zapytania są ignorowane, chyba że parametr
orderbyjest ustawiony naupdated.
Więcej informacji o parametrach zapytań znajdziesz w Przewodniku po interfejsach API danych Bloggera i w przewodniku po interfejsach Google Data API.
Aktualizowanie postów
Aby zaktualizować istniejącego posta na blogu, najpierw pobierz wpis, który chcesz zaktualizować, zmodyfikuj go, a następnie wyślij do Bloggera za pomocą metody Put. Fragment kodu poniżej określa tytuł posta na blogu, zakładając, że został 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 nowy wpis. Aby zaktualizować pozostałe właściwości, po prostu 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ąć posta, przekaż jego adres URL do metody Delete w obiekcie GDataService. Przykład:
def DeletePost(blogger_service, edit_link_href): blogger_service.Delete(edit_link_href)
Komentarze
Interfejs API danych Bloggera umożliwia tworzenie, pobieranie i usuwanie komentarzy. Aktualizowanie komentarzy nie jest obsługiwane (także 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 komentarze można publikować tylko na blogu należącym do uwierzytelnionego użytkownika.
Uwaga: ustawianie autora niestandardowego dla komentarzy nie jest obecnie obsługiwane. Wszystkie nowe komentarze będą wyglądać tak, jakby zostały utworzone przez aktualnie uwierzytelnionego użytkownika.
Pobieranie komentarzy
Możesz pobrać komentarze do konkretnego posta z adresu URL kanału komentarzy:
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ż wyświetlić komentarze ze wszystkich postów, korzystając z adresu URL kanału komentarzy:
http://www.blogger.com/feeds/blogID/comments/default
Usuwanie komentarzy
Aby usunąć komentarz, przekaż jego URL edycji do metody Delete w obiekcie GDataService w następujący sposób:
def DeleteComment(blogger_service, post_id, comment_id): feed_url = '/feeds/' + post_id + '/comments/default/' + comment_id blogger_service.Delete(feed_url)