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 Google Data API Zend. Jika Anda tertarik untuk lebih memahami protokol pokok yang digunakan library, lihat bagian Protokol dalam panduan developer ini.
Daftar Isi
Audiens
Dokumen ini ditujukan untuk programmer yang ingin menulis aplikasi klien PHP yang dapat berinteraksi dengan Blogger.
Dokumen ini mengasumsikan bahwa Anda memahami ide-ide umum di balik protokol Google Data API.
Untuk mengetahui informasi referensi tentang class dan metode yang disediakan oleh library klien, lihat referensi API library klien PHP. Untuk informasi referensi umum Blogger Data API, lihat Panduan referensi protokol.
Memulai
Untuk mendapatkan bantuan dalam menyiapkan library klien, lihat Panduan Memulai.
Library klien Zend memerlukan PHP 5.1.4 atau yang lebih baru. Versi ini tersedia sebagai bagian dari Zend Framework dan juga sebagai download terpisah. Untuk berinteraksi dengan Blogger, gunakan library klien versi 1.0.0 atau yang lebih baru.
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 yang berfungsi penuh, yang berisi semua kode contoh yang ditampilkan dalam dokumen ini, tersedia di repositori SVN Framework Zend. Sampel terletak di /framework/standard/trunk/demos/Zend/Gdata/Blogger.php. Contoh tersebut berisi semua fungsi yang dijelaskan dalam dokumen ini. Dapat dijalankan hanya dari command line:
php Blogger.php -- --user=[email_address] --pass=[password]
Sebelum menjalankan contoh ini atau mengembangkan kode Anda sendiri menggunakan Framework Zend, Anda mungkin perlu menetapkan include_path
dan memuat class yang sesuai. Jalur include dapat ditetapkan menggunakan setelan php.ini atau menggunakan metode set_include_path. Kode ini meminta akses ke class inti Zend_Gdata, class Zend_Gdata_Query, dan class autentikasi Zend_Gdata_ClientLogin.
require_once 'Zend/Loader.php'; Zend_Loader::loadClass('Zend_Gdata'); Zend_Loader::loadClass('Zend_Gdata_Query'); Zend_Loader::loadClass('Zend_Gdata_ClientLogin');
Menggunakan pengambil dan penyetel ajaib
Di seluruh library klien PHP, dukungan telah ditambahkan untuk penyetel/getter ajaib sebagai kemudahan bagi developer. Hal ini memungkinkan properti
class diakses dengan aman menggunakan metode penyetel/getter tradisional atau dengan
mengakses properti. Misalnya, jika $gdataObject
adalah instance objek dalam library ini, maka dua baris kode berikut memiliki efek identik:
$gdataObject->setFoo("bar"); $gdataObject->foo = "bar";
Demikian pula, kedua baris kode ini juga memiliki efek yang sama:
$baz = $gdataObject->getFoo(); $baz = $gdataObject->foo;
Demikian pula, metode factory magic memudahkan deklarasi objek baru. Daripada
mengingat nama class panjang yang dimandatkan oleh konvensi penamaan Zend, Anda
dapat membuat object
baru dengan memanggil newObject();
pada
klien layanan Zend. Misalnya, kedua cuplikan berikut mendeklarasikan objek ekstensi draft
baru. Anda akan melihat lebih banyak tentang drafts
di
bagian membuat postingan.
// Traditional instantiation $gdClient = new Zend_Gdata(); $draft = new Zend_Gdata_App_Extension_Draft(); // Magic factory instantiation $gdClient = new Zend_Gdata(); $draft = $gdClient->newDraft();
Penyetel/getter dan pabrik ajaib bersifat opsional, jadi gunakan pendekatan yang paling sesuai untuk Anda.
Referensi lainnya
Referensi lain untuk komponen Google Data API Zend Framework (Zend_Gdata):
- Dokumentasi Referensi
- Arsip dan informasi milis
- Info Subversi Framework Zend
- Snapshot Zend Framework Nightly
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 dalam dokumen ini mengasumsikan bahwa Anda memiliki objek klien yang diautentikasi yang disebut $gdClient
.
Autentikasi OAuth
Untuk dokumentasi tentang autentikasi OAuth menggunakan library Gend PHP 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 Zend menyediakan fungsi untuk menghasilkan URL halaman Google. Kode di bawah mengambil URL halaman AuthSubRequest:
function getAuthSubUrl() { $next = getCurrentUrl(); $scope = 'http://www.google.com/blogger/feeds/'; $secure = false; $session = true; return Zend_Gdata_AuthSub::getAuthSubTokenUri($next, $scope, $secure, $session); } $authSubUrl = getAuthSubUrl(); echo '<a href=\"$authSubUrl\">login to your Google account</a>';
Metode getAuthSubTokenUri
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.php
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.php?token=yourAuthToken
Anda dapat mengambil nilai token menggunakan $_GET['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 Zend_Gdata_AuthSub::getAuthSubSessionToken
, yang memanggil layanan
AuthSubSessionToken
:
if(! isset($_SESSION['sessionToken']) && isset($_GET['token'])) { $_SESSION['sessionToken'] = Zend_Gdata_AuthSub::getAuthSubSessionToken($_GET['token']); }
Cuplikan kode terlebih dahulu memeriksa apakah token sesi AuthSub sudah ada. Jika tidak, tetapi token sekali pakai ditentukan di URL, cuplikan kode meneruskan token sekali pakai ke metode getAuthSubSessionToken
, dan antarmuka AuthSub menampilkan token sesi. Kode kemudian menempatkan nilai token sesi dalam variabel sesi $_SESSION['sessionToken']
.
Aplikasi Anda kemudian dapat menggunakan nilai token sesi di
interaksi berikutnya dengan Blogger. Anda dapat menggunakan metode Zend_Gdata_AuthSub::getHttpClient
untuk mendapatkan objek Zend_Http_Client
yang memiliki preset header Authorization
untuk menyertakan kredensial AuthSub:
$client = Zend_Gdata_AuthSub::getHttpClient($_SESSION['sessionToken']);
Autentikasi nama pengguna/sandi ClientLogin
Gunakan autentikasi ClientLogin jika klien Anda adalah klien mandiri yang tidak diinstal (seperti aplikasi desktop).
Kode berikut menggunakan metode Zend_Gdata_ClientLogin::getHttpClient
untuk melakukan permintaan ke layanan ClientLogin, mengambil token autentikasi, dan membuat objek Zend_Http_Client
dengan header autentikasi yang sesuai. Kemudian, HttpClient
yang ditampilkan oleh metode ini digunakan untuk membuat
objek layanan Zend_Gdata
.
Perhatikan bahwa $accountType
ditetapkan secara eksplisit ke GOOGLE
. Jika parameter ini tidak disetel, pengguna G Suite tidak akan dapat menggunakan
Blogger API.
$user = 'user@example.com'; $pass = 'secretPasswd'; $service = 'blogger'; $client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service, null, Zend_Gdata_ClientLogin::DEFAULT_SOURCE, null, null, Zend_Gdata_ClientLogin::CLIENTLOGIN_URI, 'GOOGLE'); $gdClient = new Zend_Gdata($client);
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 objek $gdClient
yang diautentikasi
untuk mengambil metafeed, lalu mencetak setiap judul blog.
Class Zend_Gdata_Query
akan menangani pembuatan URL kueri. Dalam hal ini, tidak ada pekerjaan tambahan
yang perlu dilakukan, tetapi kegunaan class Query
akan
terlihat di bagian mengambil postingan berdasarkan
parameter kueri dokumen ini.
function printAllBlogs() { $query = new Zend_Gdata_Query('http://www.blogger.com/feeds/default/blogs'); $feed = $gdClient->getFeed($query); printFeed($feed); } function printFeed($feed) { $i = 0; foreach($feed->entries as $entry) { print $i ." ". $entry->title->text . "\n"; $i++; } }
Perhatikan URL yang digunakan oleh metode getFeed
. 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. Variabel $index
mewakili blog mana yang ada di feed blog pengguna yang digunakan. Kolom id
memiliki format
tag:blogger.com,1999:user-userID.blog-blogID
, sehingga
split
pada karakter '-' menempatkan ID blog pada elemen terakhir
array yang dihasilkan.
$idText = split('-', $feed->entries[$index]->id->text); $blogID = $idText[2];
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 PHP untuk memublikasikan entri blog baru.
Pertama, buat instance entri untuk mewakili postingan blog. Lalu, Anda dapat menetapkan judul, konten, dan atribut lainnya untuk postingan blog tersebut. Terakhir, panggil metode
insertEntry
untuk menyisipkan postingan. Anda dapat melihat pembuatan instance pabrik ajaib yang berfungsi di sini dengan objek Zend_Gdata_Entry
, Zend_Gdata_App_Extension_Title
, dan Zend_Gdata_App_Extension_Content
yang baru.
function createPublishedPost($title='Hello, world!', $content='I am blogging on the internet.') { $uri = 'http://www.blogger.com/feeds/' . $blogID . '/posts/default'; $entry = $gdClient->newEntry(); $entry->title = $gdClient->newTitle($title); $entry->content = $gdClient->newContent($content); $entry->content->setType('text'); $createdPost = $gdClient->insertEntry($entry, $uri); $idText = split('-', $createdPost->id->text); $newPostID = $idText[2]; return $newPostID; }
Membuat postingan blog draf
Postingan draf dibuat dengan cara yang sama seperti postingan publik, tetapi Anda perlu menyetel atribut draf objek entri. Anda dapat membuat postingan blog seperti yang di atas sebagai draf dengan menambahkan baris yang ditandai:
function createDraftPost($title='Salutations, world!', $content='Hmm ... not quite right, must rework the title later.') { $uri = 'http://www.blogger.com/feeds/' . $blogID . '/posts/default'; $entry = $gdClient->newEntry(); $entry->title = $gdClient->newTitle(trim($title)); $entry->content = $gdClient->newContent($content); $entry->content->setType('text'); $control = $gdClient->newControl(); $draft = $gdClient->newDraft('yes'); $control->setDraft($draft); $entry->control = $control; $createdPost = $gdClient->insertEntry($entry, $uri); $idText = split('-', $createdPost->id->text); return $idText[2]; }
Dengan cara yang sama seperti menetapkan judul atau konten postingan, Anda
membuat objek Zend_Gdata_App_Extension_Control
dan Zend_Gdata_App_Extension_Draft
baru,
serta menetapkannya ke atribut kontrol entri.
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
yang sama dengan yang digunakan untuk mengambil metafeed blog, tetapi kali ini kirim URL feed postingan blog:
function printAllPosts($gdClient, $blogID) { $query = new Zend_Gdata_Query('http://www.blogger.com/feeds/' . $blogID . '/posts/default'); $feed = $gdClient->getFeed($query); printFeed($feed); }
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 objek kueri dan teruskan ke metode getFeed
.
Misalnya, untuk mengirim kueri rentang tanggal, tetapkan parameter published-min
dan published-max
objek kueri. Cuplikan kode berikut
mencetak judul dan isi setiap postingan blog yang dipublikasikan antara
waktu mulai dan waktu berakhir:
function printPostsInDateRange($gdClient, $blogID, $startDate='2007-04-01', $endDate='2007-04-25') { $query = new Zend_Gdata_Query('http://www.blogger.com/feeds/' . $blogID . '/posts/default'); $query->setParam('published-min', $startDate); $query->setParam('published-max', $endDate); $feed = $gdClient->getFeed($query); printFeed($feed); }
Metode proses debug yang berguna untuk class Zend_Gdata_Query
adalah getQueryUrl()
,
yang akan menampilkan URL yang dienkode yang telah dibuat.
Catatan: Saat ini tidak ada penyetel ajaib untuk
parameter kueri published-min
dan published-max
.
Namun, Anda dapat menggunakan setStartIndex
dan setMaxResults
.
Blogger Data API mendukung parameter kueri 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
. - hasil maks
- Jumlah maksimum entri yang akan ditampilkan.
- dipublikasikan-min, dipublikasikan-maks
- Batas pada tanggal publikasi entri.
- indeks awal
- Indeks berbasis 1 dari hasil pertama yang akan diambil (untuk paging).
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 save
. Cuplikan kode berikut mengubah judul dan
konten entri blog dengan asumsi bahwa Anda telah mengambil entri dari
server.
public function updatePost($postID, $updatedTitle='Hello, World?', $updatedContent='UPDATE: Still blogging', $isDraft=False) { $query = new Zend_Gdata_Query('http://www.blogger.com/feeds/' . $blogID . '/posts/default/' . $postID); $postToUpdate = $dClient->getEntry($query); $postToUpdate->title->text = $this->gdClient->newTitle($updatedTitle); $postToUpdate->content->text = $this->gdClient->newContent($updatedContent); if ($isDraft) { $draft = $gdClient->newDraft('yes'); } else { $draft = $gdClient->newDraft('no'); } $control = $gdClient->newControl(); $control->setDraft($draft); $postToUpdate->control = $control; $updatedPost = $postToUpdate->save(); return $updatedPost; }
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 $gdClient
Anda, seperti ini:
public function deletePost($gdClient, $blogID, $postID) { $uri = 'http://www.blogger.com/feeds/' . $blogID . '/posts/default/' . $postID; $gdClient->delete($uri); }
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 entri dan sisipkan sebagai berikut:
function createComment($gdClient, $blogID, $postID, $commentText) { $uri = 'http://www.blogger.com/feeds/' . $blogID . '/' . $postID . '/comments/default'; $newComment = $gdClient->newEntry(); $newComment->content = $gdClient->newContent($commentText); $newComment->content->setType('text'); $createdComment = $gdClient->insertEntry($newComment, $uri); $editLink = split('/', $createdComment->getEditLink()->href); $newCommentID = $editLink[8]; return $newCommentID; }
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.
public function printPostComments($gdClient, $blogID, $postID) { $query = new Zend_Gdata_Query('http://www.blogger.com/feeds/' . $blogID . '/' . $postID . '/comments/default'); $feed = $gdClient->getFeed($query); $printFeed($feed); }
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 $gdClient
Anda seperti ini:
public function deleteComment($gdClient, $blogID, $postID, $commentID) { $uri = 'http://www.blogger.com/feeds/' . $blogID . '/' . $postID . '/comments/default/' . $commentID; $gdClient->delete($uri); }