डेवलपर के लिए गाइड: Python

Blogger Data API, क्लाइंट ऐप्लिकेशन को Blogger को देखने और अपडेट करने की अनुमति देता है Google Data API फ़ीड के तौर पर कॉन्टेंट उपलब्ध कराता है.

आपका क्लाइंट ऐप्लिकेशन, Blogger Data API का इस्तेमाल करके नई ब्लॉग पोस्ट बना सकता है. साथ ही, मौजूदा ब्लॉग पोस्ट में बदलाव कर सकता है या उन्हें मिटा सकता है. इसके अलावा, किसी खास शर्त से मैच होने वाली ब्लॉग पोस्ट के लिए क्वेरी भी कर सकता है.

Blogger की क्षमताओं के बारे में कुछ जानकारी देने के अलावा Data API. इस दस्तावेज़ में, बेसिक Data API इंटरैक्शन के उदाहरण दिए गए हैं. इसके तहत, Python क्लाइंट लाइब्रेरी पर जाएं. अगर आपको लाइब्रेरी में इस्तेमाल किए जाने वाले प्रोटोकॉल के बारे में ज़्यादा जानना है, तो डेवलपर के लिए बनी इस गाइड का प्रोटोकॉल सेक्शन देखें.

कॉन्टेंट

  1. दर्शक
  2. स्ट्रक्चर्ड डेटा सेट अप की शुरुआत करना
    1. Blogger खाता बनाना
    2. सैंपल कोड चलाना
  3. Blogger की सेवा की पुष्टि करना
    1. OAuth की पुष्टि करना
    2. AuthSub प्रॉक्सी की पुष्टि करना
    3. ClientLogin उपयोगकर्ता नाम/पासवर्ड की पुष्टि करना
  4. ब्लॉग की सूची वापस पाना
  5. पोस्ट बनाना
    1. ब्लॉग पोस्ट पब्लिश करना
    2. ब्लॉग पोस्ट का ड्राफ़्ट बनाना
  6. पोस्ट वापस लाना
    1. सभी ब्लॉग पोस्ट वापस लाना
    2. क्वेरी पैरामीटर का इस्तेमाल करके पोस्ट हासिल करना
  7. पोस्ट अपडेट करना
  8. पोस्ट मिटाना
  9. टिप्पणियां
    1. टिप्पणियां करना
    2. टिप्पणियां वापस पाना
    3. टिप्पणियां मिटाना

ऑडियंस

यह दस्तावेज़ उन प्रोग्रामर के लिए है जो Blogger के साथ इंटरैक्ट करने वाले Python क्लाइंट ऐप्लिकेशन लिखना चाहते हैं.

इस दस्तावेज़ में यह माना गया है कि आपको Google Data API प्रोटोकॉल के बारे में सामान्य जानकारी है.

Blogger Data API के बारे में सामान्य जानकारी के लिए, प्रोटोकॉल की रेफ़रंस गाइड देखें.

शुरू करना

क्लाइंट लाइब्रेरी सेट अप करने में मदद पाने के लिए, शुरू करने की गाइड देखें.

Python क्लाइंट लाइब्रेरी के लिए, Python 2.2 या इसके बाद के वर्शन की ज़रूरत होती है. डाउनलोड करने के बाद आपको ElementTree पैकेज को भी डाउनलोड और इंस्टॉल करना होगा.

Blogger खाता बनाना

टेस्टिंग के लिए, Blogger खाते के लिए साइन अप किया जा सकता है. Blogger, Google खातों का इस्तेमाल करता है. इसलिए, अगर पहले से ही एक Google खाता है, आप पूरी तरह से तैयार हैं.

सैंपल कोड चलाना

इस दस्तावेज़ में दिखाया गया पूरा सैंपल क्लाइंट, डायरेक्ट्री gdata-python-client/samples/blogger/ में मौजूद BloggerExample.py फ़ाइल में उपलब्ध है. इसमें, सैंपल के तौर पर दिया गया पूरा कोड शामिल है.

सैंपल क्लाइंट दिए गए ब्लॉग पर कई ऑपरेशन करता है, ताकि Blogger Data API के इस्तेमाल के बारे में बताया गया है.

सैंपल को यहां दिए गए आर्ग्युमेंट के साथ चलाया जा सकता है:

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

इस दस्तावेज़ में दिए गए उदाहरणों को अपने कोड में इस्तेमाल करने के लिए, आपको इनकी ज़रूरत होगी ये import स्टेटमेंट:

from gdata import service
import gdata
import atom

Blogger की सेवा की पुष्टि करना

Blogger Data API का इस्तेमाल करके, सार्वजनिक और निजी, दोनों फ़ीड ऐक्सेस किए जा सकते हैं. सार्वजनिक फ़ीड के लिए पुष्टि करने की ज़रूरत नहीं होती. हालांकि, ये फ़ीड रीड-ओनली होते हैं. अगर आपको नहीं चाहते हैं, तो अनुरोध करने से पहले आपके क्लाइंट को प्रमाणित करना होगा निजी फ़ीड. यह तीन तरीकों में से किसी भी तरीके का इस्तेमाल करके पुष्टि कर सकता है:OAuth ऑथेंटिकेशन, AuthSub प्रॉक्सी ऑथेंटिकेशन या ClientLogin उपयोगकर्ता नाम/पासवर्ड ऑथेंटिकेशन.

Google Data API से पुष्टि करने के बारे में ज़्यादा जानने के लिए, पुष्टि करने की प्रक्रिया दस्तावेज़ में दिया गया है.

इस दस्तावेज़ के बाद के सेक्शन में दिए गए ज़्यादातर सैंपल का मतलब है कि आपके पास एक पुष्टि किया गया GDataService इंस्टेंस.

OAuth से पुष्टि

Python GData लाइब्रेरी का इस्तेमाल करके, OAuth की मदद से पुष्टि करने के बारे में दस्तावेज़ पाने के लिए, कृपया Google Data प्रोटोकॉल क्लाइंट लाइब्रेरी में OAuth देखें.

AuthSub प्रॉक्सी की पुष्टि

AuthSub प्रॉक्सी की पुष्टि करने की सुविधा का इस्तेमाल, वेब ऐप्लिकेशन करते हैं. इन ऐप्लिकेशन को अपने उपयोगकर्ताओं की पुष्टि, Google खातों के लिए करनी होती है. वेबसाइट ऑपरेटर और क्लाइंट कोड के पास, Blogger उपयोगकर्ता के उपयोगकर्ता नाम और पासवर्ड का ऐक्सेस नहीं होता. इसके बजाय, क्लाइंट को खास AuthSub टोकन मिलते हैं. इनकी मदद से, क्लाइंट किसी उपयोगकर्ता की ओर से कार्रवाई कर सकता है. ज़्यादा जानकारी के लिए, AuthSub दस्तावेज़ देखें.

जब कोई उपयोगकर्ता पहली बार आपके ऐप्लिकेशन पर आता है, तब उसकी पुष्टि नहीं की जाती. इस मामले में, आपको कुछ जानकारी और एक लिंक दिखाना होगा ऐक्सेस के आपके अनुरोध को प्रमाणित करने के लिए, उपयोगकर्ता को किसी Google पेज पर भेजा जाएगा उनके ब्लॉग. Python क्लाइंट लाइब्रेरी, Google पेज का यूआरएल जनरेट करने के लिए एक फ़ंक्शन उपलब्ध कराती है. यहां दिया गया कोड, 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

GenerateAuthSubURL तरीका, इन पैरामीटर का इस्तेमाल करता है (ये AuthSubRequest हैंडलर के इस्तेमाल किए गए क्वेरी पैरामीटर से मेल खाते हैं):

अगली
उस पेज का यूआरएल जिस पर Google को पुष्टि करने के बाद उपयोगकर्ता को रीडायरेक्ट करना चाहिए.
दायरा
इससे पता चलता है कि ऐप्लिकेशन, Blogger फ़ीड को ऐक्सेस करने के लिए टोकन का अनुरोध कर रहा है. http://www.blogger.com/feeds/ वाली स्कोप स्ट्रिंग का इस्तेमाल किया जा सकता है. यह यूआरएल कोड में बदला गया है.
सुरक्षित
यह बताता है कि क्लाइंट सुरक्षित टोकन का अनुरोध कर रहा है या नहीं.
सत्र
यह बताता है कि लौटाए गए टोकन को, एक से ज़्यादा बार इस्तेमाल किए जा सकने वाले (सेशन) टोकन के लिए बदला जा सकता है या नहीं.

ऊपर दिया गया उदाहरण एक ऐसे कॉल को दिखाता है जो सुरक्षित टोकन का अनुरोध नहीं करता. (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%2Fwelcome.pyc

उपयोगकर्ता, Google की साइट पर दिए गए लिंक पर जाता है और अपने Google खाते की पुष्टि करता है.

उपयोगकर्ता की पुष्टि करने के बाद, AuthSub सिस्टम उसे उस यूआरएल पर रीडायरेक्ट करता है जिसे आपने AuthSubRequest यूआरएल के next क्वेरी पैरामीटर में बताया है. AuthSub सिस्टम, token क्वेरी पैरामीटर की वैल्यू के तौर पर, उस यूआरएल में पुष्टि करने वाला टोकन जोड़ता है. उदाहरण के लिए:

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

यूआरएल से टोकन वैल्यू फिर से पाने के कई तरीके हैं; उदाहरण के लिए:

import cgi

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

इस टोकन की वैल्यू, एक बार इस्तेमाल होने वाले AuthSub टोकन को दिखाती है. इस उदाहरण में, क्योंकि session = True में बताया गया था, इसलिए इस टोकन को एक्सचेंज किया जा सकता है UpgradeToSessionToken तरीके का इस्तेमाल करने वाला AuthSub सेशन टोकन, कौन AuthSubSessionToken को कॉल करता है सेवा:

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

इसका मतलब है कि एक बार इस्तेमाल होने वाले टोकन को UpgradeToSessionToken तरीके से पास किया जाता है और AuthSub इंटरफ़ेस से सेशन टोकन मिलता है.

इसके बाद, आपका ऐप्लिकेशन अगले चरण में सेशन टोकन वैल्यू का इस्तेमाल कर सकता है Blogger के साथ किए गए इंटरैक्शन. क्लाइंट लाइब्रेरी अपने-आप टोकन भेजती है के साथ किए गए अनुरोध भी शामिल हैं.

ClientLogin उपयोगकर्ता नाम/पासवर्ड की पुष्टि करें

अगर आपका क्लाइंट स्टैंडअलोन है और वह एक ही उपयोगकर्ता का इस्तेमाल करता है, तो ClientLogin की पुष्टि करने की सुविधा का इस्तेमाल करें "इंस्टॉल किया गया" (जैसे कि डेस्कटॉप ऐप्लिकेशन). अपने GDataService इंस्टेंस पर ProgrammaticLogin() वाला तरीका कॉल करें. इसके बाद, 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 के उपयोगकर्ता इसका इस्तेमाल नहीं कर पाएंगे Blogger API से कॉपी किया जा सकता है.

ClientLogin प्रमाणीकरण के बारे में ज़्यादा जानकारी के लिए, जिसमें नमूना शामिल है तो इंस्टॉल किए गए ऐप्लिकेशन के लिए प्रमाणीकरण देखें ऐप्लिकेशन दस्तावेज़.

ध्यान दें: दिया गया सेशन; Blogger के हर अनुरोध के लिए नया टोकन हासिल नहीं करना चाहिए.

ध्यान दें: ClientLogin दस्तावेज़ में बताए गए तरीके के मुताबिक, पुष्टि करने का अनुरोध पूरा न हो पाए और CAPTCHA चुनौती का अनुरोध किया जाए. अगर आप चाहते हैं कि Google कैप्चा चुनौती देने और उसे हल करने में आपकी मदद करे, उपयोगकर्ता को यहां भेजें https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है (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

Get तरीके से इस्तेमाल किए गए यूआरएल पर ध्यान दें. यह डिफ़ॉल्ट है मेटाफ़ीड यूआरएल; यह वर्तमान में प्रमाणित उपयोगकर्ता के लिए ब्लॉग की सूची दिखाता है. किसी अन्य उपयोगकर्ता के फ़ीड को ऐक्सेस करने के लिए, उसकी जगह उपयोगकर्ता का आईडी डालें मेटाफ़ीड यूआरएल में default. उपयोगकर्ता का आईडी, अंकों की स्ट्रिंग होती है दिख सकता है.

नीचे दिए गए कोड का स्निपेट बताता है कि फ़ीड. पोस्ट और टिप्पणियों को बनाने, अपडेट करने, और मिटाने के लिए, आपको ब्लॉग आईडी की ज़रूरत होगी. नीचे दिया गया स्निपेट, किसी उपयोगकर्ता के लिए पहला ब्लॉग चुनता है.

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

BloggerExample.py सैंपल में, BloggerExample क्लास बन जाती है और आसानी से ऐक्सेस करने के लिए, ब्लॉग आईडी को कंस्ट्रक्टर में सेट कर दिया जाता है बाद में. इस दस्तावेज़ में दिए गए ज़्यादातर उदाहरणों के लिए, 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!')

ब्लॉग पोस्ट का ड्राफ़्ट बनाना

ड्राफ़्ट पोस्ट सार्वजनिक पोस्ट की तरह ही बनाई जाती हैं, लेकिन आपको GDataEntry में draft एक्सटेंशन एलिमेंट इंस्टेंस. ऊपर दी गई ब्लॉग पोस्ट को ड्राफ़्ट के तौर पर बनाने के लिए, हाइलाइट की गई लाइनें जोड़ें:

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 तरीके को इस ब्लॉग-पोस्ट फ़ीड का यूआरएल:

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 को सेट करें और Query इंस्टेंस की published_min प्रॉपर्टी. नीचे दिया गया कोड स्निपेट, हर ब्लॉग पोस्ट के टाइटल और कॉन्टेंट को प्रिंट करता है तय समय और खत्म होने के समय के बीच पब्लिश किया जाएगा:

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 ऑब्जेक्ट को उसी पोस्ट का इस्तेमाल करके बनाया गया है पोस्ट फिर से पाने के लिए इस्तेमाल किए जाने वाले फ़ीड का यूआरएल.

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
पेजिंग के लिए, वापस लाए जाने वाले पहले नतीजे का एक आधारित इंडेक्स.
updated_min, updated_max
एंट्री अपडेट की तारीखों की सीमा. इन क्वेरी पैरामीटर को तब तक अनदेखा किया जाता है, जब तक orderby पैरामीटर को updated पर सेट नहीं किया जाता.

क्वेरी पैरामीटर के बारे में ज़्यादा जानकारी के लिए, Blogger का डेटा एपीआई रेफ़रंस देखें गाइड और Google Data API की रेफ़रंस गाइड.

पोस्ट अपडेट करना

किसी मौजूदा ब्लॉग पोस्ट को अपडेट करने के लिए, सबसे पहले वह एंट्री वापस पाएं जो आपको चाहिए अपडेट करें, फिर आप उसे संशोधित करते हैं, और फिर आप 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 दिखाता है. इसमें, हाल ही में अपडेट की गई पूरी पोस्ट शामिल होती है. किसी भी अन्य प्रॉपर्टी को अपडेट करने के लिए, बस उन्हें Put पर कॉल करने से पहले GDataEntry इंस्टेंस.

ध्यान दें: फ़िलहाल, पोस्ट से जुड़े लेखक के डेटा में बदलाव नहीं किया जा सकता.

पोस्ट मिटाई जा रही हैं

किसी पोस्ट को मिटाने के लिए, पोस्ट में बदलाव करने का यूआरएल Delete तरीके से दें अपने GDataService ऑब्जेक्ट पर, इस तरह से:

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

टिप्पणियां

Blogger डेटा एपीआई की मदद से टिप्पणियां बनाई जा सकती हैं, उन्हें वापस पाया जा सकता है, और मिटाया जा सकता है. टिप्पणियों को अपडेट नहीं किया जा सकता (और न ही यह वेब पर उपलब्ध है) इंटरफ़ेस).

टिप्पणियां बनाना

टिप्पणी पोस्ट करने के लिए, 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)

ध्यान दें: फ़िलहाल, इन पर सिर्फ़ टिप्पणियां पोस्ट की जा सकती हैं ऐसा ब्लॉग जिसका मालिकाना हक पुष्टि किए गए उपयोगकर्ता के पास हो.

ध्यान दें: टिप्पणियों के लिए पसंद के मुताबिक लेखक सेट करना फ़िलहाल काम नहीं करता है. सभी नई टिप्पणियां इस तरह से दिखेंगी कि उन्हें किसी ने बनाया है जिस उपयोगकर्ता की पुष्टि हो चुकी है.

टिप्पणियां वापस लाना

किसी पोस्ट की टिप्पणियों के फ़ीड के यूआरएल से, उस पोस्ट की टिप्पणियां वापस पाई जा सकती हैं:

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

इसके अलावा, ब्लॉग के टिप्पणियों वाले फ़ीड के यूआरएल का इस्तेमाल करके, सभी पोस्ट की टिप्पणियां भी देखी जा सकती हैं:

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)

वापस सबसे ऊपर जाएं