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

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

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

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

תוכן עניינים

  1. קהל
  2. תחילת העבודה
    1. יצירת חשבון Blogger
    2. הרצת הקוד לדוגמה
    3. שימוש ב-getters וב-setters קסומים
    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.

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

שימוש ב-getters וב-setters קסומים

נוספה תמיכה במגדירים/מקבלים (setters/getters) קסומים בספריית הלקוח של PHP, כדי להקל על המפתחים. הם מאפשרים לגשת למאפיינים של הכיתה בצורה בטוחה באמצעות שיטות setter/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();

ה-setters/getters וה-factories הקסומים הם אופציונליים, כך שאפשר להשתמש בכל גישה שמתאימה לכם.

משאבים אחרים

מקורות מידע נוספים על הרכיב של Google Data APIs ב-Zend Framework‏ (Zend_Gdata):

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

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

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

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

אימות OAuth

מסמכי עזרה בנושא אימות OAuth באמצעות ספריית Zend PHP GData מפורטים במאמר 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>';

השיטה getAuthSubTokenUri מקבלת את הפרמטרים הבאים (התואמים לפרמטרים של השאילתה שבהם משתמש הטיפול בבקשת AuthSub):

הבא
כתובת ה-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. אפשר להשתמש ב-method‏ 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).

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

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

אחזור פוסטים באמצעות פרמטרים של שאילתה

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

שיטה שימושית לניפוי באגים של הכיתה 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.
max-results
המספר המקסימלי של הרשומות להחזרה.
published-min, ‏ published-max
הגבלות על תאריכי פרסום של רשומות.
start-index
האינדקס שמתחיל ב-1 של התוצאה הראשונה שאוחזרה (לצורך דפדוף).

מידע נוסף על פרמטרים של שאילתות זמין במדריך למפתחים של Blogger Data API ובמדריך למפתחים של Google Data APIs.

עדכון פוסטים

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

חזרה למעלה