Blogger Data API ช่วยให้แอปพลิเคชันไคลเอ็นต์ดูและอัปเดตเนื้อหา Blogger ได้ในรูปแบบฟีด Google Data API
แอปพลิเคชันไคลเอ็นต์ของคุณสามารถใช้ Blogger Data API เพื่อสร้างบล็อกใหม่ได้ โพสต์ แก้ไขหรือลบบล็อกโพสต์ที่มีอยู่ และสอบถามบล็อกโพสต์ที่ตรงกัน เกณฑ์หนึ่งๆ
นอกจากข้อมูลเบื้องต้นเกี่ยวกับความสามารถของ Blogger Data API แล้ว เอกสารนี้ยังมีตัวอย่างการโต้ตอบพื้นฐานของ Data API โดยใช้ไลบรารีไคลเอ็นต์ Python ด้วย หากต้องการทําความเข้าใจเพิ่มเติมเกี่ยวกับโปรโตคอลพื้นฐานที่ไลบรารีใช้ โปรดดูส่วนโปรโตคอลในคู่มือสําหรับนักพัฒนาซอฟต์แวร์นี้
เนื้อหา
ผู้ชม
เอกสารนี้มีไว้สำหรับโปรแกรมเมอร์ที่ต้องการเขียนแอปพลิเคชันไคลเอ็นต์ Python ที่โต้ตอบกับ Blogger ได้
เอกสารนี้ถือว่าคุณเข้าใจแนวคิดทั่วไปที่อยู่เบื้องหลังโปรโตคอล Google Data API
ดูข้อมูลอ้างอิงทั่วไปของ Blogger 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 โดยใช้ไลบรารี GData ของ Python ได้ในส่วน OAuth ในไลบรารีไคลเอ็นต์ Google Data Protocol
การตรวจสอบสิทธิ์พร็อกซี AuthSub
เว็บแอปพลิเคชันที่จำเป็นต้องใช้การตรวจสอบสิทธิ์พร็อกซี AuthSub ตรวจสอบสิทธิ์ผู้ใช้ในบัญชี Google ผู้ดำเนินการเว็บไซต์และโค้ดไคลเอ็นต์จะไม่มีสิทธิ์เข้าถึงชื่อผู้ใช้และรหัสผ่านของผู้ใช้ Blogger แต่จะได้รับโทเค็น AuthSub พิเศษที่อนุญาตให้ไคลเอ็นต์ดำเนินการในนามของผู้ใช้รายหนึ่งๆ สำหรับข้อมูลโดยละเอียด โปรดดูเอกสาร AuthSub
เมื่อผู้ใช้เข้าชมแอปพลิเคชันของคุณเป็นครั้งแรก ผู้ใช้ยังไม่ได้ ตรวจสอบสิทธิ์แล้ว ในกรณีนี้ คุณต้องแสดงข้อมูลบางอย่างและลิงก์ที่นำผู้ใช้ไปยังหน้า Google เพื่อตรวจสอบสิทธิ์คําขอเข้าถึงบล็อก ไลบรารีของไคลเอ็นต์ Python มีฟังก์ชันในการสร้าง URL ของหน้า Google โค้ดด้านล่างจะดึง 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 ของ AuthSubRequest
URL ระบบ 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 จะแสดงผล
โทเค็นเซสชัน
จากนั้นแอปพลิเคชันจะใช้ค่าโทเค็นเซสชันได้ในภายหลัง การโต้ตอบกับบล็อกเกอร์ ไลบรารีของไคลเอ็นต์จะส่งโทเค็นพร้อมกับคำขอโดยอัตโนมัติ
การตรวจสอบสิทธิ์ชื่อผู้ใช้/รหัสผ่านของ ClientLogin
ใช้การตรวจสอบสิทธิ์ ClientLogin หากไคลเอ็นต์เป็นไคลเอ็นต์ "ที่ติดตั้ง" แบบสแตนด์อโลนและผู้ใช้คนเดียว (เช่น แอปพลิเคชันบนเดสก์ท็อป) เพียงเรียกใช้เมธอด 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 รวมถึงตัวอย่างคำขอและการตอบกลับได้ในเอกสารประกอบการตรวจสอบสิทธิ์สําหรับแอปพลิเคชันที่ติดตั้ง
หมายเหตุ: ใช้โทเค็นเดียวกันสำหรับคำขอทั้งหมดใน เซสชันที่ระบุ จะไม่ขอโทเค็นใหม่สำหรับคำขอบล็อกเกอร์แต่ละรายการ
หมายเหตุ: ตามที่อธิบายไว้ในเอกสารประกอบของ ClientLogin คําขอตรวจสอบสิทธิ์อาจไม่สําเร็จและขอคําถาม CAPTCHA ถ้าต้องการให้ Google ออกและจัดการคำถาม CAPTCHA
ส่งผู้ใช้ไปที่
https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger
(แทนที่จะเป็น URL ที่ใช้จัดการ CAPTCHA ที่ให้ไว้ใน 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
จด URL ที่ใช้โดยเมธอด Get นี่คือ URL ของฟีดเมตาเริ่มต้น ซึ่งจะแสดงรายการบล็อกของผู้ใช้ที่ตรวจสอบสิทธิ์แล้วในปัจจุบัน
หากต้องการเข้าถึงฟีดของผู้ใช้รายอื่น ให้ใส่รหัสของผู้ใช้แทน default ใน URL ของเมตาฟีด รหัสของผู้ใช้คือสตริงตัวเลขที่อยู่ท้าย URL ของโปรไฟล์ผู้ใช้
ข้อมูลโค้ดด้านล่างแสดงวิธีดึงรหัสบล็อกจากฟีด คุณจะต้องมีรหัสบล็อกเพื่อดำเนินการสร้าง อัปเดต และลบโพสต์และความคิดเห็น ข้อมูลโค้ดด้านล่างจะเลือกบล็อกแรกที่มีการดึงข้อมูลสําหรับผู้ใช้
blog_id = feed.entry[0].GetSelfLink().href.split("/")[-1]
ในตัวอย่าง BloggerExample.py BloggerExample
สร้างคลาส และตั้งค่า ID บล็อกไว้ในเครื่องมือสร้างเพื่อให้เข้าถึงได้ง่าย
ในภายหลัง สำหรับตัวอย่างต่อไปนี้ในเอกสารนี้ส่วนใหญ่
มีการส่ง 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 ฟีดโพสต์เดียวกันกับที่ใช้ดึงข้อมูลโพสต์
API ข้อมูลของ Blogger รองรับ Query ต่อไปนี้
พร็อพเพอร์ตี้:
- หมวดหมู่
- ระบุหมวดหมู่ (หรือที่เรียกว่าป้ายกำกับ) เพื่อกรองผลการค้นหาของฟีด เช่น
http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurieจะแสดงรายการที่มีทั้งป้ายกำกับFritzและLaurieหากต้องการระบุการค้นหาหมวดหมู่ดังกล่าวในไลบรารีของไคลเอ็นต์ Python คุณสามารถใช้query.categories = ['Fritz','Laurie',] - max_results
- จำนวนรายการสูงสุดที่จะแสดง
- เผยแพร่_ขั้นต่ำ เผยแพร่สูงสุดแล้ว
- ขอบเขตวันที่เผยแพร่รายการ
- start_index
- ดัชนีแบบ 1 ของผลลัพธ์แรกที่จะดึงข้อมูล (สำหรับการแบ่งหน้า)
- อัปเดต_นาที, สูงสุด_อัปเดตแล้ว
- ขอบเขตวันที่อัปเดตรายการ ระบบจะไม่สนใจพารามิเตอร์การค้นหาเหล่านี้ เว้นแต่จะมีการตั้งค่าพารามิเตอร์
orderbyเป็นupdated
ดูข้อมูลเพิ่มเติมเกี่ยวกับพารามิเตอร์การค้นหาได้ในคู่มืออ้างอิง Blogger Data API และคู่มืออ้างอิง 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)