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

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

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

באמצעות ממשק ה-API של Blogger Data תוכלו לגשת אל פידים ציבוריים ופרטיים. לא נדרש אימות כלשהו בפידים ציבוריים, אבל הם לקריאה בלבד. אם אם אתם רוצים לשנות בלוגים, הלקוח שלכם צריך לבצע אימות לפני שליחת הבקשה עדכונים פרטיים. הוא יכול לבצע אימות באמצעות אחת משתי גישות: אימות שרת 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 מפנה אותו לכתובת האתר ציינת בפרמטר השאילתה next של AuthSubRequest כתובת URL. מערכת 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. הפרמטרים האלה הם:

אימייל
כתובת האימייל של המשתמש.
סיסמה
הסיסמה של המשתמש.
שירות
השם של השירות של Blogger הוא blogger. (לשירות אחר שמות של שירותים, ועיינו ברשימת שמות השירותים.)
accountType
כדאי תמיד להגדיר את הערך הזה כ-GOOGLE כשמשתמשים ב-Blogger API. אם לא יוגדר ערך לפרמטר הזה, משתמשים שיש להם גם חשבון G Suite לא יוכלו לגשת אליו.
source
מזהה את אפליקציית הלקוח שלך. הוא צריך להיות בפורמט companyName-applicationName-versionID. בדוגמאות נעשה שימוש בשם exampleCo-exampleApp-1.

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

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

אם הפעולה מצליחה, השרת יחזיר סטטוס HTTP 200 OK בתוספת שלושה קודים אלפאנומריים ארוכים בגוף התגובה: SID , LSID ו-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 (במקום לכתובת האתר לטיפול ב-CAPTCHA שצוינה בשדה ClientLogin תיעוד).

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

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

צריך לשלוח GET HTTP לכתובת ה-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>

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

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

יצירת פוסטים

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 של הפוסט בבלוג באופן הבא. קודם כל, למקם את רכיב ה-Atom <entry> בגוף של בקשת 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 Publishing Protocol, כולל <app:control> ו <app:draft> מרחבי שמות, ראו RFC 5023.

אחזור פוסטים

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

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

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

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

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

עדכון פוסטים

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

כדי לפרסם את התגובה, צריך למקם את רכיב ה-Atom <entry> בגוף בקשת 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 את כתובת האתר הבאה עם התוכן של קובץ הייצוא בתור נתוני הבקשה application/atom+xml בתור סוג התוכן:

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

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

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

למידע נוסף על השימוש של Blogger בפורמט Atom בייצוא ראו את הפרוטוקול .

חזרה למעלה