Blogger डेटा एपीआई, क्लाइंट ऐप्लिकेशन को Google डेटा एपीआई फ़ीड के रूप में Blogger कॉन्टेंट देखने और उसे अपडेट करने की सुविधा देता है.
आपका क्लाइंट ऐप्लिकेशन, Blogger की एपीआई का इस्तेमाल करके, नई ब्लॉग पोस्ट बना सकता है और मौजूदा ब्लॉग पोस्ट में बदलाव कर सकता है या उन्हें मिटा सकता है. इसके अलावा, वह उन ब्लॉग पोस्ट के लिए क्वेरी कर सकता है जो खास शर्तें पूरी करती हैं.
इस डेटा में, Blogger डेटा एपीआई की सुविधाओं के बारे में भी जानकारी दी गई है. इसमें, Python क्लाइंट लाइब्रेरी का इस्तेमाल करके, बुनियादी डेटा एपीआई इंटरैक्शन के उदाहरण दिए गए हैं. अगर आप लाइब्रेरी में इस्तेमाल किए जा रहे प्रोटोकॉल के बारे में ज़्यादा जानना चाहते हैं, तो इस डेवलपर की गाइड के प्रोटोकॉल सेक्शन पर जाएं.
कॉन्टेंट
दर्शक
यह दस्तावेज़ ऐसे प्रोग्रामर के लिए है जो Python के क्लाइंट ऐप्लिकेशन लिखना चाहते हैं. ये ऐप्लिकेशन, Blogger से इंटरैक्ट कर सकते हैं.
इस दस्तावेज़ में यह माना जाता है कि आप Google के डेटा एपीआई प्रोटोकॉल को इस्तेमाल करने के सामान्य आइडिया समझते हैं.
Blogger के डेटा एपीआई की सामान्य जानकारी के लिए, प्रोटोकॉल रेफ़रंस गाइड देखें.
रिपोर्ट का इस्तेमाल करना
क्लाइंट लाइब्रेरी सेट अप करने में मदद पाने के लिए, शुरुआती निर्देश देखें.
Python क्लाइंट लाइब्रेरी के लिए, Python 2.2 या इससे नया वर्शन ज़रूरी है. क्लाइंट लाइब्रेरी डाउनलोड करने के बाद, आपको ElementTree पैकेज डाउनलोड और इंस्टॉल करना होगा.
Blogger खाता बनाना
टेस्टिंग के मकसद से, ब्लॉगर खाते के लिए साइन अप किया जा सकता है. Blogger, Google खातों का इस्तेमाल करता है, इसलिए अगर आपके पास पहले से कोई Google खाता है, तो आप पूरी तरह से तैयार हैं.
सैंपल कोड चलाना
नमूने के तौर पर इस्तेमाल किया जा सकने वाला एक क्लाइंट, जिसमें इस दस्तावेज़ में दिखाए गए सभी सैंपल कोड शामिल हैं, वह gdata-python-client/samples/blogger/ डायरेक्ट्री में BloggerExample.py फ़ाइल में उपलब्ध है.
सैंपल क्लाइंट, Blogger के डेटा एपीआई के इस्तेमाल को दिखाने के लिए, दिए गए ब्लॉग पर कई कार्रवाइयां करता है.
आप नीचे दिए गए आर्ग्युमेंट के साथ सैंपल चला सकते हैं:
python BloggerExample.py --email [email_address] --password [password]
अपने दस्तावेज़ में इस दस्तावेज़ के उदाहरणों का इस्तेमाल करने के लिए, आपको यहां दिए गए import स्टेटमेंट की ज़रूरत होगी:
from gdata import service import gdata import atom
Blogger सेवा की पुष्टि करना
Blogger के डेटा एपीआई का इस्तेमाल करके, सार्वजनिक और निजी, दोनों फ़ीड ऐक्सेस किए जा सकते हैं. सार्वजनिक फ़ीड के लिए, किसी पुष्टि करने की ज़रूरत नहीं होती. हालांकि, ये रीड-ओनली होते हैं. अगर आप ब्लॉग में बदलाव करना चाहते हैं, तो निजी फ़ीड का अनुरोध करने से पहले आपके क्लाइंट को पुष्टि करनी होगी. यह इन तीन में से किसी भी तरीके का इस्तेमाल करके पुष्टि कर सकता है:OAuth पुष्टि करना, AuthSub प्रॉक्सी पुष्टि करना या ClientLogin उपयोगकर्ता नाम/पासवर्ड पुष्टि करना.
Google डेटा एपीआई की मदद से पुष्टि करने के बारे में ज़्यादा जानकारी के लिए, पुष्टि करने वाला दस्तावेज़ देखें.
इस दस्तावेज़ के बाद के सेक्शन में ज़्यादातर सैंपल यह मानते हैं कि आपने
GDataService इंस्टेंस की पुष्टि की है.
OAuth प्रमाणीकरण
Python GData लाइब्रेरी का इस्तेमाल करके OAuth की पुष्टि करने वाले दस्तावेज़ के लिए, कृपया Google डेटा प्रोटोकॉल क्लाइंट लाइब्रेरी में मौजूद 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 पुष्टि का इस्तेमाल करें. बस अपने 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 एपीआई का इस्तेमाल करने से रोक दिया जाएगा.
क्लाइंट लॉगिन की पुष्टि करने के बारे में ज़्यादा जानने के लिए, इंस्टॉल किए गए ऐप्लिकेशन के लिए पुष्टि करना दस्तावेज़ देखें. इसमें सैंपल अनुरोध और जवाब भी शामिल हैं.
ध्यान दें: किसी दिए गए सेशन में सभी अनुरोधों के लिए एक ही टोकन का इस्तेमाल करें. Blogger के हर अनुरोध के लिए नया टोकन न पाएं.
नोट: जैसा कि ClientLogin दस्तावेज़ में बताया गया है, पुष्टि का अनुरोध पूरा नहीं हो सकता और कैप्चा चुनौती का अनुरोध कर सकता है. अगर आप चाहते हैं कि Google, कैप्चा चुनौती को जारी करे और उसका जवाब दे, तो
उपयोगकर्ता को
https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger
(क्लाइंट लॉगिन
दस्तावेज़ में दिए गए कैप्चा-हैंडलिंग यूआरएल के बजाय) भेजें.
ब्लॉग की सूची फ़ेच की जा रही है
Blogger डेटा एपीआई में एक फ़ीड होता है, जो किसी खास उपयोगकर्ता के ब्लॉग की सूची बनाता है; उस फ़ीड को "metafeed." कहा जाता है;
नीचे दिया गया सैंपल कोड, पुष्टि किए गए 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 के डेटा एपीआई का इस्तेमाल करके, आप नई ब्लॉग एंट्री बना सकते हैं और प्रकाशित कर सकते हैं. साथ ही, आप एंट्री के ड्राफ़्ट भी बना सकते हैं.
ध्यान दें: फ़िलहाल, पोस्ट के लिए पसंद के मुताबिक लेखक सेट करने की सुविधा मौजूद नहीं है. सभी नई पोस्ट इस तरह दिखाई देंगी जैसे कि उन्हें हाल ही में पुष्टि किए गए उपयोगकर्ता ने बनाया है.
ब्लॉग पोस्ट पब्लिश करना
नई ब्लॉग एंट्री पब्लिश करने के लिए, 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 के सार्वजनिक फ़ीड के बारे में क्वेरी की जा सकती है. इसलिए, आपको किसी सार्वजनिक ब्लॉग से पोस्ट वापस लाने से पहले क्रेडेंशियल सेट करने या पुष्टि करने की ज़रूरत नहीं पड़ती है.
सभी ब्लॉग पोस्ट वापस पाई जा रही हैं
उपयोगकर्ता की पोस्ट को वापस पाने के लिए, ब्लॉग पोस्ट फ़ीड के यूआरएल की मदद से, 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 के डेटा एपीआई की मदद से, आपके पास तय की गई शर्तों से मेल खाने वाली एंट्री के सेट का अनुरोध करने का विकल्प होता है. जैसे, दी गई तारीख की सीमा में, पब्लिश या अपडेट किए गए ब्लॉग पोस्ट का अनुरोध करना. ऐसा करने के लिए, आप 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 डेटा एपीआई में ये 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 डेटा एपीआई के रेफ़रंस की गाइड देखें.
पोस्ट अपडेट की जा रही हैं
किसी मौजूदा ब्लॉग पोस्ट को अपडेट करने के लिए, पहले आपको वह एंट्री मिलती है जिसे आप अपडेट करना चाहते हैं, फिर आप उसमें बदलाव करते हैं और फिर 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 के डेटा एपीआई से टिप्पणियां बनाने, वापस पाने, और मिटाने की सुविधा मिलती है. टिप्पणियां अपडेट करना काम नहीं करता है (न ही यह वेब इंटरफ़ेस में उपलब्ध है).
टिप्पणियां बनाना
टिप्पणी पोस्ट करने के लिए, 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
टिप्पणियां मिटाना
किसी टिप्पणी को मिटाने के लिए, टिप्पणी और #39;s के यूआरएल में बदलाव करें. ऐसा करने के लिए, अपने GDataService ऑब्जेक्ट में, Delete
तरीके का इस्तेमाल करें:
def DeleteComment(blogger_service, post_id, comment_id): feed_url = '/feeds/' + post_id + '/comments/default/' + comment_id blogger_service.Delete(feed_url)