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

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

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

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

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

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

תוכן עניינים

קהל
איך מתחילים
1. יצירת חשבון Blogger
2. הרצת הקוד לדוגמה
אימות לשירות Blogger
1. אימות שרת proxy של OAuthSub
2. אימות שם משתמש/סיסמה של ClientLogin
אחזור רשימה של בלוגים
יצירת פוסטים
1. פרסום פוסט בבלוג
2. יצירת טיוטה של פוסט בבלוג
אחזור פוסטים
1. אחזור כל הפוסטים בבלוג
2. אחזור פוסטים באמצעות פרמטרים של שאילתה
עדכון פוסטים
מחיקת פוסטים
תגובות

Audience

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

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

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

איך מתחילים

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

כדי להשתמש בספריית הלקוח מסוג NET. , נדרש זמן ריצה של NET 1 .1.בנוסף, עליכם להיות מעודכנים בכל תיקוני התוכנה. אחרי הורדה של ספריית הלקוחות, ניתן יהיה למצוא את ה-DLLs שצריך להתחיל בספריית המשנה של ההפצה lib/Release.

יצירת חשבון Blogger

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

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

לקוח לדוגמה שעובד באופן מלא ומכיל את כל הקוד לדוגמה המוצג במסמך הזה, זמין בפרויקט ספריית הלקוח מסוג NET. הדגימה ממוקמת בכתובת /trunk/clients/cs/samples/blogger/ConsoleSample.cs בכרטיסייה 'מקור' של מאגר ה-SVN.

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

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

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

using Google.GData.Client;
using System.Net;
using System.Xml;
using System.Text.RegularExpressions;

מתבצע אימות לשירות Blogger

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

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

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

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

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

נניח שהיפר-קישור הבא ל-ASP מוגדר בדף:

<asp:HyperLink ID="GotoAuthSubLink" runat="server"/>

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

GotoAuthSubLink.Text = "Login to your Google Account";
GotoAuthSubLink.NavigateUrl =
  AuthSubUtil.getRequestUrl("http://www.example.com/RetrieveToken",
  "http://www.blogger.com/feeds/",
  false,
  true);

השיטה getRequestUrl מקבלת את הפרמטרים הבאים (בהתאם לפרמטרים של השאילתה שבהם נעשה שימוש ב-AuthSubRequest handler):

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

הדוגמה שלמעלה מראה שיחה שלא מבקשת אסימון מאובטח (הערך של secure הוא false). כתובת האתר שיתקבל עשויה להיראות כך:

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%2FRetrieveToken

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

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

http://www.example.com/RetrieveToken?token=yourAuthToken

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

SessionsessionToken = AuthSubUtil.exchangeForSessionToken(Request.QueryStringtoken, null);

כלומר, אתם מעבירים את האסימון החד-פעמי לשיטה exchangeForSessionToken, יחד עם null (למצב לא רשום) או מפתח פרטי (למצב רשום), וממשק AuthSub מחזיר אסימון סשן. למידע נוסף על אפליקציות רשומות ומפתחות פרטיים, עיינו בקטע "חתימת בקשות" במסמכי התיעוד של AuthSub.

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

GAuthSubRequestFactory authFactory = new GAuthSubRequestFactory("blogger", "BloggerSampleApp");
authFactory.Token = SessionsessionToken.ToString();
Service service = new Service(authFactory.ApplicationName);
service.RequestFactory = authFactory;

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

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

Service service = new Service("blogger", "exampleCo-exampleApp-1");
service.Credentials = new GDataCredentials("user@example.com", "secretPassword");
GDataGAuthRequestFactory factory = (GDataGAuthRequestFactory) service.RequestFactory;
factory.AccountType = "GOOGLE";

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

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

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

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

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

ממשק ה-API של Blogger Data מספק עדכון שמפרט את הבלוגים של משתמש מסוים; העדכון הזה נקרא "metafeed."

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

query.Uri = new Uri("http://www.blogger.com/feeds/default/blogs");
AtomFeed feed = null;
try
{
  feed = service.Query(query);
  foreach (AtomEntry entry in feed.Entries)
  {
    Console.WriteLine("Blog Title: " + entry.Title.Text);
  }
}

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

יצירת פוסטים

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

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

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

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

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

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

AtomEntry newPost = new AtomEntry();
newPost.Title.Text = "Marriage!";
newPost.Content = new AtomContent();
newPost.Content.Content = "<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>";
newPost.Content.Type = "xhtml";

Uri blogFeedUri = new Uri("http://www.blogger.com/feeds/" + blogId + "/posts/default");
AtomEntry createdEntry = service.Insert(blogFeedUri, newPost);

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

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

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

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

AtomEntry newPost = new AtomEntry();
newPost.Title.Text = "Marriage!";
newPost.Content = new AtomContent();
newPost.Content.Content = "<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>";
newPost.Content.Type = "xhtml";
newPost.IsDraft = true;

Uri blogFeedUri = new Uri("http://www.blogger.com/feeds/" + blogId + "/posts/default");
AtomEntry createdEntry = service.Insert(blogFeedUri, newPost);

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

המערכת מאחזרת פוסטים

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

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

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

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

query.Uri = new Uri("http://www.blogger.com/feeds/" + blogId + "/posts/default");
feed = service.Query(query);
Console.WriteLine(feed.Title.Text);
foreach (AtomEntry entry in feed.Entries)
{
  Console.WriteLine("Entry Title: " + entry.Title.Text);
}

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

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

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

FeedQuery query = new FeedQuery();
query.Uri = new Uri("http://www.blogger.com/feeds/" + blogId + "/posts/default");
query.MinPublication = new DateTime(2006, 1, 1);
query.MaxPublication = new DateTime(2007, 4, 12);
AtomFeed feed = service.Query(query);
foreach (AtomEntry entry in feed.Entries)
{
  Console.WriteLine("  Entry Title: " + entry.Title.Text);
}

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

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

Alt: סוג הפיד להחזרה, למשל atom (ברירת המחדל) או rss.
/category: ציון הקטגוריות (שנקראות גם תוויות) לסינון תוצאות הפיד. לדוגמה, הפונקציה http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie מחזירה רשומות עם התוויות Fritz ו-Laurie.
תוצאות מקסימליות: המספר המרבי של ערכים להחזרה.
Orderby: הסדר שבו יש להחזיר ערכים, כגון lastmodified (ברירת המחדל), starttime או updated.
דקות פרסום, מועד פרסום מרבי: הגבולות של תאריכי הפרסום.
אינדקס התחלתי: האינדקס מבוסס-1 של התוצאה הראשונה שאוחזר (להחלפה).
הגרסה המעודכנת, דקות מעודכנות: הגבולות בתאריכי עדכון הרשומות. המערכת תתעלם מהפרמטרים של השאילתות האלה, אלא אם הפרמטר orderby מוגדר כ-updated.

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

מתבצע עדכון פוסטים

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

static AtomEntry EditEntry(AtomEntry toEdit)
{
  // Edit the entry by changing the Title and calling Update().
  if (toEdit != null)
  {
    toEdit.Title.Text = "Marriage Woes!";
    toEdit = toEdit.Update();
  }
  return toEdit;
}

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

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

מחיקת פוסטים

כדי למחוק פוסט, אפשר לקרוא למתודה Delete באובייקט AtomEntry קיים, כך:

static void DeleteEntry(AtomEntry toDelete)
{
  // Delete the edited entry
  if (toDelete != null)
  {
    toDelete.Delete();
  }
}

תגובות

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

יצירת תגובות

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

AtomEntry comment;
comment = new AtomEntry();
comment.Title.Text = "This is my first comment";
comment.Content.Content = "This is my first comment";
Uri commentPostUri = new Uri("http://www.blogger.com/feeds/" + blogId + "/" + entryId + "/comments/default");
postedComment = service.Insert(commentPostUri, comment);

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

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

מתבצע אחזור של התגובות

ניתן לאחזר את התגובות לפוסט ספציפי דרך כתובת ה-URL של פיד התגובות:

static void ListEntryComments(Service service, Uri commentUri)
{
  if (commentUri != null)
  {
    // Retrieve all comments on a blog entry
    FeedQuery query = new FeedQuery();
    query.Uri = commentUri;
    AtomFeed feed = service.Query(query);
    foreach (AtomEntry entry in feed.Entries)
    {
      Console.WriteLine("  Comment Title: " + entry.Title.Text);
    }
  }
}

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

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

מחיקת תגובות

כדי למחוק תגובה, צריך לקרוא למתודה Delete() באובייקט קיים של תגובה AtomEntry:

static void DeleteComment(AtomEntry commentEntry)
{
  if (commentEntry != null)
  {
    // Delete the comment.
    commentEntry.Delete();
  }
}

חזרה למעלה