Panduan Developer: PHP

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 ada, dan membuat kueri untuk postingan blog yang cocok dengan kriteria tertentu.

Selain memberikan beberapa latar belakang tentang kemampuan Blogger Data API, dokumen ini memberikan contoh interaksi Data API dasar menggunakan library klien Zend Google Data API. Jika Anda tertarik untuk memahami lebih lanjut 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. Menggunakan pengambil dan penyetel ajaib
   4. Referensi lainnya
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 bagi programmer yang ingin menulis aplikasi klien PHP yang dapat berinteraksi dengan Blogger.

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

Untuk informasi referensi tentang class dan metode yang disediakan oleh library klien, lihat referensi API library klien PHP. Untuk mengetahui 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. Library 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

Sebaiknya Anda 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 Zend Framework. Contoh ini terletak di /framework/standard/trunk/demos/Zend/Gdata/Blogger.php. Contoh berisi semua fungsi yang dijelaskan dalam dokumen ini. Fungsi ini hanya dapat dijalankan dari command line:

php Blogger.php -- --user=[email_address] --pass=[password]

Sebelum menjalankan contoh ini atau mengembangkan kode sendiri menggunakan Zend Framework, Anda mungkin perlu menetapkan include_path dan memuat class yang sesuai. Jalur include dapat ditetapkan menggunakan setelan php.ini atau metode set_include_path. Kode ini meminta akses ke class Zend_Gdata inti, 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/pengambil ajaib untuk memudahkan developer. Hal ini memungkinkan properti class diakses dengan aman menggunakan metode penyetel/pengambil tradisional atau dengan mengakses properti. Misalnya, jika $gdataObject adalah instance dari objek dalam library ini, dua baris kode berikut memiliki efek yang sama:

$gdataObject->setFoo("bar");
$gdataObject->foo = "bar";

Demikian juga, dua baris kode ini juga memiliki efek yang identik:

$baz = $gdataObject->getFoo();
$baz = $gdataObject->foo;

Demikian pula, metode factory ajaib mempermudah deklarasi objek baru. Daripada mengingat nama class panjang yang diamanatkan oleh konvensi penamaan Zend, Anda dapat membuat object baru dengan memanggil newObject(); pada klien layanan Zend. Misalnya, dua cuplikan berikut mendeklarasikan objek ekstensi draft baru. Anda akan melihat info lainnya 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/pengambil ajaib dan factory bersifat opsional, jadi gunakan pendekatan mana pun yang paling cocok untuk Anda.

Resource lainnya

Referensi lain untuk komponen Google Data API dari Zend Framework (Zend_Gdata):

• Dokumentasi Referensi
• Informasi dan arsip milis
• Info Subversi Zend Framework
• Snapshot Zend Framework Nightly

Mengautentikasi ke layanan Blogger

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

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

Sebagian besar contoh di bagian selanjutnya dari dokumen ini mengasumsikan bahwa Anda memiliki objek klien terautentikasi yang disebut $gdClient.

Autentikasi OAuth

Untuk dokumentasi tentang autentikasi OAuth menggunakan library GData Zend PHP, lihat OAuth di Library Klien Protokol Data Google.

Autentikasi proxy AuthSub

Autentikasi proxy AuthSub digunakan oleh aplikasi web yang perlu mengautentikasi penggunanya ke Akun Google. Operator situs dan kode klien tidak memiliki akses ke nama pengguna dan sandi pengguna Blogger. Sebagai gantinya, klien memperoleh token AuthSub khusus agar klien dapat bertindak atas nama pengguna tertentu. Untuk mengetahui informasi yang lebih mendetail, lihat dokumentasi AuthSub.

Ketika pengguna pertama kali mengunjungi aplikasi Anda, mereka belum diautentikasi. Dalam hal ini, Anda perlu menampilkan beberapa informasi dan link yang mengarahkan pengguna ke halaman Google untuk mengautentikasi permintaan Anda agar mendapatkan akses ke 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 mengambil parameter berikut (sesuai dengan parameter kueri yang digunakan oleh pengendali AuthSubRequest):

berikutnya

URL halaman 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 berenkode URL).

aman

Menunjukkan apakah klien meminta token aman.

session

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.php

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 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 sekali pakai. Dalam contoh ini, sejak $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 memeriksa terlebih dahulu apakah token sesi AuthSub sudah ada. Jika tidak, tetapi token sekali pakai ditentukan di URL, cuplikan kode akan meneruskan token sekali pakai ke metode getAuthSubSessionToken, dan antarmuka AuthSub akan menampilkan token sesi. Kode ini kemudian menempatkan nilai token sesi dalam variabel sesi $_SESSION['sessionToken'].

Aplikasi Anda kemudian dapat menggunakan nilai token sesi dalam interaksi selanjutnya 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 "terinstal" satu pengguna mandiri (seperti aplikasi desktop).

Kode berikut menggunakan metode Zend_Gdata_ClientLogin::getHttpClient untuk membuat 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 secara eksplisit ditetapkan ke GOOGLE. Jika parameter ini tidak ditetapkan, pengguna G Suite tidak akan berhasil menggunakan Blogger API.

$user = '[e-mail]';
$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 dalam sesi tertentu; jangan dapatkan token baru untuk setiap permintaan Blogger.

Catatan: Seperti yang dijelaskan dalam dokumentasi ClientLogin, permintaan autentikasi mungkin gagal dan meminta tantangan CAPTCHA. Jika Anda ingin Google mengeluarkan dan menangani tantangan CAPTCHA, arahkan 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 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 dalam 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++;
  }
}

Catat URL yang digunakan oleh metode getFeed. Ini adalah URL feed meta default. URL ini menampilkan daftar blog untuk pengguna yang saat ini diautentikasi. Untuk mengakses feed bagi pengguna yang berbeda, Anda dapat menempatkan ID pengguna sebagai pengganti default di URL feed meta. ID pengguna adalah string digit di akhir URL profil pengguna.

Cuplikan kode di bawah ini menunjukkan cara mengekstrak ID blog dari feed. Anda memerlukan ID blog untuk melakukan operasi pembuatan, pembaruan, dan penghapusan pada postingan dan komentar. Variabel $index mewakili blog mana di feed blog pengguna yang sedang digunakan. Kolom id berupa tag:blogger.com,1999:user-userID.blog-blogID, sehingga split pada karakter '-' akan menempatkan ID blog di elemen terakhir array yang dihasilkan.

$idText = split('-', $feed->entries[$index]->id->text);
$blogID = $idText[2];

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 PHP untuk memublikasikan entri blog baru.

Pertama, buat instance entri untuk mewakili postingan blog. Kemudian, Anda dapat menetapkan judul, konten, dan atribut lain untuk postingan blog tersebut. Terakhir, panggil metode insertEntry untuk menyisipkan postingan. Anda dapat melihat pembuatan instance factory ajaib di sini dengan objek Zend_Gdata_Entry, Zend_Gdata_App_Extension_Title, dan Zend_Gdata_App_Extension_Content 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 draf postingan blog

Postingan draf dibuat dengan cara yang sama seperti postingan publik, tetapi Anda harus menyetel atribut draf objek entri. Anda dapat membuat postingan blog seperti 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, lalu menetapkannya ke atribut kontrol entri.

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

Mengambil postingan

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

Anda dapat melakukan kueri feed publik Blogger tanpa autentikasi. Oleh karena itu, Anda tidak perlu menyetel 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 feed meta 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 sekumpulan 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 dari objek kueri. Cuplikan kode berikut mencetak judul dan konten setiap postingan blog yang dipublikasikan antara waktu mulai dan waktu berakhir yang ditentukan:

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 menunjukkan 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 (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.

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

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

Memperbarui postingan

Untuk memperbarui postingan blog yang sudah ada, pertama-tama ambil entri yang ingin diperbarui, lalu ubah entrinya, kemudian kirimkan ke Blogger menggunakan metode save. Cuplikan kode berikut mengubah judul dan konten entri blog, dengan asumsi bahwa Anda telah mengambil entri tersebut 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 untuk membuat, mengambil, dan menghapus komentar. Memperbarui komentar tidak didukung (juga tidak tersedia di antarmuka web).

Membuat komentar

Untuk memposting komentar, buat objek entri dan masukkan seperti 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 terautentikasi.

Catatan: Menetapkan penulis kustom untuk komentar saat ini tidak didukung. Semua komentar baru akan muncul seolah-olah dibuat oleh pengguna yang saat ini 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);
}

Anda juga 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);
}

Kembali ke atas