इस पेज का अनुवाद Cloud Translation API से किया गया है.

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

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

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

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

विषय सूची

दर्शक
स्ट्रक्चर्ड डेटा सेट अप की शुरुआत करना
Blogger की सेवा की पुष्टि करना
ब्लॉग की सूची वापस पाना
पोस्ट बनाना
1. ब्लॉग पोस्ट पब्लिश करना
2. ड्राफ़्ट ब्लॉग पोस्ट बनाना
पोस्ट वापस पाना
1. सभी ब्लॉग पोस्ट वापस पाना
2. क्वेरी पैरामीटर का इस्तेमाल करके पोस्ट वापस पाना
पोस्ट अपडेट करना
पोस्ट मिटाना
टिप्पणियां

दर्शक

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

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

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

प्रारंभ करना

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

Zend क्लाइंट लाइब्रेरी के लिए, PHP 5.1.4 या इसके बाद के वर्शन की ज़रूरत होती है. यह Zend फ़्रेमवर्क के हिस्से के तौर पर और एक अलग डाउनलोड के तौर पर भी उपलब्ध है. 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 नाम रखने के कन्वेंशन के तहत दिए गए, क्लास के लंबे नाम याद रखने के बजाय, एक नया object बनाया जा सकता है. इसके लिए, Zend सेवा क्लाइंट पर newObject(); को कॉल करें. उदाहरण के लिए, नीचे दिए गए दो स्निपेट, नए 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 API कॉम्पोनेंट (Zend_Gdata) के लिए अन्य संसाधन:

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

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

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

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

OAuth से पुष्टि

Zend PHP GData लाइब्रेरी का इस्तेमाल करके OAuth की पुष्टि करने के बारे में दस्तावेज़ पाने के लिए, कृपया Google डेटा प्रोटोकॉल क्लाइंट लाइब्रेरी में 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 में बताया गया था, इसलिए इस टोकन को किसी AuthSub सेशन टोकन से बदला जा सकता है. इसके लिए Zend_Gdata_AuthSub::getAuthSubSessionToken तरीके का इस्तेमाल किया जा सकता है, जो AuthSubSessionToken सेवा को कॉल करता है:

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

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

इसके बाद, आपका ऐप्लिकेशन, Blogger के साथ होने वाले बाद के इंटरैक्शन में सेशन टोकन की वैल्यू का इस्तेमाल कर सकता है. ऐसा Zend_Http_Client ऑब्जेक्ट पाने के लिए, Zend_Gdata_AuthSub::getHttpClient तरीके का इस्तेमाल किया जा सकता है जिसमें 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 दस्तावेज़ में दी गई जानकारी के मुताबिक, पुष्टि करने का अनुरोध पूरा नहीं हो सकता और कैप्चा चैलेंज का अनुरोध किया जा सकता है. अगर आप चाहते हैं कि 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: लौटाने के लिए प्रविष्टियों की ज़्यादा से ज़्यादा संख्या.
प्रकाशित कम से कम, ज़्यादा से ज़्यादा प्रकाशित: पब्लिकेशन की तारीखों की सीमा.
start-index: पेजिंग के लिए, वापस लाए जाने वाले पहले नतीजे का एक आधारित इंडेक्स.

क्वेरी पैरामीटर के बारे में ज़्यादा जानकारी के लिए, 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 डेटा एपीआई की मदद से टिप्पणियां बनाई जा सकती हैं, उन्हें वापस पाया जा सकता है, और मिटाया जा सकता है. टिप्पणियों को अपडेट नहीं किया जा सकता (और न ही यह वेब इंटरफ़ेस में उपलब्ध है).

टिप्पणियां करना

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

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 वाले तरीके से, टिप्पणी में बदलाव करने का यूआरएल इस तरह से भेजें:

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

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