המדריך למפתחים: PHP

ה-API של נתוני Blogger מאפשר לאפליקציות לקוח להציג ולעדכן תוכן ב-Blogger בפורמט של פידים של Google Data API.

אפליקציית הלקוח יכולה להשתמש ב-Blogger Data API כדי ליצור פוסטים חדשים בבלוג, לערוך או למחוק פוסטים קיימים בבלוג, ולשלוח שאילתות על פוסטים בבלוגים שתואמים לקריטריונים מסוימים.

בנוסף למתן קצת רקע לגבי היכולות של Blogger Data API, המסמך הזה מספק דוגמאות לאינטראקציות בסיסיות של Data API באמצעות ספריית הלקוח של Zend Google Data APIs. אם אתם מעוניינים לקבל מידע נוסף על הפרוטוקול הבסיסי שבו משתמשת הספרייה, תוכלו לעיין בקטע פרוטוקול במדריך הזה למפתחים.

תוכן עניינים

  1. קהל
  2. איך מתחילים
    1. יצירת חשבון ב-Blogger
    2. הרצת הקוד לדוגמה
    3. שימוש בתהליכי קסמים וקובעים
    4. מקורות מידע אחרים
  3. אימות מול שירות Blogger
    1. אימות OAuth
    2. אימות שרת proxy של AuthSub
    3. אימות שם משתמש/סיסמה של ClientLogin
  4. אחזור רשימת בלוגים
  5. יצירת פוסטים
    1. פרסום פוסט בבלוג
    2. יצירת טיוטה של פוסט בבלוג
  6. אחזור פוסטים
    1. אחזור כל הפוסטים בבלוג
    2. אחזור פוסטים באמצעות פרמטרים של שאילתה
  7. עדכון פוסטים
  8. מחיקת פוסטים
  9. תגובות
    1. יצירת תגובות
    2. אחזור תגובות
    3. מחיקת תגובות

קהל

המסמך הזה מיועד למתכנתים שרוצים לכתוב אפליקציות לקוח של PHP שיכולות לקיים אינטראקציה עם Blogger.

במסמך הזה יוצאים מנקודת הנחה שהבנתם את הרעיונות הכלליים שעומדים מאחורי פרוטוקול Google Data APIs.

מידע נוסף על המחלקות וה-methods שמסופקות על ידי ספריית הלקוח מופיע בחומר העזר בנושא 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 Framework, יכול להיות שתצטרכו להגדיר את include_path ולטעון את המחלקות המתאימות. ניתן להגדיר את נתיב ה-include באמצעות ההגדרה 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, נוספה תמיכה במגדירים/קבלות של קסם לנוחותם של מפתחים. הן מאפשרות לגשת בצורה בטוחה למאפיינים של הכיתה באמצעות שיטות מסורתיות של מגדיר/getter או על ידי גישה למאפיינים. לדוגמה, אם $gdataObject הוא מכונה של אובייקט בספרייה הזו, לשתי שורות הקוד הבאות יש השפעות זהות:

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

בדומה לכך, לשתי שורות הקוד האלה יש השפעות זהות:

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

באופן דומה, בזכות שיטות מפעל קסמים, קל יותר להצהיר על אובייקטים חדשים. במקום לזכור את שמות המחלקות הארוכים שנדרשים לפי המוסכמה למתן שמות של Zend, אפשר ליצור object חדש על ידי שליחת קריאה ל-newObject(); בלקוח שירות של Zend. לדוגמה, שני קטעי הקוד הבאים מצהירים על אובייקט תוסף 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 APIs של Zend Framework (Zend_Gdata):

אימות מול שירות Blogger

באמצעות ממשק ה-API של Blogger Data תוכלו לגשת אל פידים ציבוריים ופרטיים. לא נדרש אימות כלשהו בפידים ציבוריים, אבל הם לקריאה בלבד. אם אתם רוצים לשנות בלוגים, הלקוח שלכם צריך לבצע אימות לפני שיבקשו פידים פרטיים. ניתן לבצע אימות באמצעות כל אחת משלוש גישות: אימות OAuth, אימות שרת proxy של AuthSub או אימות שם משתמש/סיסמה של ClientLogin.

למידע נוסף על אימות באמצעות Google Data APIs באופן כללי, עיינו במאמרי העזרה בנושא אימות.

רוב הדוגמאות בקטעים הבאים של המסמך מניחות שיש לכם אובייקט לקוח מאומת בשם $gdClient.

אימות OAuth

למידע על אימות OAuth באמצעות ספריית GData של Zend PHP, ראו OAuth בספריות הלקוח של Google Data Protocol.

אימות שרת proxy של AuthSub

אימות שרת ה-proxy של AuthSub משמש אפליקציות אינטרנט שצריכים לאמת את המשתמשים שלהם בחשבונות Google. למפעיל האתר ולקוד הלקוח אין גישה לשם המשתמש ולסיסמה של המשתמש ב-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>';

ה-method getAuthSubTokenUri משתמשת בפרמטרים הבאים (בהתאם לפרמטרים של השאילתה שבהם משתמש ה-handler של 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 מצוין אסימון לשימוש חד-פעמי, קטע הקוד מעביר את האסימון לשימוש חד-פעמי ל-method getAuthSubSessionToken, וממשק AuthSub מחזיר אסימון סשן. לאחר מכן הקוד מוסיף את הערך של אסימון הסשן במשתנה הסשן $_SESSION['sessionToken'].

לאחר מכן האפליקציה יכולה להשתמש בערך של אסימון הסשן באינטראקציות הבאות עם Blogger. אפשר להשתמש ב-method Zend_Gdata_AuthSub::getHttpClient כדי לקבל אובייקט Zend_Http_Client שהכותרת שלו מוגדרת מראש Authorization כך שיכלול פרטי כניסה של AuthSub:

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

אימות שם משתמש/סיסמה של ClientLogin

כדאי להשתמש באימות ClientLogin אם הלקוח הוא לקוח עצמאי 'מותקן' על ידי משתמש יחיד (למשל אפליקציה למחשב).

הקוד הבא משתמש ב-method Zend_Gdata_ClientLogin::getHttpClient כדי לבצע בקשה לשירות ClientLogin, לאחזר אסימון אימות וליצור אובייקט Zend_Http_Client עם כותרת האימות המתאימה. לאחר מכן, ה-HttpClient שמוחזר באמצעות ה-method הזה משמש לבניית אובייקט שירות 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).

המערכת מאחזרת רשימת בלוגים

ה-API של נתוני Blogger מספק פיד שבו מפורטים הבלוגים של משתמש מסוים. הפיד הזה נקרא 'מטא-פיד'.

הקוד לדוגמה הבא משתמש באובייקט $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 כדי לפרסם רשומות חדשות בבלוג.

קודם כל, יוצרים מופע רשומה לייצוג הפוסט בבלוג. לאחר מכן ניתן להגדיר את הכותרת, התוכן ומאפיינים אחרים של הפוסט בבלוג. בסוף, קוראים ל-method 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 ולאחר מכן עדכון הפוסט. נעסוק באחזור ועדכון של פוסטים בשני הקטעים הבאים.

אחזור פוסטים

בקטעים הבאים מוסבר איך לאחזר רשימה של פוסטים בבלוג, עם ובלי פרמטרים של שאילתה.

אתם יכולים לשלוח שאילתה על פיד ציבורי ב-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 מאפשר לבקש קבוצת רשומות שתואמות לקריטריונים מסוימים, כמו בקשה לפרסום פוסטים בבלוג או לעדכון בטווח תאריכים נתון. כדי לעשות את זה, יוצרים אובייקט שאילתה ומעבירים אותו ל-method 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);
}

getQueryUrl() היא שיטה שימושית לניפוי באגים במחלקה Zend_Gdata_Query, שבה תוצג כתובת ה-URL המקודדת שנוצרה.

הערה: בשלב זה אין הגדרות קסם לפרמטרים של השאילתה published-min ו-published-max. עם זאת, אפשר להשתמש ב-setStartIndex וב-setMaxResults.

ה-Blogger Data API תומך בפרמטרים הבאים של שאילתות:

קטגוריות
בחירת קטגוריות (שנקראות גם תוויות) לסינון תוצאות הפיד. לדוגמה, הפונקציה http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie מחזירה רשומות עם התוויות Fritz וגם עם Laurie.
max-results
המספר המקסימלי של רשומות שצריך להחזיר.
פרסום מינימלי, פרסום מקסימלי
הגבולות לתאריכי פרסום הרשומה.
start-index
האינדקס מבוסס 1 של התוצאה הראשונה שיש לאחזר (לחלוקה לדפים).

למידע נוסף על פרמטרים של שאילתות, מומלץ לעיין במדריך העזר של Blogger Data API ובמדריך העזר לממשקי API של נתונים ב-Google.

עדכון פוסטים

כדי לעדכן פוסט קיים בבלוג, מאחזרים את הרשומה שרוצים לעדכן, משנים אותה ואז שולחים אותה ל-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 לעריכה של התגובה ל-method delete באובייקט $gdClient, באופן הבא:

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

חזרה למעלה