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

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

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

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

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

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.

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

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

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

כדי לאחזר את רשימת הבלוגים, שולחים 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>

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

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

יצירת פוסטים

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

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

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

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

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

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

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

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

לאחר מכן, Blogger מחזיר את קוד הסטטוס 200 OK של HTTP ופיד 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>

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

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

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

אפשר להשתמש בפרמטרים 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

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

סידור לפי

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

פרסום מינימלי, פרסום מקסימלי

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

start-index

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

מעודכן דקות, מעודכן-מקסימום

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

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

עדכון פוסטים

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

יצירת תגובות

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

  <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

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

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 בקובץ הייצוא מופיע במדריך העזר של הפרוטוקול.

חזרה למעלה