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

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

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

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

कॉन्टेंट

ऑडियंस

यह दस्तावेज़ उन प्रोग्रामर के लिए है जो Blogger के साथ इंटरैक्ट करने वाले PHP क्लाइंट ऐप्लिकेशन लिखना चाहते हैं.

इस दस्तावेज़ में यह माना गया है कि आपको Google Data API प्रोटोकॉल के बारे में सामान्य जानकारी है.

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

शुरू करना

क्लाइंट लाइब्रेरी सेट अप करने में मदद पाने के लिए, शुरू करने की गाइड देखें.

Zend क्लाइंट लाइब्रेरी के लिए, PHP 5.1.4 या इसके बाद का वर्शन ज़रूरी है. यह Zend Framework के हिस्से के तौर पर उपलब्ध है. साथ ही, इसे अलग से डाउनलोड भी किया जा सकता है. Blogger के साथ इंटरैक्ट करने के लिए, क्लाइंट लाइब्रेरी के 1.0.0 या उसके बाद के वर्शन का इस्तेमाल करें.

Blogger खाता बनाना

टेस्टिंग के लिए, Blogger खाते के लिए साइन अप किया जा सकता है. Blogger, Google खातों का इस्तेमाल करता है. इसलिए, अगर आपके पास पहले से ही Google खाता है, तो आपको कुछ नहीं करना होगा.

सैंपल कोड चलाना

Zend फ़्रेमवर्क के SVN रिपॉज़िटरी में, काम करने वाला एक पूरा सैंपल क्लाइंट उपलब्ध है. इसमें इस दस्तावेज़ में दिखाया गया पूरा सैंपल कोड शामिल है. सैंपल /framework/standard/trunk/demos/Zend/Gdata/Blogger.php पर मौजूद है. सैंपल में, इस दस्तावेज़ में बताए गए सभी फ़ंक्शन शामिल हैं. इसे सिर्फ़ कमांड लाइन से चलाया जा सकता है:

php Blogger.php -- --user=[email_address] --pass=[password]

इस सैंपल को चलाने या Zend फ़्रेमवर्क का इस्तेमाल करके अपना कोड बनाने से पहले, आपको include_path सेट करना पड़ सकता है और सही क्लास लोड करनी पड़ सकती हैं. शामिल किए गए पाथ को php.ini सेटिंग या set_include_path तरीके का इस्तेमाल करके सेट किया जा सकता है. यह कोड, मुख्य Zend_Gdata क्लास, Zend_Gdata_Query क्लास, और पुष्टि करने वाली क्लास Zend_Gdata_ClientLogin का ऐक्सेस पाने का अनुरोध करता है.

require_once 'Zend/Loader.php';
Zend_Loader::loadClass('Zend_Gdata');
Zend_Loader::loadClass('Zend_Gdata_Query');
Zend_Loader::loadClass('Zend_Gdata_ClientLogin');

मैजिक गैटर और सेटर का इस्तेमाल करना

डेवलपर की सुविधा के लिए, PHP क्लाइंट लाइब्रेरी में मैजिक सेटर/गेटर के लिए सहायता जोड़ी गई है. इनकी मदद से, किसी क्लास की प्रॉपर्टी को सेट करने/उन्हें ऐक्सेस करने के लिए, सामान्य सेटर/गेटर तरीकों का इस्तेमाल किया जा सकता है. उदाहरण के लिए, अगर $gdataObject इस लाइब्रेरी में किसी ऑब्जेक्ट का उदाहरण है, तो कोड की इन दो लाइनों का असर एक जैसा होगा:

$gdataObject->setFoo("bar");
$gdataObject->foo = "bar";

इसी तरह, कोड की इन दो लाइनों का भी एक जैसा असर होता है:

$baz = $gdataObject->getFoo();
$baz = $gdataObject->foo;

इसी तरह, मैजिक फ़ैक्ट्री के तरीके से नए ऑब्जेक्ट का एलान करना आसान हो जाता है. Zend के नाम रखने के नियम के मुताबिक, क्लास के लंबे नाम याद रखने के बजाय, Zend सेवा क्लाइंट पर newObject(); को कॉल करके नया object बनाया जा सकता है. उदाहरण के लिए, यहां दिए गए दोनों स्निपेट में, एक नया draft एक्सटेंशन ऑब्जेक्ट घोषित किया गया है. drafts के बारे में ज़्यादा जानने के लिए, पोस्ट बनाना सेक्शन पर जाएं.

// Traditional instantiation
$gdClient = new Zend_Gdata();
$draft = new Zend_Gdata_App_Extension_Draft();

// Magic factory instantiation
$gdClient = new Zend_Gdata();
$draft = $gdClient->newDraft();

मैजिक सेटर/गेटर और फ़ैक्ट्री ज़रूरी नहीं हैं. इसलिए, अपने हिसाब से सबसे सही तरीका अपनाएं.

अन्य संसाधन

Zend Framework के Google Data APIs कॉम्पोनेंट (Zend_Gdata) के लिए अन्य संसाधन:

• रेफ़रंस दस्तावेज़
• मेल सूची की जानकारी और संग्रह
• Zend Framework Subversion की जानकारी
• Zend Framework के हर रात के स्नैपशॉट

Blogger की सेवा की पुष्टि करना

Blogger Data API का इस्तेमाल करके, सार्वजनिक और निजी, दोनों फ़ीड ऐक्सेस किए जा सकते हैं. सार्वजनिक फ़ीड के लिए पुष्टि करने की ज़रूरत नहीं होती. हालांकि, ये फ़ीड रीड-ओनली होते हैं. अगर आपको ब्लॉग में बदलाव करने हैं, तो निजी फ़ीड का अनुरोध करने से पहले, आपके क्लाइंट को पुष्टि करनी होगी. यह तीन तरीकों में से किसी भी तरीके का इस्तेमाल करके पुष्टि कर सकता है: OAuth ऑथेंटिकेशन, AuthSub प्रॉक्सी ऑथेंटिकेशन या ClientLogin उपयोगकर्ता नाम/पासवर्ड ऑथेंटिकेशन.

Google Data API की मदद से पुष्टि करने के बारे में ज़्यादा जानने के लिए, पुष्टि करने से जुड़ा दस्तावेज़ देखें.

इस दस्तावेज़ के अगले सेक्शन में दिए गए ज़्यादातर सैंपल में यह माना गया है कि आपके पास $gdClient नाम का पुष्टि किया गया क्लाइंट ऑब्जेक्ट है.

OAuth से पुष्टि करना

Zend PHP GData लाइब्रेरी का इस्तेमाल करके, OAuth की मदद से पुष्टि करने के बारे में दस्तावेज़ पाने के लिए, कृपया Google Data Protocol क्लाइंट लाइब्रेरी में OAuth देखें.

AuthSub प्रॉक्सी की पुष्टि

AuthSub प्रॉक्सी की पुष्टि करने की सुविधा का इस्तेमाल, वेब ऐप्लिकेशन करते हैं. इन ऐप्लिकेशन को अपने उपयोगकर्ताओं की पुष्टि, Google खातों के लिए करनी होती है. वेबसाइट ऑपरेटर और क्लाइंट कोड के पास, Blogger उपयोगकर्ता के उपयोगकर्ता नाम और पासवर्ड का ऐक्सेस नहीं होता. इसके बजाय, क्लाइंट को खास AuthSub टोकन मिलते हैं. इनकी मदद से, क्लाइंट किसी उपयोगकर्ता की ओर से कार्रवाई कर सकता है. ज़्यादा जानकारी के लिए, AuthSub दस्तावेज़ देखें.

जब कोई उपयोगकर्ता पहली बार आपके ऐप्लिकेशन पर आता है, तब उसकी पुष्टि नहीं की जाती. इस मामले में, आपको कुछ जानकारी और एक लिंक दिखाना होगा. इस लिंक से उपयोगकर्ता को Google के एक पेज पर ले जाया जाएगा. इस पेज पर, उपयोगकर्ता को अपने ब्लॉग को ऐक्सेस करने के अनुरोध की पुष्टि करनी होगी. Zend क्लाइंट लाइब्रेरी, Google पेज का यूआरएल जनरेट करने के लिए एक फ़ंक्शन उपलब्ध कराती है. यहां दिया गया कोड, AuthSubRequest पेज का यूआरएल वापस लाता है:

function getAuthSubUrl()
{
  $next = getCurrentUrl();
  $scope = 'http://www.google.com/blogger/feeds/';
  $secure = false;
  $session = true;
  return Zend_Gdata_AuthSub::getAuthSubTokenUri($next, $scope, $secure, $session);
}

$authSubUrl = getAuthSubUrl();
echo '<a href=\"$authSubUrl\">login to your Google account</a>';

getAuthSubTokenUri तरीका, इन पैरामीटर का इस्तेमाल करता है (ये 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.php

उपयोगकर्ता, Google की साइट पर दिए गए लिंक पर जाता है और अपने Google खाते की पुष्टि करता है.

उपयोगकर्ता की पुष्टि करने के बाद, AuthSub सिस्टम उसे उस यूआरएल पर रीडायरेक्ट करता है जिसे आपने AuthSubRequest यूआरएल के next क्वेरी पैरामीटर में बताया है. AuthSub सिस्टम, token क्वेरी पैरामीटर की वैल्यू के तौर पर, उस यूआरएल में पुष्टि करने वाला टोकन जोड़ता है. उदाहरण के लिए:

http://www.example.com/welcome.php?token=yourAuthToken

$_GET['token'] का इस्तेमाल करके, टोकन की वैल्यू वापस पाई जा सकती है.

इस टोकन की वैल्यू, एक बार इस्तेमाल होने वाले AuthSub टोकन को दिखाती है. इस उदाहरण में, $session = true तय किया गया था. इसलिए, इस टोकन को Zend_Gdata_AuthSub::getAuthSubSessionToken तरीके का इस्तेमाल करके, AuthSub सेशन टोकन से बदला जा सकता है. यह तरीका, AuthSubSessionToken सेवा को कॉल करता है:

if(! isset($_SESSION['sessionToken']) && isset($_GET['token'])) {
  $_SESSION['sessionToken'] =
      Zend_Gdata_AuthSub::getAuthSubSessionToken($_GET['token']);
}

कोड स्निपेट सबसे पहले यह जांच करता है कि AuthSub सेशन टोकन पहले से मौजूद है या नहीं. अगर ऐसा नहीं है, लेकिन यूआरएल में सिर्फ़ एक बार इस्तेमाल होने वाला टोकन दिया गया है, तो कोड स्निपेट, एक बार इस्तेमाल होने वाले टोकन को getAuthSubSessionToken तरीके पर पास करता है. साथ ही, AuthSub इंटरफ़ेस से एक सेशन टोकन मिलता है. इसके बाद, कोड सेशन टोकन की वैल्यू को सेशन वैरिएबल $_SESSION['sessionToken'] में डाल देता है.

इसके बाद, आपका ऐप्लिकेशन Blogger के साथ होने वाले अगले इंटरैक्शन में, सेशन टोकन की वैल्यू का इस्तेमाल कर सकता है. Zend_Gdata_AuthSub::getHttpClient तरीके का इस्तेमाल करके, Zend_Http_Client ऑब्जेक्ट पाया जा सकता है. इसमें AuthSub क्रेडेंशियल शामिल करने के लिए, Authorization हेडर पहले से सेट होता है:

$client = Zend_Gdata_AuthSub::getHttpClient($_SESSION['sessionToken']);

ClientLogin उपयोगकर्ता नाम/पासवर्ड की पुष्टि

अगर आपका क्लाइंट, स्टैंडअलोन, एक उपयोगकर्ता वाला "इंस्टॉल किया गया" क्लाइंट है, तो ClientLogin की पुष्टि करने की सुविधा का इस्तेमाल करें. जैसे, डेस्कटॉप ऐप्लिकेशन.

नीचे दिया गया कोड, ClientLogin सेवा को अनुरोध करने, ऑथेंटिकेशन टोकन पाने, और सही ऑथेंटिकेशन हेडर के साथ Zend_Http_Client ऑब्जेक्ट बनाने के लिए, Zend_Gdata_ClientLogin::getHttpClient तरीके का इस्तेमाल करता है. इसके बाद, इस तरीके से मिले HttpClient का इस्तेमाल, Zend_Gdata सेवा ऑब्जेक्ट बनाने के लिए किया जाता है.

ध्यान दें कि $accountType को साफ़ तौर पर GOOGLE पर सेट किया गया है. इस पैरामीटर को सेट न करने पर, G Suite के उपयोगकर्ता Blogger API का इस्तेमाल नहीं कर पाएंगे.

$user = 'user@example.com';
$pass = 'secretPasswd';
$service = 'blogger';

$client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service, null,
        Zend_Gdata_ClientLogin::DEFAULT_SOURCE, null, null,
        Zend_Gdata_ClientLogin::CLIENTLOGIN_URI, 'GOOGLE');
$gdClient = new Zend_Gdata($client);

ClientLogin की पुष्टि करने के बारे में ज़्यादा जानकारी के लिए, इंस्टॉल किए गए ऐप्लिकेशन के लिए पुष्टि से जुड़ा दस्तावेज़ देखें. इसमें, अनुरोध और जवाब के सैंपल भी शामिल हैं.

ध्यान दें: किसी सेशन में सभी अनुरोधों के लिए एक ही टोकन का इस्तेमाल करें. हर Blogger अनुरोध के लिए नया टोकन न लें.

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

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

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

यहां दिया गया सैंपल कोड, मेटाफ़ीड को वापस पाने के लिए पुष्टि किए गए $gdClient ऑब्जेक्ट का इस्तेमाल करता है. इसके बाद, हर ब्लॉग का टाइटल प्रिंट करता है.

Zend_Gdata_Query क्लास, क्वेरी यूआरएल बनाने का काम करता है. इस मामले में, कोई और काम करने की ज़रूरत नहीं है. हालांकि, इस दस्तावेज़ के क्वेरी पैरामीटर के हिसाब से पोस्ट हासिल करना सेक्शन में, Query क्लास की मदद से काम करने का तरीका पता चलेगा.

function printAllBlogs()
{
  $query = new Zend_Gdata_Query('http://www.blogger.com/feeds/default/blogs');
  $feed = $gdClient->getFeed($query);
  printFeed($feed);
}

function printFeed($feed)
{
  $i = 0;
  foreach($feed->entries as $entry) {
    print $i ." ". $entry->title->text . "\n";
    $i++;
  }
}

getFeed तरीके से इस्तेमाल किए गए यूआरएल पर ध्यान दें. यह डिफ़ॉल्ट मेटाफ़ीड यूआरएल है. यह, पुष्टि किए गए मौजूदा उपयोगकर्ता के ब्लॉग की सूची दिखाता है. किसी दूसरे उपयोगकर्ता के फ़ीड को ऐक्सेस करने के लिए, मेटाफ़ीड यूआरएल में default के बजाय उपयोगकर्ता का आईडी डाला जा सकता है. उपयोगकर्ता का आईडी, उपयोगकर्ता की प्रोफ़ाइल के यूआरएल के आखिर में मौजूद अंकों की स्ट्रिंग होती है.

नीचे दिए गए कोड स्निपेट में, फ़ीड से ब्लॉग आईडी निकालने का तरीका बताया गया है. पोस्ट और टिप्पणियों को बनाने, अपडेट करने, और मिटाने के लिए, आपको ब्लॉग आईडी की ज़रूरत होगी. $index वैरिएबल से पता चलता है कि उपयोगकर्ता के ब्लॉग फ़ीड में मौजूद कौनसे ब्लॉग का इस्तेमाल किया जा रहा है. id फ़ील्ड का फ़ॉर्मैट tag:blogger.com,1999:user-userID.blog-blogID होता है. इसलिए, '-' वर्ण पर split, ब्लॉग आईडी को नतीजे के ऐरे के आखिरी एलिमेंट में डालता है.

$idText = split('-', $feed->entries[$index]->id->text);
$blogID = $idText[2];

पोस्ट बनाना

Blogger Data API की मदद से, नई ब्लॉग एंट्री बनाई और पब्लिश की जा सकती हैं. साथ ही, एंट्री के ड्राफ़्ट भी बनाए जा सकते हैं.

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

ब्लॉग पोस्ट पब्लिश करना

नई ब्लॉग एंट्री पब्लिश करने के लिए, PHP क्लाइंट लाइब्रेरी का इस्तेमाल किया जा सकता है.

सबसे पहले, ब्लॉग पोस्ट को दिखाने के लिए एंट्री का एक इंस्टेंस बनाएं. इसके बाद, ब्लॉग पोस्ट का टाइटल, कॉन्टेंट, और अन्य एट्रिब्यूट सेट किए जा सकते हैं. आखिर में, पोस्ट डालने के लिए insertEntry वाला तरीका कॉल करें. यहां नए Zend_Gdata_Entry, Zend_Gdata_App_Extension_Title, और Zend_Gdata_App_Extension_Content ऑब्जेक्ट के साथ, मैजिक फ़ैक्ट्री इंस्टैंशिएशन को काम करते हुए देखा जा सकता है.

function createPublishedPost($title='Hello, world!', $content='I am blogging on the internet.')
{
  $uri = 'http://www.blogger.com/feeds/' . $blogID . '/posts/default';
  $entry = $gdClient->newEntry();
  $entry->title = $gdClient->newTitle($title);
  $entry->content = $gdClient->newContent($content);
  $entry->content->setType('text');

  $createdPost = $gdClient->insertEntry($entry, $uri);
  $idText = split('-', $createdPost->id->text);
  $newPostID = $idText[2];

  return $newPostID;
}

ब्लॉग पोस्ट का ड्राफ़्ट बनाना

ड्राफ़्ट पोस्ट, सार्वजनिक पोस्ट की तरह ही बनाई जाती हैं. हालांकि, आपको एंट्री ऑब्जेक्ट के ड्राफ़्ट एट्रिब्यूट को सेट करना होगा. हाइलाइट की गई लाइनों को जोड़कर, ऊपर दी गई ब्लॉग पोस्ट जैसी ड्राफ़्ट बनाई जा सकती है:

function createDraftPost($title='Salutations, world!', $content='Hmm ... not quite right, must rework the title later.')
{
  $uri = 'http://www.blogger.com/feeds/' . $blogID . '/posts/default';
  $entry = $gdClient->newEntry();

  $entry->title = $gdClient->newTitle(trim($title));
  $entry->content = $gdClient->newContent($content);
  $entry->content->setType('text');

  $control = $gdClient->newControl();
  $draft = $gdClient->newDraft('yes');
  $control->setDraft($draft);
  $entry->control = $control;

  $createdPost = $gdClient->insertEntry($entry, $uri);
  $idText = split('-', $createdPost->id->text);
  return $idText[2];
}

किसी पोस्ट का टाइटल या कॉन्टेंट सेट करने के तरीके की तरह ही, नए Zend_Gdata_App_Extension_Control और Zend_Gdata_App_Extension_Draft ऑब्जेक्ट बनाएं और उन्हें एंट्री के कंट्रोल एट्रिब्यूट को असाइन करें.

किसी मौजूदा ड्राफ़्ट ब्लॉग पोस्ट को पब्लिश की गई पोस्ट में बदला जा सकता है. इसके लिए, ड्राफ़्ट पोस्ट को फिर से पाएं, ड्राफ़्ट एट्रिब्यूट को no पर सेट करें, और फिर पोस्ट को अपडेट करें. हम अगले दो सेक्शन में, पोस्ट वापस पाने और उन्हें अपडेट करने के बारे में बताएंगे.

पोस्ट वापस लाना

इन सेक्शन में, क्वेरी पैरामीटर के साथ और बिना क्वेरी पैरामीटर के, ब्लॉग पोस्ट की सूची पाने का तरीका बताया गया है.

पुष्टि किए बिना, Blogger के सार्वजनिक फ़ीड से क्वेरी की जा सकती है. इसलिए, किसी सार्वजनिक ब्लॉग से पोस्ट हासिल करने से पहले, आपको क्रेडेंशियल सेट करने या AuthSub की पुष्टि करने की ज़रूरत नहीं है.

सभी ब्लॉग पोस्ट वापस लाना

उपयोगकर्ता की पोस्ट पाने के लिए, ब्लॉग के मेटाफ़ीड को पाने के लिए इस्तेमाल किए गए getFeed तरीके का ही इस्तेमाल करें. हालांकि, इस बार ब्लॉग पोस्ट फ़ीड का यूआरएल भेजें:

function printAllPosts($gdClient, $blogID)
{
  $query = new Zend_Gdata_Query('http://www.blogger.com/feeds/' . $blogID . '/posts/default');
  $feed = $gdClient->getFeed($query);
  printFeed($feed);
}

क्वेरी पैरामीटर का इस्तेमाल करके पोस्ट हासिल करना

Blogger Data API की मदद से, तय की गई शर्तों से मैच करने वाली एंट्री के सेट का अनुरोध किया जा सकता है. जैसे, किसी तारीख की सीमा में पब्लिश या अपडेट की गई ब्लॉग पोस्ट का अनुरोध करना. ऐसा करने के लिए, एक क्वेरी ऑब्जेक्ट बनाएं और उसे getFeed तरीके में पास करें.

उदाहरण के लिए, तारीख की सीमा वाली क्वेरी भेजने के लिए, क्वेरी ऑब्जेक्ट के published-min और published-max पैरामीटर सेट करें. यहां दिया गया कोड स्निपेट, शुरू और खत्म होने के समय के बीच पब्लिश की गई हर ब्लॉग पोस्ट का टाइटल और कॉन्टेंट दिखाता है:

function printPostsInDateRange($gdClient, $blogID, $startDate='2007-04-01', $endDate='2007-04-25')
{
  $query = new Zend_Gdata_Query('http://www.blogger.com/feeds/' . $blogID . '/posts/default');
  $query->setParam('published-min', $startDate);
  $query->setParam('published-max', $endDate);

  $feed = $gdClient->getFeed($query);
  printFeed($feed);
}

Zend_Gdata_Query क्लास के लिए, डीबग करने का एक अच्छा तरीका getQueryUrl() है. इससे आपको कोड में बदला गया यूआरएल दिखेगा.

ध्यान दें: फ़िलहाल, published-min और published-max क्वेरी पैरामीटर के लिए कोई मैजिक सेटर नहीं है. हालांकि, setStartIndex और setMaxResults का इस्तेमाल किया जा सकता है.

Blogger Data API में ये क्वेरी पैरामीटर काम करते हैं:

श्रेणियां

फ़ीड के नतीजों को फ़िल्टर करने के लिए, कैटगरी (इन्हें लेबल भी कहा जाता है) तय करता है. उदाहरण के लिए, http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie से, Fritz और Laurie, दोनों लेबल वाली एंट्री मिलती हैं.

max-results

ज़्यादा से ज़्यादा कितनी एंट्री दिखानी हैं.

published-min, published-max

प्रवेश के पब्लिकेशन की तारीखों की सीमाएं.

start-index

पेजिंग के लिए, खोजे गए पहले नतीजे का इंडेक्स, जो 1 से शुरू होता है.

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

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

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

public function updatePost($postID, $updatedTitle='Hello, World?',
                           $updatedContent='UPDATE: Still blogging',
                           $isDraft=False)
{
  $query = new Zend_Gdata_Query('http://www.blogger.com/feeds/' . $blogID . '/posts/default/' . $postID);
  $postToUpdate = $dClient->getEntry($query);
  $postToUpdate->title->text = $this->gdClient->newTitle($updatedTitle);
  $postToUpdate->content->text = $this->gdClient->newContent($updatedContent);

  if ($isDraft) {
    $draft = $gdClient->newDraft('yes');
  } else {
    $draft = $gdClient->newDraft('no');
  }

  $control = $gdClient->newControl();
  $control->setDraft($draft);
  $postToUpdate->control = $control;

  $updatedPost = $postToUpdate->save();
  return $updatedPost;
}

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

पोस्ट मिटाना

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

public function deletePost($gdClient, $blogID, $postID)
{
  $uri = 'http://www.blogger.com/feeds/' . $blogID . '/posts/default/' . $postID;
  $gdClient->delete($uri);
}

टिप्पणियां

Blogger Data API की मदद से, टिप्पणियां बनाई जा सकती हैं, उन्हें वापस पाया जा सकता है, और उन्हें मिटाया जा सकता है. टिप्पणियों को अपडेट नहीं किया जा सकता. यह सुविधा वेब इंटरफ़ेस में भी उपलब्ध नहीं है.

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

टिप्पणी पोस्ट करने के लिए, एंट्री ऑब्जेक्ट बनाएं और उसे इस तरह डालें:

function createComment($gdClient, $blogID, $postID, $commentText)
{
  $uri = 'http://www.blogger.com/feeds/' . $blogID . '/' . $postID . '/comments/default';

  $newComment = $gdClient->newEntry();
  $newComment->content = $gdClient->newContent($commentText);
  $newComment->content->setType('text');
  $createdComment = $gdClient->insertEntry($newComment, $uri);

  $editLink = split('/', $createdComment->getEditLink()->href);
  $newCommentID = $editLink[8];

  return $newCommentID; 
}

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

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

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

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

public function printPostComments($gdClient, $blogID, $postID)
{
  $query = new Zend_Gdata_Query('http://www.blogger.com/feeds/' . $blogID . '/' . $postID . '/comments/default');
  $feed = $gdClient->getFeed($query);
  $printFeed($feed);
}

इसके अलावा, ब्लॉग के टिप्पणियों वाले फ़ीड के यूआरएल का इस्तेमाल करके, सभी पोस्ट की टिप्पणियां भी देखी जा सकती हैं:

http://www.blogger.com/feeds/blogID/comments/default

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

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

public function deleteComment($gdClient, $blogID, $postID, $commentID)
{
  $uri = 'http://www.blogger.com/feeds/' . $blogID . '/' . $postID . '/comments/default/' . $commentID;
  $gdClient->delete($uri);
}

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