หน้านี้ได้รับการแปลโดย Cloud Translation API

คู่มือสำหรับนักพัฒนาซอฟต์แวร์: Python

Blogger Data API ช่วยให้แอปพลิเคชันไคลเอ็นต์ดูและอัปเดตเนื้อหา Blogger ได้ในรูปแบบฟีด Google Data API

แอปพลิเคชันไคลเอ็นต์สามารถใช้ Blogger Data API เพื่อสร้างบล็อกโพสต์ใหม่ แก้ไขหรือลบบล็อกโพสต์ที่มีอยู่ และค้นหาบล็อกโพสต์ที่ตรงกับเกณฑ์ที่เฉพาะเจาะจง

นอกจากข้อมูลเบื้องต้นเกี่ยวกับความสามารถของ Blogger Data API แล้ว เอกสารนี้ยังมีตัวอย่างการโต้ตอบพื้นฐานของ Data API โดยใช้ไลบรารีไคลเอ็นต์ Python ด้วย หากต้องการทำความเข้าใจเพิ่มเติมเกี่ยวกับโปรโตคอลพื้นฐานที่ไลบรารีใช้ โปรดดูส่วนโปรโตคอลของคู่มือนักพัฒนาซอฟต์แวร์นี้

เนื้อหา

ผู้ชม
การเริ่มต้นใช้งาน
1. การสร้างบัญชี Blogger
2. การเรียกใช้โค้ดตัวอย่าง
การตรวจสอบสิทธิ์ในบริการ Blogger
การเรียกข้อมูลรายการบล็อก
การสร้างโพสต์
1. การเผยแพร่บล็อกโพสต์
2. การสร้างบล็อกโพสต์ฉบับร่าง
การดึงข้อมูลโพสต์
1. การดึงข้อมูลบล็อกโพสต์ทั้งหมด
2. การดึงข้อมูลโพสต์โดยใช้พารามิเตอร์การค้นหา
การอัปเดตโพสต์
การลบโพสต์
ความคิดเห็น

ผู้ชม

เอกสารนี้มีไว้สำหรับโปรแกรมเมอร์ที่ต้องการเขียนแอปพลิเคชันไคลเอ็นต์ 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 ฟีดสาธารณะไม่จําเป็นต้องตรวจสอบสิทธิ์ แต่จะเป็นฟีดแบบอ่านอย่างเดียว หากต้องการแก้ไขบล็อก ลูกค้าจะต้องตรวจสอบสิทธิ์ก่อนขอฟีดส่วนตัว โดยสามารถตรวจสอบสิทธิ์ได้โดยใช้แนวทางใดแนวทางหนึ่งต่อไปนี้ การตรวจสอบสิทธิ์ OAuth, การตรวจสอบสิทธิ์พร็อกซี AuthSub หรือการตรวจสอบสิทธิ์ชื่อผู้ใช้/รหัสผ่าน ClientLogin

ดูข้อมูลเพิ่มเติมเกี่ยวกับการตรวจสอบสิทธิ์ด้วย Google Data API โดยทั่วไปได้ที่เอกสารประกอบเกี่ยวกับการตรวจสอบสิทธิ์

ตัวอย่างส่วนใหญ่ในส่วนถัดไปของเอกสารนี้จะถือว่าคุณมีอินสแตนซ์ GDataService ที่ตรวจสอบสิทธิ์แล้ว

การตรวจสอบสิทธิ์ OAuth

ดูเอกสารประกอบเกี่ยวกับการตรวจสอบสิทธิ์ OAuth โดยใช้ไลบรารี GData ของ Python ได้ในส่วน OAuth ในไลบรารีไคลเอ็นต์ Google Data Protocol

การตรวจสอบสิทธิ์พร็อกซี AuthSub

เว็บแอปพลิเคชันที่ต้องการตรวจสอบสิทธิ์ผู้ใช้กับบัญชี Google จะใช้การตรวจสอบสิทธิ์พร็อกซี AuthSub ผู้ดำเนินการเว็บไซต์และโค้ดไคลเอ็นต์จะไม่มีสิทธิ์เข้าถึงชื่อผู้ใช้และรหัสผ่านของผู้ใช้ 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พารามิเตอร์การค้นหาของ 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 หากไคลเอ็นต์เป็นไคลเอ็นต์ "ที่ติดตั้ง" แบบสแตนด์อโลนและผู้ใช้คนเดียว (เช่น แอปพลิเคชันบนเดสก์ท็อป) เพียงเรียกใช้เมธอด 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)

การดึงข้อมูลรายการบล็อก

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 และตั้งค่ารหัสบล็อกในคอนสตรัคเตอร์เพื่อให้เข้าถึงได้ง่ายในภายหลัง ตัวอย่างส่วนใหญ่ต่อไปนี้ในเอกสารนี้จะส่ง 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!')

การสร้างฉบับร่างของบล็อกโพสต์

ระบบจะสร้างโพสต์ฉบับร่างในลักษณะเดียวกับโพสต์สาธารณะ แต่คุณต้องตั้งค่าองค์ประกอบส่วนขยาย 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 แล้วอัปเดตโพสต์ เราจะพูดถึงการดึงข้อมูลและการอัปเดตโพสต์ในส่วนถัดไป

กำลังเรียกข้อมูลโพสต์

ส่วนต่อไปนี้อธิบายวิธีดึงข้อมูลรายการบล็อกโพสต์ที่มีและไม่มีพารามิเตอร์การค้นหา

คุณค้นหาฟีดสาธารณะของ 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

การดึงข้อมูลโพสต์โดยใช้พารามิเตอร์การค้นหา

Blogger Data API ช่วยให้คุณขอชุดรายการที่ตรงกับเกณฑ์ที่ระบุได้ เช่น การขอบล็อกโพสต์ที่เผยแพร่หรืออัปเดตในช่วงวันที่ที่ระบุ โดยสร้างอินสแตนซ์ 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: จำนวนรายการสูงสุดที่จะแสดง
published_min, published_max: ขอบเขตวันที่เผยแพร่รายการ
start_index: ดัชนีฐาน 1 ของผลลัพธ์แรกที่จะดึงข้อมูล (สำหรับการแบ่งหน้า)
updated_min, updated_max: ขอบเขตวันที่อัปเดตรายการ ระบบจะไม่สนใจพารามิเตอร์การค้นหาเหล่านี้ เว้นแต่จะมีการตั้งค่าพารามิเตอร์ 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)

กลับไปด้านบน