Diese Seite wurde von der Cloud Translation API übersetzt.

Entwicklerleitfaden: PHP

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

Ihre Clientanwendung kann die Blogger Data API verwenden, um neue Blogposts zu erstellen, vorhandene Blogposts zu bearbeiten oder zu löschen und nach Blogposts zu suchen, 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 mit der Zend Google Data APIs-Clientbibliothek. Weitere Informationen zum zugrunde liegenden Protokoll, das die Bibliothek verwendet, finden Sie im Abschnitt zum Protokoll dieses Entwicklerhandbuchs.

Inhalt

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 Ideen hinter dem Google Data APIs-Protokoll vertraut sind.

Referenzinformationen zu den Klassen und Methoden der Clientbibliothek finden Sie in der API-Referenz zur PHP-Clientbibliothek. Allgemeine Informationen zur Blogger Data API finden Sie im Protokollreferenzleitfaden.

Erste Schritte

Hilfe zum Einrichten der Clientbibliothek finden Sie im Startleitfaden.

Für die Zend-Clientbibliothek ist PHP 5.1.4 oder höher erforderlich. Es ist als Teil des Zend-Frameworks und als separater Download verfügbar. Für die Interaktion mit Blogger benötigen Sie Version 1.0.0 oder höher der Clientbibliothek.

Blogger-Konto erstellen

Du kannst dich auch für ein Blogger-Konto registrieren. Blogger verwendet Google-Konten. Wenn Sie also bereits ein Google-Konto haben, müssen Sie nichts weiter tun.

Beispielcode ausführen

Ein voll funktionsfähiger Beispielclient mit dem gesamten Beispielcode aus diesem Dokument ist im ZN-Framework-SVN-Repository 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 Einschlusspfad kann entweder mit einer php.ini-Einstellung oder mit der Methode set_include_path festgelegt werden. Dieser Code fordert Zugriff auf die Stammklasse 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');

Magische Getter und Setter

In der PHP-Clientbibliothek wurde Entwicklern die Unterstützung für magische Setter/Getter erleichtert. Damit können die Attribute einer Klasse sicher mit herkömmlichen Setter-/Getter-Methoden oder durch Zugriff auf die Attribute aufgerufen werden. 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;

Ähnlich erleichtern magische Methoden die Deklaration neuer Objekte. Anstatt sich an die langen Klassennamen zu erinnern, die in der Zend-Namenskonvention festgelegt wurden, können Sie eine neue object erstellen, indem Sie newObject(); über einen Zend-Dienstclient aufrufen. Die folgenden beiden Snippets deklarieren beispielsweise beide ein neues draft-Erweiterungsobjekt. Weitere Informationen zu drafts findest du 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 und Getter und Fabriken sind optional. Verwenden Sie also den Ansatz, der für Sie am besten funktioniert.

Andere Ressourcen

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

Authentifizierung beim Blogger-Dienst

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 schreibgeschützt. Wenn du Blogs ändern möchtest, muss sich dein Client authentifizieren, bevor du private Feeds anfordern kannst. Für die Authentifizierung gibt es drei Möglichkeiten: die OAuth-Authentifizierung, die AuthSub-Proxyauthentifizierung oder die ClientLogin-Authentifizierung für Nutzernamen und Passwörter.

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

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

OAuth-Authentifizierung

Eine Dokumentation 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 bei Google-Konten authentifizieren müssen. Der Websitebetreiber und der Clientcode haben keinen Zugriff auf den Nutzernamen und das Passwort für den Blogger-Nutzer. Stattdessen erhält der Client spezielle AuthSub-Tokens, die es dem Client ermöglichen, im Namen eines bestimmten Nutzers zu handeln. Weitere Informationen finden Sie in der AuthSub-Dokumentation.

Wenn ein Nutzer Ihre Anwendung zum ersten Mal aufruft, wurde er noch nicht authentifiziert. In diesem Fall musst du einige Informationen und einen Link anzeigen, der den Nutzer zu einer Google-Seite weiterleitet, damit deine Zugriffsanfrage für seine Blogs authentifiziert werden kann. Die Zend-Clientbibliothek bietet eine Funktion zum Generieren 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 (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).
geschützt?: Gibt an, ob der Client ein sicheres Token anfordert.
session: Gibt an, ob das zurückgegebene Token gegen ein Mehrzwecktoken (Sitzungsversion) eingetauscht werden kann.

Das obige Beispiel zeigt einen Aufruf, der kein sicheres Token anfordert (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 für sein Google-Konto.

Nach der Authentifizierung des Nutzers werden sie vom AuthSub-System an die URL weitergeleitet, die Sie im Abfrageparameter next der AuthSubRequest-URL angegeben haben. Das AuthSub-System hängt als Wert des Abfrageparameters token ein Authentifizierungstoken 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 Einweg-Token für die einmalige Verwendung dar. Da in diesem Beispiel $session = true angegeben wurde, kann dieses Token mit der Methode Zend_Gdata_AuthSub::getAuthSubSessionToken, die den Dienst AuthSubSessionToken aufruft, gegen ein AuthSub-Sitzungstoken eingetauscht werden:

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

Das Code-Snippet prüft zuerst, ob bereits ein AuthSub-Sitzungstoken vorhanden ist. Ist dies nicht der Fall, ist jedoch ein Einweg-Token in der URL angegeben, gibt das Code-Snippet das Einmal-Token an die Methode getAuthSubSessionToken weiter und die AuthSub-Schnittstelle gibt ein Sitzungstoken zurück. Mit dem Code wird dann der Sitzungstokenwert in die Sitzungsvariable $_SESSION['sessionToken'] eingefügt.

Ihre Anwendung kann dann den Wert des Sitzungstokens bei nachfolgenden Interaktionen mit Blogger verwenden. Sie können die Methode Zend_Gdata_AuthSub::getHttpClient verwenden, um ein Zend_Http_Client-Objekt abzurufen, in dem der Header Authorization vorab AuthSub-Anmeldedaten enthält:

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

Authentifizierung mit Nutzername/Passwort für ClientLogin

Verwenden Sie die ClientLogin-Authentifizierung, wenn Ihr Client ein eigenständiger, einzelner Nutzerclient ist, z. B. eine Desktopanwendung.

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

Beachten Sie, dass $accountType explizit auf GOOGLE gesetzt 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 für alle Anfragen in einer bestimmten Sitzung dasselbe Token. Erhalten Sie nicht für jede Blogger-Anfrage ein neues Token.

Hinweis: Wie in der ClientLogin-Dokumentation beschrieben, schlägt die Authentifizierungsanfrage möglicherweise fehl und fordert ein CAPTCHA an. Wenn Google die CAPTCHA-Abfrage ausstellen und verarbeiten soll, leite den Nutzer an https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger weiter anstatt zur in der ClientLogin-Dokumentation angegebenen CAPTCHA-Verarbeitungs-URL.

Liste von Blogs abrufen

Die Blogger Data API bietet einen Feed, in dem die Blogs eines bestimmten Nutzers aufgelistet werden. Dieser Feed wird als Metametafeed bezeichnet.

Im folgenden Beispielcode wird ein authentifiziertes $gdClient-Objekt verwendet, um den Metafeed abzurufen. Anschließend wird der Titel jedes Blogs gedruckt.

Mit der Klasse Zend_Gdata_Query wird die Abfrage-URL erstellt. In diesem Fall müssen keine weiteren Schritte ausgeführt werden. Die Nützlichkeit der Klasse Query wird jedoch im Abschnitt Beiträge nach Suchparameter abrufen dieses Dokuments erkennbar.

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. Um auf einen Feed für einen anderen Nutzer zuzugreifen, können Sie die ID des Nutzers anstelle von default in der Meta-Feed-URL angeben. Die ID des Nutzers 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 Beiträgen und Kommentaren benötigen Sie die Blog-ID. 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. Daher fügt ein split für das Zeichen '-' die Blog-ID in das letzte Element des resultierenden Arrays ein.

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

Beiträge erstellen

Mit der Blogger Data API können Sie sowohl neue Blogeinträge als auch Entwürfe erstellen und veröffentlichen.

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

Blogpost veröffentlichen

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

Erstellen Sie zuerst eine Eintragsinstanz für den Blogpost. Anschließend kannst du 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 Werksinstanzen bei der Arbeit mit den neuen Zend_Gdata_Entry-, Zend_Gdata_App_Extension_Title- und Zend_Gdata_App_Extension_Content-Objekten.

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

Blogpostentwurf erstellen

Entwürfe werden auf die gleiche Weise wie öffentliche Beiträge erstellt. Sie müssen jedoch den Entwurfsattribut des Eingabeobjekts festlegen. Du kannst einen Blogpost wie den oben genannten als Entwurf erstellen, indem du die hervorgehobenen Zeilen hinzufügst:

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 in einen veröffentlichten Beitrag umwandeln. Rufe dazu den Entwurfsbeitrag ab, setze das Entwurfsattribut auf no und aktualisiere dann den Beitrag. In den nächsten beiden Abschnitten geht es um das Abrufen und Aktualisieren von Beiträgen.

Beiträge werden abgerufen

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

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

Alle Blogposts werden abgerufen

Um die Posts des Nutzers abzurufen, rufe dieselbe getFeed-Methode auf, die zum Abrufen des Blog-Metafeeds verwendet wird. Dieses Mal senden Sie jedoch die Blogpost-Feed-URL:

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 mit Suchparametern abrufen

Mit der Blogger Data API können Sie eine Reihe von Einträgen anfordern, die bestimmten Kriterien entsprechen, z. B. das Anfordern von 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 Inhalt jedes Blogposts aus, der zwischen dem angegebenen Start- und Enddatum 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 hilfreiche Methode zur Fehlerbehebung für die Klasse Zend_Gdata_Query ist getQueryUrl(). Sie zeigt die erstellte codierte URL an.

Hinweis: Es gibt derzeit 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 an (auch Labels genannt), um die Feedergebnisse zu filtern. http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie gibt beispielsweise Einträge mit den Labels Fritz und Laurie zurück.
Max. Ergebnisse: Die maximale Anzahl der Einträge, die zurückgegeben werden sollen.
Veröffentlicht-Min., veröffentlicht-max: Die Grenzen des Veröffentlichungsdatums des Eintrags.
Startindex: Der 1-basierte Index des ersten abzurufenden Ergebnisses (für die Seitenordnung).

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

Beiträge werden aktualisiert

Zum Aktualisieren eines vorhandenen Blogposts rufen Sie zuerst den Eintrag ab, den Sie aktualisieren möchten. Dann ändern Sie ihn und senden ihn dann mithilfe der Methode save an Blogger. Das folgende Code-Snippet ändert den Titel und den Inhalt eines Blogeintrags unter der Annahme, 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: Das Ändern von mit Beiträgen verknüpften Autorendaten wird derzeit nicht unterstützt.

Beiträge löschen

Wenn Sie einen Beitrag löschen möchten, übergeben Sie die Bearbeitungs-URL des Beitrags an die Methode delete Ihres $gdClient-Objekts. 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 weder unterstützt noch in der Weboberfläche verfügbar.

Kommentare erstellen

Erstellen Sie zum Posten eines Kommentars ein Einstiegsobjekt und fügen Sie 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 in einem Blog nur Kommentare veröffentlichen, deren Inhaber der authentifizierte Nutzer ist.

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 derzeit authentifizierten Nutzer erstellt worden.

Kommentare werden abgerufen

So kannst du Kommentare zu einem bestimmten Beitrag über die Kommentar-Feed-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);
}

Du kannst auch die Kommentare zu allen Beiträgen über die Kommentar-Feed-URL des Blogs abrufen:

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

Kommentare löschen

Übergib den Bearbeitungs-URL des Kommentars an die Methode delete deines $gdClient-Objekts, um einen Kommentar zu löschen:

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

Nach oben