Entwicklerhandbuch: PHP

Mit der Blogger Data API können Clientanwendungen Blogger-Inhalte in Form von Google Data API-Feeds anzeigen und aktualisieren.

Ihre Client-Anwendung kann die Blogger Data API verwenden, um neue Blogposts zu erstellen, vorhandene Blogposts zu bearbeiten oder zu löschen und Blogposts abzufragen, die bestimmten Kriterien entsprechen.

Zusätzlich zu einigen Hintergrundinformationen zu den Funktionen der Blogger Data API enthält dieses Dokument Beispiele für grundlegende Data API-Interaktionen mithilfe der Clientbibliothek der Zend Google Data APIs. Weitere Informationen zum zugrunde liegenden Protokoll, das von der Bibliothek verwendet wird, finden Sie im Abschnitt zu Protokollen im Entwicklerhandbuch.

Inhalt

  1. Zielgruppe
  2. Erste Schritte
    1. Blogger-Konto erstellen
    2. Beispielcode ausführen
    3. Magic Getter und Setter
    4. Weitere Informationen
  3. Beim Blogger-Dienst authentifizieren
    1. Authentifizierung mit OAuth
    2. AuthSub-Proxy-Authentifizierung
    3. Authentifizierung mit Nutzername/Passwort für ClientLogin
  4. Liste mit Blogs abrufen
  5. Beiträge erstellen
    1. Blogpost veröffentlichen
    2. Entwurf eines Blogposts erstellen
  6. Beiträge werden abgerufen
    1. Alle Blogposts werden abgerufen
    2. Beiträge mithilfe von Suchparametern abrufen
  7. Beiträge aktualisieren
  8. Beiträge löschen
  9. Kommentare
    1. Kommentare erstellen
    2. Kommentare abrufen
    3. Kommentare löschen

Zielgruppe

Dieses Dokument richtet sich an Programmierer, die PHP-Clientanwendungen schreiben möchten, die mit Blogger interagieren können.

In diesem Dokument wird davon ausgegangen, dass Sie mit den allgemeinen Konzepten hinter dem Google Data APIs-Protokoll vertraut sind.

Informationen zu den von der Clientbibliothek bereitgestellten Klassen und Methoden finden Sie in der API-Referenz zur PHP-Clientbibliothek. Allgemeine Referenzinformationen zur Blogger Data API finden Sie in der Übersicht zu Protokollen.

Erste Schritte

Informationen zur Einrichtung der Clientbibliothek finden Sie im Startleitfaden.

Für die Zend-Client-Bibliothek ist PHP 5.1.4 oder höher erforderlich. Sie ist als Teil des Zend-Frameworks sowie als separater Download verfügbar. Wenn Sie mit Blogger interagieren möchten, verwenden Sie Version 1.0.0 oder höher der Clientbibliothek.

Erstellen eines Blogger-Kontos

Du kannst dich zu Testzwecken für ein Blogger-Konto registrieren. Blogger verwendet Google-Konten. Wenn du also bereits ein Google-Konto hast, bist du startklar.

Beispielcode ausführen

Ein voll funktionsfähiger Beispielclient mit dem gesamten in diesem Dokument gezeigten Beispielcode ist im SVN-Repository für Zend Framework verfügbar. Das Beispiel befindet sich unter /framework/standard/trunk/demos/Zend/Gdata/Blogger.php. Das Beispiel enthält alle in diesem Dokument erläuterten Funktionen. Er kann nur über die Befehlszeile ausgeführt werden:

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

Bevor Sie dieses Beispiel ausführen oder Ihren eigenen Code mit dem Zend Framework entwickeln, müssen Sie möglicherweise include_path festlegen und die entsprechenden Klassen laden. Der include-Pfad kann entweder mit einer php.ini-Einstellung oder mit der Methode set_include_path festgelegt werden. Dieser Code fordert Zugriff auf die Kernklasse Zend_Gdata, die Klasse Zend_Gdata_Query und die Authentifizierungsklasse Zend_Gdata_ClientLogin an.

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

Magic Getter und Setter verwenden

In der gesamten PHP-Clientbibliothek wurde Unterstützung für magische Setter/Getter hinzugefügt, um Entwicklern die Arbeit zu erleichtern. Diese ermöglichen den sicheren Zugriff auf die Attribute einer Klasse mithilfe herkömmlicher Setter-/Getter-Methoden oder durch den Zugriff auf die Attribute. Wenn beispielsweise $gdataObject eine Instanz eines Objekts in dieser Bibliothek ist, haben die folgenden beiden Codezeilen identische Auswirkungen:

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

Ebenso haben diese beiden Codezeilen identische Auswirkungen:

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

In ähnlicher Weise vereinfachen die Magic Factory-Methoden das Deklarieren neuer Objekte. Anstatt sich die langen Klassennamen zu merken, die bei der Zend-Namenskonvention vorgeschrieben sind, können Sie eine neue object erstellen, indem Sie newObject(); auf einem Zend-Dienstclient aufrufen. Die folgenden beiden Snippets deklarieren beispielsweise ein neues draft-Erweiterungsobjekt. Weitere Informationen zu drafts finden Sie im Abschnitt Beitrag erstellen.

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

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

Die magischen Setter/Getter und Factorys sind optional, verwenden Sie also den Ansatz, der für Sie am besten geeignet ist.

Weitere Ressourcen

Weitere Ressourcen für die Google Data APIs-Komponente von Zend Framework (Zend_Gdata):

Beim Blogger-Dienst authentifizieren

Mit der Blogger Data API können Sie sowohl auf öffentliche als auch auf private Feeds zugreifen. Für öffentliche Feeds ist keine Authentifizierung erforderlich, sie sind jedoch schreibgeschützt. Wenn du Blogs ändern möchtest, muss sich dein Kunde vor dem Anfordern von privaten Feeds authentifizieren. Für die Authentifizierung gibt es drei Möglichkeiten: OAuth-Authentifizierung, AuthSub-Proxy-Authentifizierung oder ClientLogin-Authentifizierung mit Nutzername/Passwort.

Weitere Informationen zur Authentifizierung mit Google Data APIs im Allgemeinen finden Sie in der Authentifizierungsdokumentation.

Bei den meisten Beispielen in den nachfolgenden Abschnitten dieses Dokuments wird davon ausgegangen, dass Sie ein authentifiziertes Clientobjekt namens $gdClient haben.

Authentifizierung mit OAuth

Informationen zur OAuth-Authentifizierung mit der Zend PHP GData-Bibliothek finden Sie unter OAuth in den Google Data Protocol-Clientbibliotheken.

AuthSub-Proxy-Authentifizierung

Die AuthSub-Proxy-Authentifizierung wird von Webanwendungen verwendet, die ihre Nutzer für Google-Konten authentifizieren müssen. Der Websitebetreiber und der Clientcode haben keinen Zugriff auf den Nutzernamen und das Passwort des Blogger-Nutzers. Stattdessen erhält der Client spezielle AuthSub-Tokens, mit denen der Client im Namen eines bestimmten Nutzers handeln kann. Weitere Informationen finden Sie in der AuthSub-Dokumentation.

Wenn ein Nutzer Ihre Anwendung zum ersten Mal besucht, wurde er noch nicht authentifiziert. In diesem Fall musst du einige Informationen und einen Link anzeigen, der den Nutzer auf eine Google-Seite weiterleitet, um deine Zugriffsanfrage für seine Blogs zu authentifizieren. Die Zend-Clientbibliothek bietet eine Funktion zum Generieren der URL der Google-Seite. Mit dem folgenden Code wird die URL der AuthSubRequest-Seite abgerufen:

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>';

Die Methode getAuthSubTokenUri verwendet die folgenden Parameter, die den vom AuthSubRequest-Handler verwendeten Abfrageparametern entsprechen:

Weiter
Die URL der Seite, zu der Google den Nutzer nach der Authentifizierung weiterleiten soll.
Bereich
Gibt an, dass die Anwendung ein Token für den Zugriff auf Blogger-Feeds anfordert. Der zu verwendende Bereichsstring ist http://www.blogger.com/feeds/ (natürlich URL-codiert).
sicher
Gibt an, ob der Client ein sicheres Token anfordert.
session
Gibt an, ob das zurückgegebene Token gegen ein Mehrfachnutzungstoken (Sitzungstoken) ausgetauscht werden kann.

Das obige Beispiel zeigt einen Aufruf, bei dem kein sicheres Token angefordert wird (der Wert von secure ist false). Die resultierende Anfrage-URL könnte so aussehen:

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

Der Nutzer folgt dem Link zur Google-Website und authentifiziert sich bei seinem Google-Konto.

Nach der Authentifizierung des Nutzers leitet das AuthSub-System ihn an die URL weiter, die Sie im Abfrageparameter next der AuthSubRequest-URL angegeben haben. Das AuthSub-System hängt ein Authentifizierungstoken als Wert des Abfrageparameters token an diese URL an. Beispiel:

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

Sie können den Tokenwert mit $_GET['token'] abrufen.

Dieser Tokenwert stellt ein AuthSub-Einweg-Token dar. Da in diesem Beispiel $session = true angegeben wurde, kann dieses Token mithilfe der Methode Zend_Gdata_AuthSub::getAuthSubSessionToken, die den AuthSubSessionToken-Dienst aufruft, gegen ein AuthSub-Sitzungstoken ausgetauscht werden:

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

Das Code-Snippet prüft zuerst, ob ein AuthSub-Sitzungstoken bereits vorhanden ist. Wenn dies nicht der Fall ist, aber ein Einmaltoken in der URL angegeben ist, übergibt das Code-Snippet das Einmaltoken an die Methode getAuthSubSessionToken und die AuthSub-Schnittstelle gibt ein Sitzungstoken zurück. Der Code fügt dann den Wert des Sitzungstokens in die Sitzungsvariable $_SESSION['sessionToken'] ein.

Ihre Anwendung kann dann den Wert des Sitzungstokens in nachfolgenden Interaktionen mit Blogger verwenden. Mit der Methode Zend_Gdata_AuthSub::getHttpClient können Sie ein Zend_Http_Client-Objekt abrufen, in dem der Header Authorization so voreingestellt ist, dass AuthSub-Anmeldedaten enthalten sind:

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

ClientLogin-Authentifizierung mit Nutzername/Passwort

Verwenden Sie die ClientLogin-Authentifizierung, wenn Ihr Client ein eigenständiger Client ist, der für einen einzelnen Nutzer "installiert" ist (z. B. eine Desktopanwendung).

Im folgenden Code wird die Methode Zend_Gdata_ClientLogin::getHttpClient verwendet, um eine Anfrage an den ClientLogin-Dienst durchzuführen, ein Authentifizierungstoken abzurufen und ein Zend_Http_Client-Objekt mit dem entsprechenden Authentifizierungsheader zu erstellen. Anschließend wird das von dieser Methode zurückgegebene HttpClient verwendet, um ein Zend_Gdata-Dienstobjekt zu erstellen.

Beachten Sie, dass $accountType explizit auf GOOGLE gesetzt ist. Wenn dieser Parameter nicht festgelegt wird, können G Suite-Nutzer die Blogger API nicht verwenden. 

$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);

Weitere Informationen zur ClientLogin-Authentifizierung, einschließlich Beispielanfragen und -antworten, finden Sie in der Dokumentation zur Authentifizierung für installierte Anwendungen.

Hinweis: Verwenden Sie für alle Anfragen in einer bestimmten Sitzung dasselbe Token. Erwerben Sie nicht für jede Blogger-Anfrage ein neues Token.

Hinweis: Wie in der ClientLogin-Dokumentation beschrieben, kann die Authentifizierungsanfrage fehlschlagen und eine CAPTCHA-Abfrage auslösen. Wenn Google die CAPTCHA-Abfrage ausführen und verarbeiten soll, leiten Sie den Nutzer an https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger weiter und nicht an die CAPTCHA-Bearbeitungs-URL, die in der ClientLogin-Dokumentation angegeben ist.

Liste mit Blogs abrufen

Die Blogger Data API stellt einen Feed bereit, in dem die Blogs für einen bestimmten Nutzer aufgelistet werden. Dieser Feed wird als „Metafeed“ bezeichnet.

Der folgende Beispielcode verwendet ein authentifiziertes $gdClient-Objekt, um den Metafeed abzurufen, und gibt anschließend den Titel jedes Blogs aus.

Die Klasse Zend_Gdata_Query erstellt die Abfrage-URL. In diesem Fall müssen Sie nichts weiter tun. Die Nützlichkeit der Klasse Query wird jedoch im Abschnitt Beiträge anhand von Abfrageparametern abrufen dieses Dokuments deutlich.

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++;
  }
}

Notieren Sie sich die von der Methode getFeed verwendete URL. Dies ist die Standard-Metafeed-URL. Sie gibt eine Liste von Blogs für den aktuell authentifizierten Nutzer zurück. Wenn Sie auf den Feed eines anderen Nutzers zugreifen möchten, können Sie in der Metafeed-URL anstelle von default die ID des Nutzers einfügen. Die Nutzer-ID ist die Ziffernfolge am Ende der Profil-URL des Nutzers.

Das folgende Code-Snippet zeigt, wie eine Blog-ID aus dem Feed extrahiert wird. Zum Erstellen, Aktualisieren und Löschen von Posts und Kommentaren benötigst du die Blog-ID. Die Variable $index gibt an, welcher Blog im Blogfeed des Nutzers verwendet wird. Das Feld id hat die Form tag:blogger.com,1999:user-userID.blog-blogID, sodass ein split im Zeichen „-“ die Blog-ID im letzten Element des resultierenden Arrays platziert.

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

Beiträge werden erstellt

Mit der Blogger Data API können Sie neue Blogeinträge und Entwurfseinträge erstellen und veröffentlichen.

Hinweis: Das Festlegen eines benutzerdefinierten Autors für Beiträge wird derzeit nicht unterstützt. Alle neuen Beiträge werden so angezeigt, als wären sie vom aktuell authentifizierten Nutzer erstellt.

Blogposts veröffentlichen

Sie können die PHP-Clientbibliothek verwenden, um neue Blogeinträge zu veröffentlichen.

Erstellen Sie zuerst eine Eintraginstanz, die den Blogpost darstellt. Anschließend können Sie den Titel, den Inhalt und andere Attribute des Blogposts festlegen. Rufen Sie abschließend die Methode insertEntry auf, um den Beitrag einzufügen. Hier sehen Sie die Instanziierungen von Magic Factory mit den neuen Objekten Zend_Gdata_Entry, Zend_Gdata_App_Extension_Title und 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;
}

Entwurf eines Blogposts wird erstellt

Beitragsentwürfe werden auf die gleiche Weise wie öffentliche Beiträge erstellt. Sie müssen jedoch das Entwurfsattribut des Beitragsobjekts festlegen. Sie können einen Blogpost wie den obigen als Entwurf erstellen, indem Sie die markierten Zeilen einfügen:

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];
}

Ähnlich wie beim Festlegen des Titels oder Inhalts eines Beitrags erstellen Sie neue Objekte Zend_Gdata_App_Extension_Control und Zend_Gdata_App_Extension_Draft und weisen sie dem Steuerattribut des Eintrags zu.

Sie können einen vorhandenen Blogpost-Entwurf in einen veröffentlichten Post umwandeln. Dazu rufen Sie den Postentwurf ab, setzen das Entwurfsattribut auf no und aktualisieren den Post. Wie Sie Beiträge abrufen und aktualisieren, erfahren Sie in den nächsten beiden Abschnitten.

Beiträge werden abgerufen

In den folgenden Abschnitten wird beschrieben, wie Sie eine Liste von Blogposts mit und ohne Abfrageparameter abrufen.

Sie können einen öffentlichen Blogger-Feed ohne Authentifizierung abfragen. Daher müssen Sie vor dem Abrufen von Beiträgen von einem öffentlichen Blog weder Anmeldedaten festlegen noch eine AuthSub-Authentifizierung durchführen.

Alle Blogposts werden abgerufen

Wenn Sie die Beiträge des Nutzers abrufen möchten, rufen Sie dieselbe getFeed-Methode auf, die zum Abrufen des Blogs-Metafeeds verwendet wurde, aber dieses Mal die Blogpost-Feed-URL senden:

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

Beiträge mithilfe von Suchparametern abrufen

Mit der Blogger Data API können Sie eine Reihe von Einträgen anfordern, die bestimmten Kriterien entsprechen, z. B. Blogposts, die in einem bestimmten Zeitraum veröffentlicht oder aktualisiert wurden. Dazu erstellen Sie ein Abfrageobjekt und übergeben es an die Methode getFeed.

Wenn Sie beispielsweise eine Zeitraumabfrage senden möchten, legen Sie die Parameter published-min und published-max des Abfrageobjekts fest. Das folgende Code-Snippet gibt den Titel und den Inhalt jedes Blogposts aus, der zwischen der angegebenen Start- und Endzeit veröffentlicht wurde:

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);
}

Eine nützliche Methode zur Fehlerbehebung für die Klasse Zend_Gdata_Query ist getQueryUrl(). Damit sehen Sie die erstellte codierte URL.

Hinweis: Derzeit gibt es keine magischen Setter für die Abfrageparameter published-min und published-max. Sie können jedoch setStartIndex und setMaxResults verwenden.

Die Blogger Data API unterstützt die folgenden Abfrageparameter:

Kategorien
Damit werden Kategorien (auch Labels genannt) zum Filtern der Feedergebnisse angegeben. Beispielsweise gibt http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie Einträge mit den beiden Labels Fritz und Laurie zurück.
max-results
Die maximale Anzahl der zurückzugebenden Einträge.
Publish-Min., Publish-Max.
Die Grenzen der Veröffentlichungsdaten des Eintrags.
start-index
Der 1-basierte Index des ersten abzurufenden Ergebnisses (für die Seitenordnung).

Weitere Informationen zu Abfrageparametern finden Sie im Blogger Data API-Referenzhandbuch und im Referenzhandbuch für Google Data APIs.

Beiträge werden aktualisiert

Wenn Sie einen vorhandenen Blogpost aktualisieren möchten, rufen Sie zuerst den Eintrag ab, den Sie aktualisieren möchten. Anschließend ändern Sie ihn und senden ihn mit der Methode save an Blogger. Mit dem folgenden Code-Snippet werden Titel und Inhalt eines Blogeintrags geändert. Dabei wird davon ausgegangen, dass du den Eintrag bereits vom Server abgerufen hast.

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;
}

Hinweis: Die mit Beiträgen verknüpften Autorendaten können derzeit nicht geändert werden.

Beiträge werden gelöscht

Wenn du einen Beitrag löschen möchtest, übergib die Bearbeitungs-URL des Beitrags an die Methode delete auf deinem $gdClient-Objekt. Das sieht dann so aus:

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

Kommentare

Mit der Blogger Data API können Sie Kommentare erstellen, abrufen und löschen. Das Aktualisieren von Kommentaren wird nicht unterstützt und ist auch nicht über die Weboberfläche verfügbar.

Kommentare erstellen

Um einen Kommentar zu posten, erstellen Sie ein Eingabeobjekt und fügen es wie folgt ein:

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; 
}

Hinweis: Derzeit können Sie nur Kommentare in einem Blog posten, der dem authentifizierten Nutzer gehört.

Hinweis: Das Festlegen eines benutzerdefinierten Autors für Kommentare wird derzeit nicht unterstützt. Alle neuen Kommentare werden so angezeigt, als wären sie vom aktuell authentifizierten Nutzer erstellt.

Kommentare werden abgerufen

Sie können die Kommentare für einen bestimmten Beitrag über die Kommentarfeed-URL des Beitrags abrufen:

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);
}

Sie können auch die Kommentare zu allen Posts über die Kommentarfeed-URL des Blogs abrufen:

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

Kommentare werden gelöscht

Wenn Sie einen Kommentar löschen möchten, übergeben Sie die Bearbeitungs-URL des Kommentars so an die Methode delete in Ihrem $gdClient-Objekt:

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

Nach oben