Ta strona została przetłumaczona przez Cloud Translation API.

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.

Aplikacja kliencka może używać interfejsu API danych Bloggera do tworzenia nowego bloga posty, edytowanie i usuwanie istniejących postów na blogu oraz zapytania o pasujące posty na blogu określonych kryteriów.

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

Pomoc przy konfigurowaniu biblioteki klienta znajdziesz w artykule Pobieranie Uruchomiony przewodnik

Biblioteka klienta Pythona wymaga języka Python 2.2 lub nowszego. Po pobraniu biblioteki klienta, musisz też pobrać i zainstalować pakiet ElementTree.

Tworzenie konta w Bloggerze

Do celów testowych możesz założyć konto Blogger. 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 we własnym kodzie, musisz użyć tych instrukcji 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 być uwierzytelniany za pomocą jednej z 3 metod:uwierzytelniania OAuth lub serwera proxy AuthSub. uwierzytelnianie lub nazwa użytkownika/hasło ClientLogin. uwierzytelnianie.

Więcej informacji o uwierzytelnianiu za pomocą interfejsów API danych Google znajdziesz na stronie zapoznaj się z uwierzytelnianiem, dokumentacji.

Większość przykładów w kolejnych sekcjach tego dokumentu zakłada, że masz uwierzytelnioną instancję 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 serwera 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. Szczegółowe informacje znajdziesz w dokumentacji AuthSub.

Gdy użytkownik po raz pierwszy odwiedza Twoją aplikację, nie został jeszcze uwierzytelniony. W tym przypadku musisz wyświetlić informacje i link Kierowanie użytkownika na stronę Google, gdzie zostanie uwierzytelniona prośba o dostęp do swoje blogi. Biblioteka klienta w języku Python zawiera funkcję generującą Adres 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 ma przekierować użytkownika po uwierzytelnieniu.
zakres: Wskazuje, że aplikacja prosi o token dostępu do kanałów Bloggera. Ciąg zakresu, którego chcesz użyć, to http://www.blogger.com/feeds/ (oczywiście zakodowany pod adresem URL).
Bezpieczny: Wskazuje, czy klient prosi o bezpieczny token.
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). 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.

Gdy użytkownik się uwierzytelni, system AuthSub przekierowuje go do adresu URL podany w parametrze zapytania next w żądaniu AuthSubRequest Adres URL. System AuthSub dołącza do tego adresu URL token uwierzytelniania, 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 jednorazowy token AuthSub. 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.

Aplikacja może następnie używać wartości tokena sesji w kolejnych podczas interakcji z Bloggerem. Biblioteka klienta automatycznie wysyła token wraz z prośbami.

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 format: companyName-applicationName-versionID. Druga to nazwa usługi, z którą chcemy korzystać. trzeci to pod adresem serwera.

Zwróć uwagę, że wartość account_type jest jawnie ustawiona na GOOGLE. Jeśli nie ustawisz tego parametru, użytkownicy G Suite nie będą mogli korzystać z interfejs API Bloggera.

Więcej informacji o uwierzytelnianiu ClientLogin, w tym przykłady żądań i odpowiedzi zawiera sekcja Uwierzytelnianie zainstalowanych elementów aplikacji.

Uwaga: używaj tego samego tokena do wszystkich żądań w danej sesji. Nie pobieraj nowego tokena dla każdego żądania Bloggera.

Uwaga: zgodnie z opisem na stronie ClientLogin dokumentacji, może się to nie udać i pojawi się żądanie CAPTCHA do wyzwania. 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 API danych Bloggera udostępnia kanał z listą blogów o określonej tematyce user; jest nazywany „metakanałem”.

Ten przykładowy kod korzysta z uwierzytelnionego GDataService w celu pobrania metakanału, a następnie wydrukowanie tytułu 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. Jest to ustawienie domyślne. adres URL metakanału; zwraca listę blogów aktualnie uwierzytelnionego użytkownika. Aby uzyskać dostęp do pliku danych innego użytkownika, możesz umieścić jego identyfikator w miejscu default w adresie URL metakanału. Identyfikator użytkownika jest ciągiem cyfr na końcu adresu URL profilu użytkownika.

Fragment kodu poniżej pokazuje, jak wyodrębnić identyfikator bloga z kanału. Identyfikator bloga będzie potrzebny do tworzenia, aktualizowania i usuwania operacji na postach i komentarzach. Fragment poniżej wybiera pierwszego bloga pobranych 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 do niego łatwo dotrzeć w późniejszym czasie. 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ą wyświetlane tak, jakby zostały utworzone przez: aktualnie uwierzytelnionego użytkownika.

Publikowanie posta na blogu

Nowe wpisy na blogu możesz publikować za pomocą biblioteki klienta języka Python.

Najpierw utwórz instancję GDataEntry reprezentującą posta 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?')

Możesz przekształcić istniejącą wersję roboczą posta na blogu w opublikowanego posta, pobierając wersji roboczej posta, ustawiając atrybut wersji roboczej na no, a następnie aktualizacji posta. Pobieranie i aktualizowanie postów omówimy w kolejnych dwóch krokach. sekcji.

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 dotyczące 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 postów z bloga

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 API danych Bloggera umożliwia żądanie zbioru wpisów zgodnych z określonym takie jak żądanie postów na blogu opublikowanych lub zaktualizowanych w określonym dniu zakres dat. Aby to zrobić, utwórz instancję Query, a następnie wywołaj metodę Get().

Aby np. wysłać zapytanie dotyczące zakresu dat, ustaw 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 (nazywane też etykietami), aby filtrować wyniki z 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ć zapytanie dotyczące kategorii w bibliotece klienta w języku Python, możesz użyć query.categories = ['Fritz','Laurie',]
max_results: Maksymalna liczba wpisów do zwrócenia.
publish_min, publish_max: Granice dat publikacji wpisów.
start_index: Indeks pierwszego wyniku, który ma zostać pobrany (dla stronowania).
updated_min, updated_max (zaktualizowane_maks.): 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 i przewodniku po interfejsach Google Data API.

Aktualizowanie postów

Aby zaktualizować istniejący post na blogu, najpierw pobierz wpis, który chcesz ją zaktualizować i przesłać do Bloggera za pomocą Metoda Put. Ten fragment kodu zmienia tytuł bloga zakładając, że ten wpis 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 cały nowo zaktualizowany post. Aby zaktualizować inne właściwości, ustaw je w instancji GDataEntry przed wywołaniem Put.

Uwaga: zmiana danych o autorze powiązanych z Posty nie są obecnie obsługiwane.

Usuwanie postów

Aby usunąć posta, przekaż jego adres URL edycji do metody Delete na obiekcie 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ępna w przeglądarce) ).

Tworzenie komentarzy

Aby opublikować komentarz, utwórz obiekt GDataEntry i wstaw go w następujący 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 publikować komentarze tylko w bloga należącego do uwierzytelnionego użytkownika.

Uwaga: ustawienie niestandardowego autora komentarzy jest obecnie nieobsługiwane. 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ć za pomocą adresu URL kanału komentarzy pod postem:

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ż uzyskać komentarze do wszystkich postów, używając adresu URL kanału komentarzy bloga:

http://www.blogger.com/feeds/blogID/comments/default

Usuwanie komentarzy

Aby usunąć komentarz, przekaż jego adres URL edycji do funkcji Delete na obiekcie GDataService w taki 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