Entwicklerhandbuch: PHP

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

Mit der Blogger Data API können Sie in Ihrer Clientanwendung neue Blogbeiträge erstellen, vorhandene Blogbeiträge bearbeiten oder löschen und nach Blogbeiträgen suchen, die bestimmten Kriterien entsprechen.

Dieses Dokument enthält nicht nur einige Hintergrundinformationen zu den Funktionen der Blogger Data API, sondern auch Beispiele für grundlegende Data API-Interaktionen mit der Zend Google Data APIs-Clientbibliothek. Weitere Informationen zum zugrunde liegenden Protokoll, das von der Bibliothek verwendet wird, finden Sie im Abschnitt zum Protokoll dieses Entwicklerhandbuchs.

Inhalt

  1. Zielgruppe
  2. Erste Schritte
    1. Blogger-Konto erstellen
    2. Beispielcode ausführen
    3. Magische Getter und Setter verwenden
    4. Weitere Informationen
  3. Authentifizierung beim Blogger-Dienst
    1. Authentifizierung mit OAuth
    2. AuthSub-Proxy-Authentifizierung
    3. ClientLogin-Nutzername/Passwort-Authentifizierung
  4. Liste der Blogs abrufen
  5. Beiträge erstellen
    1. Blogpost veröffentlichen
    2. Blogpost-Entwurf erstellen
  6. Beiträge abrufen
    1. Alle Blogbeiträge abrufen
    2. Beiträge mithilfe von Abfrageparametern 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 des Google Data APIs-Protokolls vertraut sind.

Referenzinformationen zu den Klassen und Methoden der Clientbibliothek finden Sie in der API-Referenz der PHP-Clientbibliothek. Allgemeine Informationen zur Blogger Data API findest du im Referenzleitfaden zum Protokoll.

Erste Schritte

Informationen zum Einrichten der Clientbibliothek finden Sie im Leitfaden für den Einstieg.

Für die Zend-Clientbibliothek ist PHP 5.1.4 oder höher erforderlich. Es ist als Teil des Zend Framework und auch als separater Download verfügbar. Verwenden Sie Version 1.0.0 oder höher der Clientbibliothek, um mit Blogger zu interagieren.

Blogger-Konto erstellen

Sie können sich für Testzwecke für ein Blogger-Konto registrieren. Für Blogger werden Google-Konten verwendet. Wenn Sie also bereits ein Google-Konto haben, können Sie sofort loslegen.

Codebeispiel ausführen

Ein vollständiger, funktionierender Beispielclient mit dem gesamten in diesem Dokument gezeigten Beispielcode ist im SVN-Repository des Zend-Frameworks verfügbar. Das Beispiel befindet sich unter /framework/standard/trunk/demos/Zend/Gdata/Blogger.php. Das Beispiel enthält alle in diesem Dokument beschriebenen Funktionen. Es kann nur über die Befehlszeile ausgeführt werden:

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

Bevor Sie dieses Beispiel ausführen oder eigenen Code mit dem Zend-Framework entwickeln, müssen Sie möglicherweise die include_path festlegen und die entsprechenden Klassen laden. Der Include-Pfad kann entweder über eine php.ini-Einstellung oder über die Methode set_include_path festgelegt werden. Mit diesem Code wird der Zugriff auf die Kernklasse Zend_Gdata, die Klasse Zend_Gdata_Query und die Authentifizierungsklasse Zend_Gdata_ClientLogin angefordert.

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

Magische Getter und Setter verwenden

In der gesamten PHP-Clientbibliothek wurde die Unterstützung für magische Setter/Getter hinzugefügt, um Entwicklern die Arbeit zu erleichtern. So kann auf die Eigenschaften einer Klasse sicher mithilfe herkömmlicher Setter-/Getter-Methoden oder durch Zugriff auf die Eigenschaften zugegriffen werden. Wenn $gdataObject beispielsweise eine Instanz eines Objekts in dieser Bibliothek ist, haben die folgenden beiden Codezeilen dieselbe Wirkung:

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

Ebenso haben diese beiden Codezeilen dieselbe Wirkung:

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

Ähnlich erleichtern magische Factory-Methoden die Deklaration neuer Objekte. Anstatt sich die langen Klassennamen zu merken, die durch die Zend-Benennungskonvention vorgeschrieben sind, können Sie eine neue object erstellen, indem Sie newObject(); in einem Zend-Dienstclient aufrufen. In den folgenden beiden Snippets wird beispielsweise jeweils ein neues draft-Erweiterungsobjekt deklariert. Weitere Informationen zu drafts findest du im Abschnitt Beiträge 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 Factories sind optional. Verwenden Sie den Ansatz, der für Sie am besten geeignet ist.

Weitere Ressourcen

Weitere Ressourcen für die Google Data APIs-Komponente des Zend-Frameworks (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 aber nur lesbar. Wenn du Blogs ändern möchtest, muss sich dein Client authentifizieren, bevor er private Feeds anfordert. Es kann mit einem der drei folgenden Ansätze authentifiziert werden: OAuth-Authentifizierung, AuthSub-Proxy-Authentifizierung oder ClientLogin-Nutzername/Passwort-Authentifizierung.

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

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

Authentifizierung mit OAuth

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

AuthSub-Proxy-Authentifizierung

Die AuthSub-Proxy-Authentifizierung wird von Webanwendungen verwendet, die ihre Nutzer in Google-Konten authentifizieren müssen. Der Website-Betreiber 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 er 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 müssen Sie einige Informationen und einen Link anzeigen, über den der Nutzer zu einer Google-Seite weitergeleitet wird, um Ihre Anfrage auf Zugriff auf seine Blogs zu authentifizieren. Die Zend-Clientbibliothek bietet eine Funktion zum Generieren der URL der Google-Seite. Im folgenden Code wird die URL der Seite „AuthSubRequest“ 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 (entsprechend den Abfrageparametern, die vom AuthSubRequest-Handler verwendet werden):

Weiter
Die URL der Seite, auf die 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.
Sitzung
Gibt an, ob das zurückgegebene Token gegen ein wiederverwendbares Sitzungstoken eingetauscht 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 in 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 dieser URL ein Authentifizierungstoken als Wert des Abfrageparameters token an. Beispiel:

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

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

Dieser Tokenwert stellt ein AuthSub-Token zur einmaligen Verwendung dar. Da in diesem Beispiel $session = true angegeben wurde, kann dieses Token mit der Methode Zend_Gdata_AuthSub::getAuthSubSessionToken gegen ein AuthSub-Sitzungstoken eingetauscht werden. Dabei wird der Dienst AuthSubSessionToken aufgerufen:

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

Im Code-Snippet wird zuerst geprüft, ob bereits ein AuthSub-Sitzungstoken vorhanden ist. Ist das nicht der Fall, aber in der URL ist ein Einmaltoken angegeben, übergibt das Code-Snippet das Einmaltoken an die getAuthSubSessionToken-Methode 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 den Sitzungstokenwert dann bei nachfolgenden Interaktionen mit Blogger verwenden. Mit der Methode Zend_Gdata_AuthSub::getHttpClient kannst du ein Zend_Http_Client-Objekt abrufen, dessen Authorization-Header so voreingestellt ist, dass AuthSub-Anmeldedaten enthalten sind:

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

ClientLogin-Nutzername/Passwort-Authentifizierung

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

Im folgenden Code wird die Methode Zend_Gdata_ClientLogin::getHttpClient verwendet, um eine Anfrage an den ClientLogin-Dienst zu senden, ein Autorisierungstoken abzurufen und ein Zend_Http_Client-Objekt mit dem entsprechenden Autorisierungsheader 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 festgelegt ist. Wenn Sie diesen Parameter nicht festlegen, 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 Authentifizierung für installierte Anwendungen.

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

Hinweis: Wie in der ClientLogin-Dokumentation beschrieben, kann die Authentifizierungsanfrage fehlschlagen und ein CAPTCHA-Test angefordert werden. Wenn Google die CAPTCHA-Herausforderung stellen und verarbeiten soll, leite den Nutzer an https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger weiter (nicht an die in der ClientLogin-Dokumentation angegebene URL für die CAPTCHA-Verarbeitung).

Liste der Blogs abrufen

Die Blogger Data API stellt einen Feed bereit, in dem die Blogs eines bestimmten Nutzers aufgeführt sind. Dieser Feed wird als „Metafeed“ bezeichnet.

Im folgenden Beispielcode wird ein authentifiziertes $gdClient-Objekt verwendet, um den Metafeed abzurufen und dann den Titel jedes Blogs zu drucken.

Die Klasse Zend_Gdata_Query kümmert sich um das Erstellen der Abfrage-URL. In diesem Fall sind keine weiteren Schritte erforderlich. Die Nützlichkeit der Query-Klasse 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 URL, die von der Methode getFeed verwendet wird. Das ist die Standard-Metafeed-URL. Sie gibt eine Liste der Blogs für den aktuell authentifizierten Nutzer zurück. Wenn du auf einen Feed für einen anderen Nutzer zugreifen möchtest, kannst du die ID des Nutzers anstelle von default in die Metafeed-URL einfügen. Die ID des Nutzers ist die Ziffernfolge am Ende der Profil-URL des Nutzers.

Im folgenden Code-Snippet wird gezeigt, wie eine Blog-ID aus dem Feed extrahiert wird. Sie benötigen die Blog-ID, um Beiträge und Kommentare zu erstellen, zu aktualisieren und zu löschen. Die Variable $index gibt an, welcher Blog im Blogfeed des Nutzers verwendet wird. Das Feld id hat das Format tag:blogger.com,1999:user-userID.blog-blogID. Wenn also ein split anstelle des Minuszeichens steht, wird die Blog-ID in das letzte Element des resultierenden Arrays eingefügt.

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

Beiträge erstellen

Mit der Blogger Data API können Sie neue Blogbeiträge erstellen und veröffentlichen sowie Beitragsentwürfe erstellen.

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 worden.

Blogpost veröffentlichen

Mit der PHP-Clientbibliothek können Sie neue Blogbeiträge veröffentlichen.

Erstellen Sie zuerst eine Eintrags-Instanz für den Blogpost. 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 magischen Fabrikinstanziierungen 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;
}

Einen Blogpost-Entwurf erstellen

Entwürfe werden auf die gleiche Weise wie öffentliche Beiträge erstellt. Sie müssen jedoch das Attribut „draft“ des Eintragsobjekts festlegen. Sie können einen Blogpost wie den oben genannten als Entwurf erstellen, indem Sie die hervorgehobenen Zeilen hinzufü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 Zend_Gdata_App_Extension_Control- und Zend_Gdata_App_Extension_Draft-Objekte und weisen sie dem Steuerattribut des Eintrags zu.

Du kannst einen vorhandenen Blogpost-Entwurf in einen veröffentlichten Post umwandeln, indem du den Entwurf abrufst, das Attribut „Entwurf“ auf no setzt und den Post dann aktualisierst. Im nächsten Abschnitt erfahren Sie, wie Sie Beiträge abrufen und aktualisieren.

Beiträge abrufen

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

Sie können einen öffentlichen Blogger-Feed ohne Authentifizierung abfragen. Daher müssen Sie keine Anmeldedaten festlegen oder eine AuthSub-Authentifizierung durchführen, bevor Sie Beiträge aus einem öffentlichen Blog abrufen.

Alle Blogbeiträge abrufen

Rufe zum Abrufen der Beiträge des Nutzers dieselbe getFeed-Methode auf, die auch zum Abrufen des Metafeeds des Blogs verwendet wurde. Sende diesmal jedoch die Feed-URL des Blogposts:

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 Abfrageparametern abrufen

Mit der Blogger Data API können Sie eine Reihe von Einträgen anfordern, die bestimmten Kriterien entsprechen. So können Sie beispielsweise Blogbeiträge anfordern, 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 Abfrage für einen bestimmten Zeitraum senden möchten, legen Sie die Parameter published-min und published-max des Abfrageobjekts fest. Im folgenden Code-Snippet werden der Titel und der Inhalt jedes Blogposts ausgegeben, 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 zum Debuggen der Klasse Zend_Gdata_Query ist getQueryUrl(). Damit wird die erstellte codierte URL angezeigt.

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
Gibt Kategorien (auch als Labels bezeichnet) an, um die Feedergebnisse zu filtern. Beispiel: http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie gibt Einträge mit den Labels Fritz und Laurie zurück.
max-results
Die maximale Anzahl der Einträge, die zurückgegeben werden sollen.
published-min, published-max
Die Grenzen für die Veröffentlichungsdaten von Einträgen.
start-index
Der Index (ab 1) des ersten Ergebnisses, das abgerufen werden soll (für die Paginierung).

Weitere Informationen zu Abfrageparametern findest du im Referenzleitfaden für die Blogger Data API und im Referenzleitfaden für Google Data APIs.

Beiträge aktualisieren

Wenn Sie einen vorhandenen Blogpost aktualisieren möchten, rufen Sie zuerst den Eintrag ab, den Sie aktualisieren möchten, ändern ihn und senden Sie ihn dann mit der Methode save an Blogger. Im folgenden Code-Snippet werden der Titel und der Inhalt eines Blogposts geändert. Dabei wird davon ausgegangen, dass Sie den Eintrag bereits vom Server abgerufen haben.

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: Das Ändern der mit Beiträgen verknüpften Autordaten wird derzeit nicht unterstützt.

Beiträge löschen

Wenn du einen Beitrag löschen möchtest, übergebe die Bearbeitungs-URL des Beitrags an die delete-Methode deines $gdClient-Objekts. So gehts:

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 Kommentare erstellt, abgerufen und gelöscht werden. Das Aktualisieren von Kommentaren wird nicht unterstützt und ist auch nicht in der Weboberfläche verfügbar.

Kommentare erstellen

Wenn du einen Kommentar posten möchtest, erstelle ein Eingabeobjekt und füge es so 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 worden.

Kommentare abrufen

Du kannst die Kommentare zu einem 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);
}

Alternativ können Sie die Kommentare zu allen Beiträgen über die Kommentarfeed-URL des Blogs abrufen:

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

Kommentare löschen

Wenn du einen Kommentar löschen möchtest, übergebe die Bearbeitungs-URL des Kommentars so an die delete-Methode deines $gdClient-Objekts:

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

Nach oben