Panduan Developer: Python

Blogger Data API memungkinkan aplikasi klien melihat dan mengupdate Blogger konten dalam bentuk feed Google Data API.

Aplikasi klien Anda dapat menggunakan Blogger Data API untuk membuat blog baru postingan, edit atau hapus postingan blog yang ada, dan kueri postingan blog yang cocok kriteria tertentu.

Selain memberikan beberapa latar belakang tentang kemampuan Blogger Data API, dokumen ini memberikan contoh interaksi Data API dasar menggunakan klien Python library. Jika Anda tertarik untuk lebih memahami protokol dasar yang digunakan library, lihat bagian Protokol dalam panduan developer ini.

Daftar Isi

  1. Penonton
  2. Memulai
    1. Membuat akun Blogger
    2. Menjalankan kode contoh
  3. Mengautentikasi ke layanan Blogger
    1. Autentikasi OAuth
    2. Autentikasi proxy AuthSub
    3. Autentikasi nama pengguna/sandi ClientLogin
  4. Mengambil daftar blog
  5. Membuat postingan
    1. Memublikasikan postingan blog
    2. Membuat draf postingan blog
  6. Mengambil postingan
    1. Mengambil semua postingan blog
    2. Mengambil postingan menggunakan parameter kueri
  7. Memperbarui postingan
  8. Menghapus postingan
  9. Komentar
    1. Membuat komentar
    2. Mengambil komentar
    3. Menghapus komentar

Audiens

Dokumen ini ditujukan untuk programmer yang ingin menulis aplikasi klien Python yang dapat berinteraksi dengan Blogger.

Dokumen ini mengasumsikan bahwa Anda memahami ide umum di balik protokol Google Data API.

Untuk informasi referensi Blogger Data API umum, lihat Panduan referensi protokol.

Memulai

Untuk mendapatkan bantuan dalam menyiapkan library klien, lihat Panduan Memulai.

Library klien Python memerlukan Python 2.2 atau yang lebih baru. Setelah mendownload library klien, Anda juga harus mendownload dan menginstal paket ElementTree.

Membuat akun Blogger

Anda mungkin ingin mendaftar untuk Akun Blogger untuk tujuan pengujian. Blogger menggunakan Akun Google, jadi jika Anda sudah memiliki akun Google, Anda sudah siap.

Menjalankan kode contoh

Klien contoh yang berfungsi penuh, yang berisi semua kode contoh yang ditampilkan dalam dokumen ini, tersedia dalam file BloggerExample.py, di direktori gdata-python-client/samples/blogger/.

Klien contoh melakukan beberapa operasi di blog yang disediakan untuk menunjukkan penggunaan Blogger Data API.

Anda dapat menjalankan contoh dengan argumen berikut:

python BloggerExample.py --email [email_address] --password [password]

Untuk menggunakan contoh dalam dokumen ini di kode Anda sendiri, Anda memerlukan pernyataan import berikut:

from gdata import service
import gdata
import atom

Mengautentikasi ke layanan Blogger

Anda dapat mengakses feed publik dan pribadi menggunakan Blogger Data API. Feed publik tidak memerlukan autentikasi apa pun, tetapi bersifat hanya baca. Jika Anda ingin mengubah blog, klien Anda harus melakukan autentikasi sebelum meminta feed pribadi. Layanan ini dapat mengautentikasi menggunakan salah satu dari tiga pendekatan: autentikasi OAuth, autentikasi proxy AuthSub, atau autentikasi nama pengguna/sandi ClientLogin.

Untuk informasi selengkapnya tentang autentikasi dengan Google Data API secara umum, lihat dokumentasi autentikasi.

Sebagian besar contoh di bagian berikutnya dalam dokumen ini mengasumsikan bahwa Anda memiliki instance GDataService yang diautentikasi.

Autentikasi OAuth

Untuk dokumentasi tentang autentikasi OAuth menggunakan library GData Python, lihat OAuth di Library Klien Google Data Protocol.

Autentikasi proxy AuthSub

Autentikasi proxy AuthSub digunakan oleh aplikasi web yang perlu mengautentikasi penggunanya ke Akun Google. Operator situs dan klien kode tidak memiliki akses ke nama pengguna dan sandi untuk pengguna Blogger; sebagai gantinya, klien memperoleh token AuthSub khusus yang memungkinkan klien untuk bertindak atas nama pengguna tertentu. Untuk informasi selengkapnya, lihat dokumentasi AuthSub.

Ketika pengguna pertama kali mengunjungi aplikasi Anda, mereka belum telah diotentikasi. Dalam hal ini, Anda perlu menampilkan beberapa informasi dan tautan mengarahkan pengguna ke halaman Google untuk mengautentikasi permintaan akses Anda ke blog mereka. Library klien Python menyediakan fungsi untuk menghasilkan URL halaman Google. Kode di bawah mengambil URL halaman 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

Metode GenerateAuthSubURL mengambil parameter berikut (sesuai dengan parameter kueri yang digunakan oleh pengendali AuthSubRequest):

berikutnya
URL halaman yang menjadi tujuan pengalihan pengguna oleh Google setelah autentikasi.
cakupan
Menunjukkan bahwa aplikasi meminta token untuk mengakses feed Blogger. String cakupan yang akan digunakan adalah http://www.blogger.com/feeds/ (tentunya dienkode URL).
aman
Menunjukkan apakah klien meminta token aman.
sesi
Menunjukkan apakah token yang ditampilkan dapat ditukarkan dengan token multiguna (sesi).

Contoh di atas menunjukkan panggilan yang tidak meminta token aman (nilai secure adalah False). URL permintaan yang dihasilkan mungkin terlihat seperti ini:

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

Pengguna mengikuti link ke situs Google dan melakukan autentikasi ke Akun Google-nya.

Setelah pengguna melakukan autentikasi, sistem AuthSub akan mengalihkan mereka ke URL yang Anda tentukan dalam parameter kueri next pada AuthSubRequest . Sistem AuthSub menambahkan token autentikasi ke URL tersebut, sebagai nilai parameter kueri token. Contoh:

http://www.example.com/welcome.pyc?token=yourAuthToken

Ada beberapa cara untuk mengambil nilai token dari URL; misalnya:

import cgi

parameters = cgi.FieldStorage()
authsub_token = parameters['token']

Nilai token ini mewakili token AuthSub sekali pakai. Dalam contoh ini, karena session = True ditentukan, token ini dapat ditukarkan dengan token sesi AuthSub menggunakan metode UpgradeToSessionToken, yang memanggil AuthSubSessionToken layanan:

blogger_service = service.GDataService()
blogger_service.auth_token = authsub_token
blogger_service.UpgradeToSessionToken()

Artinya, Anda meneruskan token sekali pakai ke metode UpgradeToSessionToken, dan antarmuka AuthSub menampilkan token sesi.

Aplikasi Anda kemudian dapat menggunakan nilai token sesi dalam interaksi berikutnya dengan Blogger. Library klien secara otomatis mengirimkan token beserta permintaan.

Autentikasi nama pengguna/sandi ClientLogin

Gunakan autentikasi ClientLogin jika klien Anda adalah pengguna tunggal yang mandiri "diinstal" (seperti aplikasi desktop). Cukup panggil metode ProgrammaticLogin() pada instance GDataService Anda dan semua interaksi berikutnya dengan Blogger akan diautentikasi:

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()

Dalam cuplikan di atas, kita menetapkan tiga properti pada instance GDataService. Yang pertama adalah nama aplikasi di formatnya companyName-applicationName-versionID. Yang kedua adalah nama layanan yang ingin kita gunakan; yang ketiga adalah alamat server Anda.

Perhatikan bahwa account_type ditetapkan secara eksplisit ke GOOGLE. Kegagalan dalam menetapkan parameter ini akan mencegah pengguna G Suite berhasil menggunakan Blogger API.

Untuk mengetahui informasi selengkapnya tentang autentikasi ClientLogin, termasuk contoh permintaan dan respons, lihat dokumentasi Autentikasi untuk Aplikasi yang Diinstal.

Catatan: Gunakan token yang sama untuk semua permintaan dalam sesi tertentu; tidak memperoleh token baru untuk setiap permintaan Blogger.

Catatan: Seperti yang dijelaskan dalam ClientLogin dokumentasi, permintaan otentikasi mungkin gagal dan meminta CAPTCHA tantangan. Jika Anda ingin Google mengeluarkan dan menangani tantangan CAPTCHA, kirim pengguna ke https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger (bukan URL penanganan CAPTCHA yang diberikan di ClientLogin dokumentasi).

Mengambil daftar blog

Blogger Data API menyediakan feed yang mencantumkan blog untuk user; feed tersebut dikenal sebagai "metafeed."

Contoh kode berikut menggunakan instance GDataService yang diautentikasi untuk mengambil metafeed, lalu mencetak setiap judul blog.

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

Catat URL yang digunakan oleh metode Get. Ini adalah default URL feed meta; sistem itu menghasilkan daftar blog untuk pengguna yang saat ini diotentikasi. Untuk mengakses feed bagi pengguna lain, Anda dapat menempatkan ID pengguna sebagai default di URL feed meta. ID pengguna adalah string digit di akhir URL profil pengguna.

Cuplikan kode di bawah menunjukkan cara mengekstrak ID blog dari feed. Anda memerlukan ID blog untuk melakukan pembuatan, pembaruan, dan penghapusan pada postingan dan komentar. Cuplikan di bawah ini memilih blog pertama yang diambil untuk pengguna.

blog_id = feed.entry[0].GetSelfLink().href.split("/")[-1]

Dalam contoh BloggerExample.py, class BloggerExample dibuat, dan ID blog ditetapkan di konstruktor untuk memudahkan akses nanti. Untuk sebagian besar contoh berikut dalam dokumen ini, blog_id diteruskan sebagai variabel.

Membuat postingan

Blogger Data API memungkinkan Anda membuat dan memublikasikan entri blog baru, serta membuat draf entri.

Catatan: Menetapkan penulis kustom untuk postingan saat ini tidak didukung. Semua postingan baru akan muncul seolah-olah dibuat oleh pengguna yang saat ini diautentikasi.

Memublikasikan postingan blog

Anda dapat menggunakan library klien Python untuk memublikasikan entri blog baru.

Pertama, buat instance GDataEntry untuk mewakili postingan blog. Kemudian, Anda dapat menetapkan judul, konten, dan atribut lain untuk postingan blog. Terakhir, gunakan instance GDataService untuk menyisipkan postingan. Berikut contoh cara memublikasikan postingan blog baru:

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!')

Membuat draf postingan blog

Postingan draf dibuat dengan cara yang sama seperti postingan publik, tetapi Anda harus mengatur elemen ekstensi draft di GDataEntry di instance Compute Engine. Postingan blog di atas dapat dibuat sebagai draf dengan menambahkan baris yang ditandai:

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?')

Anda dapat mengubah draf postingan blog yang ada menjadi postingan yang dipublikasikan dengan mengambil draf postingan, menetapkan atribut draf ke no, lalu memperbarui postingan. Kita akan membahas cara mengambil dan memperbarui postingan dalam waktu dua bagian.

Mengambil postingan

Bagian berikut menjelaskan cara mengambil daftar postingan blog, dengan dan tanpa parameter kueri.

Anda dapat membuat kueri feed publik Blogger tanpa autentikasi. Oleh karena itu, Anda tidak perlu menetapkan kredensial atau melakukan otentikasi AuthSub sebelum mengambil postingan dari blog publik.

Mengambil semua postingan blog

Untuk mengambil postingan pengguna, panggil metode GetFeed dengan URL feed postingan blog:

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

Mengambil postingan menggunakan parameter kueri

Blogger Data API memungkinkan Anda meminta sekumpulan entri yang cocok dengan kriteria yang ditentukan, seperti meminta postingan blog yang dipublikasikan atau diperbarui dalam rentang tanggal tertentu. Untuk melakukannya, Anda membuat instance Query, lalu memanggil metode Get().

Misalnya, untuk mengirim kueri rentang tanggal, tetapkan published_min dan properti published_min dari instance Query. Cuplikan kode berikut mencetak judul dan konten setiap postingan blog yang dipublikasikan antara waktu mulai dan waktu berakhir yang ditentukan:

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

Perhatikan bahwa objek Query dibuat menggunakan postingan yang sama URL feed yang digunakan untuk mengambil postingan.

Blogger Data API mendukung Query berikut properti:

kategori
Menentukan kategori (disebut juga label) untuk memfilter hasil feed. Misalnya, http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie menampilkan entri dengan label Fritz dan Laurie. Untuk menentukan kueri kategori tersebut di library klien Python, Anda dapat menggunakan query.categories = ['Fritz','Laurie',]
max_results
Jumlah maksimum entri yang akan ditampilkan.
dipublikasikan_min, dipublikasikan_maks
Batas pada tanggal publikasi entri.
start_index
Indeks berbasis 1 dari hasil pertama yang akan diambil (untuk paging).
updated_min, updated_max
Batas pada tanggal pembaruan entri. Parameter kueri ini diabaikan kecuali jika parameter orderby ditetapkan ke updated.

Untuk informasi selengkapnya tentang parameter kueri, lihat Referensi Blogger Data API Guide dan Google Panduan Referensi Data API.

Memperbarui postingan

Untuk memperbarui postingan blog yang ada, pertama-tama ambil entri yang ingin Anda perbarui, lalu Anda modifikasi, kemudian kirimkan ke Blogger menggunakan Metode Put. Cuplikan kode berikut mengubah judul blog entri tersebut, dengan asumsi bahwa Anda telah mengambil entri dari server.

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)

Kode di atas menampilkan GDataEntry yang berisi seluruh yang baru diperbarui. Untuk memperbarui properti lainnya, cukup tetapkan di instance GDataEntry sebelum memanggil Put.

Catatan: Mengubah data penulis yang terkait dengan postingan saat ini tidak didukung.

Menghapus postingan

Untuk menghapus postingan, teruskan URL edit postingan ke metode Delete pada objek GDataService, seperti ini:

def DeletePost(blogger_service, edit_link_href):
  blogger_service.Delete(edit_link_href)

Komentar

Blogger Data API memungkinkan pembuatan, pengambilan, dan penghapusan komentar. Memperbarui komentar tidak didukung (dan tidak tersedia di antarmuka web).

Membuat komentar

Untuk memposting komentar, buat objek GDataEntry dan sisipkan sebagai berikut:

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)

Catatan: Saat ini, Anda hanya dapat memposting komentar ke blog milik pengguna yang diautentikasi.

Catatan: Menetapkan penulis kustom untuk komentar saat ini tidak didukung. Semua komentar baru akan muncul seolah-olah dibuat oleh pengguna yang saat ini diotentikasi.

Mengambil komentar

Anda dapat mengambil komentar untuk postingan tertentu dari URL feed komentar postingan:

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

Atau, Anda bisa mendapatkan komentar dari semua postingan menggunakan URL feed komentar blog:

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

Menghapus komentar

Untuk menghapus komentar, teruskan URL edit komentar ke Delete pada objek GDataService seperti ini:

def DeleteComment(blogger_service, post_id, comment_id):
  feed_url = '/feeds/' + post_id + '/comments/default/' + comment_id
  blogger_service.Delete(feed_url)

Kembali ke atas