Przewodnik dla programistów: Python

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

  1. Odbiorcy
  2. Pierwsze kroki
    1. Tworzenie konta w Bloggerze
    2. Uruchamianie przykładowego kodu
  3. Uwierzytelnianie w usłudze Blogger
    1. Uwierzytelnianie OAuth
    2. Uwierzytelnianie proxy AuthSub
    3. Uwierzytelnianie za pomocą nazwy użytkownika i hasła w ClientLogin
  4. Pobieranie listy blogów
  5. Tworzenie postów
    1. Publikowanie posta na blogu
    2. Tworzenie szkicu posta na blogu
  6. Pobieranie postów
    1. Pobieranie wszystkich wpisów na blogu
    2. Pobieranie postów za pomocą parametrów zapytania
  7. Aktualizowanie postów
  8. Usuwanie postów
  9. Komentarze
    1. Tworzenie komentarzy
    2. Pobieranie komentarzy
    3. Usuwanie komentarzy

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 etykietami Fritz i Laurie. Aby określić to zapytanie o kategorię w bibliotece klienta Pythona, możesz użyć funkcji query.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)

Powrót do góry