דף זה תורגם על ידי Cloud Translation API.

מדריך למפתחים: Python

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

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

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

תוכן עניינים

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

קהל

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

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

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

תחילת העבודה

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

ספריית הלקוח של Python דורשת Python 2.2 ואילך. לאחר ההורדה ספריית הלקוח, תצטרכו גם להוריד ולהתקין את חבילת ElementTree.

יצירת חשבון Blogger

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

הרצת הקוד לדוגמה

לקוח לדוגמה פועל במלואו, שמכיל את כל הקוד לדוגמה שמוצג המסמך הזה זמין בBloggerExample.py קובץ, מתחת לספרייה gdata-python-client/samples/blogger/.

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

אפשר להריץ את הדוגמה עם הארגומנטים הבאים:

python BloggerExample.py --email [email_address] --password [password]

כדי להשתמש בדוגמאות במסמך הזה בקוד שלכם, תצטרכו את הצהרות import הבאות:

from gdata import service
import gdata
import atom

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

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

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

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

אימות OAuth

למסמכים בנושא אימות OAuth באמצעות ספריית GData של Python, קראו את המאמר OAuth בספריות הלקוח של Google Data Protocol.

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

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

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

def GetAuthSubUrl():
  next = 'http://www.example.com/welcome.pyc'
  scope = 'http://www.blogger.com/feeds/'
  secure = False
  session = True
  blogger_service = service.GDataService()
  return blogger_service.GenerateAuthSubURL(next, scope, secure, session);

authSubUrl = GetAuthSubUrl();
print '<a href="%s">Login to your Google account</a>' % authSubUrl

ה-method GenerateAuthSubURL משתמשת בפרמטרים הבאים (בהתאם לפרמטרים של השאילתה ששימשו את ה-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.pyc

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

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

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

יש כמה דרכים לאחזר את ערך האסימון מכתובת ה-URL. לדוגמה:

import cgi

parameters = cgi.FieldStorage()
authsub_token = parameters['token']

ערך האסימון הזה מייצג אסימון AuthSub לשימוש יחיד. במשפט הזה, מאז שצוין session = True, ניתן להחליף את האסימון הזה אסימון סשן AuthSub באמצעות השיטה UpgradeToSessionToken, שקורא ל-AuthSubSessionToken service:

blogger_service = service.GDataService()
blogger_service.auth_token = authsub_token
blogger_service.UpgradeToSessionToken()

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

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

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

משתמשים באימות ClientLogin אם הלקוח הוא לקוח 'מותקן' עצמאי עם משתמש יחיד (למשל, אפליקציה למחשב). פשוט שולחים אמצעי תשלום ProgrammaticLogin() במכשיר GDataService שלך וכל האינטראקציות הבאות עם Blogger מאומת:

blogger_service = service.GDataService('user@example.com', 'secretPassword')
blogger_service.source = 'exampleCo-exampleApp-1.0'
blogger_service.service = 'blogger'
blogger_service.account_type = 'GOOGLE'
blogger_service.server = 'www.blogger.com'
blogger_service.ProgrammaticLogin()

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

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

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

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

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

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

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

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

def PrintUserBlogTitles(blogger_service):
  query = service.Query()
  query.feed = '/feeds/default/blogs'
  feed = blogger_service.Get(query.ToUri())

  print feed.title.text
  for entry in feed.entry:
    print "\t" + entry.title.text

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

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

blog_id = feed.entry[0].GetSelfLink().href.split("/")[-1]

בדוגמה BloggerExample.py נוצרת מחלקה BloggerExample ומזהה הבלוג מוגדר ב-constructor כדי לאפשר גישה נוחה אליו מאוחר יותר. ברוב הדוגמאות הבאות במסמך הזה, הערך blog_id מועבר כמשתנה.

יצירת פוסטים

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

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

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

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

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

def CreatePublicPost(blogger_service, blog_id, title, content):
  entry = gdata.GDataEntry()
  entry.title = atom.Title('xhtml', title)
  entry.content = atom.Content(content_type='html', text=content)
  return blogger_service.Post(entry, '/feeds/%s/posts/default' % blog_id)

blogEntry = CreatePublicPost(blogger_service, blog_id,
    title='I have the answer', content='Eureka! It is 42!')

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

טיוטות של פוסטים נוצרות בדיוק כמו פוסטים ציבוריים, אך צריך להגדיר רכיב התוסף draft בGDataEntry מכונה. כדי ליצור את הפוסט בבלוג שלמעלה כטיוטה צריך להוסיף את שורות מודגשות:

def CreateDraftPost(blogger_service, blog_id, title, content):
  entry = gdata.GDataEntry()
  entry.title = atom.Title('xhtml', title)
  entry.content = atom.Content(content_type='html', text=content)

  control = atom.Control()
  control.draft = atom.Draft(text='yes')
  entry.control = control

  return blogger_service.Post(entry, '/feeds/%s/posts/default' % blog_id)

draftEntry = CreateDraftPost(blogger_service, blog_id,
    title='I have the question',
    content='What do you get if you multiply six by nine?')

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

אחזור פוסטים

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

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

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

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

def PrintAllPosts(blogger_service, blog_id):
  feed = blogger_service.GetFeed('/feeds/' + blog_id + '/posts/default')

  print feed.title.text
  for entry in feed.entry:
    print "\t" + entry.title.text
    print "\t" + entry.content.text
    print "\t" + entry.updated.text
  print

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

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

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

def PrintPostsInDateRange(blogger_service, blog_id, start_time='2007-04-01', end_time='2007-04-25'):
  query = service.Query()
  query.feed = '/feeds/' + blog_id + '/posts/default'
  query.published_min = start_time
  query.published_max = end_time
  feed = blogger_service.Get(query.ToUri())

  print feed.title.text + " posts between " + start_time + " and " + end_time
  for entry in feed.entry:
    print "\t" + entry.title.text
    print "\t" + entry.content.text
    print "\t" + entry.updated.text
  print

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

ב-Blogger Data API יש תמיכה במאפיינים הבאים של Query נכסים:

קטגוריות: בחירת קטגוריות (שנקראות גם תוויות) לסינון תוצאות הפיד. לדוגמה, http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie מחזירה רשומות עם התווית Fritz וגם עם התווית Laurie. כדי לציין את שאילתת הקטגוריה בספריית הלקוח של Python, אפשר להשתמש בפקודה query.categories = ['Fritz','Laurie',]
max_results: המספר המקסימלי של הרשומות להחזרה.
published_min, published_max: הגבולות לתאריכי פרסום הרשומה.
start_index: האינדקס מבוסס 1 של התוצאה הראשונה שיש לאחזר (לחלוקה לדפים).
updated_min, updated_max: הגבולות לתאריכי עדכון של רשומות. המערכת מתעלמת מהפרמטרים האלה של שאילתות, אלא אם הפרמטר orderby מוגדר ל-updated.

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

עדכון פוסטים

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

def UpdatePostTitle(blogger_service, entry_to_update, new_title='The REAL answer'):
  entry_to_update.title = atom.Title('xhtml', new_title)
  return blogger_service.Put(entry_to_update, entry_to_update.GetEditLink().href)

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

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

מחיקת פוסטים

כדי למחוק פוסט, יש להעביר את כתובת ה-URL לעריכה של הפוסט לשיטה Delete באובייקט GDataService, כך:

def DeletePost(blogger_service, edit_link_href):
  blogger_service.Delete(edit_link_href)

תגובות

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

יצירת תגובות

כדי לפרסם תגובה, צריך ליצור אובייקט GDataEntry ולהוסיף אותו באופן הבא:

def CreateComment(blogger_service, blog_id, post_id, comment_text='Mostly harmless'):
  feed_uri = '/feeds/' + blog_id + '/' + post_id + '/comments/default'

  entry = gdata.GDataEntry()
  entry.content = atom.Content(content_type='xhtml', text=comment_text)
  return blogger_service.Post(entry, feed_uri)

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

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

אחזור תגובות

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

def PrintAllComments(blogger_service, blog_id, post_id):
  feed_url = '/feeds/' + blog_id + '/' + post_id + '/comments/default'
  feed = blogger_service.Get(feed_url)

  print feed.title.text
  for entry in feed.entry:
    print "\t" + entry.title.text
    print "\t" + entry.updated.text
  print

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

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

מחיקת תגובות

כדי למחוק תגובה, יש להעביר את כתובת ה-URL לעריכה של התגובה אל Delete באובייקט GDataService, כך:

def DeleteComment(blogger_service, post_id, comment_id):
  feed_url = '/feeds/' + post_id + '/comments/default/' + comment_id
  blogger_service.Delete(feed_url)

חזרה למעלה