מדריך למפתחים: פרוטוקול

חשוב: זוהי גרסה ישנה של הדף הזה. כדי לקבל את הגרסה האחרונה, אפשר להשתמש בקישורים בסרגל הניווט הימני.

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

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

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

תוכן עניינים

קהל

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

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

אם אתם משתמשים במערכת UNIX ואתם רוצים לנסות את הדוגמאות במסמך הזה בלי לכתוב קוד, תוכלו להיעזר בכלי שורת הפקודה של UNIX‏ curl או wget. למידע נוסף, תוכלו לעיין במסמכי העזרה של הכלים האלה.

מידע על Blogger Data API זמין במדריך העזרה של הפרוטוקול.

תחילת העבודה

יצירת חשבון Blogger

כדאי להירשם לחשבון Blogger למטרות בדיקה. ב-Blogger נעשה שימוש בחשבונות Google, כך שאם כבר יש לכם חשבון Google, אתם מוכנים.

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

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

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

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

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

אימות שרת proxy של AuthSub משמש אפליקציות אינטרנט שצריכות לאמת את המשתמשים שלהן בחשבונות Google. למפעיל האתר ולקוד הלקוח אין גישה לשם המשתמש ולסיסמה של משתמש Blogger. במקום זאת, הלקוח מקבל אסימוני AuthSub מיוחדים שמאפשרים לו לפעול בשם משתמש מסוים. מידע מפורט יותר זמין במסמכי התיעוד של AuthSub.

כשמשתמש נכנס לאפליקציה בפעם הראשונה, הוא עדיין לא אומת. במקרה כזה, תצטרכו להציג מידע מסוים וקישור שמפנה את המשתמש לדף של Google כדי לאמת את הבקשה שלכם לגישה לבלוגים שלהם.

הפרמטרים הבאים של השאילתה כלולים בכתובת ה-URL של AuthSubRequest:

הבא

כתובת ה-URL של הדף שאליו Google צריכה להפנות את המשתמש אחרי האימות.

היקף

הערך הזה מציין שהאפליקציה מבקשת אסימון כדי לגשת לפידים של Blogger. מחרוזת ההיקף שבה צריך להשתמש היא http://www.blogger.com/feeds/ (כמובן, מקודדת ככתובת URL).

מאובטח

הערך הזה מציין אם הלקוח מבקש אסימון מאובטח.

ביקור

הערך הזה מציין אם אפשר להמיר את האסימון שהוחזר לאסימון לשימוש רב-פעמי (סשן).

כתובת ה-URL של AuthSubRequest עשויה להיראות כך:

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

המשתמש עוקב אחרי הקישור לאתר של Google ומבצע אימות בחשבון Google שלו.

אחרי שהמשתמש עובר אימות, מערכת AuthSub מפנה אותו לכתובת ה-URL שציינתם בפרמטר השאילתה next בכתובת ה-URL של AuthSubRequest. מערכת AuthSub מצרפת אסימון אימות לכתובת ה-URL הזו, בתור הערך של פרמטר השאילתה token. לדוגמה:

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

ערך האסימון הזה מייצג אסימון AuthSub לשימוש יחיד. בדוגמה הזו, מכיוון שצוין session=1, אפשר להחליף את האסימון הזה באסימון סשן של AuthSub על ידי קריאה לשירות AuthSubSessionToken עם האסימון לשימוש יחיד בכותרת Authorization, באופן הבא:

GET /accounts/AuthSubSessionToken HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Authorization: AuthSub token="yourAuthToken"
User-Agent: Java/1.5.0_06
Host: www.google.com
Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2
Connection: keep-alive

תגובת השירות AuthSubSessionToken כוללת כותרת Token שמכילה את אסימון הסשן וכותרת Expiration שמציינת למשך כמה זמן האסימון יישאר בתוקף.

לאחר מכן, האפליקציה שלכם יכולה להשתמש בערך של אסימון הסשן בכותרת Authorization של האינטראקציות הבאות עם Blogger.

לפניכם דוגמה לבקשת HTTP, שמכילה אסימון לא מאובטח, שעשויה להישלח אל Blogger:

GET /feeds/blogID/blogs/posts/defaults HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Authorization: AuthSub token="yourSessionToken"
User-Agent: Java/1.5.0_06
Host: www.blogger.com
Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2
Connection: keep-alive

אימות באמצעות שם משתמש/סיסמה ב-ClientLogin

משתמשים באימות ClientLogin אם הלקוח הוא לקוח 'מותקן' עצמאי עם משתמש יחיד (למשל, אפליקציה למחשב). כדי לבקש אסימון אימות באמצעות מנגנון ClientLogin, שולחים בקשת POST לכתובת ה-URL הבאה:

https://www.google.com/accounts/ClientLogin

הגוף של POST צריך להכיל קבוצה של פרמטרים של שאילתות שנראים כמו פרמטרים שהועברו על ידי טופס HTML, באמצעות סוג התוכן application/x-www-form-urlencoded. הפרמטרים האלה הם:

אימייל

כתובת האימייל של המשתמש.

Passwd

הסיסמה של המשתמש.

שירות

שם השירות של Blogger הוא blogger. (שמות שירות אחרים מפורטים ברשימת שמות השירותים).

accountType

כשמשתמשים ב-Blogger API, צריך תמיד להגדיר את הערך הזה כ-GOOGLE. אם לא תגדירו את הפרמטר הזה, משתמשים שיש להם גם חשבון G Suite לא יוכלו לגשת.

source

מזהה את אפליקציית הלקוח. צריך להיות בפורמט companyName-applicationName-versionID. בדוגמאות נעשה שימוש בשם exampleCo-exampleApp-1.

מידע נוסף על הפרמטרים זמין במסמך אימות לאפליקציות מותקנות.

אם בקשת האימות נכשלת, השרת מחזיר את קוד הסטטוס 403 Forbidden של HTTP.

אם הבקשה תתבצע בהצלחה, השרת יחזיר את קוד הסטטוס 200 OK של HTTP, וגם שלושה קודים אלפאנומריים ארוכים בגוף התגובה: SID,‏ LSID ו-Auth. הערך Auth הוא אסימון ההרשאה ששולחים ל-Blogger בכל אחת מהבקשות הבאות, לכן חשוב לשמור עותק של הערך הזה. אפשר להתעלם מהערכים של SID ו-LSID.

מאחר שכל הבקשות לפידים פרטיים מחייבות אימות, צריך להגדיר את הכותרת Authorization בכל האינטראקציות הבאות עם Blogger, באמצעות הפורמט הבא:

Authorization: GoogleLogin auth=yourAuthToken

כאשר yourAuthToken היא מחרוזת האימות שמוחזרת מהבקשה ClientLogin.

למידע נוסף על אימות ClientLogin, כולל בקשות ותגובות לדוגמה, אפשר לעיין במאמר אימות לאפליקציות מותקנות.

הערה: צריך להשתמש באותו אסימון לכל הבקשות בסשן נתון, ולא לקבל אסימון חדש לכל בקשה ב-Blogger.

הערה: כפי שמתואר במסמכי העזרה של ClientLogin, ייתכן שבקשת האימות תיכשל ותתבקש השלמת אתגר CAPTCHA. אם רוצים ש-Google תיצור את האתגר של CAPTCHA ותטפל בו, צריך לשלוח את המשתמש אל https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger (במקום לכתובת ה-URL לטיפול ב-CAPTCHA שמופיעה במסמכי העזרה של ClientLogin).

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

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

כדי לאחזר את רשימת הבלוגים, שולחים HTTP GET לכתובת ה-URL הבאה:

http://www.blogger.com/feeds/userID/blogs

הערה: אפשר גם להחליף את מזהה המשתמש ב-default, כדי להורות ל-Blogger להחזיר את רשימת הבלוגים של המשתמש שהפרטים שלו מצורפים לבקשה.

רשומה במטא-פיד עשויה להיראות כך:

<entry>
  <id>tag:blogger.com,1999:blog-blogID.post-postID</id>
  <published>2006-08-02T18:44:43.089-07:00</published>
  <updated>2006-11-08T18:10:23.020-08:00</updated>
  <title type='text'>Lizzy's Diary</title>
  <summary type='html'>Being the journal of Elizabeth Bennet</summary>
  <link rel='alternate' type='text/html'
    href='http://blogName.blogspot.com/'>
  </link>
  <link rel='http://schemas.google.com/g/2005#feed'
    type='application/atom+xml'
    href='http://blogName.blogspot.com/feeds/posts/default'>
  </link>
  <link rel='http://schemas.google.com/g/2005#post'
    type='application/atom+xml'
    href='http://www.blogger.com/feeds/blogID/posts/default'>
  </link>
  <link rel='self' type='application/atom+xml'
    href='http://www.blogger.com/feeds/userID/blogs/blogID'>
  </link>
  <link rel='edit' type='application/atom+xml'
      href='http://www.blogger.com/feeds/userID/blogs/blogID'>
  </link>
  <author>
    <name>Elizabeth Bennet</name>
    <email>noreply@blogger.com</email>
    <uri>http://www.blogger.com/profile/profileID</uri>
  </author>
</entry>

למידע על המשמעות של כל אחד מהרכיבים האלה, אפשר לעיין במסמך Google Data APIs Protocol Reference או במפרט של Atom 1.0.

אם הבקשה נכשלת מסיבה כלשהי, יכול להיות ש-Blogger יחזיר קוד סטטוס אחר. מידע נוסף על קודי סטטוס HTTP זמין גם במסמך Google Data API Protocol Reference.

יצירת פוסטים

באמצעות Blogger Data API אפשר ליצור ולפרסם רשומות חדשות בבלוג, וגם ליצור טיוטות של רשומות.

פרסום פוסט בבלוג

אחרי האימות, תוכלו לפרסם רשומות חדשות בבלוג.

קודם כל, יוצרים ייצוג XML של הפוסט שרוצים לפרסם. קובץ ה-XML צריך להיות בפורמט של רכיב Atom <entry>, שעשוי להיראות כך:

<entry xmlns='http://www.w3.org/2005/Atom'>
  <title type='text'>Marriage!</title>
  <content type='xhtml'>
    <div xmlns="http://www.w3.org/1999/xhtml">
      <p>Mr. Darcy has <em>proposed marriage</em> to me!</p>
      <p>He is the last man on earth I would ever desire to marry.</p>
      <p>Whatever shall I do?</p>
    </div>
  </content>
  <category scheme="http://www.blogger.com/atom/ns#" term="marriage" />
  <category scheme="http://www.blogger.com/atom/ns#" term="Mr. Darcy" />
</entry>

הערה: בשלב הזה אי אפשר להגדיר מחבר מותאם אישית לפוסטים. כל הפוסטים החדשים יופיעו כאילו נוצרו על ידי המשתמש המאומת הנוכחי.

כדי לפרסם את הרשומה הזו, שולחים אותה לכתובת ה-URL של הפוסט בבלוג באופן הבא. קודם כול, צריך להוסיף את הרכיב <entry> של Atom לגוף של בקשת POST חדשה, באמצעות סוג התוכן application/atom+xml. לאחר מכן, מחפשים את כתובת ה-URL של הפוסט בבלוג במטא-פיד. לשם כך, מאתרים את הרכיב <link> שבו המאפיין rel מסתיים ב-#post. כתובת ה-URL של הפוסט בבלוג מצוינה כמאפיין href של הרכיב הזה, בפורמט הזה:

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

הערה: כתובת ה-URL הזו זהה לכתובת ה-URL בתג <link rel="service.post"> שמופיעה בקטע <head> בגרסה של הבלוג שניתנת לקריאה על ידי בני אדם.

מערכת Blogger יוצרת פוסט בבלוג באמצעות הרשומה ששלחתם, ואז מחזירה קוד סטטוס HTTP‏ 201 CREATED, יחד עם עותק של הפוסט החדש בצורת רכיב <entry>. הרשומה שתקבלו תהיה זהה לזו ששלחתם, אבל היא תכלול גם רכיבים שונים שנוספו על ידי Blogger, כמו רכיב <id>.

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

יצירת טיוטה של פוסט בבלוג

טיוטות של פוסטים נוצרות באותו אופן שבו נוצרים פוסטים ציבוריים, אבל עם הוספה של הרכיב <app:control> לרשומה כדי לציין שהפוסט עדיין לא צריך להתפרסם.

אלמנט ה-<app:control> הזה צריך לכלול רכיב <app:draft> יחיד כצאצא:

<app:control xmlns:app='http://purl.org/atom/app#'>
  <app:draft>yes</app:draft>
</app:control>

כדי שהפוסט יזוהה כטיוטה, הנתונים שמופיעים ברכיב <app:draft> חייבים להיות המחרוזת yes.

כדי להפוך טיוטה קיימת של פוסט בבלוג לפוסט שפורסם, אפשר לאחזר את טיוטת הפוסט, להגדיר את הנתונים של הרכיב <app:draft> למחרוזת no ואז לעדכן את הפוסט. בשני הקטעים הבאים מוסבר איך מאחזרים ומעדכנים פוסטים.

הערה: מידע נוסף על פרוטוקול הפרסום של Atom, כולל מרחב השמות <app:control> ו-<app:draft>, זמין במסמך RFC 5023.

אחזור פוסטים

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

אפשר לשלוח שאילתות לפיד ציבורי ב-Blogger בלי אימות. לכן, אין צורך להגדיר את הפרמטר Authorization כשמאחזרים פוסטים בבלוג מבלוג ציבורי.

אחזור כל פוסטי הבלוג

כדי לאחזר את הפוסטים של המשתמש, שולחים בקשת HTTP GET לכתובת ה-URL של הפיד בבלוג. לאחר מכן, Blogger מחזיר פיד שמכיל את רשומות הבלוג המתאימות. לדוגמה, כדי לקבל רשימה של פוסטים בבלוג של liz@gmail.com, שולחים את בקשת ה-HTTP הבאה ל-Blogger (כמובן, עם הערך המתאים במקום blogID):

GET http://www.blogger.com/feeds/blogID/posts/default

לאחר מכן, Blogger מחזיר קוד סטטוס HTTP 200 OK ופיד Atom 1.0 רגיל שמכיל את פוסטי הבלוג.

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

<feed xmlns='http://www.w3.org/2005/Atom'>
  <id>tag:blogger.com,1999:blog-blogID</id>
  <updated>2006-11-08T18:10:23.020-08:00</updated>
  <title type='text'>Lizzy's Diary</title>
  <link rel='alternate' type='text/html'
    href='http://blogName.blogspot.com/index.html'>
  </link>
  <link rel='http://schemas.google.com/g/2005#feed'
    type='application/atom+xml'
    href='http://blogName.blogspot.com/feeds/posts/default'>
  </link>
  <link rel='self' type='application/atom+xml'
    href='http://blogName.blogspot.com/feeds/posts/default'>
  </link>
  <author>
    <name>Elizabeth Bennet</name>
    <email>noreply@blogger.com</email>
    <uri>http://www.blogger.com/profile/profileID</uri>
  </author>
  <generator version='7.00' uri='http://www2.blogger.com'>Blogger</generator>
  <entry>
    <id>tag:blogger.com,1999:blog-blogID.post-postID</id>
    <published>2006-11-08T18:10:00.000-08:00</published>
    <updated>2006-11-08T18:10:14.954-08:00</updated>
    <title type='text'>Quite disagreeable</title>
    <content type='html'>&lt;p&gt;I met Mr. Bingley's friend Mr. Darcy
      this evening. I found him quite disagreeable.&lt;/p&gt;</content>
    <link rel='alternate' type='text/html'
      href='http://blogName.blogspot.com/2006/11/quite-disagreeable.html'>
    </link>
    <link rel='self' type='application/atom+xml'
      href='http://blogName.blogspot.com/feeds/posts/default/postID'>
    </link>
    <link rel='edit' type='application/atom+xml'
      href='http://www.blogger.com/feeds/blogID/posts/default/postID'>
    </link>
    <author>
      <name>Elizabeth Bennet</name>
      <email>noreply@blogger.com</email>
      <uri>http://www.blogger.com/profile/profileID</uri>
    </author>
  </entry>
</feed>

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

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

לדוגמה, כדי לשלוח שאילתה לפי טווח תאריכים, מוסיפים את הפרמטרים published-min ו-published-max לכתובת ה-URL של הבקשה. כדי לקבל את כל רשומות הבלוג שנוצרו בין 16 במרץ 2008 ל-24 במרץ 2008, שולחים בקשת HTTP לכתובת ה-URL של הפיד של הבלוג:

GET http://www.blogger.com/feeds/blogID/posts/default?published-min=2008-03-16T00:00:00&published-max=2008-03-24T23:59:59

כששולחים את הבקשה GET, מערכת Blogger מחזירה קוד סטטוס HTTP‏ 200 OK ופיד שמכיל את כל פוסטי הבלוג שנוצרו בטווח התאריכים שציינתם.

אפשר גם להשתמש בפרמטרים updated-min ו-updated-max כדי לקבל את כל העדכונים של רשומות הבלוג בטווח נתון. עם זאת, חשוב לזכור שהמערכת מתעלמת מהפרמטרים האלה אלא אם גם הפרמטר orderby מוגדר ל-updated.

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

alt

סוג הפיד שיוחזר, למשל atom (ברירת המחדל) או rss.

/category

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

max-results

המספר המקסימלי של הרשומות להחזרה.

orderby

הסדר שבו המערכת מחזירה את הרשומות, למשל lastmodified (ברירת המחדל), starttime או updated.

published-min, ‏ published-max

הגבלות על תאריכי פרסום של רשומות.

start-index

האינדקס שמתחיל ב-1 של התוצאה הראשונה שאוחזרה (לצורך דפדוף).

updated-min, ‏ updated-max

הגבולות של תאריכי העדכון של הרשומות. המערכת מתעלמת מהפרמטרים האלה של השאילתה, אלא אם הפרמטר orderby מוגדר כ-updated.

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

עדכון פוסטים

כדי לעדכן פוסט קיים בבלוג, קודם צריך לאחזר את הרשומה שרוצים לעדכן, ואז לשנות אותה. לאחר מכן שולחים בקשה מסוג PUT, עם הרשומה המעודכנת בגוף ההודעה, לכתובת ה-URL של עריכת הפוסט. חשוב לוודא שהערך של <id> ברשומה שאתם PUT תואם בדיוק לערך של <id> ברשומה הקיימת.

כתובת ה-URL לעריכה מודגשת ברשומה הבאה:

<entry>
  <id>tag:blogger.com,1999:blog-blogID.post-postID</id>
  <published>2006-11-08T18:10:00.000-08:00</published>
  <updated>2006-11-08T18:10:14.954-08:00</updated>
  <title type='text'>Quite disagreeable</title>
  <content type='html'>&lt;p&gt;I met Mr. Bingley's friend Mr. Darcy
    this evening. I found him quite disagreeable.&lt;/p&gt;</content>
  <link rel='alternate' type='text/html'
    href='http://blogName.blogspot.com/2006/11/quite-disagreeable.html'>
  </link>
  <link rel='self' type='application/atom+xml'
    href='http://blogName.blogspot.com/feeds/posts/default/postID'>
  </link>
  <link rel='edit' type='application/atom+xml'
    href='http://www.blogger.com/feeds/blogID/posts/default/postID'>
  </link>
  <category scheme="http://www.blogger.com/atom/ns#" term="Mr. Bingley" />
  <category scheme="http://www.blogger.com/atom/ns#" term="Mr. Darcy" />
  <author>
    <name>Elizabeth Bennet</name>
    <email>noreply@blogger.com</email>
    <uri>http://www.blogger.com/profile/profileID</uri>
  </author>
</entry>

חשוב: כדי להבטיח תאימות עתידית, חשוב לוודא שכאשר מעדכנים רשומה באמצעות PUT, שומרים את כל ה-XML שהיה קיים כשאחזרתם את הרשומה מ-Blogger. אחרת, כשנוציא לפועל תכנים חדשים ונכלול בפיד רכיבי <new-awesome-feature>, הלקוח לא יחזיר אותם והמשתמשים שלכם יפסידו. ספריות הלקוח של Google Data API מטפלות בזה בצורה נכונה, כך שאם אתם משתמשים באחת מהספריות, אתם מוכנים.

הערה: בשלב הזה אין תמיכה בשינוי נתוני המחבר שמשויכים לפוסטים.

טיפ לפתרון בעיות: חומות אש מסוימות חוסמות הודעות HTTP‏ PUT. כדי לעקוף את הבעיה הזו, אפשר לכלול כותרת X-HTTP-Method-Override: PUT בבקשת POST. פרטים נוספים זמינים במסמך יסודות הפרוטוקול של Google Data API.

מחיקת פוסטים

כדי למחוק פוסט, שולחים בקשה מסוג DELETE לכתובת ה-URL של עריכת הפוסט. זוהי אותה כתובת URL שמשמשת לעדכון פוסטים.

טיפ לפתרון בעיות: חומות אש מסוימות חוסמות הודעות HTTP‏ DELETE. כדי לעקוף את הבעיה הזו, אפשר לכלול כותרת X-HTTP-Method-Override: DELETE בבקשת POST. פרטים נוספים זמינים במסמך יסודות הפרוטוקול של Google Data API.

תגובות

Blogger Data API מאפשר ליצור, לאחזר ולמחוק תגובות. אין תמיכה בעדכון תגובות (והאפשרות הזו לא זמינה בממשק האינטרנט).

יצירת תגובות

כדי לפרסם תגובה, יוצרים רכיב Atom <entry> באופן הבא:

  <entry xmlns='http://www.w3.org/2005/Atom'>
    <title type="text">This is my first comment</title>
    <content type="html">This is my first comment</content>
  </entry>

כדי לפרסם את התגובה הזו, צריך להוסיף את הרכיב <entry> של Atom לגוף של בקשת POST חדשה, באמצעות סוג התוכן application/atom+xml. לאחר מכן שולחים את הבקשה POST לכתובת ה-URL המתאימה ב-Blogger:

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

הערה: בשלב הזה אפשר לפרסם תגובות רק בבלוג שבבעלות המשתמש המאומת.

הערה: בשלב הזה אי אפשר להגדיר מחבר מותאם אישית לתגובות. כל התגובות החדשות יופיעו כאילו נוצרו על ידי המשתמש המאומת הנוכחי.

אחזור תגובות

כדי לאחזר את התגובות לפוסט מסוים, שולחים GET לכתובת ה-URL של פיד התגובות של הפוסט הזה:

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

לחלופין, אפשר לקבל את התגובות מכל הפוסטים באמצעות כתובת ה-URL של פיד התגובות בבלוג:

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

הבקשות האלה מחזירות פיד תגובות שנראה כך:

<feed xmlns="http://www.w3.org/2005/Atom" xmlns:openSearch="http://a9.com/-/spec/opensearchrss/1.0/"
         xmlns:thr="http://purl.org/syndication/thread/1.0">
  <id>tag:blogger.com,1999:blog-blogID.post-postID.comment-commentID</id>
  <updated>2007-04-04T21:56:29.803-07:00</updated>
  <title type="text">My Blog : Time to relax</title>
  <link rel="alternate" type="text/html" href="http://blogName.blogspot.com/2007/04/first-post.html"/>
  <link rel="http://schemas.google.com/g/2005#feed" type="application/atom+xml" href="http://blogName.blogspot.com/feeds/postID/comments/default"/>
  <link rel="self" type="application/atom+xml" href="http://blogName.blogspot.com/feeds/postID/comments/default"/>
  <author>
    <name>Blog Author name</name>
  </author>
  <generator version="7.00" uri="http://www2.blogger.com">Blogger</generator>
  <openSearch:totalResults>1</openSearch:totalResults>
  <openSearch:startIndex>1</openSearch:startIndex>
  <entry>
    <id>tag:blogger.com,1999:blog-blogID.post-commentID</id>
    <published>2007-04-04T21:56:00.000-07:00</published>
    <updated>2007-04-04T21:56:29.803-07:00</updated>
    <title type="text">This is my first comment</title>
    <content type="html">This is my first comment</content>
    <link rel="alternate" type="text/html" href="http://blogName.blogspot.com/2007/04/first-post.html#commentID"/>
    <link rel="self" type="application/atom+xml" href="http://blogName.blogspot.com/feeds/postID/comments/default/commentID"/>
    <link rel="edit" type="application/atom+xml" href="http://www.blogger.com/feeds/blogID/postID/comments/default/commentID"/>
    <thr:in-reply-to href="http://blogName.blogspot.com/2007/04/first-post.html" 
                     ref="tag:blogger.com,1999:blog-blogID.post-postID" 
                     source="http://www.blogger.com/feeds/posts/default/blogID"
                     type="text/html"/>
    <author>
      <name>Blog Author name</name>
      <email>blog_author@gmail.com</email>
      <uri>http://www.blogger.com/profile/userID</uri>
    </author>
    <thr:in-reply-to xmlns:thr='http://purl.org/syndication/thread/1.0' 
         href='http://blogName.blogspot.com/2007/04/first-post.html' 
         ref='tag:blogger.com,1999:blog-blogID.post-postID' 
         source='http://blogName.blogspot.com/feeds/posts/default/postID'
         type='text/html' />
  </entry>
</feed>

מחיקת תגובות

כדי למחוק תגובה, שולחים בקשה מסוג DELETE לכתובת ה-URL של העריכה של התגובה. כתובת ה-URL הזו מודגשת בפיד התגובות שלמעלה.

פורמט הייצוא

ב-Blogger, המשתמשים יכולים לייצא ולייבא את הבלוגים שלהם באמצעות קובץ ייצוא של Blogger. קובץ הייצוא הזה מכיל את כל הפוסטים והתגובות בבלוג אחד. הפורמט של קובץ הייצוא הוא אותו פורמט Atom שמתואר בקטעים על אחזור פוסטים ותגובות. קובץ הייצוא הזה יכיל את התוכן של פיד הפוסטים ואת התוכן של פיד התגובות, בשילוב למסמך אחד.

כדי לייצא או לייבא נתוני בלוג באמצעות פורמט הייצוא, אפשר להיכנס לדף הגדרות של הבלוג. כדי לאחזר את קובץ הייצוא של הבלוג באמצעות Data API, משתמשים בכתובת ה-URL הבאה:

GET http://www.blogger.com/feeds/blogID/archive

כדי לייבא את קובץ הייצוא, יוצרים בקשת POST לכתובת ה-URL הבאה, עם תוכן קובץ הייצוא כנתוני הבקשה ו-application/atom+xml כסוג התוכן:

POST http://www.blogger.com/feeds/blogID/archive/full

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

הערה: אם אתם יוצרים קובץ ייצוא משלכם ב-Blogger, יש כרגע הגבלה אחת לגבי הסדר של הרשומות של הפוסטים והתגובות. קובץ הייצוא מ-Blogger יכלול קודם את כל הפוסטים, ואז את כל התגובות. מותר להוסיף תגובות בין פוסטים, כל עוד התגובה מופיעה אחרי הפוסט שאליו היא מתייחסת.

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

חזרה למעלה