คู่มือสําหรับนักพัฒนาซอฟต์แวร์: PHP

API ข้อมูลของ Blogger จะช่วยให้แอปพลิเคชันไคลเอ็นต์สามารถดูและอัปเดตเนื้อหาของ Blogger ในรูปแบบของฟีด Google Data API

แอปพลิเคชันไคลเอ็นต์จะใช้ Blogger Data API เพื่อสร้างบล็อกโพสต์ใหม่ แก้ไขหรือลบบล็อกโพสต์ที่มีอยู่ และค้นหาบล็อกโพสต์ที่ตรงกับเกณฑ์หนึ่งๆ ได้

นอกเหนือจากให้ข้อมูลเกี่ยวกับความสามารถของ Blogger Data API แล้ว เอกสารนี้ยังให้ตัวอย่างการโต้ตอบพื้นฐานของ Data API โดยใช้ไลบรารีของไคลเอ็นต์ Zend Google Data API หากคุณสนใจทําความเข้าใจเกี่ยวกับโปรโตคอลสําคัญที่ไลบรารีใช้ โปรดดูส่วนโปรโตคอลของคู่มือนักพัฒนาซอฟต์แวร์รายนี้

เนื้อหา

1. ผู้ชม
2. เริ่มต้นใช้งาน
   1. การสร้างบัญชี Blogger
   2. การเรียกใช้โค้ดตัวอย่าง
   3. การใช้เวทมนตร์คาถาและศัตรู
   4. แหล่งข้อมูลอื่นๆ
3. การตรวจสอบสิทธิ์บริการ Blogger
   1. การตรวจสอบสิทธิ์ OAuth
   2. การตรวจสอบสิทธิ์พร็อกซี AuthSub
   3. การตรวจสอบสิทธิ์ชื่อผู้ใช้/รหัสผ่านของ ClientLogin
4. การเรียกดูรายการบล็อก
5. การสร้างโพสต์
   1. การเผยแพร่บล็อกโพสต์
   2. การสร้างบล็อกโพสต์ฉบับร่าง
6. การเรียกดูโพสต์
   1. การเรียกข้อมูลบล็อกโพสต์ทั้งหมด
   2. การเรียกดูโพสต์โดยใช้พารามิเตอร์การค้นหา
7. การอัปเดตโพสต์
8. การลบโพสต์
9. ความคิดเห็น
   1. การสร้างความคิดเห็น
   2. การเรียกดูความคิดเห็น
   3. การลบความคิดเห็น

กลุ่มเป้าหมาย

เอกสารนี้มีไว้สําหรับโปรแกรมเมอร์ที่ต้องการเขียนแอปพลิเคชันไคลเอ็นต์ PHP ที่โต้ตอบกับ Blogger ได้

เอกสารนี้จะถือว่าคุณเข้าใจแนวคิดทั่วไปเบื้องหลังโปรโตคอล Google Data API

สําหรับข้อมูลอ้างอิงเกี่ยวกับคลาสและเมธอดที่ได้จากไลบรารีของไคลเอ็นต์ โปรดดูข้อมูลอ้างอิง API ไลบรารีของไคลเอ็นต์ PHP สําหรับข้อมูลอ้างอิงทั่วไปของ Blogger Data API โปรดดูคู่มืออ้างอิงของโปรโตคอล

เริ่มต้นใช้งาน

สําหรับความช่วยเหลือในการตั้งค่าไลบรารีไคลเอ็นต์ โปรดดูคู่มือเริ่มต้นใช้งาน

ไลบรารีของไคลเอ็นต์ Zend ต้องใช้ PHP 5.1.4 ขึ้นไป ซึ่งเป็นส่วนหนึ่งของ Zend Framework และการดาวน์โหลดแยกต่างหาก หากต้องการโต้ตอบกับ Blogger ให้ใช้ไลบรารีของไคลเอ็นต์เวอร์ชัน 1.0.0 ขึ้นไป

การสร้างบัญชี Blogger

คุณอาจต้องลงชื่อสมัครใช้บัญชี Blogger เพื่อวัตถุประสงค์ในการทดสอบ Blogger ใช้บัญชี Google ดังนั้นหากคุณมี บัญชี Google อยู่แล้ว คุณก็พร้อมใช้งานได้ทันที

การเรียกใช้โค้ดตัวอย่าง

ไคลเอ็นต์ตัวอย่างแบบเต็มที่มีโค้ดตัวอย่างทั้งหมดที่แสดงในเอกสารนี้จะอยู่ในที่เก็บข้อมูล Zend Framework SVN ตัวอย่างอยู่ที่ /framework/standard/trunk/demos/Zend/Gdata/Blogger.php ตัวอย่างนี้มีฟังก์ชันทั้งหมดที่อธิบายไว้ในเอกสารนี้ ซึ่งสามารถเรียกใช้ได้จากบรรทัดคําสั่งเท่านั้น

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

ก่อนจะเรียกใช้ตัวอย่างนี้หรือพัฒนาโค้ดของคุณเองโดยใช้เฟรมเวิร์ก Zend คุณอาจต้องตั้งค่า include_path และโหลดคลาสที่เหมาะสม คุณตั้งค่าเส้นทางที่รวมได้โดยใช้การตั้งค่า php.ini หรือใช้วิธี set_include_path โค้ดนี้จะขอสิทธิ์เข้าถึงคลาส Zend_Gdata, คลาส Zend_Gdata_Query และคลาสการตรวจสอบสิทธิ์ 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');

การใช้เวทมนตร์คาถาและศัตรู

ในไลบรารีของไคลเอ็นต์ PHP เราได้เพิ่มการรองรับตัวตั้งค่า/เครื่องมือเวทมนตร์เพื่ออํานวยความสะดวกให้นักพัฒนาแอป วิธีนี้ช่วยให้เข้าถึงพร็อพเพอร์ตี้ของชั้นเรียนได้อย่างปลอดภัยโดยใช้เมธอด terter/getter แบบดั้งเดิมหรือเข้าถึงพร็อพเพอร์ตี้ ตัวอย่างเช่น หาก $gdataObject เป็นอินสแตนซ์ของออบเจ็กต์ในไลบรารีนี้ โค้ดสองบรรทัดต่อไปนี้จะมีผลเหมือนกัน

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

ในทํานองเดียวกัน โค้ดสองบรรทัดนี้ก็มีผลเหมือนกัน

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

ในทํานองเดียวกัน วิธีการจากโรงงานช่วยให้คุณประกาศออบเจ็กต์ใหม่ๆ ได้ง่ายขึ้น แต่แทนที่จะจําชื่อคลาสที่บังคับไว้ตามแบบแผนการตั้งชื่อของ Zend คุณจะสร้าง object ใหม่ได้โดยเรียก newObject(); บนไคลเอ็นต์บริการ Zend ตัวอย่างเช่น ข้อมูลโค้ด 2 แบบต่อไปนี้จะประกาศออบเจ็กต์ส่วนขยาย draft ใหม่ และคุณจะเห็น drafts มากขึ้นที่ส่วนการสร้างโพสต์

// Traditional instantiation
$gdClient = new Zend_Gdata();
$draft = new Zend_Gdata_App_Extension_Draft();

// Magic factory instantiation
$gdClient = new Zend_Gdata();
$draft = $gdClient->newDraft();

นักเล่าเรื่องในค่าย/โรงงานและโรงงานจะเลือกไม่บังคับ ดังนั้นให้ใช้วิธีการใดที่เหมาะกับคุณที่สุด

แหล่งข้อมูลอื่นๆ

ทรัพยากรอื่นๆ สําหรับคอมโพเนนต์ Google Data API (Zend_Gdata) ของ Zend Framework

• เอกสารอ้างอิง
• ข้อมูลรายชื่ออีเมลและที่เก็บถาวร
• ข้อมูลประเภทย่อยของ Zend Framework
• สแนปชอตของ Zend Framework Nightly

การตรวจสอบสิทธิ์กับบริการ Blogger

คุณสามารถเข้าถึงได้ทั้งฟีดสาธารณะและฟีดส่วนตัวโดยใช้ Blogger Data API ฟีดสาธารณะไม่จําเป็นต้องมีการตรวจสอบสิทธิ์ แต่เป็นแบบอ่านอย่างเดียว หากต้องการแก้ไขบล็อก ลูกค้าจะต้องตรวจสอบสิทธิ์ก่อนที่จะขอฟีดส่วนตัว โดยจะตรวจสอบสิทธิ์ได้โดยใช้ 1 ใน 3 วิธีต่อไปนี้ ได้แก่ การตรวจสอบสิทธิ์ OAuth, การตรวจสอบสิทธิ์พร็อกซี AuthSub หรือการตรวจสอบสิทธิ์ชื่อผู้ใช้/รหัสผ่าน ClientLogin

ดูข้อมูลเพิ่มเติมเกี่ยวกับการตรวจสอบสิทธิ์ด้วย Google Data API โดยทั่วไปได้ในเอกสารประกอบของการตรวจสอบสิทธิ์

ตัวอย่างส่วนใหญ่ในส่วนถัดไปของเอกสารนี้จะถือว่าคุณมีออบเจ็กต์ไคลเอ็นต์ที่ผ่านการตรวจสอบสิทธิ์ชื่อ $gdClient

การตรวจสอบสิทธิ์ OAuth

ดูเอกสารประกอบของ OAuth ที่ใช้ไลบรารี Zend PHP GData ได้ที่ OAuth ในไลบรารีของไคลเอ็นต์ Google Data Protocol

การตรวจสอบสิทธิ์พร็อกซี AuthSub

เว็บแอปพลิเคชันที่ใช้การตรวจสอบสิทธิ์พร็อกซี AuthSub ต้องมีการตรวจสอบสิทธิ์ผู้ใช้กับบัญชี Google ผู้ให้บริการเว็บไซต์และโค้ดของไคลเอ็นต์จะไม่มีสิทธิ์เข้าถึงชื่อผู้ใช้และรหัสผ่านสําหรับผู้ใช้ Blogger แต่จะได้รับโทเค็น AuthSub แบบพิเศษที่ช่วยให้ไคลเอ็นต์ดําเนินการแทนผู้ใช้รายนั้นได้ โปรดดูข้อมูลโดยละเอียดในเอกสารประกอบของ AuthSub

เมื่อผู้ใช้เข้าชมแอปพลิเคชันเป็นครั้งแรก ผู้ใช้จะยังไม่ผ่านการตรวจสอบสิทธิ์ ในกรณีนี้ คุณต้องแสดงข้อมูลบางส่วนและลิงก์ที่นําผู้ใช้ไปยังหน้า Google เพื่อตรวจสอบสิทธิ์คําขอของคุณสําหรับการเข้าถึงบล็อกของพวกเขา ไลบรารีของไคลเอ็นต์ Zend มีฟังก์ชันในการสร้าง URL ของ Google #39; โค้ดด้านล่างจะเรียก URL ของหน้า 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>';

เมธอด getAuthSubTokenUri ใช้พารามิเตอร์ต่อไปนี้ (สอดคล้องกับพารามิเตอร์การค้นหาที่ใช้โดย AuthSubRequest)

ถัดไป

URL ของหน้าที่ Google ควรเปลี่ยนเส้นทางให้ผู้ใช้ไปหลังจากการตรวจสอบสิทธิ์

ขอบเขต

ระบุว่าแอปพลิเคชันกําลังขอโทเค็นเพื่อเข้าถึงฟีด Blogger สตริงขอบเขตที่จะใช้คือ http://www.blogger.com/feeds/ (แน่นอนว่ามีการเข้ารหัส URL)

รักษาความปลอดภัย

ระบุว่าไคลเอ็นต์ขอโทเค็นที่ปลอดภัยหรือไม่

เซสชัน

ระบุว่าโทเค็นที่ส่งคืนจะแลกเปลี่ยนเป็นโทเค็นแบบใช้หลายเซสชัน (เซสชัน) ได้หรือไม่

ตัวอย่างข้างต้นแสดงการเรียกที่ไม่ได้ขอโทเค็นที่ปลอดภัย (ค่าของ secure คือ false) URL ของคําขอที่ได้อาจมีลักษณะเช่นนี้

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

ผู้ใช้ติดตามลิงก์ไปยังเว็บไซต์ของ Google และตรวจสอบสิทธิ์กับบัญชี Google ของตน

หลังจากที่ผู้ใช้ตรวจสอบสิทธิ์แล้ว ระบบ AuthSub จะเปลี่ยนเส้นทางผู้ใช้ไปยัง URL ที่คุณระบุในพารามิเตอร์การค้นหาของ next ของ URL AuthSubRequest ระบบ AuthSub จะเพิ่มโทเค็นการตรวจสอบสิทธิ์ต่อท้าย URL นั้นเป็นค่าของพารามิเตอร์การค้นหา token เช่น

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

คุณดึงค่าโทเค็นได้โดยใช้ $_GET['token']

ค่าโทเค็นนี้จะแสดงโทเค็น AuthSub แบบใช้ครั้งเดียว ในตัวอย่างนี้ หลังจากระบุ $session = true แล้ว โทเค็นนี้จะถูกแลกเปลี่ยนกับโทเค็นเซสชันของ AuthSub ได้โดยใช้เมธอด Zend_Gdata_AuthSub::getAuthSubSessionToken ซึ่งเรียกบริการ AuthSubSessionToken

if(! isset($_SESSION['sessionToken']) && isset($_GET['token'])) {
  $_SESSION['sessionToken'] =
      Zend_Gdata_AuthSub::getAuthSubSessionToken($_GET['token']);
}

ข้อมูลโค้ดนี้จะตรวจสอบว่ามีโทเค็นเซสชัน AuthSub อยู่แล้วหรือไม่ หากไม่ใช่ แต่มีการระบุโทเค็นแบบใช้ครั้งเดียวไว้ใน URL ข้อมูลโค้ดจะส่งโทเค็นแบบใช้ครั้งเดียวไปยังเมธอด getAuthSubSessionToken และอินเทอร์เฟซ AuthSub จะแสดงโทเค็นเซสชัน จากนั้นโค้ดจะวางค่าโทเค็นเซสชันในตัวแปรเซสชัน $_SESSION['sessionToken']

จากนั้นแอปพลิเคชันจะใช้ค่าโทเค็นเซสชันในการโต้ตอบที่ตามมากับ Blogger ได้ คุณใช้เมธอด Zend_Gdata_AuthSub::getHttpClient เพื่อดูออบเจ็กต์ Zend_Http_Client ที่มีการกําหนดส่วนหัว Authorization ไว้ล่วงหน้าเพื่อรวมข้อมูลเข้าสู่ระบบ AuthSub ได้ดังนี้

$client = Zend_Gdata_AuthSub::getHttpClient($_SESSION['sessionToken']);

การตรวจสอบสิทธิ์ชื่อผู้ใช้/รหัสผ่านของ ClientLogin

ใช้การตรวจสอบสิทธิ์ ClientLogin หากไคลเอ็นต์เป็นไคลเอ็นต์เดี่ยว "Installed" ไคลเอ็นต์ (เช่น แอปพลิเคชันเดสก์ท็อป)

โค้ดต่อไปนี้จะใช้เมธอด Zend_Gdata_ClientLogin::getHttpClient เพื่อส่งคําขอไปยังบริการ ClientLogin เรียกโทเค็นการตรวจสอบสิทธิ์ และสร้างออบเจ็กต์ Zend_Http_Client ที่มีส่วนหัวการตรวจสอบสิทธิ์ที่เหมาะสม จากนั้น HttpClient ที่แสดงผลด้วยวิธีนี้จะใช้เพื่อสร้างออบเจ็กต์บริการ Zend_Gdata

โปรดสังเกตว่ามีการตั้งค่า $accountType เป็น GOOGLE อย่างชัดเจน การไม่ตั้งค่าพารามิเตอร์นี้จะป้องกันไม่ให้ผู้ใช้ G Suite ใช้ 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);

ดูข้อมูลเพิ่มเติมเกี่ยวกับการตรวจสอบสิทธิ์ ClientLogin รวมถึงตัวอย่างคําขอและการตอบกลับได้จากเอกสารประกอบการตรวจสอบสิทธิ์สําหรับแอปพลิเคชันที่ติดตั้งไว้

หมายเหตุ: ใช้โทเค็นเดียวกันสําหรับคําขอทั้งหมดในเซสชันที่ระบุ และอย่าสร้างโทเค็นใหม่สําหรับคําขอ Blogger แต่ละรายการ

หมายเหตุ: ตามที่อธิบายไว้ในเอกสารประกอบของ ClientLogin คําขอการตรวจสอบสิทธิ์อาจล้มเหลวและส่งคําขอ CAPTCHA หากต้องการให้ Google ออกและจัดการปัญหา CAPTCHA ให้ส่งผู้ใช้ไปที่ https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger (แทนที่จะส่ง URL การจัดการ CAPTCHA ที่ระบุในเอกสารประกอบ ClientLogin)

กําลังเรียกดูรายการบล็อก

API ข้อมูลของ Blogger มีฟีดที่แสดงรายการบล็อกของผู้ใช้บางราย ฟีดนั้นเรียกว่า "metafeed."

โค้ดตัวอย่างต่อไปนี้ใช้ออบเจ็กต์ $gdClient ที่ตรวจสอบสิทธิ์แล้วเพื่อเรียกเมตาฟีดแล้วพิมพ์ชื่อของบล็อกแต่ละรายการ

คลาส Zend_Gdata_Query จะดูแลการสร้าง URL การค้นหา ในกรณีนี้ คุณไม่จําเป็นต้องดําเนินการใดๆ เพิ่มเติม แต่ประโยชน์ของชั้นเรียน Query จะมีผลในส่วนการดึงข้อมูลโพสต์ตามพารามิเตอร์การค้นหาของเอกสารฉบับนี้

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++;
  }
}

จด URL ที่เมธอด getFeed ใช้ นี่คือ URL เมตาฟีดเริ่มต้น โดยระบบจะแสดงรายการบล็อกสําหรับผู้ใช้ที่ได้รับการตรวจสอบสิทธิ์ในปัจจุบัน หากต้องการเข้าถึงฟีดของผู้ใช้รายอื่น คุณสามารถใส่รหัสของผู้ใช้แทน default ใน URL เมตาฟีด รหัส'ของผู้ใช้คือสตริงตัวเลขท้าย URL โปรไฟล์ของผู้ใช้

ข้อมูลโค้ดด้านล่างแสดงวิธีดึงข้อมูลรหัสบล็อกจากฟีด คุณจะต้องใช้รหัสบล็อกในการสร้าง อัปเดต และลบการดําเนินการในโพสต์และความคิดเห็น ตัวแปร $index แสดงถึงบล็อกในฟีดบล็อกของผู้ใช้ ช่อง id จะใช้รูปแบบ tag:blogger.com,1999:user-userID.blog-blogID ดังนั้น split ในอักขระ '-' วางรหัสบล็อกไว้ในองค์ประกอบสุดท้ายของอาร์เรย์ผลลัพธ์

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

การสร้างโพสต์

API ข้อมูลของ Blogger ช่วยให้คุณสามารถสร้างและเผยแพร่รายการบล็อกใหม่ เช่นเดียวกับการสร้างฉบับร่างของรายการ

หมายเหตุ: ปัจจุบันระบบยังไม่รองรับการตั้งค่าผู้เขียนที่กําหนดเองสําหรับโพสต์ โพสต์ใหม่ทั้งหมดจะปรากฏเหมือนกับว่าสร้างขึ้นโดยผู้ใช้ที่ตรวจสอบสิทธิ์แล้วในปัจจุบัน

การเผยแพร่บล็อกโพสต์

คุณใช้ไลบรารีของไคลเอ็นต์ PHP เพื่อเผยแพร่รายการบล็อกใหม่ได้

ขั้นแรก สร้างอินสแตนซ์รายการสําหรับแสดงบล็อกโพสต์ จากนั้น คุณจะตั้งชื่อ เนื้อหา และแอตทริบิวต์อื่นๆ ของบล็อกโพสต์ได้ และสุดท้าย ให้เรียกเมธอด insertEntry เพื่อแทรกโพสต์ ดูการเริ่มต้นโรงงานเวทมนตร์ในที่ทํางานได้ที่นี่ด้วยออบเจ็กต์ Zend_Gdata_Entry, Zend_Gdata_App_Extension_Title และ Zend_Gdata_App_Extension_Content ใหม่

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;
}

การสร้างบล็อกโพสต์ฉบับร่าง

โพสต์ฉบับร่างสร้างขึ้นในลักษณะเดียวกับโพสต์สาธารณะ แต่คุณต้องตั้งค่าแอตทริบิวต์ฉบับร่างของออบเจ็กต์รายการ คุณสร้างบล็อกโพสต์ที่คล้ายกับด้านบนเป็นแบบร่างได้โดยการเพิ่มบรรทัดที่ไฮไลต์ ดังนี้

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];
}

คุณสามารถสร้างชื่อ Zend_Gdata_App_Extension_Control และ Zend_Gdata_App_Extension_Draft ใหม่และมอบหมายให้กับแอตทริบิวต์การควบคุมของรายการได้ในลักษณะเดียวกันกับการตั้งค่าชื่อหรือเนื้อหาของโพสต์

คุณเปลี่ยนบล็อกโพสต์ฉบับร่างที่มีอยู่เป็นโพสต์ที่เผยแพร่แล้วได้โดยเรียกข้อมูลโพสต์ฉบับร่าง ตั้งค่าแอตทริบิวต์ฉบับร่างเป็น no แล้วอัปเดตโพสต์ เราจะอธิบายถึงการเรียกและอัปเดตโพสต์ในอีก 2 ส่วนถัดไป

กําลังเรียกโพสต์

ส่วนต่อไปนี้จะอธิบายถึงวิธีเรียกรายการบล็อกโพสต์ที่มีและไม่มีพารามิเตอร์การค้นหา

คุณค้นหาฟีดสาธารณะของ Blogger ได้โดยไม่ต้องตรวจสอบสิทธิ์ ดังนั้น คุณจึงไม่จําเป็นต้องตั้งค่าข้อมูลรับรองหรือการตรวจสอบสิทธิ์ AuthSub ก่อนที่จะดึงข้อมูลโพสต์จากบล็อกสาธารณะ

กําลังเรียกบล็อกโพสต์ทั้งหมด

หากต้องการเรียกโพสต์ของผู้ใช้ ให้เรียกเมธอด getFeed เดียวกันกับที่ใช้เรียกเมตาแท็กของบล็อก แต่ครั้งนี้จะส่ง URL ของฟีดบล็อกโพสต์

function printAllPosts($gdClient, $blogID)
{
  $query = new Zend_Gdata_Query('http://www.blogger.com/feeds/' . $blogID . '/posts/default');
  $feed = $gdClient->getFeed($query);
  printFeed($feed);
}

การดึงข้อมูลโพสต์โดยใช้พารามิเตอร์การค้นหา

API ข้อมูลของ Blogger ช่วยให้คุณขอชุดรายการที่ตรงกับเกณฑ์ที่ระบุได้ เช่น การขอบล็อกโพสต์ที่เผยแพร่หรืออัปเดตในช่วงวันที่หนึ่งๆ ซึ่งทําได้โดยสร้างออบเจ็กต์การค้นหาและส่งไปยังเมธอด getFeed

ตัวอย่างเช่น หากต้องการส่งคําค้นหาตามช่วงวันที่ ให้ตั้งค่าพารามิเตอร์ published-min และ published-max ของออบเจ็กต์การค้นหา ข้อมูลโค้ดต่อไปนี้จะพิมพ์ชื่อและเนื้อหาของบล็อกโพสต์แต่ละรายการที่เผยแพร่ระหว่างเวลาเริ่มต้นและเวลาสิ้นสุดที่ระบุ

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

วิธีแก้ไขข้อบกพร่องที่มีประโยชน์สําหรับคลาส Zend_Gdata_Query คือ getQueryUrl() ซึ่งจะแสดง URL ที่เข้ารหัสซึ่งสร้างขึ้นมาแล้ว

หมายเหตุ: ขณะนี้ยังไม่มีการตั้งค่าเวทมนตร์สําหรับพารามิเตอร์การค้นหา published-min และ published-max อย่างไรก็ตาม คุณสามารถใช้ setStartIndex และ setMaxResults

Blogger Data API รองรับพารามิเตอร์การค้นหาต่อไปนี้

หมวดหมู่

ระบุหมวดหมู่ (หรือที่เรียกว่าป้ายกํากับ) เพื่อกรองผลลัพธ์ของฟีด เช่น http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie จะแสดงรายการป้ายกํากับทั้ง Fritz และ Laurie

ผลลัพธ์สูงสุด

จํานวนสูงสุดของผลลัพธ์ที่จะแสดง

เผยแพร่ต่ําสุด, เผยแพร่สูงสุด

ขอบเขตวันที่เผยแพร่รายการที่ป้อน

ดัชนีเริ่มต้น

ดัชนี 1 จากผลลัพธ์แรกที่จะดึงมา (สําหรับการแบ่งหน้า)

ดูข้อมูลเพิ่มเติมเกี่ยวกับพารามิเตอร์การค้นหาได้ที่คู่มืออ้างอิง API ข้อมูลของ Blogger และคู่มืออ้างอิงสําหรับ Google Data API

กําลังอัปเดตโพสต์

หากต้องการอัปเดตบล็อกโพสต์ที่มีอยู่ อันดับแรกให้เรียกข้อมูลรายการที่คุณต้องการอัปเดต จากนั้นแก้ไข และส่งไปยัง Blogger โดยใช้เมธอด save ข้อมูลโค้ดต่อไปนี้จะปรับเปลี่ยนชื่อและเนื้อหาของรายการบล็อก สมมติว่าคุณได้เรียกข้อมูลรายการจากเซิร์ฟเวอร์แล้ว

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;
}

หมายเหตุ: ยังไม่รองรับการแก้ไขข้อมูลผู้เขียนที่เชื่อมโยงกับโพสต์

กําลังลบโพสต์

หากต้องการลบโพสต์ ให้ส่ง URL การแก้ไขโพสต์ไปยังเมธอด delete ในออบเจ็กต์ $gdClient ดังนี้

public function deletePost($gdClient, $blogID, $postID)
{
  $uri = 'http://www.blogger.com/feeds/' . $blogID . '/posts/default/' . $postID;
  $gdClient->delete($uri);
}

ความคิดเห็น

Blogger Data API ช่วยให้สร้าง ดึงข้อมูล และลบความคิดเห็นได้ ไม่สนับสนุนการอัปเดตความคิดเห็น (หรือไม่พร้อมใช้งานในอินเทอร์เฟซเว็บ)

การสร้างความคิดเห็น

หากต้องการโพสต์ความคิดเห็น ให้สร้างออบเจ็กต์รายการแล้วแทรกไว้ดังนี้

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; 
}

หมายเหตุ: ปัจจุบันคุณสามารถโพสต์ความคิดเห็นไปยังบล็อก ของผู้ใช้ที่ผ่านการตรวจสอบสิทธิ์เท่านั้น

หมายเหตุ: ยังไม่รองรับการตั้งค่าผู้เขียนที่กําหนดเองสําหรับความคิดเห็นในขณะนี้ ความคิดเห็นใหม่ทั้งหมดจะแสดงเหมือนกับว่าความคิดเห็นเหล่านั้นสร้างขึ้นโดยผู้ใช้ที่ตรวจสอบสิทธิ์แล้วในปัจจุบัน

กําลังดึงข้อมูลความคิดเห็น

คุณสามารถดึงความคิดเห็นสําหรับโพสต์ใดโพสต์หนึ่งจาก URL ฟีดของความคิดเห็น

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

หรือรับความคิดเห็นจากทุกโพสต์โดยใช้ URL ของฟีดความคิดเห็นเกี่ยวกับบล็อกก็ได้ ดังนี้

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

กําลังลบความคิดเห็น

หากต้องการลบความคิดเห็น ให้ส่ง URL แก้ไขความคิดเห็นไปยังเมธอด delete ในออบเจ็กต์ $gdClient ดังนี้

public function deleteComment($gdClient, $blogID, $postID, $commentID)
{
  $uri = 'http://www.blogger.com/feeds/' . $blogID . '/' . $postID . '/comments/default/' . $commentID;
  $gdClient->delete($uri);
}

กลับไปด้านบน