Blogger Data API memungkinkan aplikasi klien melihat dan memperbarui konten Blogger dalam bentuk feed Google Data API.
Aplikasi klien Anda dapat menggunakan Blogger Data API untuk membuat postingan blog baru, mengedit atau menghapus postingan blog yang sudah ada, dan membuat kueri untuk postingan blog yang sesuai dengan kriteria tertentu.
Selain menyediakan beberapa latar belakang tentang kemampuan Blogger Data API, dokumen ini memberikan contoh interaksi Data API dasar menggunakan library klien Python. Jika Anda tertarik untuk memahami lebih lanjut protokol dasar yang digunakan library, lihat bagian Protokol dari panduan developer ini.
Daftar Isi
Audiens
Dokumen ini ditujukan untuk programmer yang ingin menulis aplikasi klien Python yang dapat berinteraksi dengan Blogger.
Dokumen ini mengasumsikan bahwa Anda memahami ide-ide umum di balik protokol Google Data API.
Untuk informasi referensi umum Blogger Data API, 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 dapat mendaftar ke akun Blogger untuk tujuan pengujian. Blogger menggunakan Akun Google, jadi jika Anda sudah memiliki Akun Google, berarti Anda sudah siap.
Menjalankan kode contoh
Klien contoh lengkap yang berfungsi, yang berisi semua kode contoh yang ditampilkan dalam dokumen ini, tersedia dalam file BloggerExample.py
, pada 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 dalam kode Anda sendiri, Anda akan 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 perlu melakukan autentikasi sebelum meminta feed pribadi. Autentikasi dapat dilakukan 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 sampel di bagian berikutnya pada dokumen ini mengasumsikan bahwa Anda memiliki instance GDataService
yang diautentikasi.
Autentikasi OAuth
Untuk dokumentasi tentang autentikasi OAuth menggunakan library Python GData, lihat OAuth di Library Klien Google Data Protocol.
Autentikasi proxy AuthSub
Autentikasi proxy AuthSub digunakan oleh aplikasi web yang perlu mengautentikasi pengguna ke Akun Google. Operator situs dan kode klien tidak memiliki akses ke nama pengguna dan sandi untuk pengguna Blogger; sebagai gantinya, klien mendapatkan token AuthSub khusus yang memungkinkan klien untuk bertindak atas nama pengguna tertentu. Untuk mengetahui informasi yang lebih detail, lihat dokumentasi AuthSub.
Saat pertama kali mengunjungi aplikasi Anda, pengguna belum diautentikasi. Dalam hal ini, Anda perlu menampilkan beberapa informasi dan link yang mengarahkan pengguna ke halaman Google untuk mengautentikasi permintaan Anda agar dapat mengakses 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
menggunakan parameter berikut (sesuai dengan parameter kueri yang digunakan oleh pengendali AuthSubRequest):
- berikutnya
- URL halaman tempat Google akan mengalihkan pengguna setelah autentikasi.
- cakupan
- Menunjukkan bahwa aplikasi meminta token untuk mengakses feed Blogger. String cakupan yang digunakan adalah
http://www.blogger.com/feeds/
(tentu saja dienkode ke URL). - aman
- Menunjukkan apakah klien meminta token aman.
- sesi
- Menunjukkan apakah token yang ditampilkan dapat ditukarkan dengan token multi-penggunaan (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 mengautentikasi ke Akun Google mereka.
Setelah pengguna melakukan autentikasi, sistem AuthSub akan mengalihkan mereka ke URL yang Anda tentukan dalam parameter kueri next
dari URL 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 satu kali pakai. Dalam contoh ini,
karena session = True
ditentukan, token ini dapat ditukarkan dengan
token sesi AuthSub menggunakan metode UpgradeToSessionToken
,
yang memanggil layanan
AuthSubSessionToken
:
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 di interaksi berikutnya dengan Blogger. Library klien otomatis mengirimkan token bersama dengan permintaan.
Autentikasi nama pengguna/sandi ClientLogin
Gunakan autentikasi ClientLogin jika klien Anda adalah klien mandiri yang tidak 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 kita dalam
bentuk companyName-applicationName-versionID.
Yang kedua adalah nama layanan yang ingin kita gunakan; yang ketiga adalah
alamat server.
Perhatikan bahwa account_type
ditetapkan secara eksplisit ke GOOGLE
. Jika parameter ini tidak disetel, pengguna G Suite tidak akan dapat menggunakan
Blogger API.
Untuk informasi selengkapnya tentang autentikasi ClientLogin, termasuk contoh permintaan dan respons, lihat dokumentasi Autentikasi untuk Aplikasi yang Terinstal.
Catatan: Gunakan token yang sama untuk semua permintaan di sesi tertentu; jangan dapatkan token baru untuk setiap permintaan Blogger.
Catatan: Seperti yang dijelaskan dalam dokumentasi ClientLogin, permintaan autentikasi mungkin gagal dan meminta verifikasi CAPTCHA. Jika Anda ingin Google mengeluarkan dan menangani verifikasi CAPTCHA, kirimkan pengguna ke https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger
(bukan ke URL penanganan CAPTCHA yang diberikan dalam dokumentasi ClientLogin).
Mengambil daftar blog
Blogger Data API menyediakan feed yang mencantumkan blog untuk pengguna tertentu; feed tersebut dikenal sebagai "metafeed."
Kode contoh 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
Perhatikan URL yang digunakan oleh metode Get
. Ini adalah URL metafeed
default; yang menampilkan daftar blog untuk pengguna yang saat ini diautentikasi.
Untuk mengakses feed bagi pengguna lain, Anda dapat menempatkan ID pengguna sebagai pengganti default
di URL feed meta. ID pengguna adalah string angka di akhir URL profil pengguna.
Cuplikan kode di bawah ini menunjukkan cara mengekstrak ID blog dari feed. Anda akan memerlukan ID blog untuk melakukan operasi 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 dalam konstruktor untuk kemudahan akses
nanti. Untuk sebagian besar contoh berikut dalam dokumen ini, blog_id
diteruskan sebagai variabel.
Membuat postingan
Dengan Blogger Data API, Anda dapat membuat dan memublikasikan entri blog baru, serta membuat draf entri.
Catatan: Menyetel penulis kustom untuk postingan saat ini tidak didukung. Semua postingan baru akan muncul seolah-olah dibuat oleh pengguna yang saat ini terautentikasi.
Memublikasikan postingan blog
Anda dapat menggunakan library klien Python untuk memublikasikan entri blog baru.
Pertama, buat instance GDataEntry
untuk mewakili postingan blog.
Anda kemudian dapat menetapkan judul, konten, dan atribut lain dari postingan blog tersebut.
Terakhir, gunakan instance GDataService
untuk menyisipkan postingan. Berikut adalah
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 postingan blog draf
Postingan draf dibuat dengan cara yang sama seperti postingan publik, tetapi Anda perlu menetapkan elemen ekstensi draft
di instance GDataEntry
. 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 postingan blog draf yang sudah ada menjadi postingan yang dipublikasikan dengan mengambil
postingan draf, menyetel atribut draf ke no
, lalu
memperbarui postingan. Kami akan membahas cara mengambil dan memperbarui postingan di dua
bagian berikutnya.
Mengambil postingan
Bagian berikut ini menjelaskan cara mengambil daftar postingan blog, dengan dan tanpa parameter kueri.
Anda dapat mengajukan kueri feed publik Blogger tanpa autentikasi. Oleh karena itu, Anda tidak perlu menetapkan kredensial atau melakukan autentikasi 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 serangkaian entri yang cocok dengan kriteria yang ditentukan, seperti meminta postingan blog yang dipublikasikan atau diperbarui dalam rentang tanggal tertentu. Untuk melakukannya, buat instance Query
, lalu panggil metode Get()
.
Misalnya, untuk mengirim kueri rentang tanggal, tetapkan properti published_min
dan published_min
instance Query
.
Cuplikan kode berikut mencetak judul dan isi setiap postingan blog
yang dipublikasikan antara waktu mulai dan waktu berakhir:
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 URL feed postingan
yang sama dengan yang digunakan untuk mengambil postingan.
Blogger Data API mendukung properti Query
berikut:
- categories
- Menentukan kategori (juga dikenal sebagai label) untuk memfilter hasil feed. Misalnya,
http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie
menampilkan entri dengan labelFritz
danLaurie
. Untuk menentukan kueri kategori tersebut di library klien Python, Anda dapat menggunakanquery.categories = ['Fritz','Laurie',]
- hasil_maksimum
- Jumlah maksimum entri yang akan ditampilkan.
- publikasi_mnt, dipublikasikan_maks
- Batas pada tanggal publikasi entri.
- indeks_awal
- Indeks berbasis 1 dari hasil pertama yang akan diambil (untuk paging).
- updated_min, updated_max
- Batas pada tanggal update entri. Parameter kueri ini diabaikan kecuali jika parameter
orderby
disetel keupdated
.
Untuk informasi selengkapnya tentang parameter kueri, lihat Panduan Referensi Blogger Data API dan Panduan Referensi Google Data API.
Memperbarui postingan
Untuk memperbarui postingan blog yang sudah ada, pertama-tama Anda harus mengambil entri yang ingin
diperbarui, kemudian mengubahnya, lalu mengirimnya ke Blogger menggunakan
metode Put
. Cuplikan kode berikut mengubah judul entri blog, 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 postingan yang baru diupdate. Untuk memperbarui properti lainnya, cukup tetapkan properti tersebut dalam 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
Anda, seperti ini:
def DeletePost(blogger_service, edit_link_href): blogger_service.Delete(edit_link_href)
Komentar
Blogger Data API memungkinkan Anda membuat, mengambil, dan menghapus komentar. Memperbarui komentar tidak didukung (juga tidak tersedia di antarmuka web).
Membuat komentar
Untuk memposting komentar, buat objek GDataEntry
dan sisipkan seperti 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: Menyetel penulis kustom untuk komentar saat ini tidak didukung. Semua komentar baru akan muncul seolah-olah komentar tersebut dibuat oleh pengguna yang saat ini sudah diautentikasi.
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 dengan menggunakan URL feed komentar blog:
http://www.blogger.com/feeds/blogID/comments/default
Menghapus komentar
Untuk menghapus komentar, teruskan URL edit komentar ke metode Delete
pada objek GDataService
Anda seperti ini:
def DeleteComment(blogger_service, post_id, comment_id): feed_url = '/feeds/' + post_id + '/comments/default/' + comment_id blogger_service.Delete(feed_url)