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

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

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

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

เนื้อหา

  1. ผู้ชม
  2. การเริ่มต้นใช้งาน
    1. การสร้างบัญชี Blogger
    2. การเรียกใช้โค้ดตัวอย่าง
    3. การใช้ Magic Getters และ Setter
    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 อยู่แล้ว คุณก็ใช้งานได้เลย

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

ไคลเอ็นต์ตัวอย่างที่ใช้งานได้เต็มรูปแบบซึ่งมีโค้ดตัวอย่างทั้งหมดที่แสดงในเอกสารนี้พร้อมให้ใช้งานในที่เก็บ SVN ของ Zend Framework คุณสามารถดูตัวอย่างได้ที่ /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');

การใช้ Magic Getters และ Setters

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

$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 Framework (Zend_Gdata)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Blogger Data API มีฟีดที่แสดงรายการบล็อกสำหรับผู้ใช้ โดยฟีดนั้นเรียกว่า "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];

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

Blogger Data API ช่วยให้คุณสามารถสร้างและเผยแพร่รายการบล็อกใหม่ รวมถึงสร้างแบบร่างของรายการ

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

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

คุณสามารถใช้ไลบรารีไคลเอ็นต์ 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 ใหม่และกำหนดวัตถุเหล่านั้นให้กับแอตทริบิวต์ Control ของรายการ

คุณสามารถเปลี่ยนบล็อกโพสต์ฉบับร่างที่มีอยู่แล้วเป็นโพสต์ที่เผยแพร่แล้วได้โดยการเรียกข้อมูลโพสต์ฉบับร่าง แล้วตั้งค่าแอตทริบิวต์ข้อความร่างเป็น 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);
}

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

Blogger Data API ช่วยให้คุณขอชุดรายการที่ตรงกับเกณฑ์ที่ระบุ เช่น ขอบล็อกโพสต์ที่เผยแพร่หรืออัปเดตในช่วงวันที่ที่ระบุ ในการดำเนินการนี้ คุณต้องสร้างออบเจ็กต์การค้นหาและส่งไปยังเมธอด 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 ที่เข้ารหัสซึ่งสร้างขึ้น

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

API ข้อมูลของ Blogger สนับสนุนพารามิเตอร์การค้นหาต่อไปนี้

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

โปรดดูข้อมูลเพิ่มเติมเกี่ยวกับพารามิเตอร์การค้นหาได้ในคู่มืออ้างอิง Blogger Data API และคู่มืออ้างอิงสำหรับ 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);
}

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