API ข้อมูลของ Blogger จะช่วยให้แอปพลิเคชันไคลเอ็นต์สามารถดูและอัปเดตเนื้อหาของ Blogger ในรูปแบบของฟีด Google Data API
แอปพลิเคชันไคลเอ็นต์จะใช้ Blogger Data API เพื่อสร้างบล็อกโพสต์ใหม่ แก้ไขหรือลบบล็อกโพสต์ที่มีอยู่ และค้นหาบล็อกโพสต์ที่ตรงกับเกณฑ์หนึ่งๆ ได้
นอกเหนือจากให้ข้อมูลเกี่ยวกับความสามารถของ Blogger Data API แล้ว เอกสารนี้ยังให้ตัวอย่างการโต้ตอบพื้นฐานของ Data API โดยใช้ไลบรารี Python ด้วย หากคุณสนใจทําความเข้าใจเพิ่มเติมเกี่ยวกับโปรโตคอลสําคัญที่ไลบรารีใช้ โปรดดูส่วนโปรโตคอลของคู่มือสําหรับนักพัฒนาซอฟต์แวร์นี้
เนื้อหา
กลุ่มเป้าหมาย
เอกสารนี้จัดทําขึ้นสําหรับโปรแกรมเมอร์ที่ต้องการเขียนแอปพลิเคชันไคลเอ็นต์ Python ซึ่งโต้ตอบกับ Blogger ได้
เอกสารนี้จะถือว่าคุณเข้าใจแนวคิดทั่วไปเบื้องหลังโปรโตคอล Google Data API
สําหรับข้อมูลอ้างอิงทั่วไปของ 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
คุณสามารถเข้าถึงได้ทั้งฟีดสาธารณะและฟีดส่วนตัวโดยใช้ Blogger Data API ฟีดสาธารณะไม่จําเป็นต้องมีการตรวจสอบสิทธิ์ แต่เป็นแบบอ่านอย่างเดียว หากต้องการแก้ไขบล็อก ลูกค้าจะต้องตรวจสอบสิทธิ์ก่อนที่จะขอฟีดส่วนตัว โดยจะตรวจสอบสิทธิ์ได้โดยใช้วิธีใดวิธีหนึ่งจาก 3 วิธีต่อไปนี้:OAuthการตรวจสอบสิทธิ์, AuthSubการตรวจสอบสิทธิ์ พร็อกซี หรือClientLoginการตรวจสอบสิทธิ์ชื่อผู้ใช้/รหัสผ่าน
ดูข้อมูลเพิ่มเติมเกี่ยวกับการตรวจสอบสิทธิ์ด้วย Google Data API โดยทั่วไปได้ในเอกสารประกอบของการตรวจสอบสิทธิ์
ตัวอย่างส่วนใหญ่ในส่วนถัดไปของเอกสารนี้ถือว่าคุณมีอินสแตนซ์ GDataService ที่ตรวจสอบสิทธิ์แล้ว
การตรวจสอบสิทธิ์ OAuth
ดูเอกสารประกอบของ OAuth ที่ใช้ไลบรารี Python GData ได้ที่ OAuth ในไลบรารีของไคลเอ็นต์ Google Data Protocol
การตรวจสอบสิทธิ์พร็อกซี AuthSub
เว็บแอปพลิเคชันที่ใช้การตรวจสอบสิทธิ์พร็อกซี AuthSub ต้องมีการตรวจสอบสิทธิ์ผู้ใช้กับบัญชี Google ผู้ให้บริการเว็บไซต์และโค้ดของไคลเอ็นต์จะไม่มีสิทธิ์เข้าถึงชื่อผู้ใช้และรหัสผ่านสําหรับผู้ใช้ Blogger แต่จะได้รับโทเค็น AuthSub แบบพิเศษที่ช่วยให้ไคลเอ็นต์ดําเนินการแทนผู้ใช้รายนั้นได้ โปรดดูข้อมูลโดยละเอียดในเอกสารประกอบของ AuthSub
เมื่อผู้ใช้เข้าชมแอปพลิเคชันเป็นครั้งแรก ผู้ใช้จะยังไม่ผ่านการตรวจสอบสิทธิ์ ในกรณีนี้ คุณต้องแสดงข้อมูลบางส่วนและลิงก์ที่นําผู้ใช้ไปยังหน้า Google เพื่อตรวจสอบสิทธิ์คําขอของคุณสําหรับการเข้าถึงบล็อกของพวกเขา ไลบรารีของไคลเอ็นต์ Python มีฟังก์ชันในการสร้าง URL ของ Google หน้า #39 โค้ดด้านล่างจะดึง 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
เมธอด GenerateAuthSubURL ใช้พารามิเตอร์ต่อไปนี้
(สอดคล้องกับพารามิเตอร์การค้นหาที่ใช้โดย 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 จะเปลี่ยนเส้นทางผู้ใช้ไปยัง URL ที่คุณระบุในพารามิเตอร์การค้นหาของ next ของ URL AuthSubRequest ระบบ 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
blogger_service = service.GDataService() blogger_service.auth_token = authsub_token blogger_service.UpgradeToSessionToken()
กล่าวคือ คุณจะต้องส่งโทเค็นแบบใช้ครั้งเดียวไปยังเมธอด UpgradeToSessionToken และอินเทอร์เฟซ AuthSub จะแสดงโทเค็นเซสชัน
จากนั้นแอปพลิเคชันจะใช้ค่าโทเค็นเซสชันในการโต้ตอบที่ตามมากับ Blogger ได้ ไลบรารีของไคลเอ็นต์จะส่งโทเค็นพร้อมคําขอโดยอัตโนมัติ
การตรวจสอบสิทธิ์ชื่อผู้ใช้/รหัสผ่านของ ClientLogin
ใช้การตรวจสอบสิทธิ์ ClientLogin หากไคลเอ็นต์เป็นไคลเอ็นต์เดี่ยว
"Installed" ไคลเอ็นต์ (เช่น แอปพลิเคชันเดสก์ท็อป) เพียงเรียกใช้เมธอด 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()
ในข้อมูลโค้ดด้านบน เราตั้งค่าพร็อพเพอร์ตี้ 3 รายการบนอินสแตนซ์ GDataService ชื่อแรกคือชื่อแอปพลิเคชันของเราในรูปแบบ companyName-applicationName-versionID
ส่วนที่ 2 คือชื่อบริการที่เราต้องการโต้ตอบ อย่างที่ 3 คือที่อยู่ของเซิร์ฟเวอร์
โปรดสังเกตว่ามีการตั้งค่า account_type เป็น GOOGLE อย่างชัดเจน การไม่ตั้งค่าพารามิเตอร์นี้จะป้องกันไม่ให้ผู้ใช้ G Suite ใช้ Blogger API ได้
ดูข้อมูลเพิ่มเติมเกี่ยวกับการตรวจสอบสิทธิ์ ClientLogin รวมถึงตัวอย่างคําขอและการตอบกลับได้จากเอกสารประกอบการตรวจสอบสิทธิ์สําหรับแอปพลิเคชันที่ติดตั้งไว้
หมายเหตุ: ใช้โทเค็นเดียวกันสําหรับคําขอทั้งหมดในเซสชันที่ระบุ และอย่าสร้างโทเค็นใหม่สําหรับคําขอ Blogger แต่ละรายการ
หมายเหตุ: ตามที่อธิบายไว้ในเอกสารประกอบของ ClientLogin คําขอการตรวจสอบสิทธิ์อาจล้มเหลวและส่งคําขอ CAPTCHA หากต้องการให้ Google ออกและจัดการปัญหา CAPTCHA ให้ส่งผู้ใช้ไปที่
https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger
(แทนที่จะส่ง URL การจัดการ CAPTCHA ที่ระบุในเอกสารประกอบ ClientLogin)
กําลังเรียกดูรายการบล็อก
API ข้อมูลของ 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
จด URL ที่เมธอด Get ใช้ นี่คือ URL เมตาฟีดเริ่มต้น โดยระบบจะแสดงรายการบล็อกสําหรับผู้ใช้ที่ได้รับการตรวจสอบสิทธิ์ในปัจจุบัน
หากต้องการเข้าถึงฟีดของผู้ใช้รายอื่น คุณสามารถใส่รหัสของผู้ใช้แทน default ใน URL เมตาฟีด รหัส'ของผู้ใช้คือสตริงตัวเลขท้าย URL โปรไฟล์ของผู้ใช้
ข้อมูลโค้ดด้านล่างแสดงวิธีดึงข้อมูลรหัสบล็อกจากฟีด คุณจะต้องใช้รหัสบล็อกในการสร้าง อัปเดต และลบการดําเนินการในโพสต์และความคิดเห็น ข้อมูลโค้ดด้านล่างจะเลือกบล็อกแรก ที่ดึงให้กับผู้ใช้
blog_id = feed.entry[0].GetSelfLink().href.split("/")[-1]
ในตัวอย่าง BloggerExample.py ระบบจะสร้างชั้นเรียน BloggerExample และตั้งค่ารหัสบล็อกไว้ในเครื่องมือสร้างเพื่อให้เข้าถึงได้ง่ายในภายหลัง สําหรับตัวอย่างส่วนใหญ่ต่อไปนี้ในเอกสารนี้ ระบบจะส่ง blog_id เป็นตัวแปร
การสร้างโพสต์
API ข้อมูลของ 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!')
การสร้างบล็อกโพสต์ฉบับร่าง
โพสต์ฉบับร่างสร้างขึ้นในลักษณะเดียวกับโพสต์สาธารณะ แต่คุณต้องตั้งค่าเอลิเมนต์ส่วนขยาย 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 แล้วอัปเดตโพสต์ เราจะอธิบายถึงการเรียกและอัปเดตโพสต์ในอีก 2 ส่วนถัดไป
กําลังเรียกโพสต์
ส่วนต่อไปนี้จะอธิบายถึงวิธีเรียกรายการบล็อกโพสต์ที่มีและไม่มีพารามิเตอร์การค้นหา
คุณค้นหาฟีดสาธารณะของ 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
การดึงข้อมูลโพสต์โดยใช้พารามิเตอร์การค้นหา
API ข้อมูลของ Blogger ช่วยให้คุณขอชุดรายการที่ตรงกับเกณฑ์ที่ระบุได้ เช่น การขอบล็อกโพสต์ที่เผยแพร่หรืออัปเดตในช่วงวันที่หนึ่งๆ ซึ่งทําได้โดยการสร้างอินสแตนซ์ 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
- จํานวนสูงสุดของผลลัพธ์ที่จะแสดง
- เผยแพร่แล้วต่ําสุด, เผยแพร่แล้วสูงสุด
- ขอบเขตวันที่เผยแพร่รายการที่ป้อน
- ดัชนีเริ่มต้น
- ดัชนี 1 จากผลลัพธ์แรกที่จะดึงมา (สําหรับการแบ่งหน้า)
- อัปเดต_ต่ําสุด, อัปเดต_สูงสุด
- ขอบเขตการอัปเดตวันที่ป้อนเข้า ระบบจะไม่สนใจพารามิเตอร์การค้นหาเหล่านี้ เว้นแต่จะกําหนดพารามิเตอร์
orderbyเป็นupdated
ดูข้อมูลเพิ่มเติมเกี่ยวกับพารามิเตอร์การค้นหาได้ที่คู่มืออ้างอิง API ข้อมูลของ Blogger และคู่มืออ้างอิงสําหรับ Google Data API
กําลังอัปเดตโพสต์
หากต้องการอัปเดตบล็อกโพสต์ที่มีอยู่ อันดับแรกให้เรียกข้อมูลรายการที่คุณต้องการอัปเดต จากนั้นแก้ไข และส่งไปยัง 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)