इस पेज का अनुवाद Cloud Translation API से किया गया है.

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

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

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

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

कॉन्टेंट

दर्शक
शुरू करना
1. Blogger खाता बनाना
2. सैंपल कोड चलाना
Blogger सेवा की पुष्टि करना
ब्लॉग की सूची हासिल करना
पोस्ट बनाना
1. ब्लॉग पोस्ट पब्लिश करना
2. ब्लॉग पोस्ट का ड्राफ़्ट बनाना
पोस्ट वापस पाना
1. सभी ब्लॉग पोस्ट वापस लाना
2. क्वेरी पैरामीटर का इस्तेमाल करके पोस्ट हासिल करना
पोस्ट अपडेट करना
पोस्ट मिटाना
टिप्पणियां

ऑडियंस

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

ब्लॉग की सूची वापस लाना

Blogger Data API एक ऐसा फ़ीड उपलब्ध कराता है जिसमें किसी उपयोगकर्ता के ब्लॉग की सूची होती है. इस फ़ीड को "मेटाफ़ीड" कहा जाता है.

यहां दिया गया सैंपल कोड, मेटाफ़ीड को वापस पाने के लिए पुष्टि किए गए 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() तरीका कॉल करें.

उदाहरण के लिए, तारीख की सीमा वाली क्वेरी भेजने के लिए, Query इंस्टेंस की published_min और 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: पेजिंग के लिए, खोजे गए पहले नतीजे का इंडेक्स, जो 1 से शुरू होता है.
updated_min, updated_max: डेटा अपडेट करने की तारीखों की सीमा. जब तक orderby पैरामीटर को updated पर सेट नहीं किया जाता, तब तक इन क्वेरी पैरामीटर को अनदेखा किया जाता है.

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

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

किसी मौजूदा ब्लॉग पोस्ट को अपडेट करने के लिए, सबसे पहले वह एंट्री पाएं जिसे अपडेट करना है. इसके बाद, उसमें बदलाव करें और फिर Put तरीके का इस्तेमाल करके उसे Blogger पर भेजें. नीचे दिया गया कोड स्निपेट, ब्लॉग एंट्री के टाइटल में बदलाव करता है. ऐसा तब होता है, जब आपने सर्वर से एंट्री पहले ही वापस पा ली हो.

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 इंस्टेंस में सेट करें.

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

पोस्ट मिटाना

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

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)

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

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

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

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

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

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

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

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

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